Autentificarea utilizatorului în NodeJS folosind Passport și MongoDB

Dacă doriți să protejați conținutul sensibil în aplicația dvs. Node, aveți nevoie de o modalitate de a autentifica utilizatorii. Cu toate acestea, construirea propriului sistem de autentificare este complexă și consumatoare de timp și, dacă nu este făcută corect, poate introduce vulnerabilități de securitate în aplicația dvs. Instrumentele terță parte precum Passport facilitează autentificarea.

În acest tutorial, veți învăța cum să implementați autentificarea în Node folosind Passport și MongoDB.

Ce sunt autentificarea și autorizarea?

În timp ce autentificarea și autorizarea sunt uneori folosite în mod interschimbabil, aceste două concepte de securitate au semnificații diferite. Autentificarea este procesul prin care se verifică că un utilizator este cine pretinde că este, în timp ce autorizarea este procesul de determinare dacă un utilizator autentificat are acces la anumite părți ale aplicației dvs.

Ce este Passport.js?

Passport.js (sau Passport) este un middleware de autentificare pentru NodeJS care oferă peste 500 de strategii pentru autentificarea utilizatorilor, inclusiv

pașaport-local care folosește un nume de utilizator și o parolă.

Acest tutorial folosește pașaport-local și pasaport-jwt pentru a asigura rutele.

Cum se configurează autentificarea utilizatorului în NodeJS

Acum că știți puțin despre autentificarea utilizatorilor și Passport.js, ne putem uita la cum să configurați autentificarea pe NodeJS. Mai jos, am subliniat pașii pe care va trebui să-i faceți.

Pasul 1: Configurați un server Node

Creați un folder numit user-auth-nodejs și navigați la el folosind terminalul dvs.

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

Apoi inițializați pachet.json.

npm init

Din moment ce vei folosi Expres, un cadru backend NodeJS, instalați-l rulând următoarea comandă.

npm exprim

Acum creați un fișier, app.jsși adăugați următorul cod pentru a crea serverul.

const express = require("express");
const app = expres();
const PORT = 3000;
app.listen (PORT, () => {
console.log(`Ascultare pe portul ${PORT}`);
});

Legate de: Aflați cum să instalați Npm și Node.js pe Ubuntu

Pasul 2: Configurați baza de date

Aveți nevoie de o bază de date pentru a stoca datele utilizatorului. Veți folosi mongoose pentru a crea o schemă de date MongoDB care definește structura și tipul de date pe care le veți stoca în baza de date. Deoarece stocați datele utilizatorului, creați o schemă de utilizator.

Instalați mangusta.

npm eu mangusta

Creați un fișier nou, userModel.js, și adăugați următoarele.

const mangusta = cere('mangusta')
const {Schema} = mangusta
const UserSchema = noua Schema ({
 e-mail: {
 tip: șir,
 cerut: adevărat
 },
 parola: {
 tip: șir,
 cerut: adevărat
 }
})
const UserModel = mongoose.model('utilizator', UserSchema);
module.exports = UserModel;

Legate de: Cum se creează o bază de date și o colecție în MongoDB

Înainte de a stoca parola, trebuie să o criptați din motive de securitate. Vei folosi bcryptjs, un pachet npm foarte util care facilitează lucrul cu parole criptate.

Instalare bcryptjs.

npm și bcryptjs

Modifica usermodel.js pentru a cripta parola înainte de a o salva în baza de date.

const mangusta = cere('mangusta')
const bcrypt = require('bcryptjs');
const {Schema} = mangusta
const UserSchema = noua Schema ({
...
})
UserSchema.pre('salvare', funcţie asincronă (în continuare) {
 încerca {
 // verifica metoda de inregistrare
 const user = this;
 if (!user.isModified('parola')) next();
 // generează sare
 const salt = await bcrypt.genSalt (10);
 // hash parola
 const hashedPassword = await bcrypt.hash (this.password, salt);
 // înlocuiți parola text simplu cu parola hashing
 this.parola = hashedPassword;
 Următorul();
 } captură (eroare) {
 return next (eroare);
 }
 });
...
const User = mongoose.model('Utilizator', UserSchema);

