Kasutaja autentimine NodeJS-is Passporti ja MongoDB abil

Kui soovite oma Node'i rakenduses tundlikku sisu kaitsta, vajate kasutajate autentimise viisi. Ent oma autentimissüsteemi loomine on keeruline ja aeganõudev ning kui seda ei tehta õigesti, võib see teie rakenduses tekitada turvaauke. Kolmandate osapoolte tööriistad, nagu Passport, muudavad autentimise lihtsamaks.

Sellest õpetusest saate teada, kuidas Passporti ja MongoDB abil Node'is autentimist rakendada.

Mis on autentimine ja autoriseerimine?

Kuigi autentimist ja autoriseerimist kasutatakse mõnikord sünonüümidena, on neil kahel turbekontseptsioonil erinev tähendus. Autentimine on protsess, mille käigus kontrollitakse, et kasutaja on see, kes ta väidab end olevat, samas kui autoriseerimine on protsess, mille käigus tehakse kindlaks, kas autentitud kasutajal on juurdepääs teie rakenduse teatud osadele.

Mis on Passport.js?

Passport.js (või Passport) on NodeJS-i autentimise vahevara, mis pakub kasutajate autentimiseks enam kui 500 strateegiat, sealhulgas pass-kohalik mis kasutab kasutajanime ja parooli.

See õpetus kasutab pass-kohalik ja pass-jwt marsruute.

Kuidas seadistada kasutaja autentimist NodeJS-is

Nüüd olete kasutaja autentimise ja Passport.js-i kohta veidi kursis, saame vaadata, kuidas NodeJS-is autentimist seadistada. Allpool oleme kirjeldanud samme, mida peate tegema.

1. samm: seadistage sõlmeserver

Looge kaust nimega user-auth-nodejs ja navigeerige oma terminali abil selle juurde.

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

Järgmine lähtestamine package.json.

npm init

Kuna te hakkate kasutama Ekspress, NodeJS-i taustaraamistik, installige see, käivitades järgmise käsu.

npm ma väljendan

Looge nüüd fail, app.jsja lisage serveri loomiseks järgmine kood.

const express = nõuda("ekspress");
const app = express();
const PORT = 3000;
app.listen (PORT, () => {
console.log(`Kuulamine pordis ${PORT}`);
});

Seotud: Siit saate teada, kuidas installida Ubuntusse Npm ja Node.js

2. samm: seadistage andmebaas

Kasutajaandmete salvestamiseks vajate andmebaasi. Mongoose abil saate luua MongoDB andmeskeemi, mis määrab andmebaasi salvestatavate andmete struktuuri ja tüübi. Kuna salvestate kasutajaandmeid, looge kasutajaskeem.

Paigaldage mongoose.

npm ma mangust

Looge uus fail, userModel.jsja lisage järgmine.

const mangoose = nõuda('mongoose')
const {Skeem} = mangust
const UserSchema = uus skeem ({
 email: {
 tüüp: string,
 nõutav: tõsi
 },
 parool: {
 tüüp: string,
 nõutav: tõsi
 }
})
const UserModel = mongoose.model('kasutaja', UserSchema);
module.exports = UserModel;

Seotud: Kuidas luua andmebaasi ja kogu MongoDB-s

Enne parooli salvestamist peate selle turvalisuse huvides krüpteerima. Sa kasutad bcryptjs, väga kasulik npm-pakett, mis muudab krüptitud paroolidega töötamise lihtsaks.

Installige bcryptjs.

npm ja bcryptjs

Muutma usermodel.js salasõna krüpteerimiseks enne selle andmebaasi salvestamist.

const mangoose = nõuda('mongoose')
const bcrypt = nõuda('bcryptjs');
const {Skeem} = mangust
const UserSchema = uus skeem ({
...
})
UserSchema.pre('save', asünkroonfunktsioon (next) {
 proovi {
 // kontrollige registreerimise meetodit
 const kasutaja = see;
 if (!user.isModified('parool')) next();
 // soola genereerima
 const salt = ootama bcrypt.genSalt (10);
 // räsi parool
 const hashedPassword = oodake bcrypt.hash (this.password, salt);
 // asendage lihtteksti parool räsitud parooliga
 this.password = hashedPassword;
 next();
 } püüdmine (viga) {
 tagasi järgmisena (viga);
 }
 });
