Cabeçalhos HTTP na API do cliente Websockets

Parece fácil adicionar cabeçalhos HTTP personalizados ao seu cliente de websocket com qualquer cliente de cabeçalho HTTP que suporte isso, mas não consigo encontrar como fazê-lo com a API JSON.

No entanto, parece que deve haver suporte para esses cabeçalhos nas especificações .

Alguém tem uma idéia de como alcançá-lo?

var ws = new WebSocket("ws://example.com/service");

Especificamente, preciso enviar um cabeçalho de autorização HTTP.

Atualizado 2x

Resposta curta: Não, apenas o caminho e o campo do protocolo podem ser especificados.

Resposta mais longa:

Não há método na API JavaScript WebSockets para especificar cabeçalhos adicionais para o cliente / navegador enviar. O caminho HTTP ("GET / xyz") e o cabeçalho do protocolo ("Sec-WebSocket-Protocol") podem ser especificados no construtor WebSocket.

O cabeçalho Sec-WebSocket-Protocol (que às vezes é estendido para ser usado na autenticação específica do websocket) é gerado a partir do segundo argumento opcional para o construtor WebSocket:

var ws = new WebSocket("ws://example.com/path", "protocol");
var ws = new WebSocket("ws://example.com/path", ["protocol1", "protocol2"]);

O resultado acima resulta nos seguintes cabeçalhos:

Sec-WebSocket-Protocol: protocol

e

Sec-WebSocket-Protocol: protocol1, protocol2

Um padrão comum para obter autenticação / autorização do WebSocket é implementar um sistema de emissão de bilhetes, em que a página que hospeda o cliente WebSocket solicita um ticket do servidor e depois passa esse ticket durante a configuração da conexão do WebSocket na URL / string de consulta, no campo protocolo, ou necessário como a primeira mensagem após o estabelecimento da conexão. O servidor só permite que a conexão continue se o ticket for válido (existe, ainda não foi usado, o IP do cliente codificado nas correspondências do ticket, o registro de data e hora do ticket é recente, etc.). Aqui está um resumo das informações de segurança do WebSocket: https://devcenter.heroku.com/articles/websocket-security

A autenticação básica era anteriormente uma opção, mas isso foi preterido e os navegadores modernos não enviam o cabeçalho, mesmo que seja especificado.

Informações básicas de autenticação (descontinuado) :

O cabeçalho de autorização é gerado a partir do campo nome de usuário e senha (ou apenas nome de usuário) do URI do WebSocket:

var ws = new WebSocket("ws://username:password@example.com")

O resultado acima resulta no seguinte cabeçalho com a cadeia "nome de usuário: senha" codificada em base64:

Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=

Testei a autenticação básica no Chrome 55 e Firefox 50 e verifiquei que as informações básicas de autenticação são realmente negociadas com o servidor (isso pode não funcionar no Safari).

Agradecimentos a Dmitry Frank's pela resposta básica de autenticação

Mais uma solução alternativa, mas todos os navegadores modernos enviam os cookies do domínio junto com a conexão, usando:

var authToken = 'R3YKZFKBVi';

document.cookie = 'X-Authorization=' + authToken + '; path=/';

var ws = new WebSocket(
    'wss://localhost:9000/wss/'
);

Termine com os cabeçalhos de conexão da solicitação:

Cookie: X-Authorization=R3YKZFKBVi

O problema do cabeçalho de autorização HTTP pode ser solucionado com o seguinte:

var ws = new WebSocket("ws://username:password@example.com/service");

Em seguida, um cabeçalho HTTP de autorização básica adequado será definido com o fornecido usernamee password. Se você precisa de Autorização Básica, está tudo pronto.

No Bearerentanto, quero usar e recorri ao seguinte truque: Eu me conecto ao servidor da seguinte maneira:

var ws = new WebSocket("ws://my_token@example.com/service");

E quando meu código no servidor recebe o cabeçalho de Autorização Básica com nome de usuário não vazio e senha vazia, ele interpreta o nome de usuário como um token.

Você não pode adicionar cabeçalhos, mas se precisar passar valores ao servidor no momento da conexão, poderá especificar uma parte da cadeia de caracteres de consulta no URL:

var ws = new WebSocket("ws://example.com/service?key1=value1&key2=value2");

