Autentizace uživatele v NodeJS pomocí Passport a MongoDB

Pokud chcete chránit citlivý obsah v aplikaci Node, potřebujete způsob, jak ověřit uživatele. Vybudování vlastního ověřovacího systému je však složité a časově náročné, a pokud není provedeno správně, může ve vaší aplikaci způsobit zranitelnosti zabezpečení. Nástroje třetích stran, jako je Passport, usnadňují ověřování.

V tomto tutoriálu se dozvíte, jak implementovat ověřování v Node pomocí Passport a MongoDB.

Co je autentizace a autorizace?

Zatímco autentizace a autorizace se někdy používají zaměnitelně, tyto dva bezpečnostní koncepty mají různé významy. Autentizace je proces ověření, že uživatel je tím, za koho se vydává, zatímco autorizace je tím proces určování, zda má ověřený uživatel přístup k určitým částem vaší aplikace.

Co je Passport.js?

Passport.js (nebo Passport) je autentizační middleware pro NodeJS, který poskytuje více než 500 strategií pro ověřování uživatelů, včetně pas-místní který používá uživatelské jméno a heslo.

Tento tutoriál používá pas-místní a pas-jwt k zabezpečení cest.

Jak nastavit ověřování uživatele v NodeJS

Nyní víte něco o ověřování uživatelů a Passport.js, můžeme se podívat na to, jak nastavit ověřování na NodeJS. Níže uvádíme kroky, které budete muset podniknout.

Krok 1: Nastavení serveru uzlu

Vytvořte složku s názvem user-auth-nodejs a přejděte k němu pomocí terminálu.

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

Další inicializace package.json.

npm init

Vzhledem k tomu, že budete používat Vyjádřit, backend framework NodeJS, nainstalujte jej spuštěním následujícího příkazu.

npm vyjadřuji

Nyní vytvořte soubor, app.jsa přidejte následující kód pro vytvoření serveru.

const express = require("express");
const app = express();
const PORT = 3000;
app.listen (PORT, () => {
console.log(`Poslouchání na portu ${PORT}`);
});

Příbuzný: Přečtěte si, jak nainstalovat Npm a Node.js na Ubuntu

Krok 2: Nastavte databázi

K ukládání uživatelských dat potřebujete databázi. Mongoose použijete k vytvoření datového schématu MongoDB, které definuje strukturu a typ dat, která budete ukládat do databáze. Protože ukládáte uživatelská data, vytvořte uživatelské schéma.

Nainstalujte mangoose.

npm i mangusta

Vytvořte nový soubor, userModel.jsa přidejte následující.

