Die Benutzerauthentifizierung ist der Prozess der Überprüfung der Identität eines Benutzers, der versucht, Zugriff auf Ihre Anwendung zu erhalten. Es beinhaltet die Autorisierung und Übertragung von Anmeldeinformationen, um die Authentizität eines Benutzers zu bestätigen.

Sie können in wenigen Schritten ein einfaches Benutzerauthentifizierungsmodell in Node.js mit Express, Bcrypt und MongoDB implementieren.

Schritt 1: Entwicklungsumgebung einrichten

Erstellen Sie zunächst einen Projektordner und CD hinein, indem Sie Folgendes ausführen:

mkdir Benutzerauthentifizierung
CD Benutzerauthentifizierung

Als nächstes initialisieren Sie npm in Ihrem Projektverzeichnis, indem Sie Folgendes ausführen:

npm init -y

Das -y flag initialisiert npm und erstellt Ihre Paket.json Datei mit all ihren Voreinstellungen.

Dieses Benutzerauthentifizierungsmodell erfordert einige Abhängigkeiten.

Sie beinhalten:

  • Äußern: Express ist ein Node.js-Framework das einen robusten Satz von Funktionen für Web- und mobile Anwendungen bietet. Es erleichtert das Erstellen von Backend-Anwendungen mit Node.js.
  • Bcrypt: bcrypt ist ein npm-Paket, das die bcrypt-Passwort-Hashing-Funktion implementiert. Es ermöglicht Ihnen, Hashes aus einfachen Passwortzeichenfolgen zu erstellen.
  • Mongoose: Mongoose ist eine Objektdatenmodellierungsbibliothek von MongoDB. Es vereinfacht die Interaktionen zwischen Ihrer App und einer MongoDB-Datenbank.
  • dotenv: dotenv ist ein Zero-Dependency-Paket, das Umgebungsvariablen aus a lädt .env Datei hinein process.env.
  • Validator: validator ist ein Paket, das verschiedene String-Validierungsfunktionen enthält.
  • Body-Parser: Das Body-Parser-Paket analysiert Anforderungstexte in einer Middleware vor Ihren Handlern.

Installieren Sie die Pakete, indem Sie Folgendes ausführen:

npm Installieren express bcrypt mongoose dotenv validator Karosserie-Parser

Als nächstes erstellen Sie eine app.js Datei im Stammverzeichnis Ihres Projekts und fügen Sie den folgenden Codeblock hinzu, um einen einfachen Express-Server zu erstellen:

// app.js
konst ausdrücken = benötigen('ausdrücken');
konst app = ausdrücken ();
konst bodyParser = benötigen("Body-Parser");
konst Hafen = 3000;


App.verwenden(bodyParser.json());
App.verwenden(bodyParser.urlencodiert({ erweitert: Stimmt }));
app.listen (Port, ()=>{
Konsole.Protokoll(`App lauscht am Port ${port}`);
});

Dieser Code erstellt eine Express-Anwendungsinstanz durch Aufrufen der Express-Funktion. Es verwendet dann die Body-Parser Middleware zum Analysieren eingehender Anforderungstexte. Dann beginnt es, auf Port 3000 auf Datenverkehr zu lauschen, indem es die Listen-Methode der Express-Instanz aufruft und die Port-Variable als Argument übergibt.

Schritt 2: Verbinden Sie Ihre Anwendung mit einer Datenbank

Erstellen Sie im Stammverzeichnis Ihres Projekts eine .env -Datei und speichern Sie Ihre MongoDB-Anmeldeinformationen darin. Dadurch wird vermieden, dass Ihre Datenbankanmeldeinformationen im Code offengelegt werden, wodurch böswillige Benutzer Zugriff auf Ihre Datenbank erhalten können.

Navigieren Sie als Nächstes zu Ihrer app.js Datei und Import Mongoose:

konst Mungo = benötigen("Mungo");

Rufen Sie dann import auf dotenv und ruf die an Konfig Methode drauf:

benötigen("dotenv").config();

Aufruf der Konfig Methode an dotenv lädt Umgebungsvariablen in die process.env.

Rufen Sie abschließend die connect-Methode auf Mungo und übergeben Sie Ihren MongoDB-URI als Argument:

mongoose.connect (process.env. MONGODB_URI).then(() => {
 Konsole.log ('Verbindung zur Datenbank erfolgreich hergestellt')
})

Schritt 3: Benutzermodell erstellen

Erstellen Sie im Stammverzeichnis Ihres Projekts ein „Modelle" Mappe; Hier speichern Sie Ihr Mungo-Modell:

mkdir-Modelle

Erstellen Sie als Nächstes ein „Benutzermodell”-Datei und fügen Sie die folgenden Importe hinzu:

