Vartotojo autentifikavimas NodeJS naudojant Passport ir MongoDB

Jei norite apsaugoti slaptą turinį savo Node programoje, jums reikia būdo autentifikuoti vartotojus. Tačiau sukurti savo autentifikavimo sistemą yra sudėtinga ir daug laiko, o jei tai nebus padaryta tinkamai, jūsų programoje gali atsirasti saugumo spragų. Trečiųjų šalių įrankiai, tokie kaip „Passport“, palengvina autentifikavimą.

Šiame vadove sužinosite, kaip įdiegti autentifikavimą Node naudojant Passport ir MongoDB.

Kas yra autentifikavimas ir autorizavimas?

Nors autentifikavimas ir autorizavimas kartais naudojami pakaitomis, šios dvi saugos sąvokos turi skirtingas reikšmes. Autentifikavimas yra procesas, kurio metu patikrinama, ar vartotojas yra toks, koks jis teigia esąs, o įgaliojimas yra procesas, skirtas nustatyti, ar autentifikuotas vartotojas turi prieigą prie tam tikrų jūsų programos dalių.

Kas yra Passport.js?

Passport.js (arba Passport) yra NodeJS autentifikavimo tarpinė programinė įranga, teikianti daugiau nei 500 vartotojų autentifikavimo strategijų, įskaitant pasas-vietinis kuris naudoja vartotojo vardą ir slaptažodį.

Ši pamoka naudoja pasas-vietinis ir pasas-jwt maršrutams užtikrinti.

Kaip nustatyti vartotojo autentifikavimą „NodeJS“.

Dabar šiek tiek žinote apie vartotojo autentifikavimą ir Passport.js, galime pažvelgti, kaip nustatyti autentifikavimą NodeJS. Žemiau apibūdinome veiksmus, kuriuos turėsite atlikti.

1 veiksmas: nustatykite mazgo serverį

Sukurkite aplanką pavadinimu user-auth-nodejs ir eikite į jį naudodami savo terminalą.

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

Kitas inicijavimas package.json.

npm init

Kadangi jūs naudosite Express, NodeJS backend sistemą, įdiekite ją vykdydami šią komandą.

npm išreiškiu

Dabar sukurkite failą, app.jsir pridėkite šį kodą, kad sukurtumėte serverį.

const express = reikalauti("išreikšti");
const programa = express ();
const PORT = 3000;
app.listen (PORT, () => {
console.log(`Klausymas prievade ${PORT}`);
});

Susijęs: Sužinokite, kaip įdiegti Npm ir Node.js Ubuntu

2 veiksmas: nustatykite duomenų bazę

Vartotojo duomenims saugoti reikia duomenų bazės. Naudodami mongoose sukursite MongoDB duomenų schemą, kuri apibrėžia duomenų, kuriuos saugosite duomenų bazėje, struktūrą ir tipą. Kadangi saugote vartotojo duomenis, sukurkite vartotojo schemą.

Įdiekite mangustą.

npm aš mangutas

Sukurti naują failą, userModel.jsir pridėkite toliau nurodytus dalykus.

