Lietotāja autentifikācija pakalpojumā NodeJS, izmantojot Passport un MongoDB

Ja vēlaties aizsargāt sensitīvu saturu savā Node lietojumprogrammā, jums ir nepieciešams veids, kā autentificēt lietotājus. Tomēr savas autentifikācijas sistēmas izveide ir sarežģīta un laikietilpīga, un, ja tā netiek veikta pareizi, jūsu lietojumprogrammā var rasties drošības ievainojamības. Trešo pušu rīki, piemēram, Passport, atvieglo autentifikāciju.

Šajā apmācībā jūs uzzināsit, kā ieviest autentifikāciju Node, izmantojot Passport un MongoDB.

Kas ir autentifikācija un autorizācija?

Lai gan autentifikācija un autorizācija dažkārt tiek lietoti savstarpēji aizstājami, šiem diviem drošības jēdzieniem ir atšķirīga nozīme. Autentifikācija ir process, kurā tiek pārbaudīts, vai lietotājs ir tas, par ko viņš uzdodas, kamēr tiek veikta autorizācija process, lai noteiktu, vai autentificētam lietotājam ir piekļuve noteiktām jūsu lietojumprogrammas daļām.

Kas ir Passport.js?

Passport.js (vai Passport) ir NodeJS autentifikācijas starpprogrammatūra, kas nodrošina vairāk nekā 500 lietotāju autentifikācijas stratēģijas, tostarp pase-vietējais kas izmanto lietotājvārdu un paroli.

Šī apmācība izmanto pase-vietējais un pase-jwt lai nodrošinātu maršrutus.

Kā iestatīt lietotāja autentifikāciju pakalpojumā NodeJS

Tagad jūs zināt mazliet par lietotāja autentifikāciju un Passport.js, mēs varam apskatīt, kā iestatīt autentifikāciju vietnē NodeJS. Tālāk ir norādītas darbības, kas jums jāveic.

1. darbība: iestatiet mezgla serveri

Izveidojiet mapi ar nosaukumu user-auth-nodejs un dodieties uz to, izmantojot savu termināli.

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

Nākamā inicializācija pack.json.

npm init

Tā kā jūs izmantosit Express, NodeJS aizmugursistēmas sistēmu, instalējiet to, izpildot šo komandu.

npm es izsaku

Tagad izveidojiet failu, app.jsun pievienojiet šādu kodu, lai izveidotu serveri.

const izteikt = prasīt ("izteikt");
const app = express();
const PORT = 3000;
app.listen (PORT, () => {
console.log(`Klausās portā ${PORT}`);
});

Saistīts: Uzziniet, kā Ubuntu instalēt Npm un Node.js

2. darbība: iestatiet datu bāzi

Lai saglabātu lietotāja datus, ir nepieciešama datu bāze. Jūs izmantosiet mongoose, lai izveidotu MongoDB datu shēmu, kas nosaka datu bāzē glabājamo datu struktūru un veidu. Tā kā jūs glabājat lietotāja datus, izveidojiet lietotāja shēmu.

Uzstādiet mangustu.

npm es mangusts

Izveidojiet jaunu failu, userModel.jsun pievienojiet tālāk norādīto.

const mangusts = prasīt('mangusts')
const {Shēma} = mangusts
const UserSchema = jauna shēma ({
 e-pasts: {
 tips: virkne,
 nepieciešams: patiess
 },
 parole: {
 tips: virkne,
 nepieciešams: patiess
 }
})
const UserModel = mongoose.model('lietotājs', UserSchema);
module.exports = UserModel;

Saistīts: Kā izveidot datu bāzi un kolekciju MongoDB

Pirms paroles saglabāšanas drošības nolūkos tā ir jāšifrē. Jūs izmantosiet bcryptjs, ļoti noderīga npm pakotne, kas atvieglo darbu ar šifrētām parolēm.

Uzstādīt bcryptjs.

npm i bcryptjs

Modificēt usermodel.js lai šifrētu paroli pirms tās saglabāšanas datu bāzē.

const mangusts = prasīt('mangusts')
const bcrypt = prasīt('bcryptjs');
const {Shēma} = mangusts
const UserSchema = jauna shēma ({
...
})
UserSchema.pre('saglabāt', asinhronā funkcija (nākamā) {
 mēģināt {
 // pārbaudiet reģistrācijas metodi
 const lietotājs = šis;
 if (!lietotājs.isModified('parole')) next();
 // radīt sāli
 const salt = gaidiet bcrypt.genSalt (10);
 // jaukta parole
 const hashedPassword = gaidīt bcrypt.hash (this.password, salt);
 // aizstāt vienkārša teksta paroli ar jauktu paroli
 this.password = jauktaParole;
 Nākamais();
 } nozveja (kļūda) {
 atgriezties nākamais (kļūda);
 }
 });
...
const Lietotājs = mongoose.model('Lietotājs', UserSchema);