konst Mungo = benötigen('Mungo')
konst { ist E-Mail } = benötigen('Bestätiger')

istE-Mail ist eine Validierungsfunktion, die zurückkehrt Stimmt wenn eine bestimmte Zeichenfolge eine E-Mail ist. Sie benötigen es, um die Mungo-Validierung auf Ihr Benutzermodell anzuwenden.

Fügen Sie als Nächstes den folgenden Code zu Ihrer hinzu Benutzermodell Datei:

// Modelle/Benutzermodell
konst userSchema = Mungo. Schema({
 Email: {
 Typ: Schnur,
 erforderlich: [wahr, 'E-Mail ist erforderlich'],
 validieren: {
 Prüfer: isEmail,
 Nachricht: Requisiten => `${props.value} ist keine gültige E-Mail-Adresse
 }
 },
Passwort: {
 Typ: Schnur,
 erforderlich: [wahr, 'Passwort wird benötigt'],
 validieren: {
 Prüfer: Funktion (Wert) {
Rückkehr wert.länge >= 6
 },
 Nachricht: () =>'Das Passwort muss mindestens sechs Zeichen lang sein'
 }
 }
})
Modul.Exporte = mongoose.model('Benutzer', Benutzerschema)

Der obige Code erstellt a userSchema Variable, die den Wert von speichert Mungo. Schema Methode. Der Mungo. Die Schema-Methode ordnet Eigenschaften einer MongoDB-Sammlung zu und definiert die Form der darin enthaltenen Dokumente. Das Mungo-Schema hat zwei Eigenschaften – eine Email und ein Passwort– das sind Ihre Authentifizierungsanforderungen.

Die E-Mail-Eigenschaft ist ein String-Typ und hat erforderlich auf wahr setzen. Die begleitende Fehlermeldung „E-Mail ist erforderlich“ wird angezeigt, wenn ein Anfragetext keine enthält Email Eigentum. Schließlich wird mit der benutzerdefinierten Mongoose-Validierung die Prüfer Eigenschaft bezieht sich auf die istE-Mail Funktion. Diese Funktion gibt basierend auf der Gültigkeit der Zeichenfolge als E-Mail wahr oder falsch zurück. Dann übernimmt die Nachrichteneigenschaft den E-Mail-Wert (Requisiten) und konstruiert eine aussagekräftige Fehlermeldung.

Die Kennworteigenschaft ist ein erforderlicher Zeichenfolgentyp mit einer Fehlermeldung, die lautet: „Kennwort ist erforderlich“. Das Prüfer Die Funktion ist eine anonyme, die true zurückgibt, wenn das Passwort mindestens sechs Zeichen lang ist.

Die letzte Zeile erstellt und exportiert ein Mungo-Modell, indem sie die Modell Methode an Mungo. Übergeben Sie den Modellnamen (Benutzer) als erstes Argument und ein Schema (userSchema) als zweites Argument.

Schritt 4: Implementieren von Anmelde- und Registrierungsrouten

Erstellen Sie im Stammverzeichnis Ihres Projekts eine Strecken Mappe:

mkdir-Routen

Erstellen Sie in Ihrem Routenordner eine userRoutes.js Datei und fügen Sie die folgenden Importe hinzu:

// routen/userRoutes.js
konst ausdrücken = benötigen("ausdrücken");
konst Benutzer = benötigen("../models/userModel");
konst bcrypt = benötigen("bcrypt");

Erstellen Sie eine Express Router-Instanz, indem Sie die aufrufen Router Methode an ausdrücken:

konst Router = Express. Router();

Erstellen Sie als Nächstes Ihre Anmelderoute, indem Sie den folgenden Codeblock zu Ihrer hinzufügen userRoute.js Datei:

router.post("/sign-up", asynchron (req, res) => {
Versuchen {
// E-Mail und Passwort aus dem req.body-Objekt extrahieren
konst { E-Mail, Passwort } = req.body;
// Prüfenwenn die Email ist schon inverwenden
Lassen userExists = erwarten User.findOne({E-Mail});


if (userExistiert) {
 res.status(401).json({ Nachricht: "E-Mail ist bereits da verwenden.&Zitat; });
Rückkehr;
 }


// Salzrunden definieren
konst Salzrunden = 10;


// Hash-Passwort
 bcrypt.hash (Passwort, SaltRounds, (err, Hash) => {
wenn (irren) WurfNeuFehler("Interner Server Fehler");


// Schaffen a NeuBenutzer
Lassen Benutzer = Neu Benutzer({
 Email,
 Passwort: Hasch,
 });
// Benutzer in Datenbank speichern
 user.save().then(() => {
 res.json({ Nachricht: "Benutzer erfolgreich erstellt", Benutzer });
 });
 });
 } Fang (irren) {
Rückkehrres.Status(401).senden(irren.Botschaft);
 }
});

Im obigen Codeblock haben Sie zuerst die E-Mail und das Passwort aus der destrukturiert req.body Objekt. Überprüfen Sie dann, ob ein Benutzer die E-Mail bereits verwendet, da sie für jeden Benutzer eindeutig sein sollte. Wenn die E-Mail bereits verwendet wurde, kehren Sie zurück und stoppen die Codeausführung mit einem 401-Statuscode.

Das Speichern von einfachen Passwörtern in einer Datenbank ist eine große Sicherheitsbedrohung, da böswillige Hacker Zugriff auf die Datenbank erhalten könnten. Sie sollten Passwörter hashen, bevor Sie sie in Ihre Datenbank speichern, sodass selbst dann, wenn ein Hacker sie entdeckt, kein Risiko für die Benutzer besteht. Hashing ist der Prozess der Umwandlung eines bestimmten „Schlüssels“ in einen anderen Wert. Hashing ist eine Einwegfunktion, was bedeutet, dass Sie im Gegensatz zur Verschlüsselung den ursprünglichen Wert nicht aus dem Hashwert abrufen können.

Mit bcrypt hast du gehasht Ihr Benutzerpasswort, indem Sie die Hash-Methode auf bcrypt aufrufen. Die Hash-Methode benötigt drei Parameter: die zu hashende Zeichenfolge, Salt-Runden und eine Callback-Funktion. Sie übergeben das Benutzerkennwort, die zuvor erstellte SaltRounds-Variable und einen Rückruf.

Salt-Runden beziehen sich auf die Zeit, die benötigt wird, um einen einzelnen Bcrypt-Hash zu berechnen. Je höher die Salt-Runden, desto mehr Hashing-Runden.

Wenn die Hash-Methode einen Fehler auslöst, werfen Sie einen „internen Serverfehler“ aus. Andernfalls setzen Sie die Eigenschaft password auf den erfolgreichen Hash und speichern ihn in Ihrer Datenbank, indem Sie die save-Methode auf aufrufen Benutzer Beispiel.

Erstellen Sie als Nächstes Ihre Anmelderoute, indem Sie den folgenden Codeblock zu Ihrer hinzufügen userRoute.js Datei:

router.post("/sign-in", asynchron (req, res) => {
Versuchen {
// E-Mail und Passwort aus dem req.body-Objekt extrahieren
konst { E-Mail, Passwort } = req.body;
// PrüfenwennBenutzerexistiertinDatenbank
Lassen Benutzer = erwarten User.findOne({E-Mail});


if (!Benutzer) {
 return res.status (401).json({ Nachricht: "Ungültige Anmeldeinformationen" });
 }


// Passwörter vergleichen
 bcrypt.compare (Passwort, Benutzer.Passwort, (Fehler, Ergebnis) => {
 wenn (Ergebnis) {
 return res.status (200).json({ Nachricht: "Benutzer erfolgreich angemeldet" });
 }


Konsole.log (fehler);
 return res.status (401).json({ Nachricht: "Ungültige Anmeldeinformationen" });
 });
 } Fang (Error) {
res.Status(401).senden(irren.Botschaft);
 }
});
Modul.Exporte = Router;

Im obigen Codeblock destrukturieren Sie zunächst die E-Mail und das Passwort aus der req.body Objekt. Dann prüfen Sie, ob ein Benutzer in Ihrer Datenbank vorhanden ist. Wenn der Benutzer nicht in Ihrer Datenbank vorhanden ist, kehren Sie mit einem 401-Statuscode zurück.

Geben Sie als Nächstes mit der Vergleichsmethode von bcrypt das vom Benutzer bereitgestellte Passwort und das gehashte Passwort ein, das Sie aus Ihrer Datenbank abgerufen haben. Vergleichen Sie die beiden, um zu bestätigen, ob sie übereinstimmen. Wenn die Passwörter übereinstimmen, geben Sie einen 200-Statuscode und eine Erfolgsmeldung zurück. Andernfalls geben Sie einen 401-Statuscode und eine Fehlermeldung zurück.

Schließlich importieren Router in dein app.js -Datei und verwenden Sie sie als Middleware auf Anwendungsebene.

Dies vervollständigt Ihr Benutzerauthentifizierungsmodell; Jetzt können sich Benutzer sicher bei Ihrer Anwendung registrieren und anmelden.

Die Bedeutung der Benutzerauthentifizierung

Die Benutzerauthentifizierung stellt sicher, dass nur berechtigte Benutzer Zugriff auf Ihre Anwendung erhalten. Wenn Ihre Daten in irgendeiner Weise persönlich oder privat sind, sollten Sie Maßnahmen ergreifen, um zu verhindern, dass nicht authentifizierte Benutzer Zugriff erhalten.