Intestazioni HTTP nell'API client di Websocket

Sembra che sia facile aggiungere intestazioni HTTP personalizzate al tuo client websocket con qualsiasi client di intestazione HTTP che supporti questo, ma non riesco a trovare come farlo con l'API JSON.

Tuttavia, sembra che ci dovrebbe essere supporto queste intestazioni nelle specifiche .

Qualcuno ha idea di come raggiungerlo?

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

In particolare, devo essere in grado di inviare un'intestazione di autorizzazione HTTP.

Aggiornato 2x

Risposta breve: No, è possibile specificare solo il campo percorso e protocollo.

Risposta più lunga:

Non esiste alcun metodo nell'API WebSocket JavaScript per specificare ulteriori intestazioni da inviare al client / browser. Il percorso HTTP ("GET / xyz") e l'intestazione del protocollo ("Sec-WebSocket-Protocol") possono essere specificati nel costruttore WebSocket.

L'intestazione Sec-WebSocket-Protocol (che a volte viene estesa per essere utilizzata nell'autenticazione specifica di websocket) viene generata dal secondo argomento facoltativo al costruttore WebSocket:

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

Quanto sopra risulta nelle seguenti intestazioni:

Sec-WebSocket-Protocol: protocol

e

Sec-WebSocket-Protocol: protocol1, protocol2

Un modello comune per ottenere l'autenticazione / autorizzazione WebSocket è l'implementazione di un sistema di ticketing in cui la pagina che ospita il client WebSocket richiede un ticket dal server e quindi passa questo ticket durante l'impostazione della connessione WebSocket nella stringa URL / query, nel campo protocollo, o richiesto come primo messaggio dopo aver stabilito la connessione. Il server consente quindi di continuare la connessione solo se il ticket è valido (esiste, non è già stato utilizzato, l'IP client codificato nelle corrispondenze dei ticket, il timestamp nel ticket è recente, ecc.). Ecco un riepilogo delle informazioni sulla sicurezza di WebSocket: https://devcenter.heroku.com/articles/websocket-security

L'autenticazione di base era in precedenza un'opzione, ma questo è stato deprecato e i browser moderni non inviano l'intestazione anche se è stata specificata.

Informazioni di base sull'autorizzazione (obsoleto) :

L'intestazione di autorizzazione viene generata dal campo nome utente e password (o solo nome utente) dell'URI WebSocket:

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

Quanto sopra risulta nella seguente intestazione con la stringa "nomeutente: password" codificata base64:

Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=

Ho testato l'autent di base in Chrome 55 e Firefox 50 e verificato che le informazioni sull'autent di base siano effettivamente negoziate con il server (ciò potrebbe non funzionare in Safari).

Grazie a Dmitry Frank per la risposta autentica di base

Più di una soluzione alternativa, ma tutti i browser moderni inviano i cookie di dominio insieme alla connessione, quindi utilizzando:

var authToken = 'R3YKZFKBVi';

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

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

Termina con le intestazioni di connessione richieste:

Cookie: X-Authorization=R3YKZFKBVi

Il problema dell'intestazione dell'autorizzazione HTTP può essere risolto con quanto segue:

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

Quindi, verrà impostata un'intestazione HTTP di autorizzazione di base corretta con il fornito usernamee password. Se hai bisogno dell'autorizzazione di base, sei pronto.

Voglio usare Bearercomunque, e ho fatto ricorso al seguente trucco: mi collego al server come segue:

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

E quando il mio codice sul lato server riceve l'intestazione dell'autorizzazione di base con nome utente non vuoto e password vuota, allora interpreta il nome utente come token.

Non è possibile aggiungere intestazioni ma, se è necessario solo passare valori al server al momento della connessione, è possibile specificare una parte della stringa di query sull'URL:

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

Tale URL è valido ma, ovviamente, dovrai modificare il codice del server per analizzarlo.

Non è possibile inviare un'intestazione personalizzata quando si desidera stabilire una connessione WebSocket utilizzando l'API WebSocket JavaScript. Puoi usare le Subprotocolsintestazioni usando il secondo costruttore della classe WebSocket:

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

e quindi è possibile ottenere le intestazioni dei protocolli secondari utilizzando la Sec-WebSocket-Protocolchiave sul server.

C'è anche una limitazione, i valori delle intestazioni dei sottoprotocolli non possono contenere una virgola ( ,)!

Non è possibile inviare l'intestazione di autorizzazione.

Il collegamento di un parametro di query token è un'opzione. Tuttavia, in alcune circostanze, potrebbe non essere desiderabile inviare il token di accesso principale in testo normale come parametro di query perché è più opaco rispetto all'utilizzo di un'intestazione e finirà per essere registrato da qualche parte. Se ciò solleva problemi di sicurezza per te, un'alternativa è utilizzare un token JWT secondario solo per le cose del socket web .

Creare un endpoint REST per generare questo JWT , a cui ovviamente gli utenti possono accedere solo con il tuo token di accesso principale (trasmesso tramite intestazione). Il web socket JWT può essere configurato in modo diverso rispetto al token di accesso, ad esempio con un timeout più breve, quindi è più sicuro inviare come parametro di query della richiesta di aggiornamento.

Creare un JwtAuthHandler separato per la stessa route su cui si registra SbusJS eventbusHandler . Assicurarsi che il gestore di autenticazione sia prima registrato, quindi è possibile verificare il token del socket Web rispetto al proprio database (il JWT dovrebbe essere in qualche modo collegato all'utente nel back-end).

Totalmente l'hackato in questo modo, grazie alla risposta di Kanaka.

Cliente:

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

Server (usando Koa2 in questo esempio, ma dovrebbe essere simile ovunque):

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...

Il mio caso:

• Voglio collegarmi a un server WS di produzione a www.mycompany.com/api/ws ...
• utilizzando credenziali reali (un cookie di sessione) ...
• da una pagina locale ( localhost:8000).

L'impostazione document.cookie = "sessionid=foobar;path=/"non aiuta poiché i domini non corrispondono.

La soluzione :

Aggiungi 127.0.0.1 wsdev.company.coma /etc/hosts.

In questo modo il tuo browser utilizzerà i cookie da mycompany.comquando ti connetti a www.mycompany.com/api/wscome ti connetti da un sottodominio valido wsdev.company.com.

Nella mia situazione (Azure Time Series Insights wss: //)

Utilizzando il wrapper ReconnectingWebsocket ed è stato in grado di ottenere l'aggiunta di intestazioni con una soluzione semplice:

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

Dove il payload in questo 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, invierai queste intestazioni tramite la funzione di connessione prima della fase di aggiornamento del protocollo. Questo ha funzionato per me in un nodejsprogetto:

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

Puoi passare le intestazioni come valore-chiave nel terzo parametro (opzioni) all'interno di un oggetto. Esempio con token di autorizzazione. Lasciato il protocollo (secondo parametro) come nullo

ws = new WebSocket ('ws: // localhost', null, {headers: {Autorizzazione: token}})

Modifica: sembra che questo approccio funzioni solo con la libreria nodejs e non con l'implementazione standard del browser. Lasciandolo perché potrebbe essere utile per alcune persone.