Šeit jūs izmantojat a iepriekš saglabāt āķis, lai mainītu paroli pirms tās saglabāšanas. Ideja ir saglabāt paroles jaucējversiju, nevis vienkārša teksta paroli. Hash ir gara sarežģīta virkne, kas ģenerēta no vienkārša teksta virknes.

Izmantot ir Modificēts lai pārbaudītu, vai parole tiek mainīta, jo jums ir tikai jājauc jaunas paroles. Pēc tam ģenerējiet sāli un nosūtiet to ar vienkāršā teksta paroli jaukšanas metodei, lai ģenerētu jaukto paroli. Visbeidzot datubāzē nomainiet vienkāršā teksta paroli ar jaukto paroli.

Izveidojiet db.js un konfigurējiet datu bāzi.

const mangusts = prasīt("mangusts");
mangusts. Solījums = globāls. Solījums;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mangusts.savienojums;
 db.on("kļūda", () => {
 console.log("nevarēja izveidot savienojumu");
 });
 db.once("atvērt", () => {
 console.log("> Veiksmīgi savienots ar datu bāzi");
 });
};
module.exports = {savienot};

Programmā app.js izveidojiet savienojumu ar datu bāzi.

// izveidot savienojumu ar db
const db = prasīt('./db');
db.connect();

3. darbība: iestatiet pasi

Uzstādīt Pase un pase-vietējais. Jūs izmantosit šīs pakotnes, lai reģistrētos un pieteiktos lietotāji.

npm i pase
npm i pase-vietējais

Izveidojiet jaunu failu, passConfig.jsun importēt pase-vietējais un userModel.js.

const LocalStraregy = prasīt("pase-local").Stratēģija;
const Lietotājs = prasīt("./lietotājaModelis");

Konfigurējiet Passport, lai apstrādātu lietotāja reģistrāciju.

const LocalStrategy = prasīt("passe-local");
const Lietotājs = prasīt("./lietotājaModelis");
module.exports = (pase) => {
 pass.use(
 "vietējā pierakstīšanās",
 new LocalStrategy(
 {
 lietotājvārdsLauks: "e-pasts",
 paroleLauks: "parole",
 },
 async (e-pasts, parole, gatavs) => {
 mēģināt {
 // pārbaudiet, vai lietotājs pastāv
 const userExists = gaidīt User.findOne({ "e-pasts": e-pasts });
 if (userExists) {
 atgriešana pabeigta (nulle, nepatiesa)
 }
 // Izveidojiet jaunu lietotāju ar norādītajiem lietotāja datiem
 const user = gaidīt User.create({ e-pasts, parole });
 atgriešana darīta (nulle, lietotājs);
 } nozveja (kļūda) {
 darīts (kļūda);
 }
 }
 )
 );
}

Iepriekš minētajā kodā jūs pārbaudāt, vai e-pasts jau tiek izmantots. Ja e-pasts neeksistē, reģistrējiet lietotāju. Ņemiet vērā, ka jūs iestatāt arī lietotājvārda lauku, lai pieņemtu e-pastu. Pēc noklusējuma, pase-vietējais sagaida lietotājvārdu, tāpēc jums tas ir jāpasaka, ka nosūtāt e-pastu.

Izmantot pase-vietējais lai apstrādātu arī lietotāja pieteikšanos.

module.exports = (pase) => {
 pass.use(
 "vietējā pierakstīšanās",
 new localStrategy(
 ...
 )
 );
pass.use(
 "lokālā pieteikšanās",
 new LocalStrategy(
 {
 lietotājvārdsLauks: "e-pasts",
 paroleLauks: "parole",
 },
 async (e-pasts, parole, gatavs) => {
 mēģināt {
 const user = gaidiet User.findOne({ e-pasts: e-pasts });
 if (!user) return done (null, false);
 const isMatch = gaidīt user.matchPassword (parole);
 ja (!isMatch)
 atgriešana darīta (nulle, false);
 // ja paroles atbilst atgriezties lietotājam
 atgriešana darīta (nulle, lietotājs);
 } nozveja (kļūda) {
 console.log (kļūda)
 atgriešana izdarīta (kļūda, nepatiesa);
 }
 }
 )
 );
};

Šeit pārbaudiet, vai lietotājs pastāv datu bāzē, un, ja pastāv, pārbaudiet, vai norādītā parole atbilst datu bāzē esošajai. Ņemiet vērā, ka jūs arī zvanāt uz atbilstPassword() metode lietotāja modelī, tāpēc dodieties uz userModel.js failu un pievienojiet to.

UserSchema.methods.matchPassword = asinhronā funkcija (parole) {
 mēģināt {
 atgriezties gaida bcrypt.compare (parole, this.password);
 } nozveja (kļūda) {
 mest jaunu Kļūda (kļūda);
 }
};