...
const Kasutaja = mongoose.model('Kasutaja', UserSchema);

Siin kasutate a eelsalvesta konks parooli muutmiseks enne selle salvestamist. Idee on salvestada parooli räsiversioon lihtteksti parooli asemel. Räsi on pikk keeruline string, mis on genereeritud lihtteksti stringist.

Kasuta on muudetud et kontrollida, kas parool muutub, kuna teil on vaja ainult uusi paroole räsida. Järgmisena genereerige sool ja edastage see koos lihtteksti parooliga räsimeetodile, et luua räsiparool. Lõpuks asendage lihtteksti parool andmebaasi räsitud parooliga.

Loo db.js ja konfigureerige andmebaas.

const mongoose = nõuavad("mongoose");
mangust. Lubadus = globaalne. lubadus;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mongoose.ühendus;
 db.on("viga", () => {
 console.log("ei saanud ühendust");
 });
 db.once("avatud", () => {
 console.log("> Andmebaasi ühendamine õnnestus");
 });
};
module.exports = {ühenda};

Rakenduses app.js looge ühendus andmebaasiga.

// ühendage andmebaasiga db
const db = nõuavad('./db');
db.connect();

3. samm: seadistage pass

Installige Pass ja pass-kohalik. Kasutate neid pakette kasutajate registreerimiseks ja sisselogimiseks.

npm i pass
npm i pass-kohalik

Looge uus fail, passConfig.jsja importida pass-kohalik ja userModel.js.

const LocalStraregy = nõuda("pass-local").Strateegia;
const Kasutaja = nõuda("./userModel");

Seadistage Passport kasutaja registreerimise käsitlemiseks.

const LocalStrategy = nõuda("pass-local");
const Kasutaja = nõuda("./userModel");
module.exports = (pass) => {
 pass.use(
 "kohalik registreerumine",
 uus kohalik strateegia(
 {
 kasutajanimiField: "e-post",
 paroolField: "parool",
 },
 async (e-post, parool, valmis) => {
 proovi {
 // kontrollige, kas kasutaja on olemas
 const userExists = ootama User.findOne({ "e-post": email });
 if (kasutaja eksisteerib) {
 tagastamine tehtud (null, vale)
 }
 // Looge antud kasutajaandmetega uus kasutaja
 const user = ootama User.create({ email, password });
 tagastamine tehtud (null, kasutaja);
 } püüdmine (viga) {
 tehtud (viga);
 }
 }
 )
 );
}

Ülaltoodud koodis kontrollite, kas e-posti aadress on juba kasutusel. Kui meili pole olemas, registreerige kasutaja. Pange tähele, et määrate ka kasutajanime välja e-kirja vastuvõtmiseks. Algselt, pass-kohalik eeldab kasutajanime, seega peate talle ütlema, et saadate selle asemel e-kirja.

Kasuta pass-kohalik et hallata ka kasutajate sisselogimist.

module.exports = (pass) => {
 pass.use(
 "kohalik registreerumine",
 uus kohalik strateegia(
 ...
 )
 );
pass.use(
 "kohalik sisselogimine",
 uus kohalik strateegia(
 {
 kasutajanimiField: "e-post",
 paroolField: "parool",
 },
 async (e-post, parool, valmis) => {
 proovi {
 const user = ootama User.findOne({ email: email });
 if (!kasutaja) tagastamine tehtud (null, false);
 const isMatch = oota kasutaja.matchPassword (parool);
 kui (!isMatch)
 tagastamine tehtud (null, false);
 // kui paroolid vastavad tagastatavale kasutajale
 tagastamine tehtud (null, kasutaja);
 } püüdmine (viga) {
 console.log (viga)
 tagastamine tehtud (viga, vale);
 }
 }
 )
 );
};

Siin kontrollige, kas kasutaja on andmebaasis olemas, ja kui on, siis kontrollige, kas antud parool ühtib andmebaasis olevaga. Pange tähele, et helistate ka matchPassword() meetod kasutajamudelil, nii et minge lehele userModel.js faili ja lisage see.

