Preverjanje pristnosti uporabnika v NodeJS z uporabo potnega lista in MongoDB

Če želite zaščititi občutljivo vsebino v aplikaciji Node, potrebujete način za preverjanje pristnosti uporabnikov. Vendar pa je izgradnja lastnega sistema za preverjanje pristnosti zapletena in dolgotrajna ter, če ni izvedena pravilno, lahko povzroči varnostne ranljivosti v vaši aplikaciji. Orodja tretjih oseb, kot je Passport, olajšajo preverjanje pristnosti.

V tej vadnici se boste naučili, kako implementirati avtentikacijo v Node z uporabo Passport in MongoDB.

Kaj sta avtentikacija in avtorizacija?

Čeprav se preverjanje pristnosti in avtorizacija včasih uporabljata zamenljivo, imata ta dva varnostna koncepta različna pomena. Preverjanje pristnosti je postopek preverjanja, da je uporabnik tisti, za katerega trdijo, da je, medtem ko je avtorizacija postopek ugotavljanja, ali ima overjeni uporabnik dostop do določenih delov vaše aplikacije.

Kaj je Passport.js?

Passport.js (ali Passport) je vmesna programska oprema za preverjanje pristnosti za NodeJS, ki ponuja več kot 500 strategij za preverjanje pristnosti uporabnikov, vključno z

potni list-lokalni ki uporablja uporabniško ime in geslo.

Ta vadnica uporablja potni list-lokalni in potni list-jwt za zavarovanje poti.

Kako nastaviti avtentikacijo uporabnika v NodeJS

Zdaj veste nekaj o preverjanju pristnosti uporabnikov in Passport.js, lahko si ogledamo, kako nastaviti avtentikacijo na NodeJS. Spodaj smo opisali korake, ki jih boste morali narediti.

1. korak: Nastavite strežnik Node

Ustvarite mapo z imenom uporabnik-avth-nodejs in se do njega pomaknite s svojim terminalom.

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

Naslednja inicializacija package.json.

npm init

Ker boste uporabljali Express, zaledni okvir NodeJS, ga namestite tako, da zaženete naslednji ukaz.

npm izrazim

Zdaj ustvarite datoteko, app.js, in dodajte naslednjo kodo, da ustvarite strežnik.

const express = zahteva ("express");
const app = express();
const PORT = 3000;
app.listen (PORT, () => {
console.log(`Poslušanje na vratih ${PORT}`);
});

Povezano: Naučite se namestiti Npm in Node.js v Ubuntu

2. korak: Nastavite bazo podatkov

Za shranjevanje uporabniških podatkov potrebujete bazo podatkov. Mongoose boste uporabili za ustvarjanje podatkovne sheme MongoDB, ki definira strukturo in vrsto podatkov, ki jih boste shranili v bazo podatkov. Ker shranjujete uporabniške podatke, ustvarite uporabniško shemo.

Namestite mongoose.

npm jaz mungos

Ustvari novo datoteko, userModel.js, in dodajte naslednje.

