Autentifikácia používateľa v NodeJS pomocou Passport a MongoDB

Ak chcete chrániť citlivý obsah v aplikácii Node, potrebujete spôsob autentifikácie používateľov. Vybudovanie vlastného autentifikačného systému je však zložité a časovo náročné, a ak nie je vykonané správne, môže vo vašej aplikácii spôsobiť slabé miesta. Nástroje tretích strán, ako je Passport, uľahčujú autentifikáciu.

V tomto návode sa naučíte, ako implementovať autentifikáciu v Node pomocou Passport a MongoDB.

Čo je autentifikácia a autorizácia?

Zatiaľ čo autentifikácia a autorizácia sa niekedy používajú zameniteľne, tieto dva bezpečnostné koncepty majú rozdielny význam. Autentifikácia je proces overenia toho, za koho sa používateľ vydáva, zatiaľ čo autorizácia je tým proces určenia, či má overený používateľ prístup k určitým častiam vašej aplikácie.

Čo je Passport.js?

Passport.js (alebo Passport) je autentizačný middleware pre NodeJS, ktorý poskytuje viac ako 500 stratégií na autentifikáciu používateľov vrátane pas-miestny ktorý používa používateľské meno a heslo.

Tento tutoriál používa pas-miestny a pas-jwt na zabezpečenie ciest.

Ako nastaviť autentifikáciu používateľa v NodeJS

Teraz už viete niečo o autentifikácii používateľov a Passport.js, môžeme sa pozrieť na to, ako nastaviť autentifikáciu na NodeJS. Nižšie uvádzame kroky, ktoré budete musieť podniknúť.

Krok 1: Nastavte server uzlov

Vytvorte priečinok s názvom user-auth-nodejs a prejdite k nemu pomocou terminálu.

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

Ďalej inicializujte package.json.

npm init

Keďže budete používať expresné, backend framework NodeJS, nainštalujte ho spustením nasledujúceho príkazu.

npm vyjadrujem sa

Teraz vytvorte súbor, app.jsa pridajte nasledujúci kód na vytvorenie servera.

const express = vyžadovať("expres");
const app = express();
const PORT = 3000;
app.listen (PORT, () => {
console.log(`Počúvanie na porte ${PORT}`);
});

Súvisiace: Zistite, ako nainštalovať Npm a Node.js na Ubuntu

Krok 2: Nastavte databázu

Na ukladanie používateľských údajov potrebujete databázu. Mongoose použijete na vytvorenie dátovej schémy MongoDB, ktorá definuje štruktúru a typ údajov, ktoré budete ukladať do databázy. Keďže ukladáte údaje používateľa, vytvorte schému používateľa.

Nainštalujte mangoose.

npm aj mangusta

Vytvorte nový súbor, userModel.jsa pridajte nasledujúce.

