Brugergodkendelse i NodeJS ved hjælp af Passport og MongoDB

Hvis du vil beskytte følsomt indhold i din Node-applikation, har du brug for en måde at autentificere brugere på. Det er dog komplekst og tidskrævende at bygge dit eget autentificeringssystem, og hvis det ikke gøres korrekt, kan det introducere sikkerhedssårbarheder i din applikation. Tredjepartsværktøjer som Passport gør godkendelse lettere.

I denne vejledning lærer du, hvordan du implementerer godkendelse i Node ved hjælp af Passport og MongoDB.

Hvad er godkendelse og godkendelse?

Mens autentificering og autorisation nogle gange bruges i flæng, har disse to sikkerhedskoncepter forskellige betydninger. Autentificering er processen med at bekræfte, at en bruger er den, de hævder at være, mens autorisation er processen med at afgøre, om en godkendt bruger har adgang til visse dele af din applikation.

Hvad er Passport.js?

Passport.js (eller Passport) er en autentificerings-middleware til NodeJS, der giver mere end 500 strategier til godkendelse af brugere, herunder pas-lokale som bruger brugernavn og adgangskode.

Denne tutorial bruger pas-lokale og pas-jwt at sikre ruter.

Sådan opsætter du brugergodkendelse i NodeJS

Nu ved du lidt om brugergodkendelse og Passport.js, vi kan se på, hvordan du opsætter godkendelse på NodeJS. Nedenfor har vi skitseret de trin, du skal tage.

Trin 1: Konfigurer en nodeserver

Opret en mappe med navnet user-auth-nodejs og naviger til den ved hjælp af din terminal.

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

Næste initialisering package.json.

npm init

Da du skal bruge Express, en NodeJS-backend-ramme, skal du installere den ved at køre følgende kommando.

npm jeg udtrykker

Opret nu en fil, app.js, og tilføj følgende kode for at oprette serveren.

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

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

Trin 2: Opsæt databasen

Du skal bruge en database til at gemme brugerdata. Du vil bruge mongoose til at oprette et MongoDB-dataskema, der definerer strukturen og typen af ​​data, du vil gemme i databasen. Da du gemmer brugerdata, skal du oprette et brugerskema.

Installer mongoose.

npm i mangust

Opret en ny fil, userModel.js, og tilføj følgende.

