Brukerautentisering i NodeJS ved hjelp av Passport og MongoDB

Hvis du vil beskytte sensitivt innhold i Node-applikasjonen din, trenger du en måte å autentisere brukere på. Å bygge ditt eget autentiseringssystem er imidlertid komplekst og tidkrevende, og hvis det ikke gjøres på riktig måte, kan det introdusere sikkerhetssårbarheter i applikasjonen din. Tredjepartsverktøy som Passport gjør autentisering enklere.

I denne opplæringen lærer du hvordan du implementerer autentisering i Node ved å bruke Passport og MongoDB.

Hva er autentisering og autorisasjon?

Mens autentisering og autorisasjon noen ganger brukes om hverandre, har disse to sikkerhetskonseptene forskjellige betydninger. Autentisering er prosessen med å bekrefte at en bruker er den de hevder å være mens autorisasjon er prosessen med å avgjøre om en autentisert bruker har tilgang til visse deler av applikasjonen din.

Hva er Passport.js?

Passport.js (eller Passport) er en autentiseringsmellomvare for NodeJS som gir mer enn 500 strategier for autentisering av brukere, inkludert pass-lokale som bruker brukernavn og passord.

Denne opplæringen bruker pass-lokale og pass-jwt for å sikre ruter.

Hvordan sette opp brukerautentisering i NodeJS

Nå vet du litt om brukerautentisering og Passport.js, vi kan se på hvordan du setter opp autentisering på NodeJS. Nedenfor har vi skissert trinnene du må ta.

Trinn 1: Sett opp en nodeserver

Opprett en mappe med navnet user-auth-nodejs og naviger til den ved hjelp av terminalen.

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

Neste initialisering package.json.

npm init

Siden du skal bruke Uttrykke, et NodeJS backend-rammeverk, installer det ved å kjøre følgende kommando.

npm jeg uttrykker

Lag nå en fil, app.js, og legg til følgende kode for å opprette serveren.

const express = require("express");
const app = express();
const PORT = 3000;
app.listen (PORT, () => {
console.log(`Lytter på port ${PORT}`);
});

I slekt: Lær hvordan du installerer Npm og Node.js på Ubuntu

Trinn 2: Sett opp databasen

Du trenger en database for å lagre brukerdata. Du vil bruke mongoose til å lage et MongoDB-dataskjema som definerer strukturen og typen data du vil lagre i databasen. Siden du lagrer brukerdata, må du opprette et brukerskjema.

Installer mongoose.

npm i mongoose

Opprett en ny fil, userModel.js, og legg til følgende.

