Translated ['reversing-and-exploiting/linux-exploiting-basic-esp/common-

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

@@ -16,7 +16,7 @@ Autres façons de soutenir HackTricks :
 
 ## Informations de base
 
-**La randomisation 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 considérablement 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 considérablement 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'exploitations, en particulier les débordements de tampon.
 
 ### **Vérification du statut de l'ASLR**
 
@@ -36,7 +36,7 @@ Pour **désactiver** ASLR, vous définissez la valeur de `/proc/sys/kernel/rando
 ```bash
 echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
 ```
-Vous pouvez également désactiver l'ASLR pour une exécution avec :
+Vous pouvez également désactiver ASLR pour une exécution avec :
 ```bash
 setarch `arch` -R ./bin args
 setarch `uname -m` -R ./bin args
@@ -49,7 +49,7 @@ echo 2 | sudo tee /proc/sys/kernel/randomize_va_space
 ```
 ### **Persistance à travers les redémarrages**
 
-Les modifications effectuées avec les commandes `echo` sont temporaires et seront réinitialisées lors du redémarrage. Pour rendre le changement persistant, vous devez éditer le fichier `/etc/sysctl.conf` et ajouter ou modifier la ligne suivante :
+Les modifications effectuées avec les commandes `echo` sont temporaires et seront réinitialisées lors du redémarrage. Pour rendre la modification persistante, vous devez éditer le fichier `/etc/sysctl.conf` et ajouter ou modifier la ligne suivante :
 ```tsconfig
 kernel.randomize_va_space=2 # Enable ASLR
 # or
@@ -69,17 +69,19 @@ PaX divise l'espace d'adressage du processus en **3 groupes** :
 
 * **Code et données** (initialisées et non initialisées) : `.text`, `.data`, et `.bss` —> **16 bits** d'entropie dans la variable `delta_exec`. Cette variable est initialisée de manière aléatoire à chaque processus et ajoutée aux adresses initiales.
 * **Mémoire** allouée par `mmap()` et **bibliothèques partagées** —> **16 bits**, nommé `delta_mmap`.
-* **La pile** —> **24 bits**, appelé `delta_stack`. Cependant, il utilise effectivement **11 bits** (du 10e au 20e octet inclus), alignés sur **16 octets** —> Cela donne **524 288 adresses de pile réelles possibles**.
+* **La pile** —> **24 bits**, appelé `delta_stack`. Cependant, elle utilise effectivement **11 bits** (du 10e au 20e octet inclus), alignés sur **16 octets** —> Cela donne **524 288 adresses de pile réelles possibles**.
 
-Les données précédentes sont pour les systèmes 32 bits et l'entropie finale réduite permet de contourner l'ASLR en réessayant l'exécution jusqu'à ce que l'exploit réussisse.
+Les données précédentes sont pour les systèmes 32 bits et l'entropie finale réduite permet de contourner l'ASLR en réessayant l'exécution encore et encore jusqu'à ce que l'exploit réussisse.
 
 #### Idées de force brute :
 
-* Si l'exploit est local, vous pouvez essayer de forcer de manière brute l'adresse de base de libc (utile pour les systèmes 32 bits) :
+* 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):
 ```
-* Lors d'une attaque sur 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 le **serveur met 10 secondes supplémentaires pour répondre**, vous avez trouvé l'adresse de cette fonction.
+* Lors de l'attaque d'un serveur distant, vous pourriez essayer de **forcer l'adresse de la fonction `usleep` de la bibliothèque `libc`**, en passant 10 comme argument. Si à un moment donné le **serveur met 10 secondes de plus à 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.
@@ -89,7 +91,7 @@ Sur les systèmes 64 bits, l'entropie est beaucoup plus élevée et cela n'est p
 
 * **Le défi consiste à avoir une fuite**
 
-Si vous disposez d'une fuite (dans des 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):
+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 bibliothèque `libc` utilisée dans le système que vous exploitez). Cet exploit exemple 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
 from pwn import *
 
@@ -148,17 +150,3 @@ Essayez de contourner l'ASLR en abusant des adresses à l'intérieur de la pile:
 {% content-ref url="../../stack-overflow/ret2ret.md" %}
 [ret2ret.md](../../stack-overflow/ret2ret.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>

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

@@ -20,13 +20,14 @@ Un binaire compilé en tant que PIE, ou **Exécutable à Adresse Indépendante**
 
 La technique pour exploiter ces binaires réside dans l'exploitation des **adresses relatives** - les décalages entre les parties du programme restent les mêmes même si les emplacements absolus changent. Pour **contourner le PIE, vous avez seulement besoin de divulguer une adresse**, généralement à partir de la **pile** en utilisant des vulnérabilités comme les attaques par chaîne de format. Une fois que vous avez une adresse, vous pouvez calculer les autres en fonction de leurs **décalages fixes**.
 
-Un indice utile pour exploiter les binaires PIE est que leur **adresse de base se termine généralement en 000** en raison des pages mémoire étant les unités de randomisation, de taille 0x1000 octets. Cet alignement peut être une **vérification critique si un exploit ne fonctionne pas** comme prévu, indiquant si la bonne adresse de base a été identifiée.\
+Un indice utile pour exploiter les binaires PIE est que leur **adresse de base se termine généralement en 000** en raison des pages mémoire étant les unités de randomisation, de taille de 0x1000 octets. Cet alignement peut être une **vérification critique si un exploit ne fonctionne pas** comme prévu, indiquant si la bonne adresse de base a été identifiée.\
 Ou vous pouvez utiliser cela pour votre exploit, si vous divulguez qu'une adresse est située à **`0x649e1024`** vous savez que l'**adresse de base est `0x649e1000`** et à partir de là vous pouvez simplement **calculer les décalages** des fonctions et des emplacements.
 
 ## Contournements
 
 Pour contourner le PIE, il est nécessaire de **divulguer une adresse du binaire chargé**, il existe quelques options pour cela :
 
+* **ASLR désactivé** : Si ASLR est désactivé, un binaire compilé avec PIE est toujours **chargé à la même adresse**, donc le **PIE sera inutile** car les adresses des objets seront toujours au même endroit.
 * Se **voir donner** la fuite (courant dans les défis CTF faciles, [**consultez cet exemple**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
 * **Forcer les valeurs EBP et EIP** dans la pile jusqu'à ce que vous divulguiez les bonnes :
 
@@ -34,7 +35,7 @@ Pour contourner le PIE, il est nécessaire de **divulguer une adresse du binaire
 [bypassing-canary-and-pie.md](bypassing-canary-and-pie.md)
 {% endcontent-ref %}
 
-* Utilisez une vulnérabilité de lecture arbitraire telle que les [**chaînes de format**](../../format-strings/) pour divulguer une adresse du binaire (par exemple à partir de la pile, comme dans la technique précédente) pour obtenir la base du binaire et utiliser des décalages à partir de là. [**Trouvez un exemple ici**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
+* Utilisez une vulnérabilité de lecture arbitraire telle que [**chaîne de format**](../../format-strings/) pour divulguer une adresse du binaire (par exemple à partir de la pile, comme dans la technique précédente) pour obtenir la base du binaire et utiliser des décalages à partir de là. [**Trouvez un exemple ici**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
 
 ## Références