const mongoose = require('mongoose')
const {Shema} = mungos
const UserSchema = nova shema ({
 E-naslov: {
 vrsta: vrvica,
 zahtevano: res
 },
 geslo: {
 vrsta: vrvica,
 zahtevano: res
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = Uporabniški model;

Povezano: Kako ustvariti bazo podatkov in zbirko v MongoDB

Preden shranite geslo, ga morate zaradi varnosti šifrirati. Uporabili boste bcryptjs, zelo uporaben paket npm, ki olajša delo s šifriranimi gesli.

Namestite bcryptjs.

npm in bcryptjs

Spremeni usermodel.js da šifrirate geslo, preden ga shranite v bazo podatkov.

const mongoose = require('mongoose')
const bcrypt = zahteva ('bcryptjs');
const {Shema} = mungos
const UserSchema = nova shema ({
...
})
UserSchema.pre('shrani', async funkcija (naprej) {
 poskusi {
 // preverite način registracije
 const uporabnik = to;
 if (!user.isModified('password')) next();
 // ustvarjanje soli
 const sol = await bcrypt.genSalt (10);
 // hash geslo
 const hasshedPassword = await bcrypt.hash (to.password, sol);
 // zamenjajte geslo za golo besedilo z zgoščenim geslom
 this.password = hasshedPassword;
 Naslednji();
 } ulov (napaka) {
 vrni se naslednji (napaka);
 }
 });
...
const Uporabnik = mongoose.model('Uporabnik', Uporabniška shema);

Tukaj uporabljate a pred shranjevanjem hook, da spremenite geslo, preden se shrani. Ideja je shraniti hash različico gesla namesto gesla z navadnim besedilom. Hash je dolg kompleksen niz, ustvarjen iz niza navadnega besedila.

Uporaba je spremenjeno da preverite, ali se geslo spreminja, saj morate le zgostiti nova gesla. Nato ustvarite sol in jo z geslom za golo besedilo posredujte metodi hash, da ustvarite zgoščeno geslo. Nazadnje zamenjajte geslo z navadnim besedilom z zgoščenim geslom v bazi podatkov.

Ustvarite db.js in konfigurirajte bazo podatkov.

const mongoose = require("mongoose");
mungos. Obljuba = globalna. Obljuba;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mungoose.connection;
 db.on("napaka", () => {
 console.log("ni mogoče vzpostaviti povezave");
 });
 db.once("odprto", () => {
 console.log("> Uspešno povezan z bazo podatkov");
 });
};
module.exports = { poveži};

V app.js se povežite z bazo podatkov.

// poveži se z db
const db = zahteva ('./db');
db.connect();

3. korak: Nastavite potni list

Namestite potni list in potni list-lokalni. Te pakete boste uporabili za registracijo in prijavo uporabnikov.

npm i potni list
npm i potni list lokalno

Ustvari novo datoteko, passportConfig.js, in uvoz potni list-lokalni in userModel.js.

const LocalStraregy = require("passport-local").Strategija;
const Uporabnik = zahteva ("./userModel");

Konfigurirajte Passport za registracijo uporabnika.

const LocalStrategy = zahteva ("passport-local");
const Uporabnik = zahteva ("./userModel");
module.exports = (potni list) => {
 potni list.uporaba(
 "lokalna prijava",
 nova lokalna strategija(
 {
 usernameField: "e-pošta",
 passwordField: "geslo",
 },
 async (e-pošta, geslo, končano) => {
 poskusi {
 // preveri, ali uporabnik obstaja
 const userExists = await User.findOne({ "e-pošta": email });
 če (userExists) {
 vrnitev opravljeno (null, false)
 }
 // Ustvarite novega uporabnika s podanimi uporabniškimi podatki
 const user = await User.create({ e-pošta, geslo });
 vrnitev opravljeno (nič, uporabnik);
 } ulov (napaka) {
 opravljeno (napaka);
 }
 }
 )
 );
}

V zgornji kodi preverjate, ali je e-pošta že v uporabi. Če e-poštni naslov ne obstaja, registrirajte uporabnika. Upoštevajte, da nastavite tudi polje uporabniškega imena, da sprejme e-pošto. Privzeto, potni list-lokalni pričakuje uporabniško ime, zato mu morate povedati, da namesto tega pošiljate e-pošto.

Uporaba potni list-lokalni za obdelavo tudi prijavo uporabnikov.

module.exports = (potni list) => {
 potni list.uporaba(
 "lokalna prijava",
 nova lokalna strategija(
 ...
 )
 );
potni list.uporaba(
 "lokalna prijava",
 nova lokalna strategija(
 {
 usernameField: "e-pošta",
 passwordField: "geslo",
 },
 async (e-pošta, geslo, končano) => {
 poskusi {
 const user = await User.findOne({ email: email });
 if (!user) vrnitev končano (null, false);
 const isMatch = await user.matchPassword (geslo);
 če (!isMatch)
 vrnitev opravljena (null, false);
 // če se gesla ujemajo z vrnjenim uporabnikom
 vrnitev opravljeno (nič, uporabnik);
 } ulov (napaka) {
 console.log (napaka)
 vrnitev opravljena (napaka, napačna);
 }
 }
 )
 );
};

Tukaj preverite, ali uporabnik obstaja v bazi podatkov, in če obstaja, preverite, ali se posredovano geslo ujema z geslom v bazi podatkov. Upoštevajte, da pokličete tudi matchPassword() metodo na uporabniškem modelu, zato pojdite na userModel.js datoteko in jo dodajte.

UserSchema.methods.matchPassword = async funkcija (geslo) {
 poskusi {
 return await bcrypt.compare (geslo, to.password);
 } ulov (napaka) {
 vrzi novo Napaka (napaka);
 }
};

Ta metoda primerja geslo uporabnika in geslo v bazi podatkov ter vrne true, če se ujemata.

4. korak: Nastavite poti za preverjanje pristnosti

Zdaj morate ustvariti končne točke, kamor bodo uporabniki pošiljali podatke. Prva je pot prijave, ki bo sprejela e-pošto in geslo novega uporabnika.

V app.js, uporabite vmesno programsko opremo za preverjanje pristnosti potnega lista, ki ste jo pravkar ustvarili, da registrirate uporabnika.

app.post(

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

Povezano: Preverjanje pristnosti vs. Pooblastilo: v čem je razlika?

Če je uspešna, mora pot prijave vrniti ustvarjenega uporabnika.

Nato ustvarite pot za prijavo.

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

5. korak: Dodajte zaščitene poti

Do sedaj ste uporabljali potni list ustvariti vmesno programsko opremo, ki registrira uporabnika v bazi podatkov, in drugo, ki registriranemu uporabniku omogoča prijavo. Nato boste ustvarili vmesno programsko opremo za avtorizacijo za zaščito občutljivih poti z uporabo spletnega žetona JSON (JWT). Za izvajanje avtorizacije JWT morate:

• Ustvarite žeton JWT.
• Predajte žeton uporabniku. Uporabnik ga bo poslal nazaj v zahtevah za avtorizacijo.
• Preverite žeton, ki ga je uporabnik poslal nazaj.

Uporabili boste jsonwebtoken paket za obdelavo JWT.

Zaženite naslednji ukaz, da ga namestite.

npm in jsonwebtoken

Nato ustvarite žeton za vsakega uporabnika, ki se uspešno prijavi.

V app.js, uvoz jsonwebtoken in spremenite pot prijave, kot je prikazano spodaj.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Vpiši se
 jwt.sign({user: req.user}, 'secretKey', {expiresIn: '1h'}, (err, žeton) => {
 če (napaka) {
 vrni res.json({
 sporočilo: "Prijava ni uspela",
 žeton: nič,
 });
 }
 res.json({
 žeton
 });
 })
 }
);

V resnični aplikaciji bi uporabili bolj zapleten skrivni ključ in ga shranili v konfiguracijsko datoteko.

Pot prijave vrne žeton, če je uspešna.

Uporaba potni list-jwt za dostop do zaščitenih poti.

npm i potni list-jwt

V passportConfig.js, konfigurirajte potni list-jwt.

const JwtStrategy = require("passport-jwt").Strategija;
const { ExtractJwt } = Zahtevaj("passport-jwt")
module.exports = (potni list) => {
potni list.uporaba(
 "lokalna prijava",
 nova lokalna strategija(
 ...
 );
potni list.uporaba(
 nova strategija Jwt(
 {
 jwtFromRequest: ExtractJwt.fromHeader("avtorizacija"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, končano) => {
 poskusi {
 // Izvleček uporabnika
 const uporabnik = jwtPayload.user;
 končano (nič, uporabnik);
 } ulov (napaka) {
 opravljeno (napaka, napačno);
 }
 }
 )
 );
};

Upoštevajte, da izvlečete JWT iz glave avtorizacije namesto telesa zahteve. To preprečuje hekerjem, da bi prestregli zahtevo in zgrabili žeton.

Da vidim kako potni list-jwt varuje poti, ustvari zaščiteno pot v app.js.

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

Samo zahteva z veljavnim JWT vrne uporabniške podatke.

Zdaj ste pripravljeni, da svojo avtentikacijo uporabnika dvignete na naslednjo raven

V tej vadnici ste se naučili, kako lahko overite uporabnike z e-pošto in geslom s pomočjo potnega lista. Na prvi pogled se morda zdi zastrašujoče, vendar je postopek razmeroma preprost. Lahko greste še dlje in uporabite ponudnike identitete tretjih oseb, ki jih podpira Passport, kot so Twitter, Facebook in Google.

Kaj je avtentikacija uporabnika in kako deluje?

Pomembno je razumeti osnove preverjanja pristnosti uporabnikov, da zagotovite najvišjo raven varnosti vaših spletnih računov. Torej, potopimo se noter.

Preberite Naprej

O avtorju