Aici folosești un pre salvare hook pentru a modifica parola înainte de a fi salvată. Ideea este de a stoca versiunea hash a parolei în loc de parola text simplu. Un hash este un șir lung și complex generat dintr-un șir de text simplu.

Utilizare esteModificat pentru a verifica dacă parola se schimbă, deoarece trebuie doar să codificați parole noi. Apoi, generați o sare și transmiteți-o cu parola text simplu la metoda hash pentru a genera parola hash. În cele din urmă, înlocuiți parola text simplu cu parola codificată în baza de date.

Creați db.js și configurați baza de date.

const mangusta = require("mangusta");
mangustă. Promisiune = global. Promisiune;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mangoose.connection;
 db.on(„eroare”, () => {
 console.log("nu s-a putut conecta");
 });
 db.once("deschis", () => {
 console.log("> Conectat cu succes la baza de date");
 });
};
module.exports = { conecta };

În app.js, conectați-vă la baza de date.

// se conectează la db
const db = require('./db');
db.connect();

Pasul 3: Configurați Passport

Instalare Pașaport și pașaport-local. Veți folosi aceste pachete pentru a vă înregistra și a vă autentifica utilizatorii.

npm i pașaport
npm i pasaport-local

Creați un fișier nou, passportConfig.js, și import pașaport-local si userModel.js.

const LocalStraregy = require("pașaport-local").Strategy;
const User = require("./userModel");

Configurați Passport pentru a gestiona înregistrarea utilizatorilor.

const LocalStrategy = require("pașaport-local");
const User = require("./userModel");
module.exports = (pașaport) => {
 pasaport.use(
 "înregistrare locală",
 noua Strategie Locală(
 {
 usernameField: „e-mail”,
 passwordField: „parolă”,
 },
 asincron (e-mail, parolă, terminat) => {
 încerca {
 // verifică dacă utilizatorul există
 const userExists = await User.findOne({ "email": email });
 if (userExists) {
 return done (null, false)
 }
 // Creați un utilizator nou cu datele utilizatorului furnizate
 const user = await User.create({ email, parola });
 return done (null, user);
 } captură (eroare) {
 terminat (eroare);
 }
 }
 )
 );
}

În codul de mai sus, verificați dacă e-mailul este deja utilizat. Dacă e-mailul nu există, înregistrați utilizatorul. Rețineți că setați, de asemenea, câmpul de nume de utilizator pentru a accepta un e-mail. În mod implicit, pașaport-local așteaptă un nume de utilizator, așa că trebuie să îi spuneți că trimiteți un e-mail.

Utilizare pașaport-local pentru a gestiona și autentificarea utilizatorului.

module.exports = (pașaport) => {
 pasaport.use(
 "înregistrare locală",
 noua strategie locala(
 ...
 )
 );
pasaport.use(
 "local-login",
 noua Strategie Locală(
 {
 usernameField: „e-mail”,
 passwordField: „parolă”,
 },
 asincron (e-mail, parolă, terminat) => {
 încerca {
 const user = await User.findOne({ email: email });
 if (!user) return done (null, false);
 const isMatch = await user.matchPassword (parola);
 dacă (! este Match)
 return done (null, false);
 // dacă parolele se potrivesc cu utilizatorul returnat
 return done (null, user);
 } captură (eroare) {
 console.log (eroare)
 return done (eroare, fals);
 }
 }
 )
 );
};

Aici, verificați dacă utilizatorul există în baza de date, iar dacă există, verificați dacă parola furnizată se potrivește cu cea din baza de date. Rețineți că apelați și la potriviParola() metoda pe modelul utilizatorului, deci accesați userModel.js fișier și adăugați-l.

UserSchema.methods.matchPassword = funcție asincronă (parolă) {
 încerca {
 return await bcrypt.compare (parolă, this.password);
 } captură (eroare) {
 throw new Error (eroare);
 }
};

Această metodă compară parola de la utilizator și cea din baza de date și returnează true dacă se potrivesc.

Pasul 4: Configurați rutele de autentificare

Acum trebuie să creați punctele finale către care utilizatorii vor trimite date. Mai întâi este ruta de înscriere care va accepta e-mailul și parola unui nou utilizator.

