Autenticazione utente in NodeJS utilizzando Passport e MongoDB

Se vuoi proteggere i contenuti sensibili nella tua applicazione Node, hai bisogno di un modo per autenticare gli utenti. Tuttavia, la creazione del proprio sistema di autenticazione è complessa e richiede tempo e, se non eseguita correttamente, può introdurre vulnerabilità di sicurezza nell'applicazione. Strumenti di terze parti come Passport semplificano l'autenticazione.

In questo tutorial imparerai come implementare l'autenticazione in Node usando Passport e MongoDB.

Cosa sono l'autenticazione e l'autorizzazione?

Sebbene l'autenticazione e l'autorizzazione siano talvolta utilizzate in modo intercambiabile, questi due concetti di sicurezza hanno significati diversi. L'autenticazione è il processo per verificare che un utente sia chi afferma di essere mentre l'autorizzazione è il processo per determinare se un utente autenticato ha accesso a determinate parti dell'applicazione.

Cos'è Passport.js?

Passport.js (o Passport) è un middleware di autenticazione per NodeJS che fornisce più di 500 strategie per l'autenticazione degli utenti, tra cui

passaporto locale che utilizza un nome utente e una password.

Questo tutorial utilizza passaporto locale e passaporto-jwt per proteggere le rotte.

Come configurare l'autenticazione utente in NodeJS

Ora che conosci un po' di autenticazione utente e Passport.js, possiamo vedere come impostare l'autenticazione su NodeJS. Di seguito, abbiamo delineato i passaggi che dovrai intraprendere.

Passaggio 1: configurare un server nodo

Crea una cartella denominata utente-auth-nodejs e vai ad esso usando il tuo terminale.

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

Avanti inizializza pacchetto.json.

npm init

Dal momento che utilizzerai Esprimere, un framework di backend NodeJS, installalo eseguendo il comando seguente.

npm esprimo

Ora crea un file, app.jse aggiungi il codice seguente per creare il server.

const express = require("express");
const app = express();
cost PORT = 3000;
app.ascolta (PORTA, () => {
console.log(`Ascolto sulla porta ${PORT}`);
});

Imparentato: Scopri come installare Npm e Node.js su Ubuntu

Passaggio 2: configurare il database

Hai bisogno di un database per memorizzare i dati degli utenti. Utilizzerai mongoose per creare uno schema di dati MongoDB che definisce la struttura e il tipo di dati che memorizzerai nel database. Poiché si archiviano i dati utente, creare uno schema utente.

Installa la mangusta.

npm io mangusta

Crea un nuovo file, userModel.jse aggiungi quanto segue.

