Uwierzytelnianie użytkownika w NodeJS przy użyciu Passport i MongoDB

Jeśli chcesz chronić poufne treści w aplikacji węzła, potrzebujesz sposobu na uwierzytelnianie użytkowników. Jednak budowanie własnego systemu uwierzytelniania jest złożone i czasochłonne, a jeśli nie zostanie wykonane poprawnie, może wprowadzić luki w zabezpieczeniach aplikacji. Narzędzia innych firm, takie jak Passport, ułatwiają uwierzytelnianie.

W tym samouczku dowiesz się, jak zaimplementować uwierzytelnianie w Node za pomocą Passport i MongoDB.

Co to jest uwierzytelnianie i autoryzacja?

Chociaż uwierzytelnianie i autoryzacja są czasami używane zamiennie, te dwie koncepcje bezpieczeństwa mają różne znaczenia. Uwierzytelnianie to proces sprawdzania, czy użytkownik jest tym, za kogo się podaje, podczas gdy autoryzacja jest proces określania, czy uwierzytelniony użytkownik ma dostęp do niektórych części Twojej aplikacji.

Co to jest Passport.js?

Paszport.js (lub Passport) to oprogramowanie pośredniczące do uwierzytelniania dla NodeJS, które zapewnia ponad 500 strategii uwierzytelniania użytkowników, w tym paszport-lokalny który używa nazwy użytkownika i hasła.

Ten samouczek wykorzystuje paszport-lokalny oraz paszport-jwt do zabezpieczania tras.

Jak skonfigurować uwierzytelnianie użytkownika w NodeJS

Teraz wiesz trochę o uwierzytelnianiu użytkowników i Passport.js, możemy przyjrzeć się, jak skonfigurować uwierzytelnianie w NodeJS. Poniżej przedstawiamy kroki, które musisz podjąć.

Krok 1: Skonfiguruj serwer węzła

Utwórz folder o nazwie user-auth-nodejs i przejdź do niego za pomocą terminala.

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

Następna inicjalizacja pakiet.json.

początek npm

Ponieważ będziesz używać Wyrazić, framework zaplecza NodeJS, zainstaluj go, uruchamiając następujące polecenie.

npm wyrażam

Teraz utwórz plik, app.jsi dodaj następujący kod, aby utworzyć serwer.

const express = require("ekspres");
const aplikacja = express();
const PORT = 3000;
app.listen (PORT, () => {
console.log(`Nasłuch na porcie ${PORT}`);
});

Związane z: Dowiedz się, jak zainstalować Npm i Node.js na Ubuntu

Krok 2: Skonfiguruj bazę danych

Potrzebujesz bazy danych do przechowywania danych użytkownika. Użyjesz mongoose do utworzenia schematu danych MongoDB, który definiuje strukturę i typ danych, które będą przechowywane w bazie danych. Ponieważ przechowujesz dane użytkownika, utwórz schemat użytkownika.

Zainstaluj mangusty.

npm ja mangusta

Utwórz nowy plik, userModel.jsi dodaj następujące.