UserSchema.methods.matchPassword = asünkroonimisfunktsioon (parool) {
 proovi {
 tagasi ootama bcrypt.compare (parool, this.password);
 } püüdmine (viga) {
 viska uus Error (error);
 }
};

See meetod võrdleb kasutaja parooli ja andmebaasis oleva parooli ning tagastab tõene, kui need kattuvad.

4. samm: seadistage autentimismarsruudid

Nüüd peate looma lõpp-punktid, kuhu kasutajad andmeid saadavad. Esiteks on registreerumismarsruut, mis aktsepteerib uue kasutaja meili ja parooli.

sisse app.js, kasutage kasutaja registreerimiseks just loodud passi autentimise vahevara.

app.post(

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

Seotud: Autentimine vs. Autoriseerimine: mis vahe on?

Edu korral peaks registreerumismarsruut tagastama loodud kasutaja.

Järgmisena looge sisselogimismarsruut.

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

5. samm: lisage kaitstud marsruute

Seni olete kasutanud Pass luua vahevara, mis registreerib kasutaja andmebaasis ja teine, mis võimaldab registreeritud kasutajal sisse logida. Järgmisena loote autoriseerimise vahevara, et kaitsta tundlikke marsruute JSON-i veebimärgi (JWT) abil. JWT autoriseerimise rakendamiseks peate:

• Genereeri JWT tunnus.
• Edastage žetoon kasutajale. Kasutaja saadab selle autoriseerimistaotlustes tagasi.
• Kontrollige kasutaja poolt tagasi saadetud luba.

Te kasutate jsonwebtoken pakett JWT-de käsitsemiseks.

Selle installimiseks käivitage järgmine käsk.

npm i jsonwebtoken

Järgmisena looge iga edukalt sisse loginud kasutaja jaoks tunnus.

sisse app.js, importida jsonwebtoken ja muutke sisselogimismarsruuti nagu allpool.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Logi sisse
 jwt.sign({kasutaja: req.user}, 'secretKey', {expiresIn: '1h'}, (err, token) => {
 if (err) {
 return res.json({
 teade: "Sisselogimine ebaõnnestus",
 märk: null,
 });
 }
 res.json({
 märk
 });
 })
 }
);

Päriselurakenduses kasutaksite keerulisemat salajast võtit ja salvestaksite selle konfiguratsioonifaili.

Sisselogimismarsruut tagastab õnnestumise korral märgi.

Kasuta pass-jwt pääseda kaitstud teedele.

npm i pass-jwt

sisse passConfig.js, konfigureerige pass-jwt.

const JwtStrategy = nõuda("pass-jwt").Strateegia;
const { ExtractJwt } = nõua("pass-jwt")
module.exports = (pass) => {
pass.use(
 "kohalik sisselogimine",
 uus kohalik strateegia(
 ...
 );
pass.use(
 uus JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("volitus"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, tehtud) => {
 proovi {
 // Kasutaja ekstraktimine
 const kasutaja = jwtPayload.user;
 tehtud (null, kasutaja);
 } püüdmine (viga) {
 tehtud (viga, vale);
 }
 }
 )
 );
};

Pange tähele, et eraldate JWT päringu keha asemel autoriseerimispäisest. See takistab häkkeritel päringu pealtkuulamist ja märgi haaramist.

Et näha, kuidas pass-jwt valvab marsruute, loo sisse kaitstud marsruut app.js.

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

Ainult kehtiva JWT-ga päring tagastab kasutajaandmed.

Nüüd olete valmis viima oma kasutaja autentimise järgmisele tasemele

Sellest õpetusest õppisite, kuidas saate Passporti abil e-posti ja parooli abil kasutajaid autentida. See võib alguses tunduda hirmutav, kuid protsess on suhteliselt lihtne. Võite minna veelgi kaugemale ja kasutada Passporti toetatud kolmandate osapoolte identiteedipakkujaid, nagu Twitter, Facebook ja Google.

Mis on kasutaja autentimine ja kuidas see töötab?

Oluline on mõista kasutaja autentimise põhitõdesid, et tagada oma veebikontode maksimaalne turvalisuse tase. Niisiis, sukeldume sisse.

Loe edasi

Autori kohta