const mangoose = vyžadovat('mongoose')
const {Schéma} = mangusta
const UserSchema = nové schéma ({
 e-mailem: {
 typ: Řetězec,
 požadováno: pravda
 },
 Heslo: {
 typ: Řetězec,
 požadováno: pravda
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = UserModel;

Příbuzný: Jak vytvořit databázi a kolekci v MongoDB

Před uložením hesla jej musíte z bezpečnostních důvodů zašifrovat. budete používat bcryptjs, velmi užitečný balíček npm, který usnadňuje práci se šifrovanými hesly.

Nainstalujte bcryptjs.

npm a bcryptjs

Modifikovat usermodel.js k zašifrování hesla před jeho uložením do databáze.

const mangoose = vyžadovat('mongoose')
const bcrypt = require('bcryptjs');
const {Schéma} = mangusta
const UserSchema = nové schéma ({
...
})
UserSchema.pre('save', asynchronní funkce (další) {
 Snaž se {
 // kontrola způsobu registrace
 const user = toto;
 if (!user.isModified('heslo')) next();
 // generuje sůl
 const salt = čekat na bcrypt.genSalt (10);
 // hash heslo
 const hasshedPassword = čekat na bcrypt.hash (toto.heslo, sůl);
 // nahrazení hesla ve formátu prostého textu heslem hash
 this.password = hasshedPassword;
 další();
 } catch (chyba) {
 vrátit další (chyba);
 }
 });
...
const User = mongoose.model('User', UserSchema);

Zde používáte a předem uložit háček pro úpravu hesla před jeho uložením. Cílem je uložit hash verzi hesla namísto hesla ve formátu prostého textu. Hash je dlouhý složitý řetězec generovaný z řetězce prostého textu.

Použití isModified zkontrolovat, zda se heslo mění, protože potřebujete pouze hašovat nová hesla. Dále vygenerujte sůl a předejte ji s heslem ve formátu prostého textu metodě hash, aby se vygenerovalo heslo hash. Nakonec nahraďte heslo ve formátu prostého textu hašovaným heslem v databázi.

Vytvořte db.js a nakonfigurujte databázi.

const mangoose = vyžadovat("mongoose");
mangusta. Slib = globální. Slib;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mongoose.connection;
 db.on("chyba", () => {
 console.log("nelze se připojit");
 });
 db.once("open", () => {
 console.log("> Úspěšně připojeno k databázi");
 });
};
module.exports = { připojit };

V app.js se připojte k databázi.

// připojení k db
const db = vyžadovat('./db');
db.connect();

Krok 3: Nastavte Passport

Nainstalujte Cestovní pas a pas-místní. Tyto balíčky budete používat k registraci a přihlášení uživatelů.

npm i pas
npm i pas-místní

Vytvořte nový soubor, passportConfig.jsa importovat pas-místní a userModel.js.

const LocalStraregy = require("passport-local").Strategie;
const User = require("./userModel");

Nakonfigurujte službu Passport pro zpracování registrace uživatele.

const LocalStrategy = require("passport-local");
const User = require("./userModel");
module.exports = (pas) => {
 passport.use(
 "místní registrace",
 nová LocalStrategy(
 {
 usernameField: "e-mail",
 passwordField: "heslo",
 },
 async (e-mail, heslo, hotovo) => {
 Snaž se {
 // kontrola, zda uživatel existuje
 const userExists = wait User.findOne({ "e-mail": email });
 if (userExists) {
 return done (null, false)
 }
 // Vytvořte nového uživatele s poskytnutými uživatelskými daty
 const user = wait User.create({ email, heslo });
 return done (null, uživatel);
 } catch (chyba) {
 hotovo (chyba);
 }
 }
 )
 );
}

Ve výše uvedeném kódu kontrolujete, zda je e-mail již používán. Pokud e-mail neexistuje, zaregistrujte uživatele. Všimněte si, že také nastavujete pole uživatelského jména tak, aby přijímalo e-mail. Ve výchozím stavu, pas-místní očekává uživatelské jméno, takže mu musíte sdělit, že místo toho posíláte e-mail.

Použití pas-místní také zvládnout přihlášení uživatele.

module.exports = (pas) => {
 passport.use(
 "místní registrace",
 nová místní strategie(
 ...
 )
 );
passport.use(
 "místní přihlášení",
 nová LocalStrategy(
 {
 usernameField: "e-mail",
 passwordField: "heslo",
 },
 async (e-mail, heslo, hotovo) => {
 Snaž se {
 const user = wait User.findOne({ email: email });
 if (!user) return done (null, false);
 const isMatch = wait user.matchPassword (heslo);
 jestliže (!isMatch)
 return done (null, false);
 // pokud se hesla shodují, vrátí uživatel
 return done (null, uživatel);
 } catch (chyba) {
 console.log (chyba)
 return done (chyba, nepravda);
 }
 }
 )
 );
};

Zde zkontrolujte, zda uživatel v databázi existuje, a pokud ano, zkontrolujte, zda poskytnuté heslo odpovídá heslu v databázi. Všimněte si, že také voláte matchPassword() metoda na uživatelském modelu, takže přejděte na userModel.js soubor a přidejte jej.

UserSchema.methods.matchPassword = asynchronní funkce (heslo) {
 Snaž se {
 return wait bcrypt.compare (heslo, toto.heslo);
 } catch (chyba) {
 hodit nový Error (chyba);
 }
};

Tato metoda porovnává heslo od uživatele a heslo v databázi a vrátí hodnotu true, pokud se shodují.

Krok 4: Nastavte ověřovací cesty

Nyní musíte vytvořit koncové body, do kterých budou uživatelé posílat data. První na řadě je cesta registrace, která přijme e-mail a heslo nového uživatele.

v app.js, použijte k registraci uživatele právě vytvořený middleware pro ověřování pasů.

app.post(

 "/auth/registrace",
 passport.authenticate('local-signup', { session: false }),
 (req, res, next) => {
 // Přihlásit se
 res.json({
 uživatel: req.user,
 });
 }
);

Příbuzný: Autentizace vs. Autorizace: Jaký je rozdíl?

Pokud bude úspěšná, trasa registrace by měla vrátit vytvořeného uživatele.

Dále vytvořte přihlašovací trasu.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // přihlásit se
 res.json({
 uživatel: req.user,
 });
 }
);