const mongoose = require('mongoose')
const {Skjema} = mangust
const UserSchema = new Schema ({
 e-post: {
 type: streng,
 nødvendig: sant
 },
 passord: {
 type: streng,
 nødvendig: sant
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = Brukermodell;

I slekt: Hvordan lage en database og samling i MongoDB

Før du lagrer passordet, må du kryptere det av sikkerhetshensyn. Du vil bruke bcryptjs, en veldig nyttig npm-pakke som gjør det enkelt å jobbe med krypterte passord.

Installere bcryptjs.

npm i bcryptjs

Endre usermodel.js for å kryptere passordet før du lagrer det i databasen.

const mongoose = require('mongoose')
const bcrypt = require('bcryptjs');
const {Skjema} = mangust
const UserSchema = new Schema ({
...
})
UserSchema.pre('save', async function (neste) {
 prøv {
 // sjekk metode for registrering
 const bruker = dette;
 if (!user.isModified('passord')) next();
 // generere salt
 const salt = avvente bcrypt.genSalt (10);
 // hash passordet
 const hashedPassword = vent bcrypt.hash (this.password, salt);
 // erstatte ren tekst passord med hashed passord
 this.password = hashedPassword;
 neste();
 } catch (feil) {
 returnere neste (feil);
 }
 });
...
const Bruker = mongoose.model('Bruker', Brukerskjema);

Her bruker du en forhåndslagring koble til for å endre passordet før det lagres. Tanken er å lagre hash-versjonen av passordet i stedet for ren tekstpassordet. En hash er en lang kompleks streng generert fra en ren tekststreng.

Bruk er Modifisert for å sjekke om passordet endres siden du bare trenger å hash nye passord. Deretter genererer du et salt og sender det med ren tekstpassordet til hash-metoden for å generere det hash-passordet. Til slutt erstatter du ren tekstpassordet med det hashed-kodede passordet i databasen.

Opprett db.js og konfigurer databasen.

const mongoose = require("mongoose");
mangust. Løfte = globalt. Love;
const dbUrl = "mongodb://localhost/bruker";
const connect = asynkron () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mongoose.connection;
 db.on("feil", () => {
 console.log("kunne ikke koble til");
 });
 db.once("open", () => {
 console.log("> Koblet til databasen");
 });
};
module.exports = { koble til };

Koble til databasen i app.js.

// koble til db
const db = require('./db');
db.connect();

Trinn 3: Sett opp pass

Installere Pass og pass-lokale. Du vil bruke disse pakkene til å registrere og logge inn brukere.

npm i pass
npm i pass-lokale

Opprett en ny fil, passportConfig.js, og importere pass-lokale og userModel.js.

const LocalStraregy = require("passport-local").Strategi;
const Bruker = require("./userModel");

Konfigurer Passport for å håndtere brukerregistrering.

const LocalStrategy = require("pass-local");
const Bruker = require("./userModel");
module.exports = (pass) => {
 passport.use(
 "lokal registrering",
 ny lokal strategi(
 {
 brukernavnfelt: "e-post",
 passordfelt: "passord",
 },
 asynkron (e-post, passord, ferdig) => {
 prøv {
 // sjekk om brukeren eksisterer
 const userExists = await User.findOne({ "email": email });
 if (brukereksisterer) {
 retur ferdig (null, usann)
 }
 // Opprett en ny bruker med de oppgitte brukerdataene
 const bruker = await User.create({ e-post, passord });
 return gjort (null, bruker);
 } catch (feil) {
 gjort (feil);
 }
 }
 )
 );
}

I koden ovenfor sjekker du om e-posten allerede er i bruk. Hvis e-posten ikke eksisterer, registrer brukeren. Merk at du også setter brukernavnfeltet til å godta en e-post. Som standard, pass-lokale forventer et brukernavn, så du må fortelle det at du sender i en e-post i stedet.

Bruk pass-lokale for også å håndtere brukerinnlogging.

module.exports = (pass) => {
 passport.use(
 "lokal registrering",
 ny lokalstrategi(
 ...
 )
 );
passport.use(
 "lokal-pålogging",
 ny lokal strategi(
 {
 brukernavnfelt: "e-post",
 passordfelt: "passord",
 },
 asynkron (e-post, passord, ferdig) => {
 prøv {
 const bruker = await User.findOne({ email: email });
 hvis (!bruker) returnerer utført (null, usann);
 const isMatch = avvente bruker.matchPassword (passord);
 if (!isMatch)
 return gjort (null, usann);
 // hvis passord samsvarer med returbruker
 return gjort (null, bruker);
 } catch (feil) {
 console.log (feil)
 return gjort (feil, usann);
 }
 }
 )
 );
};

Sjekk her om brukeren finnes i databasen, og hvis de gjør det, sjekk om passordet som er oppgitt samsvarer med det i databasen. Merk at du også ringer til matchPassword() metode på brukermodellen så gå til userModel.js fil og legg den til.

UserSchema.methods.matchPassword = asynkronfunksjon (passord) {
 prøv {
 return await bcrypt.compare (passord, dette.passord);
 } catch (feil) {
 kaste ny Feil (feil);
 }
};

Denne metoden sammenligner passordet fra brukeren og passordet i databasen og returnerer true hvis de samsvarer.

Trinn 4: Sett opp autentiseringsruter

Du må nå opprette endepunktene som brukerne skal sende data til. Først ut er registreringsruten som godtar e-posten og passordet til en ny bruker.

I app.js, bruk mellomvaren for passautentisering du nettopp opprettet for å registrere brukeren.

app.post(

 "/auth/registrering",
 passport.authenticate('local-signup', { session: false }),
 (req, res, neste) => {
 // melde deg på
 res.json({
 bruker: req.user,
 });
 }
);

I slekt: Autentisering vs. Autorisasjon: Hva er forskjellen?

Hvis den lykkes, bør registreringsruten returnere den opprettede brukeren.

Deretter oppretter du påloggingsruten.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, neste) => {
 // Logg Inn
 res.json({
 bruker: req.user,
 });
 }
);

