Autenticación de usuarios en NodeJS usando Passport y MongoDB

Si desea proteger el contenido confidencial en su aplicación Node, necesita una forma de autenticar a los usuarios. Sin embargo, construir su propio sistema de autenticación es complejo y requiere mucho tiempo y, si no se hace correctamente, puede introducir vulnerabilidades de seguridad en su aplicación. Las herramientas de terceros como Passport facilitan la autenticación.

En este tutorial, aprenderá cómo implementar la autenticación en Node utilizando Passport y MongoDB.

¿Qué son la autenticación y la autorización?

Si bien la autenticación y la autorización a veces se usan indistintamente, estos dos conceptos de seguridad tienen significados diferentes. La autenticación es el proceso de verificar que un usuario es quien dice ser, mientras que la autorización es el proceso de determinar si un usuario autenticado tiene acceso a ciertas partes de su aplicación.

¿Qué es Passport.js?

Pasaporte.js (o Passport) es un middleware de autenticación para NodeJS que proporciona más de 500 estrategias para autenticar a los usuarios, incluidas

pasaporte-local que utiliza un nombre de usuario y una contraseña.

Este tutorial utiliza pasaporte-local y pasaporte-jwt para asegurar las rutas.

Cómo configurar la autenticación de usuario en NodeJS

Ahora que sabe un poco sobre la autenticación de usuarios y Passport.js, podemos ver cómo configurar la autenticación en NodeJS. A continuación, describimos los pasos que deberá seguir.

Paso 1: configurar un servidor de nodo

Crear una carpeta llamada usuario-auth-nodejs y navegue hasta él usando su terminal.

mkdir usuario-auth-nodejs. 
cd usuario-auth-nodejs

Siguiente inicializar paquete.json.

inicio npm

Ya que estarás usando Rápido, un marco de back-end de NodeJS, instálelo ejecutando el siguiente comando.

npm expreso

Ahora crea un archivo, aplicación.jsy agregue el siguiente código para crear el servidor.

const expreso = require("expreso");
const aplicación = express();
constante PUERTO = 3000;
app.escuchar (PORT, () => {
console.log(`Escuchando en el puerto ${PORT}`);
});

Relacionados: Aprenda a instalar Npm y Node.js en Ubuntu

Paso 2: configurar la base de datos

Necesita una base de datos para almacenar datos de usuario. Utilizará mongoose para crear un esquema de datos MongoDB que defina la estructura y el tipo de datos que almacenará en la base de datos. Dado que está almacenando datos de usuario, cree un esquema de usuario.

Instalar mangosta.

npm yo mangosta

Crear un nuevo archivo, modelo de usuario.jsy agregue lo siguiente.

const mangosta = require('mangosta')
const {Esquema} = mangosta
const UserSchema = nuevo esquema ({
 Email: {
 tipo: Cadena,
 requerido: cierto
 },
 clave: {
 tipo: Cadena,
 requerido: cierto
 }
})
const UserModel = mongoose.model('usuario', UserSchema);
módulo.exportaciones = Modelo de usuario;

Relacionados: Cómo crear una base de datos y una colección en MongoDB

Antes de almacenar la contraseña, debe cifrarla por motivos de seguridad. Usarás bcryptjs, un paquete npm muy útil que facilita el trabajo con contraseñas cifradas.

Instalar en pc bcryptjs.

npm y bcryptjs

Modificar modelo de usuario.js para cifrar la contraseña antes de guardarla en la base de datos.

const mangosta = require('mangosta')
const bcrypt = require('bcryptjs');
const {Esquema} = mangosta
const UserSchema = nuevo esquema ({
...
})
UserSchema.pre('guardar', función asíncrona (siguiente) {
 tratar {
 // comprobar el método de registro
 const usuario = esto;
 if (!usuario.isModified('contraseña')) next();
 // generar sal
 sal const = esperar bcrypt.genSalt (10);
 // hash la contraseña
 const hashPassword = await bcrypt.hash (this.password, salt);
 // reemplaza la contraseña de texto sin formato con contraseña hash
 this.contraseña = hashPassword;
 próximo();
 } atrapar (error) {
 volver siguiente (error);
 }
 });
...
const Usuario = mongoose.model('Usuario', UserSchema);

Aquí estás usando un antes de guardar hook para modificar la contraseña antes de guardarla. La idea es almacenar la versión hash de la contraseña en lugar de la contraseña de texto sin formato. Un hash es una cadena larga y compleja generada a partir de una cadena de texto sin formato.

