authentication - example - bibliotecas de autenticación de usuario para node.js?
passport authenticate (12)
¿Hay bibliotecas de autenticación de usuario existentes para node.js? En particular, estoy buscando algo que pueda hacer la autenticación de contraseña para un usuario (usando una base de datos de autenticación backend personalizada) y asociar a ese usuario con una sesión.
Antes de escribir una biblioteca de autenticación, pensé que vería si la gente supiera de las bibliotecas existentes. No se pudo encontrar nada obvio a través de una búsqueda en Google.
-Shreyas
Sesión + si
Supongo que la razón por la que no ha encontrado muchas bibliotecas buenas es que el uso de una biblioteca para la autenticación está sobregrabado.
Lo que estás buscando es solo una carpeta de sesión :) Una sesión con:
if login and user == xxx and pwd == xxx
then store an authenticated=true into the session
if logout destroy session
Eso es.
No estoy de acuerdo con tu conclusión de que el plugin connect-auth es el camino a seguir.
También estoy usando connect pero no uso connect-auth por dos razones:
En mi humilde opinión se rompe connect-auth, la muy potente y fácil lectura de la arquitectura de cebolla en forma de anillo de connect. Un no-go - mi opinión :). Puede encontrar un artículo muy bueno y breve sobre cómo funciona Connect y la idea del anillo de cebolla here .
Si, como está escrito, solo desea utilizar un inicio de sesión http o básico con una base de datos o un archivo. Connect-auth es demasiado grande. Es más para cosas como OAuth 1.0, OAuth 2.0 y Co
Una autentificación muy sencilla con conexión.
(Está completo. Solo ejecútelo para realizar pruebas, pero si desea usarlo en producción, asegúrese de usar https) (Y para cumplir con los principios de REST, debe usar una solicitud POST en lugar de una solicitud GET b / c cambias de estado :)
var connect = require(''connect'');
var urlparser = require(''url'');
var authCheck = function (req, res, next) {
url = req.urlp = urlparser.parse(req.url, true);
// ####
// Logout
if ( url.pathname == "/logout" ) {
req.session.destroy();
}
// ####
// Is User already validated?
if (req.session && req.session.auth == true) {
next(); // stop here and pass to the next onion ring of connect
return;
}
// ########
// Auth - Replace this example with your Database, Auth-File or other things
// If Database, you need a Async callback...
if ( url.pathname == "/login" &&
url.query.name == "max" &&
url.query.pwd == "herewego" ) {
req.session.auth = true;
next();
return;
}
// ####
// This user is not authorized. Stop talking to him.
res.writeHead(403);
res.end(''Sorry you are not authorized./n/nFor a login use: /login?name=max&pwd=herewego'');
return;
}
var helloWorldContent = function (req, res, next) {
res.writeHead(200, { ''Content-Type'': ''text/plain'' });
res.end(''authorized. Walk around :) or use /logout to leave/n/nYou are currently at ''+req.urlp.pathname);
}
var server = connect.createServer(
connect.logger({ format: '':method :url'' }),
connect.cookieParser(),
connect.session({ secret: ''foobar'' }),
connect.bodyParser(),
authCheck,
helloWorldContent
);
server.listen(3000);
NOTA
Escribí esta declaración hace más de un año y actualmente no tengo proyectos de nodo activos. Así que puede haber cambios en la API en Express. Por favor agregue un comentario si debo cambiar algo.
Aquí hay dos bibliotecas Github populares para la autenticación del nodo js:
https://github.com/jaredhanson/passport (sugerible)
Aquí hay un código para la autenticación básica de uno de mis proyectos. Lo uso contra CouchDB con un caché de datos de autenticación adicional, pero eliminé ese código.
Envuelva un método de autenticación alrededor de su solicitud de manejo y proporcione una segunda devolución de llamada para la autenticación sin éxito. La devolución de llamada exitosa obtendrá el nombre de usuario como un parámetro adicional. No olvide manejar correctamente las solicitudes con credenciales incorrectas o faltantes en la devolución de llamada de error:
/**
* Authenticate a request against this authentication instance.
*
* @param request
* @param failureCallback
* @param successCallback
* @return
*/
Auth.prototype.authenticate = function(request, failureCallback, successCallback)
{
var requestUsername = "";
var requestPassword = "";
if (!request.headers[''authorization''])
{
failureCallback();
}
else
{
var auth = this._decodeBase64(request.headers[''authorization'']);
if (auth)
{
requestUsername = auth.username;
requestPassword = auth.password;
}
else
{
failureCallback();
}
}
//TODO: Query your database (don''t forget to do so async)
db.query( function(result)
{
if (result.username == requestUsername && result.password == requestPassword)
{
successCallback(requestUsername);
}
else
{
failureCallback();
}
});
};
/**
* Internal method for extracting username and password out of a Basic
* Authentication header field.
*
* @param headerValue
* @return
*/
Auth.prototype._decodeBase64 = function(headerValue)
{
var value;
if (value = headerValue.match("^Basic//s([A-Za-z0-9+/=]+)$"))
{
var auth = (new Buffer(value[1] || "", "base64")).toString("ascii");
return {
username : auth.slice(0, auth.indexOf('':'')),
password : auth.slice(auth.indexOf('':'') + 1, auth.length)
};
}
else
{
return null;
}
};
Aquí hay una nueva biblioteca de autenticación que usa tokens con marca de tiempo. Los tokens se pueden enviar por correo electrónico o enviar mensajes de texto a los usuarios sin la necesidad de almacenarlos en una base de datos. Se puede utilizar para la autenticación sin contraseña o para la autenticación de dos factores.
https://github.com/vote539/easy-no-password
Divulgación: Soy el desarrollador de esta biblioteca.
Básicamente estaba buscando lo mismo. Específicamente, quería lo siguiente:
- Para usar express.js, que envuelve la capacidad de middleware de Connect
- Autenticación "basada en formulario"
- Control granular sobre cuales rutas son autenticadas.
- Un back-end de base de datos para usuarios / contraseñas
- Sesiones de uso
Lo que terminé haciendo fue crear mi propia función de middleware check_auth que paso como argumento a cada ruta que quiero autenticar. check_auth simplemente verifica la sesión y si el usuario no ha iniciado sesión, luego los redirige a la página de inicio de sesión, de esta manera:
function check_auth(req, res, next) {
// if the user isn''t logged in, redirect them to a login page
if(!req.session.login) {
res.redirect("/login");
return; // the buck stops here... we do not call next(), because
// we don''t want to proceed; instead we want to show a login page
}
// the user is logged in, so call next()
next();
}
Luego, para cada ruta, me aseguro de que esta función se pase como middleware. Por ejemplo:
app.get(''/tasks'', check_auth, function(req, res) {
// snip
});
Finalmente, necesitamos manejar el proceso de inicio de sesión. Esto es sencillo:
app.get(''/login'', function(req, res) {
res.render("login", {layout:false});
});
app.post(''/login'', function(req, res) {
// here, I''m using mongoose.js to search for the user in mongodb
var user_query = UserModel.findOne({email:req.body.email}, function(err, user){
if(err) {
res.render("login", {layout:false, locals:{ error:err } });
return;
}
if(!user || user.password != req.body.password) {
res.render("login",
{layout:false,
locals:{ error:"Invalid login!", email:req.body.email }
}
);
} else {
// successful login; store the session info
req.session.login = req.body.email;
res.redirect("/");
}
});
});
En cualquier caso, este enfoque fue diseñado principalmente para ser flexible y simple. Estoy seguro de que hay muchas formas de mejorarlo. Si tiene alguno, me gustaría mucho su comentario.
EDITAR: Este es un ejemplo simplificado. En un sistema de producción, nunca querría almacenar y comparar contraseñas en texto plano. Como señala un comentarista, hay librerías que pueden ayudar a administrar la seguridad de la contraseña.
Ejemplo simple y rápido que usa mongo, para una API que proporciona autenticación de usuario para, por ejemplo, un cliente Angular
en app.js
var express = require(''express'');
var MongoStore = require(''connect-mongo'')(express);
// ...
app.use(express.cookieParser());
// obviously change db settings to suit
app.use(express.session({
secret: ''blah1234'',
store: new MongoStore({
db: ''dbname'',
host: ''localhost'',
port: 27017
})
}));
app.use(app.router);
Para tu ruta algo como esto:
// (mongo connection stuff)
exports.login = function(req, res) {
var email = req.body.email;
// use bcrypt in production for password hashing
var password = req.body.password;
db.collection(''users'', function(err, collection) {
collection.findOne({''email'': email, ''password'': password}, function(err, user) {
if (err) {
res.send(500);
} else {
if(user !== null) {
req.session.user = user;
res.send(200);
} else {
res.send(401);
}
}
});
});
};
Luego, en las rutas que requieren autenticación, puede verificar la sesión del usuario:
if (!req.session.user) {
res.send(403);
}
Han pasado algunos años y me gustaría presentar mi solución de autenticación para Express. Se llama Lockit . Puedes encontrar el proyecto en GitHub y una breve introducción en mi blog .
Entonces, ¿cuáles son las diferencias con las soluciones existentes?
- fácil de usar: configure su DB, npm install,
require(''lockit''),lockit(app), listo - rutas ya incorporadas (/ registro, / inicio de sesión, / contraseña olvidada, etc.)
- vistas ya integradas (basadas en Bootstrap pero puedes usar fácilmente tus propias vistas)
- admite la comunicación JSON para sus aplicaciones de página única AngularJS / Ember.js
- NO es compatible con OAuth y OpenID. Sólo
usernameypassword. - funciona con varias bases de datos (CouchDB, MongoDB, SQL) fuera de la caja
- tiene pruebas (no pude encontrar ninguna prueba para Drywall)
- se mantiene activamente (en comparación con todos)
- verificación de correo electrónico y proceso de contraseña olvidada (enviar correo electrónico con token, no es compatible con Passport)
- modularidad: usa solo lo que necesites
- Flexibilidad: personaliza todas las cosas.
Echa un vistazo a los examples .
Hay un proyecto llamado Drywall que implementa un sistema de inicio de sesión de usuario con Passport y también tiene un panel de administración de administración de usuarios. Si está buscando un sistema de administración y autenticación de usuarios con todas las funciones, similar a lo que Django tiene pero para Node.js, aquí está. Descubrí que era un muy buen punto de partida para construir una aplicación de nodo que requería un sistema de administración y autenticación de usuarios. Vea la respuesta de Jared Hanson para obtener información sobre cómo funciona Passport.
Parece que el complemento connect-auth para el middleware de conexión es exactamente lo que necesito: http://wiki.github.com/ciaranj/connect-auth/creating-a-form-based-strategy
Estoy usando Express [ http://expressjs.com ], por lo que el complemento de conexión se adapta muy bien ya que Express está subclasificado (ok - prototyped) de connect
Si está buscando un marco de autenticación para Connect o Express, vale la pena investigar Passport: https://github.com/jaredhanson/passport
(Divulgación: Soy el desarrollador de Passport)
Desarrollé Passport después de investigar tanto connect-auth como everyauth. Si bien ambos son grandes módulos, no se adaptaron a mis necesidades. Quería algo que fuera más ligero y discreto.
El pasaporte se divide en módulos separados, por lo que puede elegir usar solo lo que necesita (OAuth, solo si es necesario). Passport tampoco monta ninguna ruta en su aplicación, lo que le brinda la flexibilidad de decidir cuándo y dónde desea la autenticación, y los enlaces para controlar lo que sucede cuando la autenticación se realiza correctamente o no.
Por ejemplo, aquí está el proceso de dos pasos para configurar la autenticación basada en formulario (nombre de usuario y contraseña):
passport.use(new LocalStrategy(
function(username, password, done) {
// Find the user from your DB (MongoDB, CouchDB, other...)
User.findOne({ username: username, password: password }, function (err, user) {
done(err, user);
});
}
));
app.post(''/login'',
passport.authenticate(''local'', { failureRedirect: ''/login'' }),
function(req, res) {
// Authentication successful. Redirect home.
res.redirect(''/'');
});
Existen estrategias adicionales disponibles para la autenticación a través de Facebook, Twitter, etc. Se pueden insertar estrategias personalizadas, si es necesario.
También eche un vistazo a everyauth si desea la integración de inicio de sesión de terceros / redes sociales.
Una versión diferente de la autenticación es Passwordless, un módulo de autenticación basado en token para Express que evita el problema inherente de las contraseñas [1]. Es rápido de implementar, no requiere demasiados formularios y ofrece una mejor seguridad para el usuario promedio (revelación completa: soy el autor).
[1]: Las contraseñas son obsoletas