Trinn 5: Legg til beskyttede ruter

Så langt har du brukt Pass å lage en mellomvare som registrerer en bruker i databasen og en annen som lar en registrert bruker logge på. Deretter vil du opprette en autorisasjonsmellomvare for å beskytte sensitive ruter ved å bruke et JSON-netttoken (JWT). For å implementere JWT-autorisasjon må du:

• Generer JWT-token.
• Gi tokenet til brukeren. Brukeren vil sende den tilbake i autorisasjonsforespørsler.
• Bekreft tokenet som er sendt tilbake av brukeren.

Du vil bruke jsonwebtoken pakke for å håndtere JWT-er.

Kjør følgende kommando for å installere den.

npm i jsonwebtoken

Deretter genererer du et token for hver bruker som logger på.

I app.js, importere jsonwebtoken og endre påloggingsruten som nedenfor.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, neste) => {
 // Logg Inn
 jwt.sign({user: req.user}, 'secretKey', {expiresIn: '1h'}, (feil, token) => {
 if (feil) {
 return res.json({
 melding: "Kunne ikke logge på",
 token: null,
 });
 }
 res.json({
 token
 });
 })
 }
);

I en virkelig applikasjon vil du bruke en mer komplisert hemmelig nøkkel og lagre den i en konfigurasjonsfil.

Påloggingsruten returnerer et token hvis vellykket.

Bruk pass-jwt for å få tilgang til beskyttede ruter.

npm i pass-jwt

I passportConfig.js, konfigurere pass-jwt.

const JwtStrategy = require("passport-jwt").Strategi;
const { ExtractJwt } = require("passport-jwt")
module.exports = (pass) => {
passport.use(
 "lokal-pålogging",
 ny lokal strategi(
 ...
 );
passport.use(
 ny JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("autorisasjon"),
 secretOrKey: "secretKey",
 },
 asynkron (jwtPayload, ferdig) => {
 prøv {
 // Pakk ut bruker
 const bruker = jwtPayload.user;
 ferdig (null, bruker);
 } catch (feil) {
 gjort (feil, usant);
 }
 }
 )
 );
};

Legg merke til at du trekker ut JWT fra autorisasjonsoverskriften i stedet for forespørselsteksten. Dette forhindrer hackere i å avskjære en forespørsel og gripe tokenet.

For å se hvordan pass-jwt vokter ruter, lage en beskyttet rute i app.js.

app.get(
 "/bruker/beskyttet",
 passport.authenticate("jwt", { session: false }),
 (req, res, neste) => {
 res.json({bruker: req.bruker});
 }
);

Bare en forespørsel med en gyldig JWT returnerer brukerdataene.

Nå er du klar til å ta brukerautentiseringen din til neste nivå

I denne opplæringen lærte du hvordan du kan autentisere brukere ved å bruke en e-post og et passord ved hjelp av Passport. Det kan virke skremmende i begynnelsen, men prosessen er relativt grei. Du kan gå enda lenger og bruke tredjeparts identitetsleverandører som støttes av Passport som Twitter, Facebook og Google.

Hva er brukerautentisering og hvordan fungerer det?

Det er viktig å forstå det grunnleggende om brukerautentisering for å sikre maksimalt sikkerhetsnivå for nettkontoene dine. Så la oss dykke inn.

Les Neste

Om forfatteren