Autenticazione sicura con node.js e session.socket.io?

Question

Sto utilizzando le ultime versioni di node.js e session.socket.io e questo è come ho impostato la sessione (si ricorda che non sto usando una connessione HTTPS in modo che nessun secure: true):

app.configure(function() { 
    app.use(cookieParser); 
    app.use(express.session({ 
     signed: true, 
     store: sessionStore, 
     secret: 'SECRET', 
     cookie: { 
      maxAge: 24 * 60 * 60 * 1000, 
      httpOnly: true 
     } 
    })); 
}); 
var sessionSockets = new SessionSockets(io, sessionStore, cookieParser); 

// Later 
sessionSockets.on('connection', function(error, socket, session) { 
    // session could be used here to detect if user is logged in 

    // e.g. login: session.name = 'x'; session.save(); 
    // e.g. checkIfLoggedIn: if (session.name) return true; 
}); 

è il mio codice sicuro/corretto o in che modo posso autenticare l'utente che ha effettuato l'accesso? E 'possibile/raccomandato di cambiare il sid del cookie sui client (a causa del fatto che è menzionato here)?

Answer 1

Si consiglia di evitare di reinventare la ruota e utilizzare una libreria come PassportJS. Esiste un modulo specifico per l'utilizzo di PassportJS con Socket.io here (non l'ho mai usato anche se attualmente sto lavorando a un progetto in cui ne avrò bisogno presto). Ho usato PassportJS ed è abbastanza semplice. Lo raccomanderei.

Answer 2

Autenticazione utente e la sessione di storage utilizzando Passport

var express = require('express'), 
routes = require('./routes'), 
api = require('./routes/api'), 
http = require('http'), 
path = require('path'), 
mysql = require('mysql'), 
passport = require('passport'), 
LocalStrategy = require('passport-local').Strategy; 

//MySQL 

var sqlInfo = { 
    host: 'localhost', 
    user: 'root', 
    password: '', 
    database: 'dbname' 
} 


global.client = mysql.createConnection(sqlInfo); 

client.connect(); 




var app = module.exports = express(); 




/** 
* Configuration 
*/ 

// all environments 
app.set('port', process.env.PORT || 3000); 
app.set('views', __dirname + '/views'); 
app.set('view engine', 'jade'); 
app.use(express.logger('dev')); 
app.use(express.bodyParser()); 
app.use(express.methodOverride()); 
app.use(express.static(path.join(__dirname, 'public'))); 

app.use(express.cookieParser("secret")); 
app.use(express.session({ 
    secret: 'keyboard cat' 
})); 
app.use(passport.initialize()); 
app.use(passport.session()); 

app.use(app.router); 




passport.use(new LocalStrategy(

    function(username, password, done) { 

     return check_auth_user(username,password,done); 

    } 

    )); 


// development only 
if (app.get('env') === 'development') { 
    app.use(express.errorHandler()); 
} 

// production only 
if (app.get('env') === 'production') { 
// TODO 
} 



/** 
* routes start--------------------------------------------------------------- 
*/ 
// home page contain login form 
app.get('/home', function(reg, res){ 
    //check user session value, is logged in 
    if(req.user) 
     res.render('dash',{ 
      username: req.user['member_id']//req.user array contains serializeUser data 
     }); 
    else 
     res.render('index'); 

}); 

app.get('/logout', function(req, res){ 

    req.logout(); 
    res.redirect('/home'); 
}); 

//login form submit as post 

app.post('/login', 
    passport.authenticate('local', { 
     successRedirect: '/dashboard', 
     failureRedirect: '/home' 
    }) 
    ); 
//to project dashboard 
app.get('/dash',routes.dash); 
//to project dashboard 
app.get('/signup',routes.signup); 
//to project dashboard 

app.get('*', routes.index); 

/** 
* routes end--------------------------------------------------------------------- 
*/ 


/** 
* Start Server 
*/ 

http.createServer(app).listen(app.get('port'), function() { 
    console.log('Express server listening on port ' + app.get('port')); 
}); 

Click for more details with example!.

Answer 3

So che questo è un po 'vecchio, ma per i futuri lettori oltre all'approccio descritto da @kentcdodds di analizzare il cookie e recuperare la sessione dall'archivio (ad esempio il mio modulo passport.socketio) si potrebbe anche considerare un approccio basato su token .

In questo esempio utilizzo i token Web JSON che sono piuttosto standard. Devi dare alla pagina client il token, in questo esempio immaginate un endpoint di autenticazione che restituisce JWT:

var jwt = require('jsonwebtoken'); 
// other requires 

app.post('/login', function (req, res) { 

    // TODO: validate the actual user user 
    var profile = { 
    first_name: 'John', 
    last_name: 'Doe', 
    email: 'john@doe.com', 
    id: 123 
    }; 

    // we are sending the profile in the token 
    var token = jwt.sign(profile, jwtSecret, { expiresInMinutes: 60*5 }); 

    res.json({token: token}); 
}); 

Ora, il server socket.io può essere configurato come segue:

var socketioJwt = require('socketio-jwt'); 

var sio = socketIo.listen(server); 

sio.set('authorization', socketioJwt.authorize({ 
    secret: jwtSecret, 
    handshake: true 
})); 

sio.sockets 
    .on('connection', function (socket) { 
    console.log(socket.handshake.decoded_token.email, 'has joined'); 
    //socket.on('event'); 
    }); 

Il middleware socket.io-JWT si aspetta che il token in una stringa di query, quindi dal client è sufficiente attaccarlo quando si collega:

var socket = io.connect('', { 
    query: 'token=' + token 
}); 

ho scritto una spiegazione più dettagliata su questo meth od e biscotti here.