const mongoose = vyžadovať('mongoose')
const {Schéma} = mongoose
const UserSchema = new Schema ({
 email: {
 typ: reťazec,
 požadované: pravda
 },
 heslo: {
 typ: reťazec,
 požadované: pravda
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = UserModel;

Súvisiace: Ako vytvoriť databázu a kolekciu v MongoDB

Pred uložením hesla ho musíte z bezpečnostných dôvodov zašifrovať. Budete používať bcryptjs, veľmi užitočný balík npm, ktorý uľahčuje prácu so šifrovanými heslami.

Inštalácia bcryptjs.

npm a bcryptjs

Upraviť usermodel.js na zašifrovanie hesla pred jeho uložením do databázy.

const mongoose = vyžadovať('mongoose')
const bcrypt = require('bcryptjs');
const {Schéma} = mongoose
const UserSchema = new Schema ({
...
})
UserSchema.pre('save', async function (next) {
 skúste {
 // kontrola spôsobu registrácie
 const user = toto;
 if (!user.isModified('heslo')) next();
 // vygeneruje soľ
 const salt = wait bcrypt.genSalt (10);
 // hash heslo
 const hashedPassword = čakať na bcrypt.hash (toto.heslo, soľ);
 // nahradenie hesla vo formáte obyčajného textu hashovaným heslom
 this.password = hashedPassword;
 Ďalšie();
 } catch (chyba) {
 návrat ďalej (chyba);
 }
 });
...
const User = mongoose.model('User', UserSchema);

Tu používate a vopred uložiť hák na úpravu hesla pred jeho uložením. Cieľom je uložiť hash verziu hesla namiesto hesla vo formáte obyčajného textu. Hash je dlhý zložitý reťazec vygenerovaný z jednoduchého textového reťazca.

Použite isModified aby ste skontrolovali, či sa heslo mení, pretože potrebujete iba hashovať nové heslá. Potom vygenerujte soľ a odovzdajte ju spolu s heslom vo formáte obyčajného textu hashovacej metóde, aby sa vygenerovalo hashované heslo. Nakoniec nahraďte heslo vo formáte obyčajného textu hašovaným heslom v databáze.

Vytvorte db.js a nakonfigurujte databázu.

const mongoose = vyžadovať("mongoose");
mangusta. Sľub = globálny. Sľub;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mongoose.connection;
 db.on("chyba", () => {
 console.log("nepodarilo sa pripojiť");
 });
 db.once("open", () => {
 console.log("> Úspešne pripojené k databáze");
 });
};
module.exports = { connect };

V app.js sa pripojte k databáze.

// pripojenie k db
const db = vyžadovať('./db');
db.connect();

Krok 3: Nastavte Passport

Inštalácia pas a pas-miestny. Tieto balíčky budete používať na registráciu a prihlásenie používateľov.

npm a pas
npm i pas-miestne

Vytvorte nový súbor, passportConfig.jsa importovať pas-miestny a userModel.js.

const LocalStraregy = require("passport-local").Stratégia;
const User = require("./userModel");

Nakonfigurujte službu Passport na spracovanie registrácie používateľa.

const LocalStrategy = require("passport-local");
const User = require("./userModel");
module.exports = (pas) => {
 passport.use(
 "miestna registrácia",
 nová LocalStrategy(
 {
 usernameField: "e-mail",
 hesloPole: "heslo",
 },
 async (e-mail, heslo, hotovo) => {
 skúste {
 // skontrolujte, či používateľ existuje
 const userExists = wait User.findOne({ "e-mail": email });
 if (userExists) {
 návrat hotový (null, false)
 }
 // Vytvorenie nového používateľa s poskytnutými používateľskými údajmi
 const user = wait User.create({ email, heslo });
 return done (null, user);
 } catch (chyba) {
 hotovo (chyba);
 }
 }
 )
 );
}

Vo vyššie uvedenom kóde kontrolujete, či sa e-mail už používa. Ak e-mail neexistuje, zaregistrujte používateľa. Upozorňujeme, že tiež nastavujete pole používateľského mena na prijímanie e-mailu. Predvolene, pas-miestny očakáva používateľské meno, takže mu musíte povedať, že namiesto toho posielate e-mail.

Použite pas-miestny tiež zvládnuť prihlásenie používateľa.

module.exports = (pas) => {
 passport.use(
 "miestna registrácia",
 nová miestna stratégia(
 ...
 )
 );
passport.use(
 "miestne prihlásenie",
 nová LocalStrategy(
 {
 usernameField: "e-mail",
 hesloPole: "heslo",
 },
 async (e-mail, heslo, hotovo) => {
 skúste {
 const user = wait User.findOne({ email: email });
 if (!user) return done (null, false);
 const isMatch = čaká na používateľa.matchPassword (heslo);
 ak (!isMatch)
 return done (null, false);
 // ak sa heslá zhodujú, vráti používateľ
 return done (null, user);
 } catch (chyba) {
 console.log (chyba)
 návrat vykonaný (chyba, nepravda);
 }
 }
 )
 );
};

Tu skontrolujte, či používateľ existuje v databáze, a ak áno, skontrolujte, či sa poskytnuté heslo zhoduje s heslom v databáze. Všimnite si, že zavoláte aj na matchPassword() na používateľskom modeli, takže prejdite na userModel.js súbor a pridajte ho.

UserSchema.methods.matchPassword = async function (heslo) {
 skúste {
 return wait bcrypt.compare (heslo, toto.heslo);
 } catch (chyba) {
 hodiť nový Error (chyba);
 }
};

Táto metóda porovnáva heslo používateľa a heslo v databáze a vráti hodnotu true, ak sa zhodujú.

Krok 4: Nastavte overovacie trasy

Teraz musíte vytvoriť koncové body, do ktorých budú používatelia odosielať údaje. Prvá je cesta registrácie, ktorá akceptuje e-mail a heslo nového používateľa.

In app.js, použite na registráciu používateľa midlvér na overenie pasu, ktorý ste práve vytvorili.

app.post(

 "/auth/registrácia",
 passport.authenticate('local-signup', { session: false }),
 (req, res, next) => {
 // Prihlásiť Se
 res.json({
 užívateľ: req.user,
 });
 }
);

Súvisiace: Autentifikácia vs. Autorizácia: Aký je rozdiel?

Ak bude úspešný, trasa registrácie by mala vrátiť vytvoreného používateľa.

Ďalej vytvorte prihlasovaciu cestu.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Prihlásiť sa
 res.json({
 užívateľ: req.user,
 });
 }
);