În app.js, utilizați middleware-ul de autentificare a pașaportului pe care tocmai l-ați creat pentru a înregistra utilizatorul.

app.post(

 „/auth/signup”,
 passport.authenticate('local-signup', {sesiune: fals }),
 (req, res, next) => {
 // Inscrie-te
 res.json({
 utilizator: req.user,
 });
 }
);

Legate de: Autentificare vs. Autorizare: Care este diferența?

Dacă reușește, ruta de înscriere ar trebui să returneze utilizatorul creat.

Apoi, creați ruta de conectare.

app.post(
 „/auth/login”,
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Autentificare
 res.json({
 utilizator: req.user,
 });
 }
);

Pasul 5: Adăugați rute protejate

Pana acum ai folosit Pașaport pentru a crea un middleware care înregistrează un utilizator în baza de date și altul care permite unui utilizator înregistrat să se conecteze. Apoi, veți crea un middleware de autorizare pentru a proteja rutele sensibile folosind un token web JSON (JWT). Pentru a implementa autorizarea JWT, trebuie să:

• Generați tokenul JWT.
• Transmiteți jetonul utilizatorului. Utilizatorul îl va trimite înapoi în cereri de autorizare.
• Verificați simbolul trimis înapoi de utilizator.

Veți folosi jsonwebtoken pachet pentru a gestiona JWT.

Rulați următoarea comandă pentru a o instala.

npm și jsonwebtoken

Apoi, generați un simbol pentru fiecare utilizator care se conectează cu succes.

În app.js, import jsonwebtoken și modificați ruta de conectare ca mai jos.

app.post(
 „/auth/login”,
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Autentificare
 jwt.sign({user: req.user}, 'secretKey', {expiresIn: '1h'}, (err, token) => {
 dacă (eră) {
 returnează res.json({
 mesaj: „Nu s-a putut conecta”,
 simbol: nul,
 });
 }
 res.json({
 jeton
 });
 })
 }
);

Într-o aplicație reală, ați folosi o cheie secretă mai complicată și ați stoca-o într-un fișier de configurare.

Ruta de conectare returnează un simbol dacă are succes.

Utilizare pasaport-jwt pentru a accesa rutele protejate.

npm i pasaport-jwt

În passportConfig.js, configurați pasaport-jwt.

const JwtStrategy = require("passport-jwt").Strategy;
const { ExtractJwt } = require("pașaport-jwt")
module.exports = (pașaport) => {
pasaport.use(
 "local-login",
 noua Strategie Locală(
 ...
 );
pasaport.use(
 noua JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader ("autorizare"),
 secretOrKey: "secretKey",
 },
 asincron (jwtPayload, terminat) => {
 încerca {
 // Extrage utilizatorul
 utilizator const = jwtPayload.user;
 terminat (null, utilizator);
 } captură (eroare) {
 făcut (eroare, fals);
 }
 }
 )
 );
};

Observați că extrageți JWT din antetul de autorizare în loc de corpul cererii. Acest lucru îi împiedică pe hackeri să intercepteze o solicitare și să preia jetonul.

Ca să vezi cum pasaport-jwt pazeste trasee, creeaza un traseu protejat in app.js.

app.get(
 „/utilizator/protejat”,
 passport.authenticate("jwt", { sesiune: fals }),
 (req, res, next) => {
 res.json({user: req.user});
 }
);

Doar o solicitare cu un JWT valid returnează datele utilizatorului.

Acum sunteți gata să vă duceți autentificarea utilizatorului la următorul nivel

În acest tutorial, ați învățat cum puteți autentifica utilizatorii folosind un e-mail și o parolă cu ajutorul lui Passport. Ar putea părea descurajantă la început, dar procesul este relativ simplu. Puteți merge și mai departe și puteți utiliza furnizori de identitate terți acceptați de Passport, cum ar fi Twitter, Facebook și Google.

Ce este autentificarea utilizatorului și cum funcționează?

Este important să înțelegeți elementele de bază ale autentificării utilizatorilor pentru a asigura nivelul maxim de securitate pentru conturile dvs. online. Deci, hai să ne scufundăm.

Citiți în continuare

Despre autor