Krok 5: Přidejte chráněné trasy

Doposud jste používali Cestovní pas vytvořit middleware, který zaregistruje uživatele do databáze, a další, který umožní registrovanému uživateli přihlásit se. Dále vytvoříte autorizační middleware pro ochranu citlivých tras pomocí webového tokenu JSON (JWT). Chcete-li implementovat autorizaci JWT, musíte:

• Vygenerujte token JWT.
• Předejte token uživateli. Uživatel jej zašle zpět v požadavcích na autorizaci.
• Ověřte token odeslaný zpět uživatelem.

Budete používat jsonwebtoken balíček pro manipulaci s JWT.

Spusťte následující příkaz a nainstalujte jej.

npm a jsonwebtoken

Dále vygenerujte token pro každého uživatele, který se úspěšně přihlásí.

v app.js, import jsonwebtoken a upravte cestu přihlášení, jak je uvedeno níže.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // přihlásit se
 jwt.sign({user: req.user}, 'secretKey', {expiresIn: '1h'}, (chyba, token) => {
 if (chyba) {
 return res.json({
 zpráva: "Přihlášení se nezdařilo",
 token: null,
 });
 }
 res.json({
 žeton
 });
 })
 }
);

V reálné aplikaci byste použili složitější tajný klíč a uložili jej do konfiguračního souboru.

Přihlašovací trasa v případě úspěchu vrátí token.

Použití pas-jwt pro přístup k chráněným trasám.

npm i pas-jwt

v passportConfig.js, nakonfigurujte pas-jwt.

const JwtStrategy = require("passport-jwt").Strategie;
const { ExtractJwt } = require("passport-jwt")
module.exports = (pas) => {
passport.use(
 "místní přihlášení",
 nová LocalStrategy(
 ...
 );
passport.use(
 nová JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("autorization"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, hotovo) => {
 Snaž se {
 // Extrahujte uživatele
 const user = jwtPayload.user;
 hotovo (null, uživatel);
 } catch (chyba) {
 hotovo (chyba, nepravda);
 }
 }
 )
 );
};

Všimněte si, že extrahujete JWT z autorizační hlavičky namísto těla požadavku. To zabraňuje hackerům zachytit požadavek a získat token.

Abyste viděli jak pas-jwt střeží cesty, vytvořte chráněnou cestu dovnitř app.js.

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

Uživatelská data vrátí pouze požadavek s platným JWT.

Nyní jste připraveni posunout ověřování uživatelů na další úroveň

V tomto tutoriálu jste se naučili, jak můžete ověřit uživatele pomocí e-mailu a hesla pomocí služby Passport. Zpočátku se to může zdát skličující, ale proces je poměrně přímočarý. Můžete jít ještě dále a používat poskytovatele identity třetích stran podporované službou Passport, jako jsou Twitter, Facebook a Google.

Co je autentizace uživatele a jak funguje?

Je důležité porozumět základům ověřování uživatelů, aby byla zajištěna maximální úroveň zabezpečení vašich online účtů. Pojďme se tedy ponořit.

Přečtěte si další

O autorovi