const mongoose = require('mongoose')
const {Skema} = mangust
const UserSchema = nyt skema ({
 e-mail: {
 type: streng,
 påkrævet: sandt
 },
 adgangskode: {
 type: streng,
 påkrævet: sandt
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = Brugermodel;

Relaterede: Sådan opretter du en database og samling i MongoDB

Før du gemmer adgangskoden, skal du kryptere den af ​​sikkerhedsmæssige årsager. Du vil bruge bcryptjs, en meget nyttig npm-pakke, der gør det nemt at arbejde med krypterede adgangskoder.

Installere bcryptjs.

npm i bcryptjs

Modificere brugermodel.js for at kryptere adgangskoden, før du gemmer den i databasen.

const mongoose = require('mongoose')
const bcrypt = require('bcryptjs');
const {Skema} = mangust
const UserSchema = nyt skema ({
...
})
UserSchema.pre('save', async-funktion (næste) {
 prøve {
 // tjek registreringsmetoden
 const bruger = denne;
 if (!user.isModified('adgangskode')) next();
 // generere salt
 const salt = afvent bcrypt.genSalt (10);
 // hash adgangskoden
 const hashedPassword = afvent bcrypt.hash (this.password, salt);
 // erstatte almindelig tekst adgangskode med hashed adgangskode
 this.password = hashedPassword;
 Næste();
 } fange (fejl) {
 returnere næste (fejl);
 }
 });
...
const Bruger = mongoose.model('Bruger', BrugerSchema);

Her bruger du en gem på forhånd krog for at ændre adgangskoden, før den gemmes. Ideen er at gemme hash-versionen af ​​adgangskoden i stedet for almindelig tekstadgangskode. En hash er en lang kompleks streng genereret ud fra en almindelig tekststreng.

Brug er Modificeret for at kontrollere, om adgangskoden ændres, da du kun skal hash nye adgangskoder. Generer derefter et salt og send det med almindelig tekstadgangskode til hash-metoden for at generere det hash-kodeord. Til sidst skal du erstatte den almindelige tekstadgangskode med den hash-kodede adgangskode i databasen.

Opret db.js og konfigurer databasen.

const mongoose = require("mongoose");
mangust. Løfte = globalt. Løfte;
const dbUrl = "mongodb://localhost/bruger";
const connect = asynkron () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mongoose.forbindelse;
 db.on("fejl", () => {
 console.log("kunne ikke oprette forbindelse");
 });
 db.once("åben", () => {
 console.log("> Forbundet til databasen med succes");
 });
};
module.exports = { connect };

I app.js skal du oprette forbindelse til databasen.

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

Trin 3: Konfigurer pas

Installere Pas og pas-lokale. Du skal bruge disse pakker til at registrere og logge på brugere.

npm i pas
npm i pas-lokale

Opret en ny fil, passportConfig.js, og importere pas-lokale og userModel.js.

const LocalStraregy = require("pas-lokal").Strategi;
const Bruger = require("./userModel");

Konfigurer Passport til at håndtere brugerregistrering.

const LocalStrategy = require("pas-lokal");
const Bruger = require("./userModel");
module.exports = (pas) => {
 pas.brug(
 "lokal tilmelding",
 ny lokal strategi(
 {
 brugernavnFelt: "e-mail",
 passwordField: "adgangskode",
 },
 async (e-mail, adgangskode, udført) => {
 prøve {
 // tjek om brugeren findes
 const userExists = await User.findOne({ "email": email });
 if (brugereksisterer) {
 returnere udført (nul, falsk)
 }
 // Opret en ny bruger med de angivne brugerdata
 const user = await User.create({ email, password });
 returnering udført (nul, bruger);
 } fange (fejl) {
 udført (fejl);
 }
 }
 )
 );
}

I ovenstående kode tjekker du, om e-mailen allerede er i brug. Hvis e-mailen ikke findes, skal du registrere brugeren. Bemærk, at du også indstiller brugernavnsfeltet til at acceptere en e-mail. Som standard, pas-lokale forventer et brugernavn, så du skal fortælle det, at du sender i en e-mail i stedet.

Brug pas-lokale til også at håndtere brugerlogin.

module.exports = (pas) => {
 pas.brug(
 "lokal tilmelding",
 ny lokalstrategi(
 ...
 )
 );
pas.brug(
 "lokal-login",
 ny lokal strategi(
 {
 brugernavnFelt: "e-mail",
 passwordField: "adgangskode",
 },
 async (e-mail, adgangskode, udført) => {
 prøve {
 const user = await User.findOne({ email: email });
 hvis (!bruger) returnerer udført (nul, falsk);
 const isMatch = afvent bruger.matchPassword (adgangskode);
 hvis (!isMatch)
 returnere udført (nul, falsk);
 // hvis adgangskoder matcher returbruger
 returnering udført (nul, bruger);
 } fange (fejl) {
 console.log (fejl)
 returnering udført (fejl, falsk);
 }
 }
 )
 );
};

Her skal du kontrollere, om brugeren findes i databasen, og hvis de gør det, skal du kontrollere, om den angivne adgangskode matcher den i databasen. Bemærk du også ringer til matchPassword() metode på brugermodellen så gå til userModel.js fil og tilføje den.

UserSchema.methods.matchPassword = asynkronfunktion (adgangskode) {
 prøve {
 return await bcrypt.compare (password, this.password);
 } fange (fejl) {
 smide ny Fejl (fejl);
 }
};

Denne metode sammenligner adgangskoden fra brugeren og den i databasen og returnerer sand, hvis de matcher.

Trin 4: Konfigurer godkendelsesruter

Du skal nu oprette de endepunkter, som brugerne vil sende data til. Først op er tilmeldingsruten, som vil acceptere e-mail og adgangskode for en ny bruger.

I app.js, skal du bruge den mellemware til pasgodkendelse, du lige har oprettet, til at registrere brugeren.

app.post(

 "/auth/tilmelding",
 passport.authenticate('local-signup', { session: false }),
 (req, res, næste) => {
 // Tilmelde
 res.json({
 bruger: req.bruger,
 });
 }
);

Relaterede: Autentificering vs. Autorisation: Hvad er forskellen?

Hvis det lykkes, bør tilmeldingsruten returnere den oprettede bruger.

Opret derefter login-ruten.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, næste) => {
 // Log på
 res.json({
 bruger: req.bruger,
 });
 }
);

