hacktricks/binary-exploitation/basic-binary-exploitation-methodology/README.md

# Méthodologie de base pour l'exploitation binaire

<details>

<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>

Autres façons de soutenir HackTricks :

* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.

</details>

## Informations de base sur ELF

Avant de commencer à exploiter quoi que ce soit, il est intéressant de comprendre une partie de la structure d'un **binaire ELF** :

{% content-ref url="elf-tricks.md" %}
[elf-tricks.md](elf-tricks.md)
{% endcontent-ref %}

## Outils d'exploitation

{% content-ref url="tools/" %}
[outils](tools/)
{% endcontent-ref %}

## Méthodologie du débordement de pile

Avec autant de techniques, il est bon d'avoir un schéma pour savoir quand chaque technique sera utile. Notez que les mêmes protections affecteront différentes techniques. Vous pouvez trouver des moyens de contourner les protections dans chaque section de protection, mais pas dans cette méthodologie.

## Contrôler le flux

Il existe différentes façons de contrôler le flux d'un programme :

* [**Débordements de pile**](../stack-overflow/) en écrasant le pointeur de retour de la pile ou l'EBP -> ESP -> EIP.
* Pourrait nécessiter d'abuser des [**Débordements d'entiers**](../integer-overflow.md) pour provoquer le débordement
* Ou via **Écritures arbitraires + Écrire quoi où à l'exécution**
* [**Chaines de format**](../format-strings/)**:** Abuser de `printf` pour écrire un contenu arbitraire à des adresses arbitraires.
* [**Indexation de tableaux**](../array-indexing.md) : Abuser d'une indexation mal conçue pour pouvoir contrôler certains tableaux et obtenir une écriture arbitraire.
* Pourrait nécessiter d'abuser des [**Débordements d'entiers**](../integer-overflow.md) pour provoquer le débordement
* **bof vers WWW via ROP** : Abuser d'un débordement de tampon pour construire un ROP et pouvoir obtenir un WWW.

Vous pouvez trouver les techniques **Écrire quoi où à l'exécution** dans :

{% content-ref url="../arbitrary-write-2-exec/" %}
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
{% endcontent-ref %}

## Boucles éternelles

Il est important de prendre en compte que généralement **une seule exploitation d'une vulnérabilité pourrait ne pas suffire** pour exécuter avec succès une exploitation, en particulier si certaines protections doivent être contournées. Par conséquent, il est intéressant de discuter de certaines options pour **rendre une seule vulnérabilité exploitable plusieurs fois** dans la même exécution du binaire :

* Écrire dans une chaîne **ROP** l'adresse de la fonction **`main`** ou à l'adresse où la **vulnérabilité** se produit.
* En contrôlant une chaîne ROP appropriée, vous pourriez être capable d'effectuer toutes les actions dans cette chaîne
* Écrire dans l'adresse **`exit` dans GOT** (ou toute autre fonction utilisée par le binaire avant la fin) l'adresse pour revenir à la **vulnérabilité**
* Comme expliqué dans [**.fini\_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md#eternal-loop)**,** stockez 2 fonctions ici, une pour appeler à nouveau la vulnérabilité et une autre pour appeler **`__libc_csu_fini`** qui appellera à nouveau la fonction de `.fini_array`.

## Objectifs d'exploitation

### Objectif : Appeler une fonction existante

* [**ret2win**](./#ret2win) : Il y a une fonction dans le code que vous devez appeler (peut-être avec des paramètres spécifiques) pour obtenir le drapeau.
* Dans un **bof régulier sans** [**PIE**](../common-binary-protections-and-bypasses/pie/) **et** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), vous avez juste besoin d'écrire l'adresse dans l'adresse de retour stockée dans la pile.
* Dans un bof avec [**PIE**](../common-binary-protections-and-bypasses/pie/), vous devrez le contourner
* Dans un bof avec [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), vous devrez le contourner
* Si vous devez définir plusieurs paramètres pour appeler correctement la fonction **ret2win**, vous pouvez utiliser :
* Une chaîne [**ROP**](./#rop-and-ret2...-techniques) **s'il y a suffisamment de gadgets** pour préparer tous les paramètres
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) (au cas où vous pourriez appeler cet appel système) pour contrôler de nombreux registres
* Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) et [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) pour contrôler plusieurs registres
* Via un [**Écrire quoi où**](../arbitrary-write-2-exec/) vous pourriez abuser d'autres vulnérabilités (pas de bof) pour appeler la fonction **`win`**.
* [**Redirection de pointeurs**](../stack-overflow/pointer-redirecting.md) : Si la pile contient des pointeurs vers une fonction qui va être appelée ou vers une chaîne qui va être utilisée par une fonction intéressante (system ou printf), il est possible de remplacer cette adresse.
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) pourraient affecter les adresses.
* [**Variables non initialisées**](../stack-overflow/uninitialized-variables.md) : On ne sait jamais.

