Can I pass multiple URLs? about passport-ldapauth HOT 9 CLOSED

var jwt = require('jsonwebtoken');
var config = require('../../config');
var superSecret = config.secret;
var passport = require('passport');
var LdapStrategy = require('passport-ldapauth');

module.exports = function(app, express) {

    var apiRouter = express.Router();

    passport.use('ldap1', new LdapStrategy(config.ldap1));
    passport.use('ldap2', new LdapStrategy(config.ldap2));
    apiRouter.use(passport.initialize());

    // route for authenticating users (POST /api/login)
    apiRouter.post('/login', function (req, res, next) {
        passport.authenticate(['ldap1', 'ldap2'], { session: false, userNotFound: 'Sorry, but we could not find that username.' }, function(err, user, info) {
            // code here
        })(req, res, next);
    });

// other routes here

    return apiRouter;
};

passport.use('ldap1', new LdapStrategy(opts1, function(user, done){ });
passport.use('ldap2', new LdapStrategy(opts2, function(user, done){ });

app.post('/login', passport.authenticate(['ldap1', 'ldap2']), function(req, res) { });

var jwt = require('jsonwebtoken');
var config = require('../../config');
var superSecret = config.secret;
var passport = require('passport');
var LdapStrategy = require('passport-ldapauth');

module.exports = function(app, express) {

    var apiRouter = express.Router();

    passport.use('ldap1', new LdapStrategy(config.ldap1));
    passport.use('ldap2', new LdapStrategy(config.ldap2));
    apiRouter.use(passport.initialize());

    // route for authenticating users (POST /api/login)
    apiRouter.post('/login', function (req, res, next) {
        passport.authenticate(['ldap1', 'ldap2'], { session: false, userNotFound: 'Sorry, but we could not find that username.' }, function(err, user, info) {
            var generateToken = function () {
                var token = jwt.sign({
                    name: user.name,
                    username: user.mailNickname
                    department: user.departmentName,
                    location: user.locationDesk
                    // more user info
                }, superSecret, {
                    expiresInMinutes: 1440 // 24 hours
                });

                // return the information including a token
                return res.json({
                    success: true,
                    message: 'User ' + user.name + ' authenticated successfully!',
                    token: token
                });
            };

            if (err)
                return next(err);

            if (!user) {
                var message = 'Invalid credentials'; // default message

                    for (var data of info) {
                        if (!!data) {
                            message = data.message;
                            break;
                        }
                    }

                return res.json({
                    success: false,
                    message: 'Authentication failed! ' + message + '.'
                });
            }

            if (user) {
                // check if you need to verify group membership (memberof), otherwise, just generate the token
                if (!!config.ldapgroup) {
                    if (!!user.memberOf) {
                        for (var group of user.memberOf) {
                            if (config.ldapgroup === group)
                                return generateToken();
                        }
                    }

                    // if no group membership or no match was found, return no access message
                    return res.json({
                        success: false,
                        message: 'We are sorry, but it seems that user ' + user.name + ' doesn\'t have access to this application.'
                    });
                }

                return generateToken();
            }
        })(req, res, next);
    });

// route middleware to verify a token
    apiRouter.use(function (req, res, next) {
        console.log('Somebody came to the app');

        // check header, url parameters or post parameters for token
        var token = req.body.token || req.params.token || req.headers['x-access-token'];

        // decode token
        if (token) {
            // verify secret and check expiration
            jwt.verify(token, superSecret, function (err, decoded) {
                if (err) {
                    return res.status(403).send({success: false, message: 'Failed to authenticate token!'});
                }
                else {
                    // if everything is good, save the request to be used by other routes
                    req.decoded = decoded;

                    next(); // allow the users to continue to the other routes
                }
            });
        }
        else {
            // if there is no token, return an HTTP response of 403 (forbidden) and an error message
            return res.status(403).send({success: false, message: 'No token provided.'});
        }
    });

// routes any authenticated user can access here

// api endpoint to get user information
    apiRouter.get('/me', function (req, res) {
        res.send(req.decoded);
    });

// route middleware to verify user can access the routes below
    apiRouter.use(function (req, res, next) {
        var userInfo = req.decoded

        // verify department example
        if (userInfo.department === config.departmentName) 
                    next(); // allow the users to continue to the other routes
        else
            return res.status(403).send({success: false, message: 'User not allowed access to the section.'});
    });

// user role protected routes here

    return apiRouter;
};

//config.js
var fs = require('fs');

module.exports = {
    'port': process.env.PORT || 8080,
    'env': process.env.ENV || 'develpment',
    'secret': 'mysupersecret',
    'ldap1': {
        server: {
            url: 'ldaps://server1.company.com',
            bindDn: 'my-binding-username',
            bindCredentials: 'my-binding-username-password',
            searchBase: 'dc=company,dc=com',
            searchFilter: '(sAMAccountName={{username}})',
            tlsOptions: {
                ca: [
                    fs.readFileSync(__dirname + '/certs/certificate-for-server1.cert')
                ]
            }
        }
    },
    'ldap2': {
        server: {
            url: 'ldaps://server2.company.com',
            bindDn: 'my-binding-username',
            bindCredentials: 'my-binding-username-password',
            searchBase: 'dc=company,dc=com',
            searchFilter: '(sAMAccountName={{username}})',
            tlsOptions: {
                ca: [
                    fs.readFileSync(__dirname + '/certs/certificate-for-server2.cert')
                ]
            }
        }
    },
    ldapgroup: 'group-to-compare-user-membership-in-verify-function'
};

//api.js
//...
apiRouter.post('/login', function (req, res, next) {
        passport.authenticate(['ldap1', 'ldap2'], { session: false, userNotFound: 'Sorry, but we could not find that username.' }, function(err, user, info) {
            console.log('user attributes:', user);
// var generate token = ...
    })(req, res, next);
}
//...

var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
//var passport = require('./auth.js');
var passport = require('passport');
var LdapStrategy = require('passport-ldapauth');
var ldapConfig = require('./ldapConfig');
var expressSession = require('express-session');
var flash = require('connect-flash');
var redis = require('redis');
var redisConfig = require('./redisClientConfig');
var redisClient = redis.createClient(redisConfig.port, redisConfig.host, redisConfig.options);
var RedisStore = require('connect-redis')(expressSession);

// configure routes
var routes = require('./routes/index');
var login = require('./routes/login');
var local = require('./routes/local');
var remote = require('./routes/remote');
var digma = require('./routes/digma');
var history = require('./routes/history');
var locations = require('./routes/locations');
var providers = require('./routes/providers');

var app = express();

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');

// uncomment after placing your favicon in /public
app.use(favicon(__dirname + '/public/favicon(5).ico'));
app.use(logger('dev'));

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

RedisStore.client = redisClient;
app.use(expressSession({ secret: 'aawwoivwfeoijkreroijlkqjlkjwqef',
                  resave: 'false',
                  saveUninitialized: 'false',
                  cookie: { maxAge: 3600000 * 12 },
                  unset: 'destroy',
                  store: new RedisStore({ttl:86400}),
}));
app.use(flash());

// Passport session setup.
//   To support persistent login sessions, Passport needs to be able to
//   serialize users into and deserialize users out of the session.  Typically,
//   this will be as simple as storing the user ID when serializing, and finding
//   the user by ID when deserializing.
passport.serializeUser(function(user, done) {
    console.log('serializeUser ' + user);
  done(null, user);
});

/*passport.deserializeUser(function(id, done) {
  User.findById(id, function(err, user) {
    done(null, user);
  });
});*/
passport.deserializeUser(function(user, done){
    console.log('deserializeUser ' + user);
    done(null,user);
});

passport.use('ldap1', new LdapStrategy(ldapConfig.ldap1),
    function(user, done) {
        return done(null, user);
    });
passport.use('ldap2', new LdapStrategy(ldapConfig.ldap2),
    function(user, done) {
        return done(null, user);
    });
// Initialize Passport!  Also use passport.session() middleware, to support
// persistent login sessions (recommended).
app.use(passport.initialize());
app.use(passport.session());

if (app.get('env') === 'production') {
  sess.cookie.secure = true; // serve secure cookies
}

app.post('/login', passport.authenticate(['ldap1', 'ldap2'], {session: true,
                                                              failureRedirect:'login',
                                                              failureFlash: 'Invalid user name or password.'}), function(req, res) {
    //console.log('req.session.redirect_to ' + req.session.redirect_to);
    var redirect_to = req.session.redirect_to ? req.session.redirect_to : '/';
    delete req.session.redirect_to;
    res.redirect(redirect_to);
    //res.redirect('/');
  //res.send({status: 'ok'});
});

app.use('/', routes);
app.use('/login', login);
app.use('/local', local);
app.use('/remote', remote);
app.use('/digma', digma);
app.use('/history', history);
app.use('/locations', locations);
app.use('/providers', providers);

/*
app.post('/login', function(req, res){
  res.json(req.body);
})*/

app.get('/logout', function(req, res){
  //req.session.destroy();
  req.logout();
  res.redirect('/login');
});

// error handlers

// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
  app.use(function(err, req, res, next) {
    res.status(err.status || 500);
    res.render('error', {
      message: err.message,
      error: err
    });
  });
}

// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
  res.status(err.status || 500);
  res.render('error', {
    message: err.message,
    error: {}
  });
});

// catch 404 and forward to error handler
app.use(function(req, res, next) {
  var err = new Error('Not Found');
  err.status = 404;
  next(err);
});

module.exports = app;

localStorage.removeItem(token); // token is the key that you used to store the token value