Utilizar es modificado para verificar si la contraseña está cambiando, ya que solo necesita codificar nuevas contraseñas. A continuación, genere un salt y páselo con la contraseña de texto sin formato al método hash para generar la contraseña hash. Finalmente, reemplace la contraseña de texto sin formato con la contraseña codificada en la base de datos.

Cree db.js y configure la base de datos.

const mangosta = require("mangosta");
mangosta. Promesa = mundial. Promesa;
const dbUrl = "mongodb://localhost/usuario";
const conectar = asíncrono () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mangosta.conexión;
 db.on("error", () => {
 console.log("no se pudo conectar");
 });
 db.once("abrir", () => {
 console.log("> Conexión exitosa a la base de datos");
 });
};
módulo.exportaciones = {conectar};

En app.js, conéctese a la base de datos.

// conectar a la base de datos
const db = require('./db');
db.conectar();

Paso 3: configurar el pasaporte

Instalar en pc Pasaporte y pasaporte-local. Utilizará estos paquetes para registrar e iniciar sesión de usuarios.

npm i pasaporte
npm i pasaporte-local

Crear un nuevo archivo, pasaporteConfig.jse importar pasaporte-local y el modelo de usuario.js.

const LocalStraregy = require("passport-local").Strategy;
const Usuario = require("./userModel");

Configure Passport para gestionar el registro de usuarios.

const LocalStrategy = require("pasaporte-local");
const Usuario = require("./userModel");
módulo.exportaciones = (pasaporte) => {
 pasaporte.use(
 "inscripción local",
 nueva estrategia local (
 {
 campo de nombre de usuario: "correo electrónico",
 campo de contraseña: "contraseña",
 },
 asíncrono (correo electrónico, contraseña, listo) => {
 tratar {
 // comprobar si el usuario existe
 const userExists = await User.findOne({ "correo electrónico": correo electrónico });
 si (el usuario existe) {
 retorno hecho (nulo, falso)
 }
 // Crear un nuevo usuario con los datos de usuario proporcionados
 const usuario = await User.create({correo electrónico, contraseña});
 retorno hecho (nulo, usuario);
 } atrapar (error) {
 hecho (error);
 }
 }
 )
 );
}

En el código anterior, está comprobando si el correo electrónico ya está en uso. Si el correo electrónico no existe, registre al usuario. Tenga en cuenta que también está configurando el campo de nombre de usuario para aceptar un correo electrónico. Por defecto, pasaporte-local espera un nombre de usuario, por lo que debe decirle que está pasando un correo electrónico en su lugar.

Utilizar pasaporte-local para manejar también el inicio de sesión del usuario.

módulo.exportaciones = (pasaporte) => {
 pasaporte.use(
 "inscripción local",
 nueva estrategia local (
 ...
 )
 );
pasaporte.use(
 "inicio de sesión local",
 nueva estrategia local (
 {
 campo de nombre de usuario: "correo electrónico",
 campo de contraseña: "contraseña",
 },
 asíncrono (correo electrónico, contraseña, listo) => {
 tratar {
 const usuario = espera Usuario.findOne({correo electrónico: correo electrónico});
 if (!usuario) devuelve hecho (nulo, falso);
 const isMatch = espera usuario.matchPassword (contraseña);
 si (! es Coincidencia)
 retorno hecho (nulo, falso);
 // si las contraseñas coinciden, devuelve el usuario
 retorno hecho (nulo, usuario);
 } atrapar (error) {
 consola.log (error)
 retorno hecho (error, falso);
 }
 }
 )
 );
};

Aquí, verifique si el usuario existe en la base de datos y, si existe, verifique si la contraseña proporcionada coincide con la de la base de datos. Tenga en cuenta que también llama al Contraseña de coincidencia () método en el modelo de usuario, así que vaya a modelo de usuario.js archivo y agregarlo.

UserSchema.methods.matchPassword = función asíncrona (contraseña) {
 tratar {
 return await bcrypt.compare (contraseña, this.password);
 } atrapar (error) {
 lanzar un nuevo error (error);
 }
};

Este método compara la contraseña del usuario y la de la base de datos y devuelve verdadero si coinciden.

Paso 4: configurar rutas de autenticación

Ahora debe crear los puntos finales a los que los usuarios enviarán datos. Primero está la ruta de registro que aceptará el correo electrónico y la contraseña de un nuevo usuario.

