Introduction
This post describes an authentication method for socket.io that sends the credentials in a message after connection, rather than including them in the query string as usually done. Note that the implementation is already packed in the socketio-auth module, so you should use that instead of the code below.
The reason to use this approach is that putting credentials in a query string is generally a bad security practice (see this, this and this), and though some of the frequent risks may not apply to the socket.io connection request, it should be avoided as there’s no general convention in treating urls as sensitive information. Ideally such data should travel on a header, but that doesn’t seem to be an option for socket.io, as not all of the transports it supports (WebSocket being one) allow sending headers.
Needless to say, all of this should be done over HTTPS, otherwise no security level is to be expected.
Implementation
In order to authenticate socket.io connections, most tutorials suggest to do something like:
io.set('authorization', function (handshakeData, callback) {
var token = handshakeData.query.token;
//will call callback(null, true) if authorized
checkAuthToken(token, callback);
});
Or, with the middleware syntax introduced in socket.io 1.0:
io.use(function(socket, next) {
var token = socket.request.query.token;
checkAuthToken(token, function(err, authorized){
if (err || !authorized) {
next(new Error("not authorized"));
}
next();
});
});
Then the client would connect to the server passing its credentials, which can be an authorization token, user and password or whatever value that can be used for authentication:
socket = io.connect('http://localhost', {
query: "token=" + myAuthToken
});
The problem with this approach is that it credentials information in a query string, that is as part of an url. As mentioned, this is not a good idea since urls can be logged and cached and are not generally treated as sensitive information.
My workaround for this was to allow the clients to establish a connection, but force them to send an authentication message before they can actually start emitting and receiving data. Upon connection, the server marks the socket as not authenticated and adds a listener to an ‘authenticate’ event:
var io = require('socket.io').listen(app);
io.on('connection', function(socket){
socket.auth = false;
socket.on('authenticate', function(data){
//check the auth data sent by the client
checkAuthToken(data.token, function(err, success){
if (!err && success){
console.log("Authenticated socket ", socket.id);
socket.auth = true;
}
});
});
setTimeout(function(){
//If the socket didn't authenticate, disconnect it
if (!socket.auth) {
console.log("Disconnecting socket ", socket.id);
socket.disconnect('unauthorized');
}
}, 1000);
}
A timeout is added to disconnect the client if it didn’t authenticate after a second. The client will emit it’s auth data to the ‘authenticate’ event right after connection:
var socket = io.connect('http://localhost');
socket.on('connect', function(){
socket.emit('authenticate', {token: myAuthToken});
});
An extra step is required to prevent the client from receiving broadcast messages during that window where it’s connected but not authenticated. Doing that required fiddling a bit with the socket.io namespaces code; the socket is removed from the object that tracks the connections to the namespace:
var _ = require('underscore');
var io = require('socket.io').listen(app);
_.each(io.nsps, function(nsp){
nsp.on('connect', function(socket){
if (!socket.auth) {
console.log("removing socket from", nsp.name)
delete nsp.connected[socket.id];
}
});
});
Then, when the client does authenticate, we set it back as connected to those namespaces where it was connected:
socket.on('authenticate', function(data){
//check the auth data sent by the client
checkAuthToken(data.token, function(err, success){
if (!err && success){
console.log("Authenticated socket ", socket.id);
socket.auth = true;
_.each(io.nsps, function(nsp) {
if(_.findWhere(nsp.sockets, {id: socket.id})) {
console.log("restoring socket to", nsp.name);
nsp.connected[socket.id] = socket;
}
});
}
});
});
No silver bullet 