Krok 5: Pridajte chránené trasy

Doteraz ste používali pas vytvoriť middleware, ktorý zaregistruje používateľa do databázy, a ďalší, ktorý umožní registrovanému používateľovi prihlásiť sa. Ďalej vytvoríte autorizačný middleware na ochranu citlivých trás pomocou webového tokenu JSON (JWT). Ak chcete implementovať autorizáciu JWT, musíte:

• Vygenerujte token JWT.
• Odovzdajte token používateľovi. Používateľ ho pošle späť v žiadostiach o autorizáciu.
• Overte token odoslaný späť používateľom.

Budete používať jsonwebtoken balík na manipuláciu s JWT.

Spustite nasledujúci príkaz a nainštalujte ho.

npm a jsonwebtoken

Ďalej vygenerujte token pre každého používateľa, ktorý sa úspešne prihlási.

In app.js, dovoz jsonwebtoken a upravte cestu prihlásenia, ako je uvedené nižšie.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Prihlásiť sa
 jwt.sign({user: req.user}, 'secretKey', {expiresIn: '1h'}, (chyba, token) => {
 if (chyba) {
 return res.json({
 správa: "Nepodarilo sa prihlásiť",
 token: null,
 });
 }
 res.json({
 žetón
 });
 })
 }
);

V reálnej aplikácii by ste použili komplikovanejší tajný kľúč a uložili ho do konfiguračného súboru.

Ak je prihlasovacia cesta úspešná, vráti token.

Použite pas-jwt na prístup k chráneným trasám.

npm a pas-jwt

In passportConfig.js, nakonfigurujte pas-jwt.

const JwtStrategy = require("passport-jwt").Stratégia;
const { ExtractJwt } = required("passport-jwt")
module.exports = (pas) => {
passport.use(
 "miestne prihlásenie",
 nová LocalStrategy(
 ...
 );
passport.use(
 nová JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("autorizácia"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, hotovo) => {
 skúste {
 // Extrahujte používateľa
 const user = jwtPayload.user;
 hotovo (null, užívateľ);
 } catch (chyba) {
 hotovo (chyba, nepravda);
 }
 }
 )
 );
};

Všimnite si, že extrahujete JWT z hlavičky autorizácie namiesto tela požiadavky. To bráni hackerom zachytiť požiadavku a získať token.

Ak chcete vidieť ako pas-jwt stráži cesty, vytvorte chránenú cestu v app.js.

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

Údaje používateľa vráti iba žiadosť s platným JWT.

Teraz ste pripravení posunúť autentifikáciu používateľa na ďalšiu úroveň

V tomto návode ste sa naučili, ako môžete autentifikovať používateľov pomocou e-mailu a hesla pomocou služby Passport. Na prvý pohľad sa to môže zdať skľučujúce, ale proces je pomerne jednoduchý. Môžete ísť ešte ďalej a používať poskytovateľov identity tretích strán podporovaných službou Passport, ako sú Twitter, Facebook a Google.

Čo je autentifikácia používateľa a ako funguje?

Je dôležité porozumieť základom overovania používateľov, aby ste zaistili maximálnu úroveň zabezpečenia vašich online účtov. Takže, poďme sa ponoriť.

Prečítajte si ďalej

O autorovi