const mangustas = reikalauti ("mangustas")
const {Schema} = mangustas
const UserSchema = nauja schema ({
 paštas: {
 tipas: styga,
 privaloma: tiesa
 },
 Slaptažodis: {
 tipas: styga,
 privaloma: tiesa
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = UserModel;

Susijęs: Kaip sukurti duomenų bazę ir kolekciją MongoDB

Prieš išsaugodami slaptažodį, saugumo sumetimais turite jį užšifruoti. Jūs naudosite bcryptjs, labai naudingas npm paketas, palengvinantis darbą su užšifruotais slaptažodžiais.

Diegti bcryptjs.

npm ir bcryptjs

Modifikuoti usermodel.js užšifruoti slaptažodį prieš išsaugant jį duomenų bazėje.

const mangustas = reikalauti ("mangustas")
const bcrypt = reikalauti('bcryptjs');
const {Schema} = mangustas
const UserSchema = nauja schema ({
...
})
UserSchema.pre('išsaugoti', asinchronizavimo funkcija (next) {
 bandyti {
 // patikrinkite registracijos būdą
 const user = tai;
 if (!user.isModified('slaptažodis')) next();
 // generuoti druską
 const druska = laukti bcrypt.genSalt (10);
 // sumaišyti slaptažodį
 const hashedPassword = laukti bcrypt.hash (this.password, salt);
 // pakeisti paprasto teksto slaptažodį maišos slaptažodžiu
 this.password = maišytaSlaptažodis;
 Kitas();
 } sugauti (klaida) {
 grįžti toliau (klaida);
 }
 });
...
const Vartotojas = mongoose.model('Vartotojas', UserSchema);

Čia jūs naudojate a iš anksto išsaugoti kabliukas, kad pakeistumėte slaptažodį prieš jį išsaugant. Idėja yra saugoti slaptažodžio maišos versiją, o ne paprasto teksto slaptažodį. Maiša yra ilga sudėtinga eilutė, sugeneruota iš paprasto teksto eilutės.

Naudokite yra Modifikuota norėdami patikrinti, ar slaptažodis nesikeičia, nes reikia tik maišyti naujus slaptažodžius. Tada sugeneruokite druską ir perduokite ją su paprasto teksto slaptažodžiu maišos metodui, kad sukurtumėte maišos slaptažodį. Galiausiai pakeiskite paprasto teksto slaptažodį duomenų bazėje sumaišytu slaptažodžiu.

Sukurkite db.js ir sukonfigūruokite duomenų bazę.

const mongoose = reikalauti("monguzas");
mangustas. Pažadas = pasaulinis. Pažadas;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mongoose.connection;
 db.on("klaida", () => {
 console.log("nepavyko prisijungti");
 });
 db.once("atidaryti", () => {
 console.log("> Sėkmingai prisijungta prie duomenų bazės");
 });
};
module.exports = { prisijungti };

Programoje app.js prisijunkite prie duomenų bazės.

// prisijungti prie db
const db = reikalauti('./db');
db.connect();

3 veiksmas: nustatykite pasą

Diegti Pasas ir pasas-vietinis. Šiuos paketus naudosite naudotojams užsiregistruoti ir prisijungti.

npm ir pasas
npm i pasas-vietinis

Sukurti naują failą, passConfig.js, ir importuoti pasas-vietinis ir userModel.js.

const LocalStraregy = reikalauti("passport-local").Strategija;
const Vartotojas = reikalauti("./userModel");

Sukonfigūruokite Passport, kad galėtumėte tvarkyti vartotojo registraciją.

const LocalStrategy = reikalauti("pasas-vietinis");
const Vartotojas = reikalauti("./userModel");
module.exports = (pasas) => {
 pass.use(
 „vietinė registracija“,
 new LocalStrategy(
 {
 vartotojo vardasLaukas: "el. paštas",
 slaptažodžio laukas: "slaptažodis",
 },
 async (el. paštas, slaptažodis, padaryta) => {
 bandyti {
 // patikrinkite, ar yra vartotojas
 const userExists = laukti User.findOne({ "el. paštas": el. paštas });
 if (userExists) {
 grąžinimas atliktas (nulis, klaidingas)
 }
 // Sukurkite naują vartotoją su pateiktais vartotojo duomenimis
 const user = laukti User.create({ el. paštas, slaptažodis });
 grąžinimas atliktas (nulis, vartotojas);
 } sugauti (klaida) {
 padaryta (klaida);
 }
 }
 )
 );
}

Aukščiau pateiktame kode tikrinate, ar el. paštas jau naudojamas. Jei el. pašto adreso nėra, užregistruokite vartotoją. Atminkite, kad taip pat nustatote vartotojo vardo lauką, kad priimtumėte el. laišką. Pagal numatytuosius nustatymus pasas-vietinis tikisi vartotojo vardo, todėl turite pasakyti, kad siunčiate el. laišką.

Naudokite pasas-vietinis taip pat tvarkyti vartotojo prisijungimą.

module.exports = (pasas) => {
 pass.use(
 „vietinė registracija“,
 nauja vietinė strategija(
 ...
 )
 );
pass.use(
 „vietinis prisijungimas“,
 new LocalStrategy(
 {
 vartotojo vardasLaukas: "el. paštas",
 slaptažodžio laukas: "slaptažodis",
 },
 async (el. paštas, slaptažodis, padaryta) => {
 bandyti {
 const user = laukti User.findOne({ el. paštas: el. paštas });
 if (!user) return done (null, false);
 const isMatch = laukti vartotojo.matchPassword (slaptažodis);
 jei (!isMatch)
 grąžinimas atliktas (null, false);
 // jei slaptažodžiai atitinka grįžtamąjį vartotoją
 grąžinimas atliktas (nulis, vartotojas);
 } sugauti (klaida) {
 console.log (klaida)
 grąžinimas atliktas (klaida, klaidinga);
 }
 }
 )
 );
};

Čia patikrinkite, ar vartotojas egzistuoja duomenų bazėje, o jei yra, patikrinkite, ar pateiktas slaptažodis atitinka esantį duomenų bazėje. Atkreipkite dėmesį, kad taip pat skambinate matchPassword() metodas vartotojo modelyje, todėl eikite į userModel.js failą ir pridėkite.

UserSchema.methods.matchPassword = asinchroninė funkcija (slaptažodis) {
 bandyti {
 grįžti laukti bcrypt.palyginti (password, this.password);
 } sugauti (klaida) {
 mesti naują Klaida (klaida);
 }
};

Šis metodas palygina vartotojo slaptažodį su slaptažodžiu duomenų bazėje ir pateikia teisingą, jei jie sutampa.

4 veiksmas: nustatykite autentifikavimo maršrutus

Dabar turite sukurti galinius taškus, į kuriuos vartotojai siųs duomenis. Pirmiausia yra registracijos maršrutas, kuris priims naujo vartotojo el. paštą ir slaptažodį.

Į app.js, naudokite ką tik sukurtą paso autentifikavimo tarpinę programinę įrangą, kad užregistruotumėte vartotoją.

app.post(

 "/auth/registravimas",
 passport.authenticate('local-signup', { session: false }),
 (req, res, next) => {
 // Registruotis
 res.json({
 vartotojas: req.user,
 });
 }
);

Susijęs: Autentifikavimas vs. Autorizacija: koks skirtumas?

Jei pavyks, registracijos maršrutas turėtų grąžinti sukurtą vartotoją.

Tada sukurkite prisijungimo maršrutą.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Prisijungti
 res.json({
 vartotojas: req.user,
 });
 }
);

