Autenticação do usuário no NodeJS usando Passport e MongoDB

Se você deseja proteger o conteúdo confidencial em seu aplicativo Node, você precisa de uma maneira de autenticar os usuários. No entanto, construir seu próprio sistema de autenticação é complexo e demorado e, se não for feito corretamente, pode introduzir vulnerabilidades de segurança em seu aplicativo. Ferramentas de terceiros, como o Passport, facilitam a autenticação.

Neste tutorial, você aprenderá como implementar a autenticação no Node usando o Passport e o MongoDB.

O que são autenticação e autorização?

Embora a autenticação e a autorização às vezes sejam usadas de forma intercambiável, esses dois conceitos de segurança têm significados diferentes. Autenticação é o processo de verificar se um usuário é quem ele afirma ser, enquanto a autorização é o processo de determinar se um usuário autenticado tem acesso a determinadas partes do seu aplicativo.

O que é o Passport.js?

Passaporte.js (ou Passport) é um middleware de autenticação para NodeJS que fornece mais de 500 estratégias para autenticar usuários, incluindo passaporte-local que usa um nome de usuário e senha.

Este tutorial usa passaporte-local e passaporte-jwt para garantir rotas.

Como configurar a autenticação do usuário no NodeJS

Agora que você conhece um pouco sobre autenticação de usuário e Passport.js, podemos ver como configurar a autenticação no NodeJS. Abaixo, descrevemos as etapas que você precisará seguir.

Etapa 1: configurar um servidor de nó

Crie uma pasta chamada user-auth-nodejs e navegue até ele usando seu terminal.

mkdir user-auth-nodejs. 
cd user-auth-nodejs

Próxima inicialização pacote.json.

npm init

Já que você vai usar Expressar, uma estrutura de back-end NodeJS, instale-a executando o comando a seguir.

npm eu expresso

Agora crie um arquivo, app.jse adicione o código a seguir para criar o servidor.

const expresso = require("expresso");
const app = express();
const PORTA = 3000;
app.listen (PORT, () => {
console.log(`Ouvindo na porta ${PORT}`);
});

Relacionado: Aprenda a instalar o Npm e o Node.js no Ubuntu

Etapa 2: configurar o banco de dados

Você precisa de um banco de dados para armazenar dados do usuário. Você usará o mongoose para criar um esquema de dados do MongoDB que define a estrutura e o tipo de dados que você armazenará no banco de dados. Como você está armazenando dados do usuário, crie um esquema de usuário.

Instale o mangusto.

npm eu mangusto

Crie um novo arquivo, userModel.jse adicione o seguinte.