const mangusta = require('mangusta')
const {Schemat} = mangusta
const UserSchema = nowy schemat ({
 e-mail: {
 typ: ciąg,
 wymagane: prawda
 },
 hasło: {
 typ: ciąg,
 wymagane: prawda
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = ModelUżytkownika;

Związane z: Jak utworzyć bazę danych i kolekcję w MongoDB

Przed przechowywaniem hasła należy je zaszyfrować ze względów bezpieczeństwa. Wykorzystasz bcryptjs, bardzo przydatny pakiet npm, który ułatwia pracę z zaszyfrowanymi hasłami.

zainstalować bcryptjs.

npm i bcryptjs

Modyfikować usermodel.js aby zaszyfrować hasło przed zapisaniem go w bazie danych.

const mangusta = require('mangusta')
const bcrypt = require('bcryptjs');
const {Schemat} = mangusta
const UserSchema = nowy schemat ({
...
})
UserSchema.pre('save', funkcja asynchroniczna (następna) {
 próbować {
 // sprawdź sposób rejestracji
 const użytkownik = to;
 if (!user.isModified('hasło')) next();
 // generuj sól
 const sól = czekaj bcrypt.genSalt (10);
 // hash hasło
 const hashedPassword = czekaj bcrypt.hash (this.password, salt);
 // zamień hasło w postaci zwykłego tekstu na hasło haszowane
 this.password = hashedPassword;
 Następny();
 } złapać (błąd) {
 powróć dalej (błąd);
 }
 });
...
const Użytkownik = mongoose.model('Użytkownik', UserSchema);

Tutaj używasz przed zapisaniem hook, aby zmodyfikować hasło przed jego zapisaniem. Pomysł polega na przechowywaniu hash wersji hasła zamiast hasła w postaci zwykłego tekstu. Hash to długi, złożony ciąg wygenerowany ze zwykłego ciągu tekstowego.

Stosowanie jest zmodyfikowana aby sprawdzić, czy hasło się zmienia, ponieważ wystarczy zahaszować nowe hasła. Następnie wygeneruj sól i przekaż ją z hasłem w postaci zwykłego tekstu do metody skrótu, aby wygenerować hasło zaszyfrowane. Na koniec zamień hasło w postaci zwykłego tekstu na hasło zaszyfrowane w bazie danych.

Utwórz db.js i skonfiguruj bazę danych.

const mangusta = require("mangusta");
mangusta. Obietnica = globalna. Obietnica;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mangusta.connection;
 db.on("błąd", () => {
 console.log("nie można się połączyć");
 });
 db.once("otwarty", () => {
 console.log("> Pomyślnie połączono z bazą danych");
 });
};
module.exports = { połącz };

W app.js połącz się z bazą danych.

// połącz z db
const db = wymagaj('./db');
db.connect();

Krok 3: Skonfiguruj paszport

zainstalować Paszport oraz paszport-lokalny. Pakiety te będą używane do rejestracji i logowania użytkowników.

npm i paszport
npm i paszport-lokalny

Utwórz nowy plik, paszportConfig.jsi importu paszport-lokalny i userModel.js.

const LocalStraregy = require("passport-local").Strategy;
const Użytkownik = wymagaj("./userModel");

Skonfiguruj Paszport do obsługi rejestracji użytkownika.

const LocalStrategy = require("passport-local");
const Użytkownik = wymagaj("./userModel");
module.exports = (paszport) => {
 paszport.użycie(
 "rejestracja lokalna",
 nowa strategia lokalna(
 {
 usernameField: "e-mail",
 passwordField: "hasło",
 },
 async (e-mail, hasło, gotowe) => {
 próbować {
 // sprawdź, czy użytkownik istnieje
 const userExists = await User.findOne({ "email": email });
 jeśli (użytkownik istnieje) {
 zwróć gotowe (null, false)
 }
 // Utwórz nowego użytkownika z podanymi danymi użytkownika
 const user = await User.create({ email, password });
 return done (null, user);
 } złapać (błąd) {
 zrobione (błąd);
 }
 }
 )
 );
}

W powyższym kodzie sprawdzasz, czy e-mail jest już używany. Jeśli e-mail nie istnieje, zarejestruj użytkownika. Pamiętaj, że ustawiasz również pole nazwy użytkownika, aby akceptować wiadomość e-mail. Domyślnie, paszport-lokalny oczekuje nazwy użytkownika, więc musisz powiedzieć, że zamiast tego przekazujesz wiadomość e-mail.

Stosowanie paszport-lokalny do obsługi logowania użytkownika.

module.exports = (paszport) => {
 paszport.użycie(
 "rejestracja lokalna",
 nowa strategia lokalna(
 ...
 )
 );
paszport.użycie(
 "Logowanie lokalne",
 nowa strategia lokalna(
 {
 usernameField: "e-mail",
 passwordField: "hasło",
 },
 async (e-mail, hasło, gotowe) => {
 próbować {
 const user = await User.findOne({ email: email });
 if (!user) return done (null, false);
 const isMatch = await user.matchPassword (hasło);
 jeśli (!isMatch)
 return done (null, false);
 // jeśli hasła pasują do powrotu użytkownika
 return done (null, user);
 } złapać (błąd) {
 console.log (błąd)
 zwrot wykonany (błąd, fałsz);
 }
 }
 )
 );
};

W tym miejscu sprawdź, czy użytkownik istnieje w bazie danych, a jeśli tak, sprawdź, czy podane hasło jest zgodne z tym w bazie. Zauważ, że nazywasz również dopasujhasło() metoda na modelu użytkownika, więc przejdź do userModel.js plik i dodaj go.

UserSchema.methods.matchPassword = funkcja asynchroniczna (hasło) {
 próbować {
 return await bcrypt.compare (hasło, this.password);
 } złapać (błąd) {
 wyrzuć nowy błąd (błąd);
 }
};

Ta metoda porównuje hasło od użytkownika z hasłem w bazie danych i zwraca true, jeśli są zgodne.

Krok 4: Skonfiguruj trasy uwierzytelniania

Teraz musisz utworzyć punkty końcowe, do których użytkownicy będą wysyłać dane. Najpierw jest ścieżka rejestracji, która zaakceptuje adres e-mail i hasło nowego użytkownika.

w app.js, użyj utworzonego właśnie oprogramowania pośredniczącego do uwierzytelniania paszportu, aby zarejestrować użytkownika.

aplikacja.post(

 "/uwierz/rejestracja",
 paszport.authenticate('local-signup', { session: false }),
 (req, res, next) => {
 // Zapisz się
 res.json({
 użytkownik: żądany użytkownik,
 });
 }
);

Związane z: Uwierzytelnianie a Autoryzacja: jaka jest różnica?

Jeśli się powiedzie, ścieżka rejestracji powinna zwrócić utworzonego użytkownika.

Następnie utwórz ścieżkę logowania.

aplikacja.post(
 "/uwierz/logowanie",
 paszport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Zaloguj sie
 res.json({
 użytkownik: żądany użytkownik,
 });
 }
);

Krok 5: Dodaj chronione trasy

Do tej pory używałeś Paszport aby utworzyć oprogramowanie pośredniczące, które rejestruje użytkownika w bazie danych i inne, które umożliwia zalogowanie się zarejestrowanemu użytkownikowi. Następnie utworzysz oprogramowanie pośredniczące autoryzacji, aby chronić wrażliwe trasy za pomocą tokena internetowego JSON (JWT). Aby zaimplementować autoryzację JWT, musisz:

• Wygeneruj token JWT.
• Przekaż token użytkownikowi. Użytkownik odeśle go w prośbach o autoryzację.
• Sprawdź token odesłany przez użytkownika.

Użyjesz jsonwebtoken pakiet do obsługi tokenów JWT.

Uruchom następujące polecenie, aby go zainstalować.

npm i jsonwebtoken

Następnie wygeneruj token dla każdego użytkownika, który pomyślnie się zaloguje.

w app.js, import jsonwebtoken i zmodyfikuj ścieżkę logowania jak poniżej.

aplikacja.post(
 "/uwierz/logowanie",
 paszport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Zaloguj sie
 jwt.sign({user: req.user}, 'secretKey', {expiresIn: '1h'}, (err, token) => {
 jeśli (błąd) {
 return res.json({
 komunikat: „Nie udało się zalogować”,
 token: null,
 });
 }
 res.json({
 znak
 });
 })
 }
);