5 veiksmas: pridėkite apsaugotus maršrutus

Iki šiol naudojote Pasas sukurti tarpinę programinę įrangą, kuri registruoja vartotoją duomenų bazėje, ir kitą, leidžiančią registruotam vartotojui prisijungti. Tada sukursite autorizacijos tarpinę programinę įrangą, kad apsaugotumėte jautrius maršrutus naudodami JSON žiniatinklio prieigos raktą (JWT). Norėdami įdiegti JWT leidimą, turite:

• Sugeneruokite JWT prieigos raktą.
• Perduokite žetoną vartotojui. Vartotojas atsiųs jį atgal leidimo užklausose.
• Patikrinkite vartotojo atsiųstą prieigos raktą.

Jūs naudosite jsonwebtoken paketas JWT tvarkymui.

Paleiskite šią komandą, kad ją įdiegtumėte.

npm ir jsonwebtoken

Tada kiekvienam sėkmingai prisijungusiam vartotojui sugeneruokite prieigos raktą.

Į app.js, importuoti jsonwebtoken ir pakeiskite prisijungimo maršrutą, kaip nurodyta toliau.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Prisijungti
 jwt.sign({user: req.user}, 'secretKey', {expiresIn: '1h'}, (err, token) => {
 if (err) {
 return res.json({
 pranešimas: "Nepavyko prisijungti",
 tokenas: null,
 });
 }
 res.json({
 žetonu
 });
 })
 }
);

Realioje programoje turėtumėte naudoti sudėtingesnį slaptąjį raktą ir išsaugoti jį konfigūracijos faile.

Sėkmingai prisijungimo maršrutas grąžina prieigos raktą.

Naudokite pasas-jwt patekti į saugomus kelius.

npm ir pasas-jwt

Į passConfig.js, sukonfigūruokite pasas-jwt.

const JwtStrategy = reikalauti("pasas-jwt").Strategija;
const { ExtractJwt } = reikalauti("pasas-jwt")
module.exports = (pasas) => {
pass.use(
 „vietinis prisijungimas“,
 new LocalStrategy(
 ...
 );
pass.use(
 nauja JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("autorizacija"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, atlikta) => {
 bandyti {
 // Išskleisti vartotoją
 const user = jwtPayload.user;
 atlikta (nulinis, vartotojas);
 } sugauti (klaida) {
 padaryta (klaida, klaidinga);
 }
 }
 )
 );
};

Atkreipkite dėmesį, kad JWT ištraukiate iš prieigos teisės antraštės, o ne iš užklausos turinio. Tai neleidžia įsilaužėliams perimti užklausą ir patraukti žetoną.

Norėdami pamatyti, kaip pasas-jwt saugo maršrutus, sukurkite saugomą maršrutą app.js.

app.get(
 "/vartotojas/apsaugotas",
 passport.authenticate("jwt", { session: false }),
 (req, res, next) => {
 res.json({vartotojas: req.user});
 }
);

Tik užklausa su galiojančiu JWT grąžina vartotojo duomenis.

Dabar esate pasirengę perkelti naudotojo autentifikavimą į kitą lygį

Šioje pamokoje sužinojote, kaip galite autentifikuoti vartotojus naudodami el. pašto adresą ir slaptažodį naudodami Passport. Iš pradžių tai gali atrodyti bauginančiai, tačiau procesas yra gana paprastas. Galite eiti dar toliau ir naudoti trečiųjų šalių tapatybės teikėjus, palaikomus „Passport“, pvz., „Twitter“, „Facebook“ ir „Google“.

Kas yra vartotojo autentifikavimas ir kaip jis veikia?

Svarbu suprasti vartotojo autentifikavimo pagrindus, kad būtų užtikrintas maksimalus jūsų internetinių paskyrų saugumo lygis. Taigi, pasinerkime.

Skaitykite toliau

Apie autorių