const mangusta = require('mangusta')
const {Schema} = mangusta
const UserSchema = nuovo schema ({
 e-mail: {
 tipo: stringa,
 richiesto: vero
 },
 parola d'ordine: {
 tipo: stringa,
 richiesto: vero
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = Modello Utente;

Imparentato: Come creare un database e una raccolta in MongoDB

Prima di memorizzare la password, è necessario crittografarla per motivi di sicurezza. Userai bcryptjs, un pacchetto npm molto utile che semplifica il lavoro con password crittografate.

Installare bcryptjs.

npm e bcryptjs

Modificare usermodel.js per crittografare la password prima di salvarla nel database.

const mangusta = require('mangusta')
const bcrypt = require('bcryptjs');
const {Schema} = mangusta
const UserSchema = nuovo schema ({
...
})
UserSchema.pre('salva', funzione asincrona (successiva) {
 Tentativo {
 // controlla il metodo di registrazione
 const utente = questo;
 if (!user.isModified('password')) next();
 // genera sale
 const salt = attendi bcrypt.genSalt (10);
 // hash la password
 const hashPassword = await bcrypt.hash (this.password, salt);
 // Sostituisci la password in testo normale con la password hash
 this.password = hashPassword;
 prossimo();
 } cattura (errore) {
 ritorna successivo (errore);
 }
 });
...
const User = mongoose.model('User', UserSchema);

Qui stai usando a pre-salvataggio hook per modificare la password prima che venga salvata. L'idea è di memorizzare la versione hash della password invece della password in testo normale. Un hash è una lunga stringa complessa generata da una stringa di testo normale.

Utilizzo isModificato per verificare se la password sta cambiando poiché devi solo eseguire l'hashing delle nuove password. Quindi, genera un salt e passalo con la password in testo normale al metodo hash per generare la password con hash. Infine, sostituisci la password in testo normale con la password con hash nel database.

Crea db.js e configura il database.

const mangusta = require("mangusta");
mangusta. Promessa = globale. Promettere;
const dbUrl = "mongodb://localhost/utente";
const connect = asincrono () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mongoose.connection;
 db.on("errore", () => {
 console.log("Impossibile connettersi");
 });
 db.once("aperto", () => {
 console.log("> Collegato con successo al database");
 });
};
module.exports = {connetti};

In app.js, connettiti al database.

// connettiti a db
const db = require('./db');
db.connect();

Passaggio 3: imposta il passaporto

Installare Passaporto e passaporto locale. Utilizzerai questi pacchetti per registrare e accedere agli utenti.

npm i passaporto
npm i passaporto-locale

Crea un nuovo file, passaportoConfig.jse importare passaporto locale e il userModel.js.

const LocalStraregy = require("passport-local").Strategy;
const Utente = require("./userModel");

Configura Passport per gestire la registrazione degli utenti.

const LocalStrategy = require("passaporto-locale");
const Utente = require("./userModel");
module.exports = (passaporto) => {
 passaporto.usa(
 "registrazione locale",
 nuova Strategia Locale(
 {
 usernameCampo: "email",
 passwordCampo: "password",
 },
 asincrono (e-mail, password, fatto) => {
 Tentativo {
 // controlla se l'utente esiste
 const userExists = await User.findOne({ "email": email });
 se (utente esiste) {
 ritorno fatto (null, false)
 }
 // Crea un nuovo utente con i dati utente forniti
 const user = await User.create({ email, password });
 ritorno fatto (null, user);
 } cattura (errore) {
 fatto (errore);
 }
 }
 )
 );
}

Nel codice sopra, stai controllando se l'e-mail è già in uso. Se l'e-mail non esiste, registra l'utente. Tieni presente che stai anche impostando il campo del nome utente per accettare un'e-mail. Per impostazione predefinita, passaporto locale si aspetta un nome utente, quindi devi dirgli che stai passando un'e-mail.

Utilizzo passaporto locale per gestire anche il login utente.

module.exports = (passaporto) => {
 passaporto.usa(
 "registrazione locale",
 nuova strategia locale(
 ...
 )
 );
passaporto.usa(
 "login locale",
 nuova Strategia Locale(
 {
 usernameCampo: "email",
 passwordCampo: "password",
 },
 asincrono (e-mail, password, fatto) => {
 Tentativo {
 const user = await User.findOne({ email: email });
 if (!user) return done (null, false);
 const isMatch = attendi user.matchPassword (password);
 se (!isMatch)
 ritorno fatto (null, false);
 // se le password corrispondono all'utente di ritorno
 ritorno fatto (null, user);
 } cattura (errore) {
 console.log (errore)
 ritorno fatto (errore, falso);
 }
 }
 )
 );
};

Qui, controlla se l'utente esiste nel database e, in tal caso, controlla se la password fornita corrisponde a quella nel database. Nota che chiami anche il corrispondenzaPassword() metodo sul modello utente, quindi vai a userModel.js file e aggiungilo.

UserSchema.methods.matchPassword = funzione asincrona (password) {
 Tentativo {
 return await bcrypt.compare (password, this.password);
 } cattura (errore) {
 lancia un nuovo errore (errore);
 }
};

Questo metodo confronta la password dell'utente e quella nel database e restituisce true se corrispondono.

Passaggio 4: impostare percorsi di autenticazione

Ora devi creare gli endpoint a cui gli utenti invieranno i dati. Il primo è il percorso di registrazione che accetterà l'e-mail e la password di un nuovo utente.

Nel app.js, utilizza il middleware di autenticazione del passaporto appena creato per registrare l'utente.

app.post(

 "/ autenticazione/registrazione",
 passport.authenticate('local-signup', {session: false }),
 (req, res, successivo) => {
 // iscrizione
 res.json({
 utente: utente richiesto,
 });
 }
);

Imparentato: Autenticazione vs. Autorizzazione: qual è la differenza?

In caso di successo, il percorso di registrazione dovrebbe restituire l'utente creato.

Quindi, crea il percorso di accesso.

app.post(
 "/autorizzazione/accesso",
 passport.authenticate('local-login', { session: false }),
 (req, res, successivo) => {
 // Accedere
 res.json({
 utente: utente richiesto,
 });
 }
);

Passaggio 5: aggiungi percorsi protetti

Finora hai usato Passaporto per creare un middleware che registra un utente nel database e un altro che consente a un utente registrato di accedere. Successivamente, creerai un middleware di autorizzazione per proteggere i percorsi sensibili utilizzando un token Web JSON (JWT). Per implementare l'autorizzazione JWT, è necessario:

• Genera token JWT.
• Passa il token all'utente. L'utente lo rispedirà nelle richieste di autorizzazione.
• Verificare il token restituito dall'utente.

Userai il jsonwebtoken pacchetto per gestire i JWT.

Esegui il comando seguente per installarlo.

npm e jsonwebtoken

Quindi, genera un token per ogni utente che accede correttamente.

Nel app.js, importare jsonwebtoken e modifica il percorso di accesso come di seguito.

app.post(
 "/autorizzazione/accesso",
 passport.authenticate('local-login', { session: false }),
 (req, res, successivo) => {
 // Accedere
 jwt.sign({utente: req.user}, 'secretKey', {expiresIn: '1h'}, (err, token) => {
 se (err) {
 restituisce res.json({
 messaggio: "Accesso fallito",
 gettone: nullo,
 });
 }
 res.json({
 gettone
 });
 })
 }
);

In un'applicazione reale, useresti una chiave segreta più complicata e la memorizzeresti in un file di configurazione.

Il percorso di accesso restituisce un token in caso di esito positivo.

Utilizzo passaporto-jwt per accedere a percorsi protetti.

npm i passaporto-jwt

Nel passaportoConfig.js, configurare il passaporto-jwt.

const JwtStrategy = require("passport-jwt").Strategy;
const { EstraiJwt } = require("passport-jwt")
module.exports = (passaporto) => {
passaporto.usa(
 "login locale",
 nuova Strategia Locale(
 ...
 );
passaporto.usa(
 nuova JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader ("autorizzazione"),
 secretOrKey: "secretKey",
 },
 asincrono (jwtPayload, fatto) => {
 Tentativo {
 // Estrai utente
 const utente = jwtPayload.user;
 fatto (null, utente);
 } cattura (errore) {
 fatto (errore, falso);
 }
 }
 )
 );
};

Nota che stai estraendo il JWT dall'intestazione dell'autorizzazione anziché dal corpo della richiesta. Ciò impedisce agli hacker di intercettare una richiesta e prendere il token.

Per vedere come passaporto-jwt custodisce percorsi, crea un percorso protetto in app.js.

app.get(
 "/utente/protetto",
 passport.authenticate("jwt", {session: false }),
 (req, res, successivo) => {
 res.json({utente: req.utente});
 }
);

Solo una richiesta con un JWT valido restituisce i dati utente.

Ora sei pronto per portare la tua autenticazione utente al livello successivo

In questo tutorial, hai imparato come autenticare gli utenti utilizzando un'e-mail e una password con l'aiuto di Passport. All'inizio potrebbe sembrare scoraggiante, ma il processo è relativamente semplice. Puoi andare ancora oltre e utilizzare provider di identità di terze parti supportati da Passport come Twitter, Facebook e Google.

Che cos'è l'autenticazione utente e come funziona?

È importante comprendere le basi dell'autenticazione utente per garantire il massimo livello di sicurezza per i tuoi account online. Quindi, tuffiamoci.

Leggi Avanti

Circa l'autore