Användarautentisering i NodeJS med Passport och MongoDB

Om du vill skydda känsligt innehåll i din Node-applikation behöver du ett sätt att autentisera användare. Men att bygga ett eget autentiseringssystem är komplext och tidskrävande och om det inte görs på rätt sätt kan det introducera säkerhetsbrister i din applikation. Tredjepartsverktyg som Passport gör autentisering enklare.

I den här handledningen kommer du att lära dig hur du implementerar autentisering i Node med Passport och MongoDB.

Vad är autentisering och auktorisering?

Även om autentisering och auktorisering ibland används omväxlande, har dessa två säkerhetskoncept olika betydelser. Autentisering är processen för att verifiera att en användare är den de utger sig för att vara medan auktorisering är process för att avgöra om en autentiserad användare har tillgång till vissa delar av din applikation.

Vad är Passport.js?

Passport.js (eller Passport) är en autentiseringsmellanvara för NodeJS som tillhandahåller mer än 500 strategier för autentisering av användare, inklusive pass-lokal som använder ett användarnamn och lösenord.

Denna handledning använder pass-lokal och pass-jwt för att säkra rutter.

Hur man ställer in användarautentisering i NodeJS

Nu vet du lite om användarverifiering och Passport.js, vi kan titta på hur man ställer in autentisering på NodeJS. Nedan har vi beskrivit de steg du måste ta.

Steg 1: Konfigurera en nodserver

Skapa en mapp med namnet user-auth-nodejs och navigera till den med din terminal.

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

Initiera nästa package.json.

npm init

Eftersom du kommer att använda uttrycka, ett NodeJS backend-ramverk, installera det genom att köra följande kommando.

npm uttrycker jag

Skapa nu en fil, app.js, och lägg till följande kod för att skapa servern.

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

Relaterad: Lär dig hur du installerar Npm och Node.js på Ubuntu

Steg 2: Konfigurera databasen

Du behöver en databas för att lagra användardata. Du kommer att använda mongoose för att skapa ett MongoDB-dataschema som definierar strukturen och typen av data som du kommer att lagra i databasen. Eftersom du lagrar användardata, skapa ett användarschema.

Installera mongoose.

npm jag mangust

Skapa en ny fil, userModel.jsoch lägg till följande.

const mongoose = require('mongoose')
const {Schema} = mangust
const UserSchema = nytt schema ({
 e-post: {
 typ: String,
 krävs: sant
 },
 Lösenord: {
 typ: String,
 krävs: sant
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = Användarmodell;

Relaterad: Hur man skapar en databas och samling i MongoDB

Innan du lagrar lösenordet måste du kryptera det av säkerhetsskäl. Du kommer att använda bcryptjs, ett mycket användbart npm-paket som gör det enkelt att arbeta med krypterade lösenord.

Installera bcryptjs.

npm i bcryptjs

Ändra usermodel.js för att kryptera lösenordet innan du sparar det i databasen.

const mongoose = require('mongoose')
const bcrypt = require('bcryptjs');
const {Schema} = mangust
const UserSchema = nytt schema ({
...
})
UserSchema.pre('save', async function (next) {
 Prova {
 // kontrollera registreringsmetoden
 const användare = detta;
 if (!user.isModified('lösenord')) next();
 // generera salt
 const salt = invänta bcrypt.genSalt (10);
 // hasha lösenordet
 const hashedPassword = invänta bcrypt.hash (this.password, salt);
 // ersätt vanlig textlösenord med hashat lösenord
 this.password = hashedPassword;
 Nästa();
 } fånga (fel) {
 returnera nästa (fel);
 }
 });
...
const Användare = mongoose.model('Användare', Användarschema);

Här använder du en spara i förväg krok för att ändra lösenordet innan det sparas. Tanken är att lagra hashversionen av lösenordet istället för lösenordet med vanlig text. En hash är en lång komplex sträng som genereras från en vanlig textsträng.

Använda sig av är Modifierad för att kontrollera om lösenordet ändras eftersom du bara behöver hasha nya lösenord. Skapa sedan ett salt och skicka det med vanlig textlösenordet till hashmetoden för att generera det hashade lösenordet. Slutligen, ersätt lösenordet med vanlig text med det hashade lösenordet i databasen.

Skapa db.js och konfigurera databasen.

const mongoose = require("mongoose");
mungo. Löfte = globalt. Löfte;
const dbUrl = "mongodb://localhost/user";
const connect = asynkron () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mongoose.connection;
 db.on("fel", () => {
 console.log("kunde inte ansluta");
 });
 db.once("öppen", () => {
 console.log("> Ansluten till databasen framgångsrikt");
 });
};
module.exports = { connect };

Anslut till databasen i app.js.

// anslut till db
const db = require('./db');
db.connect();

Steg 3: Konfigurera pass

Installera Pass och pass-lokal. Du kommer att använda dessa paket för att registrera och logga in användare.

npm i pass
npm i pass-lokal

Skapa en ny fil, passportConfig.jsoch importera pass-lokal och den userModel.js.

const LocalStraregy = require("pass-local").Strategy;
const User = require("./userModel");

Konfigurera Passport för att hantera användarregistrering.

const LocalStrategy = require("pass-local");
const User = require("./userModel");
module.exports = (pass) => {
 passport.use(
 "lokal registrering",
 ny lokal strategi(
 {
 användarnamnFält: "e-post",
 lösenordsfält: "lösenord",
 },
 async (e-post, lösenord, klar) => {
 Prova {
 // kontrollera om användaren finns
 const userExists = await User.findOne({ "email": email });
 if (userExists) {
 returnera klar (null, falsk)
 }
 // Skapa en ny användare med användardata som tillhandahålls
 const user = await User.create({ email, password });
 returnering klar (null, användare);
 } fånga (fel) {
 gjort (fel);
 }
 }
 )
 );
}

I koden ovan kontrollerar du om e-postmeddelandet redan används. Om e-postadressen inte finns registrerar du användaren. Observera att du också ställer in användarnamnsfältet för att acceptera ett e-postmeddelande. Som standard, pass-lokal förväntar sig ett användarnamn, så du måste berätta att du skickar i ett e-postmeddelande istället.

Använda sig av pass-lokal för att även hantera användarinloggning.

module.exports = (pass) => {
 passport.use(
 "lokal registrering",
 ny lokal strategi(
 ...
 )
 );
passport.use(
 "lokal-inloggning",
 ny lokal strategi(
 {
 användarnamnFält: "e-post",
 lösenordsfält: "lösenord",
 },
 async (e-post, lösenord, klar) => {
 Prova {
 const user = await User.findOne({ email: email });
 if (!user) return done (null, false);
 const isMatch = invänta användare.matchPassword (lösenord);
 om (!isMatch)
 return done (null, false);
 // om lösenord matchar returanvändare
 returnering klar (null, användare);
 } fånga (fel) {
 console.log (fel)
 returnering gjort (fel, falskt);
 }
 }
 )
 );
};

Kontrollera här om användaren finns i databasen, och om de gör det, kontrollera om det angivna lösenordet matchar det i databasen. Observera att du också ringer till matchPassword() metod på användarmodellen så gå till userModel.js fil och lägg till den.

UserSchema.methods.matchPassword = asynkronfunktion (lösenord) {
 Prova {
 return await bcrypt.compare (lösenord, detta.lösenord);
 } fånga (fel) {
 kasta nytt Fel (fel);
 }
};

Denna metod jämför lösenordet från användaren och lösenordet i databasen och returnerar sant om de matchar.

Steg 4: Ställ in autentiseringsrutter

Du måste nu skapa de slutpunkter som användare ska skicka data till. Först ut är registreringsvägen som kommer att acceptera e-post och lösenord för en ny användare.

I app.js, använd mellanvaran för passautentisering som du just skapade för att registrera användaren.

app.post(

 "/auth/registrering",
 passport.authenticate('local-signup', { session: false }),
 (req, res, nästa) => {
 // Bli Medlem
 res.json({
 användare: req.user,
 });
 }
);

Relaterad: Autentisering vs. Auktorisering: Vad är skillnaden?

Om den lyckas bör registreringsvägen returnera den skapade användaren.

Skapa sedan inloggningsrutten.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, nästa) => {
 // logga in
 res.json({
 användare: req.user,
 });
 }
);