Trin 5: Tilføj beskyttede ruter

Indtil videre har du brugt Pas at oprette en middleware, der registrerer en bruger i databasen og en anden, der tillader en registreret bruger at logge ind. Dernæst vil du oprette en godkendelses-middleware til at beskytte følsomme ruter ved hjælp af et JSON-webtoken (JWT). For at implementere JWT-autorisation skal du:

• Generer JWT-token.
• Giv tokenet til brugeren. Brugeren sender det tilbage i godkendelsesanmodninger.
• Bekræft det token, der er sendt tilbage af brugeren.

Du vil bruge jsonwebtoken pakke til at håndtere JWT'er.

Kør følgende kommando for at installere det.

npm i jsonwebtoken

Derefter genererer du et token for hver bruger, der logger ind.

I app.js, import jsonwebtoken og ændre login-ruten som nedenfor.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, næste) => {
 // Log på
 jwt.sign({user: req.user}, 'secretKey', {expiresIn: '1h'}, (fejl, token) => {
 if (fejl) {
 returner res.json({
 besked: "Kunne ikke logge på",
 token: null,
 });
 }
 res.json({
 polet
 });
 })
 }
);

I et virkeligt program ville du bruge en mere kompliceret hemmelig nøgle og gemme den i en konfigurationsfil.

Login-ruten returnerer et token, hvis det lykkes.

Brug pas-jwt for at få adgang til beskyttede ruter.

npm i pas-jwt

I passportConfig.js, konfigurere pas-jwt.

const JwtStrategy = require("pas-jwt").Strategi;
const { ExtractJwt } = require("pas-jwt")
module.exports = (pas) => {
pas.brug(
 "lokal-login",
 ny lokal strategi(
 ...
 );
pas.brug(
 ny JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("autorisation"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, færdig) => {
 prøve {
 // Udpak bruger
 const bruger = jwtPayload.user;
 udført (nul, bruger);
 } fange (fejl) {
 udført (fejl, falsk);
 }
 }
 )
 );
};

Bemærk, at du udtrækker JWT fra autorisationsoverskriften i stedet for anmodningsteksten. Dette forhindrer hackere i at opsnappe en anmodning og gribe tokenet.

For at se hvordan pas-jwt bevogter ruter, lav en beskyttet rute ind app.js.

app.get(
 "/bruger/beskyttet",
 passport.authenticate("jwt", { session: false }),
 (req, res, næste) => {
 res.json({bruger: req.bruger});
 }
);

Kun en anmodning med en gyldig JWT returnerer brugerdataene.

Nu er du klar til at tage din brugergodkendelse til det næste niveau

I denne vejledning lærte du, hvordan du kan godkende brugere ved hjælp af en e-mail og en adgangskode ved hjælp af Passport. Det kan virke skræmmende i starten, men processen er forholdsvis ligetil. Du kan gå endnu længere og bruge tredjeparts identitetsudbydere understøttet af Passport såsom Twitter, Facebook og Google.

Hvad er brugergodkendelse, og hvordan fungerer det?

Det er vigtigt at forstå det grundlæggende i brugergodkendelse for at sikre det maksimale sikkerhedsniveau for dine onlinekonti. Så lad os dykke ind.

Læs Næste

Om forfatteren