const mangusto = require('mangusto')
const {Schema} = mangusto
const UserSchema = new Schema ({
 o email: {
 tipo: seqüência de caracteres,
 obrigatório: verdadeiro
 },
 senha: {
 tipo: seqüência de caracteres,
 obrigatório: verdadeiro
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = UserModel;

Relacionado: Como criar um banco de dados e uma coleção no MongoDB

Antes de armazenar a senha, você precisa criptografá-la para fins de segurança. Você vai usar bcryptjs, um pacote npm muito útil que facilita o trabalho com senhas criptografadas.

Instalar bcryptjs.

npm e bcryptjs

Modificar usermodel.js para criptografar a senha antes de salvá-la no banco de dados.

const mangusto = require('mangusto')
const bcrypt = require('bcryptjs');
const {Schema} = mangusto
const UserSchema = new Schema ({
...
})
UserSchema.pre('salvar', função assíncrona (próximo) {
 experimentar {
 //verifica a forma de cadastro
 const usuario = this;
 if (!user.isModified('password')) next();
 // gera sal
 const salt = espera bcrypt.genSalt (10);
 // hash a senha
 const hashedPassword = await bcrypt.hash (this.password, salt);
 // substitui a senha de texto simples por senha com hash
 this.password = hashSenha;
 Próximo();
 } pegar (erro) {
 retornar próximo (erro);
 }
 });
...
const Usuário = mongoose.model('Usuário', UserSchema);

Aqui você está usando um pré-salvar hook para modificar a senha antes de salvá-la. A ideia é armazenar a versão hash da senha em vez da senha de texto simples. Um hash é uma string complexa longa gerada a partir de uma string de texto simples.

Usar isModified para verificar se a senha está mudando, pois você só precisa fazer o hash de novas senhas. Em seguida, gere um salt e passe-o com a senha de texto simples para o método hash para gerar a senha com hash. Por fim, substitua a senha de texto simples pela senha com hash no banco de dados.

Crie db.js e configure o banco de dados.

const mangusto = require("mangusto");
mangusto. Promessa = global. Promessa;
const dbUrl = "mongodb://localhost/user";
const conectar = assíncrono () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mangusto.conexão;
 db.on("erro", () => {
 console.log("não foi possível conectar");
 });
 db.once("abrir", () => {
 console.log("> Conectado com sucesso ao banco de dados");
 });
};
module.exports = { conectar };

Em app.js, conecte-se ao banco de dados.

// conecta ao banco de dados
const db = require('./db');
db.connect();

Etapa 3: configurar o passaporte

Instalar Passaporte e passaporte-local. Você usará esses pacotes para registrar e fazer login de usuários.

passaporte npm
npm i passaporte-local

Crie um novo arquivo, passaporteConfig.js, e importar passaporte-local e a userModel.js.

const LocalEstratégia = require("passaporte-local").Estratégia;
const User = require("./userModel");

Configure o Passport para lidar com o registro do usuário.

const LocalStrategy = require("passport-local");
const User = require("./userModel");
module.exports = (passaporte) => {
 passaporte.use(
 "inscrição local",
 new LocalStrategy(
 {
 usernameField: "e-mail",
 passwordField: "senha",
 },
 async (e-mail, senha, feito) => {
 experimentar {
 //verifica se o usuário existe
 const userExists = await User.findOne({ "email": email });
 if (userExists) {
 retorno feito (nulo, falso)
 }
 // Cria um novo usuário com os dados do usuário fornecidos
 const user = await User.create({ email, password });
 retorno feito (nulo, usuário);
 } pegar (erro) {
 feito (erro);
 }
 }
 )
 );
}

No código acima, você está verificando se o e-mail já está em uso. Se o e-mail não existir, registre o usuário. Observe que você também está configurando o campo de nome de usuário para aceitar um e-mail. Por padrão, passaporte-local espera um nome de usuário, então você precisa informar que está enviando um e-mail.

Usar passaporte-local para também lidar com o login do usuário.

module.exports = (passaporte) => {
 passaporte.use(
 "inscrição local",
 new localStrategy(
 ...
 )
 );
passaporte.use(
 "login local",
 new LocalStrategy(
 {
 usernameField: "e-mail",
 passwordField: "senha",
 },
 async (e-mail, senha, feito) => {
 experimentar {
 const user = await User.findOne({ email: email });
 if (!user) return done (null, false);
 const isMatch = aguarde user.matchPassword (senha);
 if (!isCorrespondência)
 retorno feito (null, false);
 // se as senhas corresponderem retorna usuário
 retorno feito (nulo, usuário);
 } pegar (erro) {
 console.log (erro)
 retorno feito (erro, falso);
 }
 }
 )
 );
};

Aqui, verifique se o usuário existe no banco de dados e, se existir, verifique se a senha fornecida corresponde à do banco de dados. Observe que você também chama o matchPassword() método no modelo do usuário, então vá para userModel.js arquivo e adicione-o.

UserSchema.methods.matchPassword = função assíncrona (senha) {
 experimentar {
 return await bcrypt.compare (senha, this.password);
 } pegar (erro) {
 lançar novo Erro (erro);
 }
};

Este método compara a senha do usuário e a do banco de dados e retorna true se corresponderem.

Etapa 4: configurar rotas de autenticação

Agora você precisa criar os endpoints para os quais os usuários enviarão dados. Primeiro é a rota de inscrição que aceitará o e-mail e a senha de um novo usuário.

Dentro app.js, use o middleware de autenticação de passaporte que você acabou de criar para registrar o usuário.

app.post(

 "/auth/inscrição",
 passaporte.authenticate('local-signup', { session: false }),
 (req, res, próximo) => {
 // inscrever-se
 res.json({
 usuário: req.user,
 });
 }
);

Relacionado: Autenticação vs. Autorização: qual é a diferença?

Se for bem-sucedida, a rota de inscrição deve retornar o usuário criado.

Em seguida, crie a rota de login.

app.post(
 "/auth/login",
 passaporte.authenticate('local-login', { session: false }),
 (req, res, próximo) => {
 // Conecte-se
 res.json({
 usuário: req.user,
 });
 }
);

Etapa 5: adicionar rotas protegidas

Até agora, você usou Passaporte para criar um middleware que registre um usuário no banco de dados e outro que permita o login de um usuário registrado. Em seguida, você criará um middleware de autorização para proteger rotas confidenciais usando um token da Web JSON (JWT). Para implementar a autorização JWT, você precisa:

• Gerar token JWT.
• Passe o token para o usuário. O usuário irá enviá-lo de volta em solicitações de autorização.
• Verifique o token enviado de volta pelo usuário.

Você vai usar o jsonwebtoken pacote para lidar com JWTs.

Execute o seguinte comando para instalá-lo.

npm e jsonwebtoken

Em seguida, gere um token para cada usuário que fizer login com êxito.

Dentro app.js, importar jsonwebtoken e modifique a rota de login como abaixo.

app.post(
 "/auth/login",
 passaporte.authenticate('local-login', { session: false }),
 (req, res, próximo) => {
 // Conecte-se
 jwt.sign({usuário: req.user}, 'secretKey', {expiresIn: '1h'}, (err, token) => {
 se (erro) {
 return res.json({
 mensagem: "Falha ao logar",
 token: nulo,
 });
 }
 res.json({
 símbolo
 });
 })
 }
);

Em um aplicativo da vida real, você usaria uma chave secreta mais complicada e a armazenaria em um arquivo de configuração.

A rota de login retorna um token se for bem-sucedida.

Usar passaporte-jwt para acessar rotas protegidas.

npm i passaporte-jwt

Dentro passaporteConfig.js, configure o passaporte-jwt.

const JwtStrategy = require("passport-jwt").Strategy;
const { ExtractJwt } = require("passport-jwt")
module.exports = (passaporte) => {
passaporte.use(
 "login local",
 new LocalStrategy(
 ...
 );
passaporte.use(
 new JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("autorização"),
 secretOrKey: "secretKey",
 },
 assíncrono (jwtPayload, feito) => {
 experimentar {
 //Extrai usuário
 const usuário = jwtPayload.user;
 feito (nulo, usuário);
 } pegar (erro) {
 feito (erro, falso);
 }
 }
 )
 );
};

Observe que você está extraindo o JWT do cabeçalho de autorização em vez do corpo da solicitação. Isso evita que hackers interceptem uma solicitação e peguem o token.

Para ver como passaporte-jwt guarda rotas, crie uma rota protegida em app.js.

app.get(
 "/usuário/protegido",
 passaporte.authenticate("jwt", { session: false }),
 (req, res, próximo) => {
 res.json({usuário: req.usuário});
 }
);

Somente uma solicitação com um JWT válido retorna os dados do usuário.

Agora você está pronto para levar sua autenticação de usuário para o próximo nível

Neste tutorial, você aprendeu como autenticar usuários usando um email e uma senha com a ajuda do Passport. Pode parecer assustador no começo, mas o processo é relativamente simples. Você pode ir ainda mais longe e usar provedores de identidade de terceiros suportados pelo Passport, como Twitter, Facebook e Google.

O que é autenticação de usuário e como funciona?

É importante entender os fundamentos da autenticação do usuário para garantir o nível máximo de segurança para suas contas online. Então, vamos mergulhar.

Leia a seguir

Sobre o autor