Steg 5: Lägg till skyddade rutter

Hittills har du använt Pass för att skapa en mellanprogramvara som registrerar en användare i databasen och en annan som tillåter en registrerad användare att logga in. Därefter kommer du att skapa en auktoriseringsmellanprogramvara för att skydda känsliga rutter med hjälp av en JSON-webtoken (JWT). För att implementera JWT-auktorisering måste du:

• Generera JWT-token.
• Skicka token till användaren. Användaren kommer att skicka tillbaka det i auktoriseringsförfrågningar.
• Verifiera token som skickats tillbaka av användaren.

Du kommer att använda jsonwebtoken paket för att hantera JWT.

Kör följande kommando för att installera det.

npm i jsonwebtoken

Skapa sedan en token för varje användare som loggar in.

I app.js, importera jsonwebtoken och ändra inloggningsrutten enligt nedan.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, nästa) => {
 // logga in
 jwt.sign({user: req.user}, 'secretKey', {expiresIn: '1h'}, (fel, token) => {
 if (fel) {
 returnera res.json({
 meddelande: "Det gick inte att logga in",
 token: null,
 });
 }
 res.json({
 tecken
 });
 })
 }
);

I ett verkligt program skulle du använda en mer komplicerad hemlig nyckel och lagra den i en konfigurationsfil.

Inloggningsvägen returnerar en token om den lyckas.

Använda sig av pass-jwt för att komma åt skyddade vägar.

npm i pass-jwt

I passportConfig.js, konfigurera pass-jwt.

const JwtStrategy = require("passport-jwt").Strategy;
const { ExtractJwt } = require("passport-jwt")
module.exports = (pass) => {
passport.use(
 "lokal-inloggning",
 ny lokal strategi(
 ...
 );
passport.use(
 ny JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("auktorisation"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, klar) => {
 Prova {
 // Extrahera användare
 const användare = jwtPayload.user;
 gjort (null, användare);
 } fånga (fel) {
 gjort (fel, falskt);
 }
 }
 )
 );
};

Lägg märke till att du extraherar JWT från auktoriseringshuvudet istället för begärandekroppen. Detta förhindrar hackare från att fånga upp en begäran och ta tag i token.

För att se hur pass-jwt bevakar rutter, skapa en skyddad rutt i app.js.

app.get(
 "/användare/skyddad",
 passport.authenticate("jwt", { session: false }),
 (req, res, nästa) => {
 res.json({användare: req.användare});
 }
);

Endast en begäran med en giltig JWT returnerar användardata.

Nu är du redo att ta din användarautentisering till nästa nivå

I den här handledningen lärde du dig hur du kan autentisera användare med hjälp av en e-post och ett lösenord med hjälp av Passport. Det kan verka skrämmande till en början, men processen är relativt okomplicerad. Du kan gå ännu längre och använda tredjepartsidentitetsleverantörer som stöds av Passport som Twitter, Facebook och Google.

Vad är användarautentisering och hur fungerar det?

Det är viktigt att förstå grunderna för användarautentisering för att säkerställa maximal säkerhetsnivå för dina onlinekonton. Så, låt oss dyka in.

Läs Nästa

Om författaren