Šī metode salīdzina lietotāja paroli un datu bāzē esošo paroli un atgriež patieso, ja tās sakrīt.

4. darbība: iestatiet autentifikācijas maršrutus

Tagad jums ir jāizveido galapunkti, uz kuriem lietotāji sūtīs datus. Vispirms ir reģistrēšanās maršruts, kas pieņems jauna lietotāja e-pastu un paroli.

In app.js, izmantojiet tikko izveidoto pases autentifikācijas starpprogrammatūru, lai reģistrētu lietotāju.

app.post(

 "/auth/signup",
 passport.authenticate('local-signup', { session: false }),
 (req, res, next) => {
 // Pierakstīties
 res.json({
 lietotājs: req.user,
 });
 }
);

Saistīts: Autentifikācija vs. Autorizācija: kāda ir atšķirība?

Ja tas izdodas, pierakstīšanās maršrutam ir jāatgriež izveidotais lietotājs.

Pēc tam izveidojiet pieteikšanās maršrutu.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Pieslēgties
 res.json({
 lietotājs: req.user,
 });
 }
);

5. darbība. Pievienojiet aizsargātos maršrutus

Līdz šim esat izmantojis Pase izveidot starpprogrammatūru, kas reģistrē lietotāju datu bāzē, un citu, kas ļauj reģistrētam lietotājam pierakstīties. Pēc tam izveidosit autorizācijas starpprogrammatūru, lai aizsargātu sensitīvus maršrutus, izmantojot JSON tīmekļa pilnvaru (JWT). Lai ieviestu JWT autorizāciju, jums ir nepieciešams:

• Ģenerējiet JWT marķieri.
• Nododiet marķieri lietotājam. Lietotājs to nosūtīs atpakaļ autorizācijas pieprasījumos.
• Pārbaudiet lietotāja nosūtīto pilnvaru.

Jūs izmantosiet jsonwebtoken paketi JWT apstrādei.

Lai to instalētu, palaidiet šo komandu.

npm i jsonwebtoken

Pēc tam ģenerējiet marķieri katram lietotājam, kurš veiksmīgi piesakās.

In app.js, imports jsonwebtoken un mainiet pieteikšanās maršrutu, kā norādīts tālāk.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Pieslēgties
 jwt.sign({lietotājs: req.user}, 'secretKey', {expiresIn: '1h'}, (err, token) => {
 if (err) {
 return res.json({
 ziņojums: "Neizdevās pieteikties",
 marķieris: null,
 });
 }
 res.json({
 žetons
 });
 })
 }
);

Reālajā dzīvē jūs izmantotu sarežģītāku slepeno atslēgu un saglabātu to konfigurācijas failā.

Pieteikšanās maršruts atgriež marķieri, ja tas ir veiksmīgs.

Izmantot pase-jwt piekļūt aizsargātajiem ceļiem.

npm i pase-jwt

In passConfig.js, konfigurējiet pase-jwt.

const JwtStrategy = prasīt("pase-jwt").Stratēģija;
const { ExtractJwt } = prasīt("passe-jwt")
module.exports = (pase) => {
pass.use(
 "lokālā pieteikšanās",
 new LocalStrategy(
 ...
 );
pass.use(
 jauna JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("autorizācija"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, gatavs) => {
 mēģināt {
 // Izvilkt lietotāju
 const lietotājs = jwtPayload.user;
 darīts (nulle, lietotājs);
 } nozveja (kļūda) {
 darīts (kļūda, nepatiess);
 }
 }
 )
 );
};

Ievērojiet, ka JWT izņemat no autorizācijas galvenes, nevis pieprasījuma pamatteksta. Tas neļauj hakeriem pārtvert pieprasījumu un satvert marķieri.

Lai redzētu, kā pase-jwt apsargā maršrutus, izveidot aizsargātu maršrutu iekšā app.js.

app.get(
 "/lietotājs/aizsargāts",
 passport.authenticate("jwt", { session: false }),
 (req, res, next) => {
 res.json({lietotājs: req.user});
 }
);

Tikai pieprasījums ar derīgu JWT atgriež lietotāja datus.

Tagad esat gatavs pacelt savu lietotāja autentifikāciju uz nākamo līmeni

Šajā apmācībā jūs uzzinājāt, kā ar Passport palīdzību var autentificēt lietotājus, izmantojot e-pastu un paroli. Sākumā tas varētu šķist biedējoši, taču process ir samērā vienkāršs. Varat iet vēl tālāk un izmantot trešās puses identitātes nodrošinātājus, ko atbalsta Passport, piemēram, Twitter, Facebook un Google.

Kas ir lietotāja autentifikācija un kā tā darbojas?

Ir svarīgi izprast lietotāju autentifikācijas pamatus, lai nodrošinātu maksimālu drošības līmeni jūsu tiešsaistes kontiem. Tātad, ienirt.

Lasiet Tālāk

Par autoru