En aplicación.js, use el middleware de autenticación de pasaporte que acaba de crear para registrar al usuario.

aplicación.post(

 "/autorización/registro",
 pasaporte.authenticate('registro local', { sesión: falso }),
 (requerido, res, siguiente) => {
 // inscribirse
 res.json({
 usuario: req.usuario,
 });
 }
);

Relacionados: Autenticación frente a Autorización: ¿Cuál es la diferencia?

Si tiene éxito, la ruta de registro debe devolver el usuario creado.

A continuación, cree la ruta de inicio de sesión.

aplicación.post(
 "/autenticación/iniciar sesión",
 pasaporte.authenticate('inicio de sesión local', { sesión: falso }),
 (requerido, res, siguiente) => {
 // acceso
 res.json({
 usuario: req.usuario,
 });
 }
);

Paso 5: Agregar rutas protegidas

Hasta ahora, has usado Pasaporte para crear un middleware que registre a un usuario en la base de datos y otro que permita iniciar sesión a un usuario registrado. A continuación, creará un middleware de autorización para proteger las rutas confidenciales mediante un token web JSON (JWT). Para implementar la autorización JWT, debe:

• Genera token JWT.
• Pase el token al usuario. El usuario lo devolverá en solicitudes de autorización.
• Verifique el token devuelto por el usuario.

Usarás el jsonwebtoken paquete para manejar JWT.

Ejecute el siguiente comando para instalarlo.

npm y jsonwebtoken

A continuación, genere un token para cada usuario que inicie sesión correctamente.

En aplicación.js, importar jsonwebtoken y modifique la ruta de inicio de sesión como se muestra a continuación.

aplicación.post(
 "/autenticación/iniciar sesión",
 pasaporte.authenticate('inicio de sesión local', { sesión: falso }),
 (requerido, res, siguiente) => {
 // acceso
 jwt.sign({usuario: req.user}, 'secretKey', {expiresIn: '1h'}, (err, token) => {
 si (err) {
 devuelve res.json({
 mensaje: "Error al iniciar sesión",
 token: nulo,
 });
 }
 res.json({
 simbólico
 });
 })
 }
);

En una aplicación de la vida real, usaría una clave secreta más complicada y la almacenaría en un archivo de configuración.

La ruta de inicio de sesión devuelve un token si tiene éxito.

Utilizar pasaporte-jwt para acceder a rutas protegidas.

npm i pasaporte-jwt

En pasaporteConfig.js, configurar el pasaporte-jwt.

const JwtStrategy = require("passport-jwt").Strategy;
const {ExtractJwt} = require("pasaporte-jwt")
módulo.exportaciones = (pasaporte) => {
pasaporte.use(
 "inicio de sesión local",
 nueva estrategia local (
 ...
 );
pasaporte.use(
 nueva estrategia Jwt(
 {
 jwtFromRequest: ExtractJwt.fromHeader("autorización"),
 secretoOrClave: "clavesecreta",
 },
 asíncrono (jwtPayload, hecho) => {
 tratar {
 // Extraer usuario
 const usuario = jwtPayload.user;
 hecho (nulo, usuario);
 } atrapar (error) {
 hecho (error, falso);
 }
 }
 )
 );
};

Observe que está extrayendo el JWT del encabezado de autorización en lugar del cuerpo de la solicitud. Esto evita que los piratas informáticos intercepten una solicitud y obtengan el token.

Para ver como pasaporte-jwt rutas de guardias, crear una ruta protegida en aplicación.js.

aplicación.obtener(
 "/usuario/protegido",
 pasaporte.authenticate("jwt", { sesión: falso }),
 (requerido, res, siguiente) => {
 res.json({usuario: req.usuario});
 }
);

Solo una solicitud con un JWT válido devuelve los datos del usuario.

Ahora está listo para llevar su autenticación de usuario al siguiente nivel

En este tutorial, aprendió cómo puede autenticar a los usuarios mediante un correo electrónico y una contraseña con la ayuda de Passport. Puede parecer abrumador al principio, pero el proceso es relativamente sencillo. Puede ir aún más lejos y utilizar proveedores de identidad de terceros compatibles con Passport, como Twitter, Facebook y Google.

¿Qué es la autenticación de usuario y cómo funciona?

Es importante comprender los conceptos básicos de la autenticación de usuarios para garantizar el máximo nivel de seguridad para sus cuentas en línea. Entonces, vamos a sumergirnos.

Leer siguiente

Sobre el Autor