Esse URL é válido, mas - é claro - você precisará modificar o código do servidor para analisá-lo.

Você não pode enviar cabeçalho personalizado quando desejar estabelecer uma conexão WebSockets usando a API JavaScript WebSockets. Você pode usar Subprotocolscabeçalhos usando o segundo construtor de classe WebSocket:

var ws = new WebSocket("ws://example.com/service", "soap");

e então você pode obter os cabeçalhos de subprotocolo usando Sec-WebSocket-Protocol chave no servidor.

Há também uma limitação: os valores dos cabeçalhos dos subprotocolo não podem conter vírgula ( ,)!

O cabeçalho de autorização de envio não é possível.

Anexar um parâmetro de consulta de token é uma opção. No entanto, em algumas circunstâncias, pode ser indesejável enviar seu token de logon principal em texto sem formatação como um parâmetro de consulta, porque é mais opaco do que o uso de um cabeçalho e acabará sendo registrado em quem sabe. Se isso suscitar preocupações de segurança para você, uma alternativa é usar um token JWT secundário apenas para o material do soquete da web .

Crie um terminal REST para gerar esse JWT , que obviamente só pode ser acessado por usuários autenticados com seu token de login principal (transmitido via cabeçalho). O JWT do soquete da Web pode ser configurado de maneira diferente do seu token de login, por exemplo, com um tempo limite mais curto, para que seja mais seguro enviar como parâmetros de consulta da sua solicitação de atualização.

Crie um JwtAuthHandler separado para a mesma rota em que o SockJS eventbusHandler é registrado . Verifique se o manipulador de autenticação está registrado primeiro, para que você possa verificar o token do soquete da Web no seu banco de dados (o JWT deve estar de alguma forma vinculado ao seu usuário no back-end).

Totalmente hackeado assim, graças à resposta de kanaka.

Cliente:

var ws = new WebSocket(
    'ws://localhost:8080/connect/' + this.state.room.id, 
    store('token') || cookie('token') 
);

Servidor (usando o Koa2 neste exemplo, mas deve ser semelhante em qualquer lugar):

var url = ctx.websocket.upgradeReq.url; // can use to get url/query params
var authToken = ctx.websocket.upgradeReq.headers['sec-websocket-protocol'];
// Can then decode the auth token and do any session/user stuff...

O meu caso:

• Quero me conectar a um servidor WS de produção www.mycompany.com/api/ws ...
• usando credenciais reais (um cookie de sessão) ...
• de uma página local ( localhost:8000).

A configuração document.cookie = "sessionid=foobar;path=/"não ajudará, pois os domínios não correspondem.

A solução :

Adicionar 127.0.0.1 wsdev.company.com a /etc/hosts.

Dessa forma, seu navegador usará cookies mycompany.comquando www.mycompany.com/api/wsvocê se conectar a partir de um subdomínio válido wsdev.company.com.

Na minha situação (Azure Time Series Insights wss: //)

Usando o wrapper ReconnectingWebsocket e conseguiu adicionar cabeçalhos com uma solução simples:

socket.onopen = function(e) {
    socket.send(payload);
};

Onde a carga útil neste caso é:

{
  "headers": {
    "Authorization": "Bearer TOKEN",
    "x-ms-client-request-id": "CLIENT_ID"
}, 
"content": {
  "searchSpan": {
    "from": "UTCDATETIME",
    "to": "UTCDATETIME"
  },
"top": {
  "sort": [
    {
      "input": {"builtInProperty": "$ts"},
      "order": "Asc"
    }], 
"count": 1000
}}}

Tecnicamente, você enviará esses cabeçalhos através da função de conexão antes da fase de atualização do protocolo. Isso funcionou para mim em um nodejsprojeto:

var WebSocketClient = require('websocket').client;
var ws = new WebSocketClient();
ws.connect(url, '', headers);

Você pode passar os cabeçalhos como um valor-chave no terceiro parâmetro (opções) dentro de um objeto. Exemplo com token de autorização. Deixou o protocolo (segundo parâmetro) como nulo

ws = novo WebSocket ('ws: // localhost', nulo, {cabeçalhos: {Authorization: token}})

Editar: Parece que essa abordagem funciona apenas com a biblioteca nodejs, não com a implementação padrão do navegador. Deixando porque pode ser útil para algumas pessoas.