### Objectif : RCE

#### Via shellcode, si nx est désactivé ou en mélangeant shellcode avec ROP :

* [**(Stack) Shellcode**](./#stack-shellcode) : Cela est utile pour stocker un shellcode dans la pile avant ou après avoir écrasé le pointeur de retour, puis **sauter dessus** pour l'exécuter :
* **Dans tous les cas, s'il y a un** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)**,** dans un bof régulier vous devrez le contourner (leak)
* **Sans** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **et** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) il est possible de sauter à l'adresse de la pile car elle ne changera jamais
* **Avec** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) vous aurez besoin de techniques telles que [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) pour y sauter
* **Avec** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), vous devrez utiliser un certain [**ROP**](../rop-return-oriented-programing/) **pour appeler `memprotect`** et rendre certaines pages `rwx`, afin de **stocker ensuite le shellcode là-dedans** (en appelant read par exemple) et ensuite y sauter.
* Cela mélange le shellcode avec une chaîne ROP.
#### Via appels système

* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Utile pour appeler `execve` afin d'exécuter des commandes arbitraires. Vous devez être capable de trouver les **gadgets pour appeler l'appel système spécifique avec les paramètres**.
* Si [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) sont activés, vous devrez les contourner **pour utiliser les gadgets ROP** du binaire ou des bibliothèques.
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) peut être utile pour préparer le **ret2execve**
* Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) et [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) pour contrôler plusieurs registres

#### Via libc

* [**Ret2lib**](../rop-return-oriented-programing/ret2lib/): Utile pour appeler une fonction d'une bibliothèque (généralement de **`libc`**) comme **`system`** avec certains arguments préparés (par exemple `'/bin/sh'`). Vous avez besoin que le binaire **charge la bibliothèque** avec la fonction que vous souhaitez appeler (généralement libc).
* Si **compilé statiquement et sans** [**PIE**](../common-binary-protections-and-bypasses/pie/), l'**adresse** de `system` et `/bin/sh` ne va pas changer, il est donc possible de les utiliser statiquement.
* **Sans** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **et en connaissant la version de libc** chargée, l'**adresse** de `system` et `/bin/sh` ne va pas changer, il est donc possible de les utiliser statiquement.
* Avec [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **mais sans** [**PIE**](../common-binary-protections-and-bypasses/pie/)**, en connaissant la libc et en utilisant la fonction `system`** du binaire, il est possible de **`ret` à l'adresse de system dans le GOT** avec l'adresse de `'/bin/sh'` en paramètre (vous devrez résoudre cela).
* Avec [ASLR](../common-binary-protections-and-bypasses/aslr/) mais sans [PIE](../common-binary-protections-and-bypasses/pie/), en connaissant la libc et **sans que le binaire utilise le `system`** :
* Utilisez [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) pour résoudre l'adresse de `system` et l'appeler&#x20;
* **Contourner** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) et calculer l'adresse de `system` et `'/bin/sh'` en mémoire.
* **Avec** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **et** [**PIE**](../common-binary-protections-and-bypasses/pie/) **et sans connaître la libc**: Vous devez :
* Contourner [**PIE**](../common-binary-protections-and-bypasses/pie/)
* Trouver la **version de la libc** utilisée (fuite de quelques adresses de fonctions)
* Vérifiez les **scénarios précédents avec ASLR** pour continuer.

#### Via EBP/RBP

* [**Pivotement de pile / EBP2Ret / Chaining EBP**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Contrôlez l'ESP pour contrôler RET à travers l'EBP stocké dans la pile.
* Utile pour les débordements de pile **d'un octet**
* Utile comme moyen alternatif de contrôler l'EIP tout en abusant de l'EIP pour construire la charge utile en mémoire, puis y sauter via l'EBP

#### Divers

* [**Redirection de pointeurs**](../stack-overflow/pointer-redirecting.md): Dans le cas où la pile contient des pointeurs vers une fonction qui va être appelée ou vers une chaîne qui va être utilisée par une fonction intéressante (system ou printf), il est possible de remplacer cette adresse.
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) peuvent affecter les adresses.
* [**Variables non initialisées**](../stack-overflow/uninitialized-variables.md): On ne sait jamais

<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>