W rzeczywistej aplikacji użyjesz bardziej skomplikowanego tajnego klucza i przechowasz go w pliku konfiguracyjnym.

Trasa logowania zwraca token, jeśli się powiedzie.

Stosowanie paszport-jwt aby uzyskać dostęp do chronionych tras.

npm i paszport-jwt

w paszportConfig.js, skonfiguruj paszport-jwt.

const JwtStrategy = require("paszport-jwt").Strategia;
const { ExtractJwt } = require("passport-jwt")
module.exports = (paszport) => {
paszport.użycie(
 "Logowanie lokalne",
 nowa strategia lokalna(
 ...
 );
paszport.użycie(
 nowa strategia Jwt(
 {
 jwtFromRequest: ExtractJwt.fromHeader("autoryzacja"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, gotowe) => {
 próbować {
 // Wyodrębnij użytkownika
 const user = jwtPayload.user;
 gotowe (null, użytkownik);
 } złapać (błąd) {
 zrobione (błąd, fałsz);
 }
 }
 )
 );
};

Zwróć uwagę, że wyodrębniasz token JWT z nagłówka autoryzacji, a nie z treści żądania. Zapobiega to przechwyceniu żądania przez hakerów i przechwyceniu tokena.

Aby zobaczyć jak paszport-jwt chroni trasy, stwórz chronioną trasę w app.js.

aplikacja.pobierz(
 "/użytkownik/chroniony",
 paszport.authenticate("jwt", { sesja: fałsz }),
 (req, res, next) => {
 res.json({użytkownik: żądany.użytkownik});
 }
);

Tylko żądanie z poprawnym tokenem JWT zwraca dane użytkownika.

Teraz jesteś gotowy, aby przenieść swoje uwierzytelnianie użytkownika na wyższy poziom

W tym samouczku dowiedziałeś się, jak możesz uwierzytelniać użytkowników za pomocą adresu e-mail i hasła za pomocą usługi Passport. Na początku może się to wydawać zniechęcające, ale proces jest stosunkowo prosty. Możesz pójść jeszcze dalej i korzystać z zewnętrznych dostawców tożsamości obsługiwanych przez Passport, takich jak Twitter, Facebook i Google.

Co to jest uwierzytelnianie użytkownika i jak to działa?

Aby zapewnić maksymalny poziom bezpieczeństwa kont internetowych, ważne jest zrozumienie podstaw uwierzytelniania użytkowników. Więc zanurkujmy.

Czytaj dalej

O autorze