Transkripte
1. Kurseinführung: Willkommen zurück zum
Express Jazz-Kurs, Modell Neun, Authentifizierung
und Autorisierung. Mein Name ist ShenraGunhi und ich werde Ihr Lehrer
für dieses spannende Modul sein Im Laufe der Jahre hatte ich
das Privileg, sichere,
skalierbare Backend-Systeme für
eine Vielzahl von Anwendungen zu
entwickeln ,
und ich bin hier, um mein Fachwissen mit Ihnen zu teilen Eines meiner besten Projekte
war die Entwicklung eines Benutzerauthentifizierungssystems
für eine E-Commerce-Plattform, wodurch die Sicherheit und Benutzerfreundlichkeit erheblich verbessert Heute wirst du lernen, etwas
aufzubauen, das
genauso wirkungsvoll In diesem Modul befassen wir uns
eingehend mit Authentifizierung
und Autorisierung, zwei kritischen Aspekten der
modernen Webentwicklung Sie lernen also, wie Sie
Benutzer sicher mit
Hash-Passwörtern registrieren , Benutzer
mit JCN-Webtkens
authentifizieren, sensible
Routen mit Middleware
schützen
und schließlich
eine rollenbasierte Autorisierung zur Verwaltung von Benutzerberechtigungen implementieren Benutzer
mit JCN-Webtkens
authentifizieren, sensible
Routen mit Middleware
schützen
und schließlich
eine rollenbasierte Autorisierung zur Verwaltung von Benutzerberechtigungen implementieren. Dieses Wissen ist entscheidend für die Sicherung jeder
Backend-Anwendung,
und am Ende dieses Moduls werden
Sie sicher sein, diese Funktionen werden
Sie sicher sein für die Sicherung jeder
Backend-Anwendung,
und am Ende dieses Moduls werden
Sie sicher sein, diese Funktionen in Ihren Projekten zu implementieren. Daher ist dieses Modul
für Entwickler konzipiert, die ihre
Express-JS-Anwendungen auf die nächste Stufe heben
möchten Express-JS-Anwendungen auf die nächste Stufe heben Wenn Sie
die vorherigen Module abgeschlossen haben, können Sie loslegen. Grundkenntnisse in JavaScript, ohne JS und Monger
DB werden empfohlen Authentifizierung und
Autorisierung sind Eckpfeiler jeder
sicheren Webanwendung diese Konzepte beherrschen, können Sie nicht nur
sicherere Anwendungen entwickeln, sondern auch Ihren
Wert als Entwickler steigern Diese
Fähigkeiten sind unverzichtbar, um
benutzerorientierte Plattformen
in der heutigen Technologiewelt zu schaffen benutzerorientierte Plattformen
in der heutigen Technologiewelt Und schließlich werden Sie für das Projekt
alles, was
Sie
gelernt haben, in die
Fair Wheels-App integrieren . Genauer gesagt werden
Sie Funktionen zur
Benutzerregistrierung und
Anmeldung implementieren Funktionen zur
Benutzerregistrierung und
Anmeldung Benutzer
mithilfe von JCN-Webtoken
sicher authentifizieren Wenden Sie die rollenbasierte Autorisierung an, um Routen und Ressourcen zu schützen Am Ende werden Sie über ein sicheres und skalierbares
Benutzerverwaltungssystem für die Fair Wheels App verfügen. Dieses Modul ist ein entscheidender Faktor für Ihre
Entwicklungsreise bei Bend Lassen Sie uns also gemeinsam sichere
Anwendungen entwickeln. Wir sehen uns in der ersten
Vorlesung. Lass uns anfangen.
2. Authentifizierung und Autorisierung – Eine Einführung: In Ordnung, also zurück zu unserer
Fair Wheels-Anwendung. Bisher haben wir
diese API-Endpunkte erstellt. So können wir Unternehmen,
Autos, Kunden und Vermietungen verwalten Autos, Kunden und Vermietungen Mittlerweile
erfordern fast alle
Anwendungen irgendeine Art von
Authentifizierung und Autorisierung. In diesem Abschnitt
werden wir diese
Anwendung auf
die nächste Ebene bringen und Authentifizierung
und Autorisierung
implementieren. Bevor wir also weitermachen, möchte
ich sicherstellen, dass
wir auf derselben Wellenlänge sind. Authentifizierung
ist also der Prozess wird, ob der Benutzer der ist
, für den er sich ausgibt. Dann melden wir uns an. Also senden wir unseren Benutzer und unser
Passwort an den Server und der Server authentifiziert uns Autorisierung wird festgestellt, ob der Benutzer über die
erforderlichen Berechtigungen verfügt , um den angegebenen Vorgang auszuführen In unserer Fair
Wheels-Anwendung möchten
wir also sicherstellen, dass
nur authentifizierte Benutzer oder nur angemeldete Benutzer Operationen ausführen
können, bei denen Daten geändert werden Wenn der Benutzer also anonym ist und nicht angemeldet ist, kann
er nur Daten
von diesen Endpunkten lesen Wenn sie ein neues
Unternehmen gründen oder ein Auto aktualisieren möchten, müssen
sie sich zuerst
authentifizieren Als zusätzliche Sicherheit möchten
wir nun sicherstellen, dass nur Admin-Benutzer Daten löschen
können Das ist also eine zweite
Autorisierungsebene. Wir sprechen hier über
Genehmigungen. Das sind also die Anforderungen die
wir
in diesem Abschnitt implementieren werden. Um dies zu tun, müssen wir unserer Anwendung zwei neue Endpunkte
hinzufügen Erstens sollten wir in der
Lage sein, Benutzer zu registrieren. Dafür werden wir eine Post-Anfrage an Slash
API Slash USERS
senden , weil wir posten,
wir neue Ressourcen erstellen In diesem Fall ein neuer Benutzer. Wir sollten auch in der
Lage sein, einen Benutzer anzumelden, und das wird zur
Authentifizierung verwendet. Nun, hier ist eine Frage an dich. Welche SDDP-Methode sollten wir
verwenden, um die Anmeldung zu implementieren? Denn mit der Anmeldung erstellen wir
keine neue Ressource. Wir aktualisieren oder
entfernen keine bestehende. Wie können wir
das also erholsam umsetzen? Dies ist eines der
Szenarien, denen Sie in
realen Anwendungen häufig
begegnen können in
realen Anwendungen häufig
begegnen Manchmal verfügt die Operation, mit der Sie es zu tun
haben, nicht über diese Semantik zum Erstellen, Lesen, Aktualisieren und Löschen Wir modellieren dies
in restful-Begriffen indem wir dies
als Anfrage oder Befehl bezeichnen Sie erstellen also eine neue Login-Anfrage oder
einen Login-Befehl In diesem Fall verwenden wir
Post, weil wir eine neue Ressource
erstellen,
also verwenden wir einen Schrägstrich für API-Logins Jetzt in Ihrer Anwendung möchten Sie
vielleicht
alle Anmeldungen in der Anwendung in einer separaten
Sammlung in
Mongo Deb speichern Anwendung in einer separaten
Sammlung in
Mongo Sie können also sehen, dass die Verwendung von Post
hier absolut sinnvoll ist. Aber auch wenn Sie keine
einzelnen Logins speichern und nur
den Benutzer und das Passwort validieren möchten, können
Sie
diese Ressource dennoch als
Login-Ressource behandeln und
post verwenden, um sie zu erstellen Nun, hier ist eine Übung für dich. Ich möchte, dass Sie diese
API implementieren, um neue Benutzer zu registrieren. also für jeden Benutzer Wir möchten also für jeden Benutzer
diese Eigenschaften,
Namen, E-Mail-Adresse und Passwort haben . Wenn
Sie Ihr Schema für
die E-Mail-Eigenschaft
im Schematyp-Objekt definieren,
setzen Sie außerdem die E-Mail-Eigenschaft
im Schematyp-Objekt definieren, die eindeutige Eigenschaft auf true. Wenn wir also das Schema definieren, legen
wir den E-Mail-Typ auf ein Objekt fest, das unser
Schematyp-Objekt ist. Wir setzen den Typ hier auf string und auch unique auf true. Damit stellen wir sicher,
dass wir nicht
zwei Dokumente mit
derselben E-Mail in Mongo Di B speichern .
Okay. Machen Sie also weiter und implementieren Sie nur diese API
, um neue Benutzer zu registrieren Ich werde dasselbe
in der nächsten Vorlesung tun.
3. Das Benutzermodell erstellen: Ordnung. Also werde
ich zuerst
ein neues Benutzermodell definieren. Also hier im Modellordner
in einer neuen Datei user dot js. Um Zeit zu sparen, gehe
ich zur Firma dot js und leihe mir von hier
etwas Code Kopieren Sie also zurück zu userdtjs und fügen Sie es hier ein. Jetzt oben, also
haben wir dieses Schema. Ich werde das definieren, während ich die Modellmethode
aufrufe. In
diesem Fall ist es wirklich nicht nötig , dies
als separate Konstante zu definieren. Holen wir uns also dieses
Schemaobjekt und fügen es hier hinzu. Und jetzt können wir dieses Schema
loswerden. Okay, das ist besser. Also das ist unser Modell. Wir sollten das
Constant User nennen. Und die entsprechende Sammlung
sollte auch Benutzer sein. Hier haben wir nun die
Eigenschaft name, was eine Zeichenfolge ist. Es ist erforderlich und besteht 5-50 Zeichen. Das
klingt für mich gut Als Nächstes fügen wir E-Mail hinzu. Also werde ich mir all
das Gute schnappen und es duplizieren. Und die zweite
Eigenschaft ist E-Mail. Also nochmal, wir haben
diese Eigenschaften. Ich möchte
die maximale Länge
auf 255 Zeichen erhöhen . Außerdem sollten
wir, wie ich Ihnen
in der letzten Vorlesung gesagt habe, die einzigartige
Eigenschaft hinzufügen, um sicherzustellen, dass wir nicht zwei Benutzer mit
derselben E-Mail-Adresse in Manga Divi speichern Und die letzte Eigenschaft ist Passwb. Also werde ich das alles kopieren,
duplizieren und diese Passwort-Eigenschaft hinzufügen Jetzt werde ich die
maximale Länge von Passwörtern auf
einen höheren Wert setzen , weil wir diese Passwörter hashen
werden. Und hier brauchen wir
die einzigartige Immobilie nicht. Als nächstes kommt unsere Validierungsfunktion. Also müssen wir
das umbenennen, um den Benutzer zu validieren. Überprüfen Sie den Benutzer,
der einen Benutzerparameter verwendet. Hier haben wir einen Namen, der
5-50 Zeichen lang ist und erforderlich ist Wir haben eine E-Mail, die 5-255 Zeichen
lang sein sollte. Sie sollte erforderlich sein.
Und hier rufen wir auch die E-Mail-Methode auf, um
sicherzustellen, dass es sich um eine gültige E-Mail handelt. Und schließlich haben wir ein Passwort, das ebenfalls eine Zeichenfolge mit mindestens fünf Zeichen
und maximal, sagen
wir, 255 Zeichen ist, je nach Bedarf. Das ist also das Passwort, das der Benutzer im Klartext sendet. Wir werden das hashen, was eine längere Zeichenfolge
sein wird, und das ist die Zeichenfolge, die wir in Mongo TV speichern
werden Wir sind also mit unserer
gültigen Benutzerfunktion fertig. Jetzt müssen wir
unser Benutzermodell exportieren, sodass wir nicht die
erste Exportanweisung für
das Löschen unseres Schemas benötigen . Hier werden wir das als Benutzer
exportieren, und unsere
Validierungsfunktion ist auch gut. Wunderschön. Wir sind also
mit unserem Benutzermodell fertig. In der nächsten Vorlesung werde
ich
eine Route hinzufügen , um neue Benutzer zu registrieren.
4. Benutzerregistrierung: In Ordnung. Jetzt werden wir
eine neue Route erstellen , um neue Benutzer zu
registrieren. Also hier im Routenordner werde
ich eine neue
Datei users dot js hinzufügen. Zeit zu sparen, gehe
ich jetzt wieder zu
companies dot js und kopiere diese erforderlichen
Anweisungen
sowie die zweite Route
in unser neues Modul. Also kopiere es, füge es hier ein. Kopieren Sie erneut die Post-Route. Und hier einfügen. Und übrigens, ich mache das nur, weil
ich
Ihre Zeit nicht damit verschwenden will, mir
zuzusehen, wie ich das alles von Hand tippe. In der realen Welt sollten
Sie den
Copy-Paste-Ansatz vermeiden, es sei denn,
Sie sind sehr vorsichtig und werden
jede einzelne Zeile
des kopierten Codes lesen , um sicherzustellen, dass
Sie keinen Fehler gemacht haben. Es ist immer besser,
den Code von Hand einzugeben. Lassen Sie uns jetzt Änderungen vornehmen. Obendrein müssen
wir also das
Benutzermodell anstelle des Unternehmens importieren. Aus Models User importieren
wir also die Benutzerklasse sowie die
Validierungsfunktion. Wir brauchen auch Express und Router. Also hier ist unsere neue Route, die für die Erstellung neuer Benutzer vorgesehen
ist. Und schließlich
müssen wir diesen Router exportieren. Also Modul Dot Exports. Wir haben das auf diesen Router eingestellt. Jetzt müssen wir zu
unserem Indexpunkt JS zurückkehren und Express mitteilen , dass wir für alle Routen, die mit dem Schrägstrich ABS SRS
beginnen, diesen Router verwenden sollten
, den wir hier exportieren Gehen wir also zu Index oder Js. Lassen Sie uns oben dieses neue Modul
importieren. Also ständige Benutzer. Wir haben das so eingestellt, dass
vom Routenordner Benutzer verlangt werden. Und dann rufen wir hier
Apps auf, die unserem Pfad einen
Schrägstrich geben , APAs Benutzer und unseren
Router, also Okay, wir haben also
das große Ganze aufgebaut. Kehren wir nun zu unserem
Benutzermodul zurück und implementieren wir
diese neue Route. Also hier werden wir die Anfrage
validieren. Wenn sie nicht gültig ist, geben
wir
einen 400-Fehler zurück , was eine schlechte Anfrage
ist. Andernfalls erstellen
wir ein neues Benutzerobjekt und
speichern es in der Datenbank. Also werden wir
die ersten beiden Zeilen
genau so lassen , wie sie sind. Wir möchten die Anfrage validieren. Wir verwenden unsere
Joy-Validierungsfunktion. Wenn also die Eigenschaften
Name, E-Mail oder Passwort nicht gültig sind, geben
wir dem Client einen
400-Fehler zurück. Als Nächstes müssen wir
eine andere Art der Validierung durchführen. Sie möchten sicherstellen, dass dieser Benutzer nicht
bereits registriert ist. Also nennen wir den Benutzer dot Fine one, übergeben hier ein Abfrageobjekt. Wir suchen nach einem Benutzer mit einer bestimmten E-Mail, bei der es sich um eine
Anfrage mit einem Textpunkt als E-Mail handelt. Beachten Sie also, dass
ich hier nicht fine by
ID verwendet habe, da wir den
Benutzer
nicht anhand seiner ID suchen. Wir suchen sie anhand
einer ihrer Eigenschaften. So ein feiner. Nun, das
ist ein Versprechen. Also warten wir darauf und
bekommen ein Benutzerobjekt. In diesem Fall
definiere ich nun eine Variable statt
einer Konstante, weil
wir sie zurücksetzen
werden, wie Sie gleich sehen werden. In diesem Fall sollten wir also, wenn
wir dieses
Benutzerobjekt in der Datenbank haben, einen Fehler bei der fehlerhaften
Anfrage an den Client zurückgeben. also den
Antwortstatus 400 zurück, was dem Punkt Senden der schlechten Anfrage entspricht und hier ist die Nachricht, dass der
Benutzer bereits registriert ist. Zu diesem Zeitpunkt haben wir also
ein gültiges Benutzerobjekt. Dieser Benutzer ist nicht
in der Datenbank registriert, daher müssen wir diesen
Benutzer in der Datenbank speichern. Also hier werde ich
dieses Benutzerobjekt zurücksetzen, weil es zu diesem Zeitpunkt nein sein sollte. Wir setzen das auf einen neuen Benutzer und hier legen wir die Eigenschaften fest. Also Name, wir stellen das so ein, dass Punktkörper, Punktname
angefordert wird. E-Mail, um eine
Dot Body Dot E-Mail anzufordern. Und Passwort, um das
Dot Body-Passwort anzufordern. Das ist also unser Benutzerobjekt. Jetzt speichern wir es. Warten Sie also, der Benutzer speichert es und geben Sie
es schließlich an den Client zurück. Also brauchen wir diese beiden Zeilen nicht um mit dem Unternehmen zu arbeiten. Löschen. Und schließlich geben diesen neuen Benutzer an den Client zurück.
Lassen Sie uns das jetzt testen. Also, zurück in Postman, werde
ich
eine Post-Anfrage an den
Local Host Port 3.000
Slash APAS USERS senden Local Host Port 3.000
Slash APAS Und dann werde
ich das im Hauptteil
der Anfrage auf Raw
und den Typ auf JSON setzen Hier übergeben wir ein JSON-Objekt
mit drei Eigenschaften, name, Shiv, und dann setzen wir E-Mail Ich werde
eine ungültige E-Mail einrichten und ich werde auch kein Passwort festlegen Ich möchte sicherstellen, dass unsere Validierungsfunktion
ordnungsgemäß funktioniert. Also sende. Okay, wir
haben eine schlechte Anfrage. Das ist gut. Die Länge des Namens muss mindestens fünf
Zeichen lang sein. Lassen Sie mich das
in Hewnder Alright ändern. Lassen Sie uns jetzt eine weitere Anfrage senden. Wir haben eine weitere schlechte Anfrage. Die E-Mail-Länge muss
mindestens fünf Zeichen lang sein. Also ändern wir
das auf 12, drei, vier, fünf, sechs, aber das
ist keine gültige E-Mail. Jetzt sollten wir also
einen anderen Fehler bekommen. E-Mail muss eine gültige E-Mail sein. Wunderschön. Also lass uns das ändern , um 123 auf regmil.com zu testen Lassen Sie uns eine weitere Anfrage senden. Okay, jetzt bekommen wir, dass
ein Passwort erforderlich ist. Wunderschön. Abschließend fügen wir ein Passwort hinzu, das mindestens
fünf Zeichen lang ist. Also eins, zwei, drei,
vier, fünf, Senden. Diesmal erhielten wir eine Antwort von 200. Wunderschön. Und das ist das Benutzerobjekt, das Sie in der Datenbank
gespeichert haben. Sie haben also die ID-Eigenschaft
sowie Name, E-Mail
und Passwort. Wenn wir jetzt
einen neuen Benutzer registrieren, möchten
wir dessen
Passwort nicht an den Client zurückgeben. Das werden
wir also in der nächsten Vorlesung
beheben. Aber lassen Sie uns eine weitere Anfrage
mit genau den gleichen Werten senden . Diesmal sollten wir einen anderen Fehler
erhalten, der uns
mitteilt, dass der Benutzer bereits registriert
ist. Also sende. Okay, wir haben
eine weitere schlechte Anfrage und hier ist die Nachricht. Benutzer ist bereits
registriert. Wunderschön. In der nächsten Vorlesung werden
wir also die
Antwort dieser API modifizieren und darauf hinweisen.
5. Lodash verwenden: Zurück in unserer Post-Methode wollen
wir also die
Antwort an den Client ändern Hier gibt es also zwei Möglichkeiten. Ein Ansatz besteht darin,
ein benutzerdefiniertes Objekt wie dieses zurückzugeben den Namen
auf Benutzerpunktnamen
und E-Mail auf Benutzerpunkt-E-Mail zu
setzen . Auf diese Weise können wir
das Passwort und die
Versionseigenschaften ausschließen . Dieser Ansatz ist völlig in
Ordnung, aber in diesem Vortrag werde
ich Ihnen eine nützliche Bibliothek vorstellen, die Ihnen viele
Hilfsfunktionen für die Arbeit mit Objekten bietet. Wenn Sie ein erfahrener
JavaScript-Entwickler sind, wissen
Sie wahrscheinlich, wovon ich
spreche . Das ist Lourdes Also geh rüber zu lodash.com. Das ist Lodash, was
im Grunde die optimierte
Version von Underscore ist im Grunde die optimierte
Version Underscore gibt es
schon lange. Es hat viele Utility-Engines
für die Arbeit mit Objekten, Zeichenketten, Arrays usw. Wenn Sie also in
der Dokumentation nachschauen, können wir
hier alle Hilfsfunktionen sehen
,
die wir für die Arbeit
mit verschiedenen Typen haben Wir haben viele
Hilfsfunktionen für die Arbeit mit Arrays, Zahlen, Zeichenketten,
Objekten usw. Lodash ist also extrem mächtig. Und in diesem Vortrag werde
ich
Ihnen zeigen, wie Sie es in
Ihrer Node-Anwendung verwenden Also zurück im Terminal,
NPM installiere Lodash. Beachten Sie also, dass ich in der aktuellen
Version 4.17 0.21 verwende. Alles klar, jetzt wieder im Code. Also hier in unserem
Benutzermodell oben werde
ich Lodash importieren Benötige also Lodash. Konventionell speichern wir
das Ergebnis nun in einer Konstante
namens Underscore Sie können das alles nennen, Sie können es Lodash nennen, aber laut Konvention verwenden wir
Unterstriche, weil
das kurz und sauber ist Nun hat dieses
Underscore-Objekt, das wir hier
haben, eine
Hilfsmethode namens pick so underscore Wir geben dem ein Objekt. In diesem Fall unser Benutzerobjekt und dann übergeben wir eine Reihe
von Eigenschaften in diesem Benutzerobjekt, die
wir auswählen möchten. Und das wird ein neues Objekt
mit nur diesen Eigenschaften
zurückgeben . Also hier in diesem Array werde
ich
Namen und E-Mail weitergeben. Wenn wir also
diese Pick-Methode aufrufen, erhalten
wir ein neues Objekt mit diesen beiden Eigenschaften,
Name und E-Mail. Anstatt den Benutzerpunkt manuell
zu wiederholen, können
wir jetzt diese Pi-Methode verwenden. Das ist eleganter. Also können wir dieses Objekt
hier durch das ersetzen , was wir
von der PI-Methode bekommen. So einfach ist das. Vielleicht möchten
Sie hier auch
die IR-Eigenschaft mit einbeziehen. So
verwenden wir also die PIC-Methode. In ähnlicher Weise können wir diesen Code
ändern, und anstatt die
Anfrage zu wiederholen, Punkt Hauptpunkt
anfordern, Punkt als Hauptpunkt
mit Unterstrich PIC Also werde ich dieses Objekt durch den Unterstrich
Pig
ersetzen . Wir haben ihm die Anfrage Punkt Py gegeben. Jetzt
haben wir hier vielleicht 50 Immobilien. Ein böswilliger Benutzer kann
uns Eigenschaften senden , die in der Datenbank
gespeichert werden sollen. Wir wollen nur einige davon von Hand
auswählen. Also übergeben wir ein Array. Wir sind nur an
Name, E-Mail und Passwort interessiert. Okay, also erstellen wir
den Benutzer und speichern ihn und geben dann dieses
benutzerdefinierte Objekt an den Client zurück. Lassen Sie uns das noch einmal testen , um sicherzustellen, dass
alles funktioniert. Also Backend-Terminal. Lassen Sie uns die Anwendung ausführen. Wunderschön. Jetzt zurück
im Postman Ich werde eine neue Anfrage
über den Server senden. Senden. Okay, hier ist unser
neues Benutzerobjekt. Wir haben nur ID,
Name und E-Mail. Bei all diesen
Anfragen
habe ich bisher wirklich
einfache Passwörter gesendet. Wenn Sie die Komplexität von
Passwörtern erzwingen möchten, gibt es ein auf Joy
aufbauendes NPM-Paket namens
Joi
Password Suchen Sie also wieder bei Google nach
Joy Password Complexity. Das ist das NPM-Paket. Damit können Sie also ein Objekt
konfigurieren, das die
Passwortkomplexität in Ihrer Anwendung bestimmt Passwortkomplexität in Ihrer Anwendung Mindestanzahl von
Zeichen, Höchstzahl, wie viele Klein- oder
Großbuchstaben Sie haben möchten, wie viele Zahlen usw. Der Name des Pakets
lautet also Joy Password Complexity. In diesem Kurs werden wir
das nicht verwenden, da Sie das selbst
tun können. Ordnung, unser neuer
API-Endpunkt ist in einem guten Zustand, aber wir speichern unsere
Passwörter als Klartext, und das ist sehr, sehr schlecht. In der nächsten Vorlesung werde
ich Ihnen zeigen, wie
man diese Passwörter hasht.
6. Passwörter hashen: In diesem Vortrag werde
ich
Ihnen zeigen, wie man Passwörter hasht Dafür werden wir
eine sehr beliebte Bibliothek
namens B crypt verwenden eine sehr beliebte Bibliothek
namens B crypt also hier im Terminal Lassen Sie uns also hier im Terminal B Crypt installieren Installiere. Notieren Sie sich die
Version, die ich verwende. Das ist Version 5.1 0.1. Jetzt werde ich hier eine Playground-Datei
erstellen, damit Sie lernen, wie man
mit dieser BCRP-Bibliothek arbeitet, und dann
nehmen wir diesen Code und fügen ihn
in eine Route ein, um das
Passwort neuer Benutzer zu hashen Lassen Sie uns also eine neue
Datei erstellen, Hash Dot JS. In dieser Datei müssen
wir zuerst BCRP laden Dadurch wird ein Objekt beibehalten. Wir lagern es hier. B Krypta. Um jetzt ein Passwort zu
haben, brauchen wir ein Salz. Was ist ein Salz? Nun, stell dir vor, unser Passwort
ist eins, zwei, drei, vier. Wenn wir es hashen,
stellen wir uns vor, wir bekommen
eine Zeichenfolge wie diese. Nun, dieser
Hashing-Algorithmus ist eine Möglichkeit. Wenn wir also A, B, CD haben, können
wir das nicht entschlüsseln und
bekommen eins, zwei, drei, vier Aus
sicherheitstechnischer Sicht ist das also großartig. Wenn sich ein Hacker unsere Datenbank
ansieht, er oder sie
diese Hash-Passwörter nicht entschlüsseln Sie können jedoch eine Liste
beliebter Passwörter
zusammenstellen und Und dann können sie sich die Datenbank unserer Anwendung ansehen. Sie finden dieses Hash-Passwort
und wissen, dass ABCD
für eins, zwei, drei, vier steht Deshalb brauchen wir ein SALT. Denn SALT ist im Grunde eine zufällige Zeichenfolge, die vor oder
nach diesem Passwort
hinzugefügt wird . Das resultierende
Hash-Passwort wird also anders sein. Jedes Mal basierend auf einem
Angriff, der verwendet wird. Okay, lass mich
dir das in Aktion zeigen. Also hier nennen wir B
Crypt Dot Gen SLT. Beachten Sie, dass diese Methode zwei
Versionen hat. Die erste ist asynchron. Der zweite ist synchron. Als bewährte Methode sollten
Sie immer
asynchrone Methoden verwenden, sollten
Sie immer
asynchrone Methoden verwenden da wir Ihnen, wie ich Ihnen zu
Beginn des Kurses gesagt habe, ich Ihnen zu
Beginn des Kurses gesagt habe,
in Knotenanwendungen einen einzigen
Thread haben Wir wollen
diesen Thread nicht ausgelastet halten, weil wir dann andere Clients nicht
bedienen können Deshalb nennen wir GensLT
als Argument. Wir geben die Anzahl der Stirnrunzeln weiter. Wir wollen diesen Algorithmus ausführen, um das SLT
zu generieren. Je höher die Zahl,
desto länger
wird es dauern, das Salz zu
erzeugen Außerdem wird der SOT komplexer und
schwerer zu knacken
sein. Der Standardwert ist also zehn. Wir werden das jetzt verwenden,
weil es sich um eine
asynchrone Methode handelt Wir können entweder hier den
Rückruf weiterleiten, und das sehen Sie in
ihrer offiziellen Dokumentation sowie in vielen
Tutorials im Internet Aber diese Methode hat auch eine Überlastung, die ein Versprechen
zurückgibt Anstatt also einen Rückruf
weiterzuleiten, bekommen
wir ein Versprechen, warten darauf und holen uns dann das Salz Also müssen wir das jetzt
in eine Acing-Funktion wie run einbinden in eine Acing-Funktion wie run Okay, lassen Sie uns das
Salz auf die Konsole legen. Und zum Schluss nennen wir
das Run-Funktion. Jetzt, zurück im
Terminalknoten, muss Js. Das ist also ein Beispiel für Salz. Sie können sehen, wie viele Patronen wir im Salz verwendet haben. Wenn wir hier also 20
statt zehn verwenden, hätten wir 20. Hier haben wir also eine
lange zufällige Zeichenfolge , die beim Hashing unserer Passwörter enthalten ist Und damit erhalten wir jedes Mal, wenn
wir unser Passwort
mit einem neuen Salt hashen, unterschiedliche Ergebnisse Jetzt, wo wir einen Salt haben, können
wir ihn verwenden, um unser
Passwort zu hashen. Wir haben hier eine andere Methode dieses B-Crypt-Objekt
, nämlich Hash Also geben wir ihm unsere Daten. Stellen wir uns vor, unser
Passwort ist eins, zwei, drei, vier, und
geben es salzen. Und noch einmal, sieh mal, das dritte
Argument kann ein Rückruf sein. Wir werden das nicht benutzen. Stattdessen werden wir
das Versprechen erhalten , das von dieser Methode
zurückgegeben wird. Also warten wir auf dieses Versprechen und
erhalten das Hash-Passwort. Lassen Sie uns das jetzt auch
auf der Konsole protokollieren. Gehackt. Okay, zurück im
Terminalknoten, gehasht oder gejagt Okay, sieh mal, in der ersten
Zeile haben wir unser Salz. In der zweiten Zeile kannst du das Salz auch hier
sehen. Das SALT ist also
im Hash-Passwort enthalten. Der Grund, warum dies enthalten ist
, ist , dass wir später, wenn wir den Benutzer authentifizieren
möchten, seinen
Benutzernamen und sein Passwort validieren möchten Dort sendet der Benutzer also ein
Passwort im Klartext. Wir müssen es erneut hashen, aber wir benötigen
das ursprüngliche Salz, das verwendet wurde
, um diesen Hash zu
generieren. Beim Vergleich des
Klartext-Passworts
mit dem Hash-Passwort muss
B crypt also das Original-Salt kennen, das Original-Salt kennen das für das Hashing des Passworts
verwendet wurde Nun, da Sie wissen,
wie B Crypt funktioniert, nehmen
wir diese beiden Zeilen und fügen sie in
unseren Also schneide sie von hier aus ab. Gehen wir zu Users Dot Js. Okay, hier ist unser Benutzerobjekt. Lassen Sie uns diese Zeilen hier einfügen. Also generieren wir ein Salz und dann brauchen wir
das Passwort Anstatt eins,
zwei, drei, vier verwenden
wir das
Benutzer-Punkt-Passwort. Das ist ein Klartext-Passwort. Also hacken wir es mit
Salz und setzen es dann zurück. Also Benutzer-Punkt-Passwort. Jetzt oben
müssen wir auch B-Krypt importieren,
also konstante B-Krypta also konstante B-Krypta Wir haben das so eingestellt, dass Bcrypt erforderlich ist. Jetzt, hier in Compass, möchte
ich die Sammlung des
Benutzers löschen weil alle Benutzer, die
wir bisher haben, Klartext-Passwort
haben Also lösche. In Ordnung. Jetzt zurück im Terminal, lass uns Node Mod ausführen. Und dann werden
wir hier in Postman eine neue Anfrage
senden S. Wunderschön. Also hier haben wir einen neuen Benutzer. Jetzt zurück in Compass, lassen Sie uns die Liste aktualisieren. Wir haben die Sammlung des Benutzers und hier ist unser neuer Benutzer
mit einem Hash-Passwort Wunderschön. Deshalb haben wir diesen Endpunkt
implementiert
, um neue Benutzer zu registrieren. Wir sind hier fertig. Als Nächstes werden wir uns mit der
Authentifizierung von Benutzern befassen
7. Benutzerauthentifizierung: Ordnung, also hier
im Routenordner, fügen
wir eine neue Datei Wir nennen das Logins
Dojs oder Auth Dot JS. Beides funktioniert, aber
Auth ist üblicher. Also authentifizieren Sie Js. Also, du sparst Zeit, ich leihe mir einen Gehen wir also zu Users Dot Js. Ich werde den gesamten Code
, den wir in diesem Abschnitt geschrieben haben, kopieren , den wir in diesem Abschnitt geschrieben haben, und dann Auth Dot JS einfügen Bevor wir zu den Details
kommen, gehen
wir zu Index Dot JS Importieren Sie
dieses neue Modul auf Knopfdruck. Also Cs OT, wir haben das so eingestellt,
dass Routes OT erforderlich ist. Wenn wir also eine Anfrage
an diesen Endpunkt, Slash API OT oder einen
seiner untergeordneten Endpunkte
haben, werden wir
diese an den OT-Router delegieren Das große Ganze ist also erledigt. Schauen wir uns nun die Details an. Zurück im Auth-Modul, ganz oben, müssen
wir zuerst den Hauptteil der Anfrage validieren Aber diese
Validierungsfunktion, die wir hier haben, ist die, die wir aus unserem Benutzermodul
importiert haben Das bestätigt das also. Im Hauptteil der Anfrage haben
wir drei Eigenschaften:
Name, E-Mail und Passwort Und in der
realen Anwendung verfügen
Sie möglicherweise über andere Eigenschaften
, wenn Sie einen Benutzer registrieren. Diese Validierungsfunktion
dient also der Validierung eines neuen Benutzers. Sie dient nicht der Validierung
der E-Mail-Adresse und des Passworts, die wir an
diesem Endpunkt erwarten Also hier brauchen wir eine andere
Validierungsfunktion. Also werde ich diese
Validierungsfunktion von
hier entfernen und
eine separate
Validierungsfunktion in diesem Modul definieren . Um Zeit zu sparen, gehe
ich zum Benutzermodul und kopiere
diese Validierungsfunktion. Also haben wir den Benutzer validiert. Kopieren wir das zurück
in das Auth-Modul, fügen es hier ein und
ändern wir es dann, um es zu validieren Jetzt können wir den angeforderten
Parameter ändern. Für dieses Schemaobjekt benötigen
wir jetzt nur noch zwei Eigenschaften,
E-Mail und Passwort. Löschen wir also den
Namen und wir sind fertig. Also zurück zu unserem Route-Handler, das ist unsere erste Validierung. Als Nächstes müssen wir sicherstellen , dass wir einen Benutzer
mit einer bestimmten E-Mail haben. Also laden wir den Benutzer. Wenn wir den Benutzer nicht haben, so wenden wir hier
den Not-Operator an. Wenn wir den Benutzer nicht haben, sollten
wir einen
400-Fehler an den Client senden,
was bedeutet, dass die Anfrage
und die Nachricht eine ungültige E-Mail-Adresse oder ein ungültiges Passwort
sein sollten . Beachten Sie, dass ich hier keine Vier oder Vier
sende,
was bedeutet, dass nicht gefunden wurde,
weil wir dem Client nicht
mitteilen wollen , warum die
Authentifizierung fehlschlägt. Wir möchten nicht
sagen, ob diese E-Mail oder das Passwort korrekt
ist. Wir möchten also nicht sagen, dass wir keinen Benutzer
mit einer bestimmten E-Mail haben. Wir teilen dem Kunden nur mit
, dass dies eine schlechte Anfrage ist. Es sind nicht die richtigen
Daten für die Verarbeitung vorhanden. In diesem Fall dient dies also zur Überprüfung des Benutzernamens und der
E-Mail-Adresse Als Nächstes müssen wir das Passwort
validieren. Dafür müssen wir BCRP verwenden. Lassen Sie uns also den ganzen Code löschen. Dieses B-Crypt-Objekt, das wir
haben, hat eine Vergleichsmethode. Wir verwenden dies, um
ein Klartext-Passwort
mit einem Hash-Passwort zu vergleichen . Unser Klartext-Passwort
ist also das Anforderungspasswort mit Punkt im
Hauptteil und unser Hash-Passwort steht
in User That Password Wie Sie bereits gesehen haben, beinhaltet
dieses Hash-Passwort das SLT Wenn wir also die
Vergleichsmethode aufrufen, holt sich B crypt das Salz und verwendet es, um dieses
Klartext-Passwort Wenn sie gleich sind, gibt
das den Wert true zurück. Also hier müssen wir auf
dieses Versprechen warten und das
Ergebnis hier in einem gültigen Passwort speichern. Wenn das Passwort nun erneut nicht gültig
ist, wir einen 400-Fehler
mit dieser vagen Nachricht, einer
ungültigen E-Mail oder einem ungültigen Passwort
zurück mit dieser vagen Nachricht, ungültigen E-Mail oder einem ungültigen Passwort Also werde ich das einfach kopieren
und hier einfügen. Und schließlich, wenn wir
das bis zu diesem Punkt erreichen, bedeutet
das, dass es sich um ein gültiges Login
handelt. Im Moment
möchte ich nur einen einfachen,
wahren Wert an den Fussel senden .
8. Die Authentifizierung testen: Lassen Sie uns zunächst
diese Authentifizierungsroute testen. Vorher also ein oder Punkt js. Hier habe ich vergessen, Load Joy zu
erwähnen. Also lass mich das schnell machen. Last Joy, stelle das so ein,
dass es Joy erfordert. Okay. Und unten
für die Validierungsfunktion müssen wir
hier eine
Schemadot-Validierungsanfrage zurückgeben. Okay, wir sind also bereit. Lass uns Postmin öffnen. Also hier werde
ich einen neuen Tab öffnen. Wählen wir hier Beitrag aus. Lassen Sie mich den Endpunkt eingeben. Es ist TP, lokaler Host OT, API OT. Und im Hauptteil der Anfrage werde
ich die GSN versenden Lassen Sie mich hier also Json auswählen. Und jetzt haben wir zwei Parameter. Die erste ist also E-Mail. Die E-Mail, die wir verwendet
haben, ist 23, vier, fünf, sechs, sieben, zum Beispiel gmail.com Und unser Passwort ist eins,
zwei, drei, vier, fünf Also lass mich diese Anfrage schicken, SN. Wunderschön. Wir haben
einen Status 200. Okay. Und hier ist unsere Antwort. Lassen Sie mich jetzt
das Passwort hier auf
etwas anderes wie 67 ändern und die Anfrage
dann erneut senden. Sehen Sie, wir haben eine ungültige 400er-Anfrage
und den generischen Befehl
, der eine ungültige
E-Mail-Adresse oder ein ungültiges Passwort lautet. Lassen Sie uns nun die E-Mail in eine
andere mit
dem richtigen Passwort ändern . Also so etwas. Und lassen Sie mich die
Anfrage erneut senden. Also sende. Sehen Sie, wir haben wieder
eine 400 schlechte Anfrage und die generische Nachricht
, die eine ungültige
E-Mail oder ein ungültiges Passwort lautet. Unser
Authentifizierungsendpunkt funktioniert also einwandfrei. In der nächsten Lektion werden
wir uns die Antwort ansehen, die wir
hier senden , und sie in
etwas ändern, das wir als
angrenzendes Web-Token bezeichnen.
9. JSON-Web-Token: Wir haben also einen Endpunkt
für die Authentifizierung von Benutzern. Jetzt müssen wir
die Antwort hier ändern, und anstatt einen wahren Wert
zurückzugeben, müssen
wir
ein JCN-Webtoken zurückgeben AJCN-Webtoken ist im Grunde eine lange Zeichenfolge, die einen Benutzer
identifiziert Als Metapher
können Sie es sich
als Ihren Führerschein
oder Ihren Reisepass vorstellen als Ihren Führerschein
oder Ihren Reisepass Es ist dem sehr ähnlich. Wenn sich der Benutzer also auf dem Server anmeldet
, wir dieses JCN-Web-Token, das wie ein
Führerschein oder Reisepass ist Wir geben es dem Kunden
und sagen ihm dann: Hey, du das
nächste Mal hierher zurückkommen
und einen
unserer API-Endpunkte anrufen willst , musst
du deinen Reisepass vorzeigen Sie müssen Ihren Führerschein vorzeigen.
Das ist dein Ausweis. Auf dem Client müssen wir also dieses JCN-Webtoken
speichern, das eine lange Zeichenfolge ist, damit wir es für zukünftige API-Aufrufe an
den Server zurücksenden können für zukünftige API-Aufrufe an
den Server Jetzt kann der Client eine Webanwendung oder
eine mobile Anwendung Wenn es sich um eine Webanwendung handelt, wenn Sie eine Anwendung
mit Angular oder React erstellen, können
Sie lokalen Speicher verwenden. Das ist ein spezieller
Speicherplatz, in jedem
Browser verfügbar
ist. Wenn Sie eine mobile App erstellen, haben
Sie
je nach verwendeter
Plattform eine ähnliche Option . Lassen Sie mich Ihnen nun ein
Beispiel für AJCNWBTKEN zeigen. Gehen Sie zu JWT Punkt II. Auf dieser Website haben wir hier einen Debugger für die Arbeit
mit JS Hier im codierten Bereich können
Sie also ein echtes Beispiel
für ein AJCN-Webtoken sehen Diese lange Zeichenfolge, die Sie
im codierten
Abschnitt sehen , steht für ein JCNoBr-Objekt. Wenn wir das dekodieren,
erhalten wir ein CN-Objekt ein JCNoBr-Objekt. Wenn wir das dekodieren,
erhalten wir ein CN-Objekt. Okay? Jetzt können wir sehen, dass
diese Zeichenfolge aus drei Teilen besteht, und jeder Teil ist ein Farbcode. Der erste Teil ist also rot, der zweite Teil ist lila und der dritte Teil ist blau. Auf der rechten Seite können Sie
sehen, wie diese Zeichenfolge dekodiert ist. Der rote Teil ist also das, was wir den Header
eines JCN-Web-Tokens
nennen In diesem Header
haben wir zwei Eigenschaften. Eine davon ist L, die
Abkürzung für Algorithmus, der den Algorithmus bestimmt
, der für die Kodierung dieses Tokens
verwendet wird. Der Typ ist GWT, was ein JCN-Webtoken ist Jetzt müssen wir uns über diesen Header
keine Gedanken mehr machen. Es ist nur ein Standard. Was uns wichtig ist,
ist der zweite Teil, die Nutzlast,
der lila Teil Hier haben wir also ein JCN-Objekt
mit drei Eigenschaften:
sub, was einer
Benutzer-ID entspricht, einem Namen und einem Admin Nun, die Payload, die Sie sehen unterscheidet sich von
der Payload, die ich habe,
weil ich das Fold-JS und Webtog modifiziert habe und
sie Also habe ich ein benutzerdefiniertes
Web-Token generiert und es hier abgelegt. Worauf ich hier
hinweisen möchte, ist, dass diese Nutzlast öffentliche
Eigenschaften über den Benutzer enthält Genau wie in Ihrem Reisepass haben
Sie einige Eigenschaften
über sich selbst, wie
Ihren Namen, Ihr Geburtsdatum, Ihren Geburtsort und so Wir haben also genau das gleiche
Konzept für benachbarte Web-Token. Kann einige grundlegende öffentliche
Eigenschaften über den Benutzer enthalten. Und damit können wir jedes Mal, wenn wir ein Token vom
Client an den Server
senden, ein Token vom
Client an den Server
senden,
die
Benutzer-ID einfach aus der Nutzlast extrahieren Wenn wir
den Namen des Benutzers wissen
müssen, können wir ihn auch hier einfach extrahieren Wir müssen nicht die Datenbank
abfragen, diese ID
senden, um ein Benutzerobjekt zu
erhalten und dann
die Namenseigenschaft extrahieren. Aus dem gleichen Grund können
wir das hier angeben,
wenn Sie wissen möchten , ob der Benutzer ein
Admin-Benutzer ist oder nicht . Auch hier müssen wir keine zusätzliche Abfrage
an
die Datenbank senden, um festzustellen, ob der Benutzer mit einer bestimmten
ID Admin ist oder nicht. Sie vielleicht besorgt über Aus
Sicherheitsgründen sind Sie vielleicht besorgt über
diesen Ansatz,
weil Sie vielleicht denken, dass
jeder diese Admin-Eigenschaft
für sich selbst einfach auf true
setzen kann , und dann wird er auf dem Server
als Administrator behandelt. Aber so funktionieren
Jason-Ptokane nicht. Der dritte Teil
dieses JCN-Web-Tokens
, der blau ist, ist
eine digitale Signatur Diese digitale Signatur wird auf der Grundlage des Inhalts
dieses JCN-WebTokens zusammen mit
einem geheimen oder privaten Schlüssel
erstellt dieses JCN-WebTokens zusammen mit
einem geheimen Der geheime oder private Schlüssel ist nur auf dem Server verfügbar Wenn also ein böswilliger Benutzer
das JCN-WebTken erhält und
die Admin-Eigenschaft ändert, die digitale Signatur ungültig,
da der Inhalt des
JCN-WebTKen geändert
wird da der Inhalt des
JCN-WebTKen Jetzt benötigen wir eine neue
digitale Signatur, aber der Hacker kann
diese digitale Signatur nicht generieren ,
da er den privaten Schlüssel benötigt,
der nur auf dem aber der Hacker kann
diese digitale Signatur nicht generieren,
da er den privaten Schlüssel benötigt,
der nur auf dem Server verfügbar ist. Wenn sie also keinen
Zugriff auf den Server haben, können
sie keine
gültige digitale Signatur erstellen Und wenn sie dieses
temperierte
JCN-Webtoken an den Server senden , lehnt der Server das ab Der Server wird sagen, dass dies
kein gültiges JCN-Webtoken ist. So funktionieren
JCN-Webtoken.
10. Authentifizierungs-Token generieren: Wenn Sie
sich also auf dieser Seite die Bibliotheken ansehen, finden Sie
hier
verschiedene Module oder Bibliotheken für
verschiedene Plattformen. Wenn du also nach unten
scrollst, wirst du sehen Tad net one C B, C, C plus, Node und so weiter Lassen Sie uns also das Terminal öffnen
und JCN Webtook und BM installieren und ASN Web Took installieren Okay, wenn Sie sich
das JSON-Paket ansehen, werden
Sie sehen, dass die Version, die
wir verwenden, 9.0 0.2 ist Also lass uns das schließen. Wir haben den Pfad zur
Authentifizierung von Benutzern. Jetzt müssen wir ein
JCN-WebToken erstellen , bevor wir eine
Antwort an den Client senden Vorher müssen Sie also JCN
WebTken laden. Also zuerst
brauchen Sie Jason Rep, Choke und speichern Sie es in Toll. Jetzt verwenden wir hier die
Sinus-Methode von JWT. Also JW Punkt Sinus, sodass es zwei Argumente
akzeptiert. erste ist die Nutzlast und der zweite ist der
geheime oder private König Die Nutzlast könnte also eine einfache Zeichenfolge
sein oder es könnte ein Objekt sein, wie
Sie es hier sehen Lassen Sie uns also unser Objekt
mit nur einer Eigenschaft erstellen. Wir werden die Underscore-ID angeben und diese an den
Benutzer mit der Punkt-Underscore-ID senden Gemäß dem zweiten Argument werden
wir dies nun an eine Zeichenfolge senden Idealerweise
sollten Sie
Ihren geheimen oder privaten
Schlüssel jedoch nicht in Ihrem Quellcode speichern . Später werde ich Ihnen zeigen, wie Sie das in einer
Umgebung
speichern können, in der das nicht der Fall ist. Aber lassen Sie uns das vorerst einfach auf JWT Secret
setzen Es muss kein geheimer JWT-Schlüssel
sein. Es könnte alles sein,
jede Zeichenfolge. Aber fürs Erste nutzen wir das. Wir haben also eine Zeichenmethode verwendet und als Ergebnis erhalten wir ein Token. Speichern wir es also in einer Konstante
und nennen wir es Token. Und jetzt werden wir die Antwort als Hook zurückgeben oder
an unseren Kunden senden. Also da ist das zurück
zum Terminal. Lass uns runtergehen. Lass uns jetzt zum Postboten gehen. Hier senden wir die
richtige E-Mail und das richtige Passwort an diese
Authentifizierungsroute. Dann lass uns das schicken. Und hier ist unser JCN-Web-Token. Also lass mich das kopieren. Und gehen wir zurück
zum Debugger. In diesem codierten Abschnitt können
Sie einfach diesen
löschen und den, können
Sie einfach diesen
löschen den
wir kopieren, einfügen Und hier, im
dekodierten Abschnitt, können
Sie unser Objekt sehen,
das wir
als Token senden . Hier
haben wir also die ID-Eigenschaft, die auf
die
Objekt-ID in der Mongaim-Datenbank gesetzt ist Außerdem
haben wir IAT, das ist die aktuelle Uhrzeit und
die Uhrzeit, zu der dieses Token erstellt wurde Dies wird verwendet, um das Token zu H zu erhalten. Also haben wir
das Token erfolgreich erstellt und es
als Antwort auf unser Klima gesendet. Im nächsten Video zeige
ich Ihnen, wie Sie diesen geheimen Schlüssel in
eine Umgebungsvariable
aufnehmen
11. Geheimnisse in Umgebungsvariablen speichern: Zu Beginn des Kurses, als ich über
Express-Themen für Fortgeschrittene sprach, habe ich Ihnen ein
Node-Paket namens Config vorgestellt. Wir verwenden dieses Paket, um die
Konfigurationseinstellungen
unserer Anwendung in JSON-Dateien
oder Umgebungsvariablen zu
speichern . In dieser Vorlesung
werden wir also diesen geheimen Schlüssel herausnehmen und ihn in
einer Umgebungsvariablen speichern ,
denn wie ich Ihnen bereits gesagt habe, sollten
Sie Ihre
Geheimnisse niemals in Ihrer Codebasis speichern. Andernfalls sind diese Geheimnisse jeden
sichtbar, der
Zugriff auf Ihre Quelle hat. Also zurück im Terminal, lasst uns das Config-Modul installieren. Ich kann mir die
Versionsnummer merken, die 3.3 0.11 ist. Jetzt müssen wir zuerst
einen neuen Ordner erstellen, der config ist. In diesem Ordner fügen wir eine Standardkonfigurationsdatei hinzu
, die standardmäßig Dot JSM ist Also ein einfaches SN-Objekt. Wir könnten hier mehrere
Einstellungen haben. Aber vorerst möchte
ich nur eine Einstellung hinzufügen. Das ist der geheime JWT-Schlüssel. In dieser Standard-GSN-Datei werden
wir dies jetzt auf eine leere
Zeichenfolge setzen Der tatsächliche Wert ist nicht hier. Also hier definieren wir nur eine Vorlage für alle
Einstellungen in unserer Anwendung. Jetzt müssen wir
eine weitere Datei erstellen, bei der es sich benutzerdefinierte
Umgebungsvariablen dot JS handelt. Beachten Sie die Schreibweise und achten
Sie darauf, dass Sie sie richtig machen. Andernfalls wird das,
was ich Ihnen in
diesem Vortrag zeigen werde
, auf Ihrem Computer nicht funktionieren. Wie ich Ihnen
bereits sagte,
haben wir in dieser Datei die Zuordnung zwischen
unseren Anwendungseinstellungen
und Umgebungsvariablen spezifiziert . Also gehe ich zurück
zu unserem Standardpunkt Sohn, kopiere das alles und füge es hier ein. Das ist also die Struktur
unseres Anwendungseinstellungsobjekts. Jetzt wollen wir
dies der Einstellung einer Umgebungsvariablen
namens JWT Secret Key zuordnen Aber als bewährte Methode ist
es
, wie ich Ihnen bereits gesagt habe, besser, diesem Namen
unseren Anwendungsnamen voranzustellen , damit nicht am Ende eine
Anwendungseinstellung eine andere
Anwendungseinstellung überschreibt Also bringen wir den geheimen
JWT-Schlüssel auf Vordermann. Damit können wir jetzt
zu unserem Auth-Modul zurückkehren, also Js. Dies ist also ein Ort, an dem
wir auf
das Geheimnis verwiesen haben . Wir werden es einen Aufruf
der Confic Dot Get-Methode
ersetzen Also zuerst müssen
wir das Konfigurationsobjekt importieren. Also Cs config. Wir haben das so eingestellt, dass Confit
erforderlich ist. Okay. Jetzt, zurück in der Post-Methode, rufen
wir Config Dot Cat und übergeben den Namen der
Anwendungseinstellung. In diesem Fall JWT Secret K.
Also das ist jetzt kein Geheimnis. Das ist der Name unserer
Anwendungseinstellung. Der tatsächliche Wert,
das tatsächliche Geheimnis wird in einer
Umgebungsvariablen sein. Eine letzte Änderung, wir müssen
zu Index Dot js gehen. Wenn die Anwendung gestartet wird, möchten
Sie sicherstellen, dass diese
Umgebungsvariable gesetzt ist. Andernfalls müssen wir die Anwendung
beenden da unser
Authentifizierungsendpunkt nicht richtig funktionieren kann. Oben laden
wir erneut das Konfigurationsmodul. Config, wir haben das so eingestellt
, dass eine Konfiguration erforderlich ist. Jetzt rufen
wir noch einmal
config dot get pass auf und geben den Namen der Anwendung an, die den geheimen Schlüssel
JWT Wenn das nicht definiert ist, werden wir
einen schwerwiegenden Fehler protokollieren Der geheime JWT-Schlüssel ist nicht definiert. Und dann müssen wir den Prozess
beenden. Zuvor haben Sie etwas über
dieses Prozessobjekt gelernt. Dies ist eines der
globalen Objekte im Knoten. Hier haben wir eine
Methode namens exit. Wir geben ihr einen Code, Null
bedeutet Erfolg. Alles andere als Null bedeutet Misserfolg. Sehr oft verwenden wir exit
one, wenn Sie den
Prozess im Falle eines Fehlers beenden möchten. Daher habe ich
diese Umgebungsvariable derzeit nicht gesetzt. Lassen Sie uns die Anwendung ausführen
und sehen, was passiert. Also Norman Index Dot JS, okay, schau, wir haben
diesen fatalen Fehler. Die App ist abgestürzt und hat vor dem Start auf
Dateiänderungen gewartet. Jetzt denken Sie vielleicht, dass
die Anwendung
immer noch läuft , weil
Norman immer noch da ist Sie ist nicht beendet. Wenn Sie jedoch zu
Postman gehen und
eine SDDP-Anfrage an
die Anwendung senden , werden
Sie feststellen, dass unsere
Anwendung nicht reagiert Wenn die Anwendung also abstürzt, funktioniert Norman immer noch Norman läuft immer noch. Lass mich dir zeigen, was ich meine. Wenn ich also statt Non-Mod eine Anwendung mit
Node starte, sehe
ich , dass die
Anwendung abgestürzt ist, und jetzt sind wir wieder
im Terminal Wir antworten also nicht auf Anfragen
von Kunden Lassen Sie uns nun die
Umgebungsvariable setzen. Wie ich Ihnen bereits gesagt habe, verwenden
Sie auf dem Mac Export, unter Windows verwenden
Sie set für Befehlszeile und die
Dollar-ENV-Spalte für Power Shell Spalte „Dollar ENV“, „Fair Wheels“, „
Underline“, Schlüssel „JWT Secret“.
Das haben wir auch eingestellt Sagen wir meinen sicheren Schlüssel. Lassen Sie uns die
Anwendung jetzt erneut ausführen. Knotenindex oder Js.
Okay, wunderschön. Wir verbinden es mit
Mongadib und wenn wir zu Postman
zurückkehren und
eine weitere Anfrage an Login senden, ist
hier unser gültiges Cheese- und Web-Token, das
mit unserem geheimen Schlüssel signiert ist
, der in einer Umgebungsvariablen gespeichert ist
12. Antwort-Header einrichten: In der aktuellen
Implementierung generieren
wir also, wenn sich der Benutzer anmeldet, wenn sich der Benutzer anmeldet, ein JCN-Webtoken und geben es im
Hauptteil der Antwort zurück Lassen Sie uns diese
Anwendung nun auf die nächste Ebene bringen. Stellen wir uns vor, wenn sich
der Benutzer registriert, gehen
wir davon aus
, dass er angemeldet ist, sodass er sich nicht separat
anmelden muss. Natürlich gilt diese Anforderung
nicht für jede Anwendung. Manchmal möchten Sie
den Benutzer zwingen ,
seine E-Mail-Adresse zu verifizieren. Nachdem sie sich angemeldet haben, senden Sie ihnen eine E-Mail und sie
klicken auf einen Link. Der Prozess ist also anders. Aber
stellen wir uns in diesem Kurs vor, dass Fair Wheels
eine Anwendung ist , die
lokal in einer Autovermietung ausgeführt wird. Leute, die
diese Anwendung verwenden, sind also Leute, die in dieser Autovermietung arbeiten. Wir müssen
ihre E-Mail-Adresse nicht verifizieren. Am ersten Tag, an dem
sie dem Shop beitreten, müssen
sie also ein Konto erstellen, und bumm, sie sind angemeldet. Gehen wir also zu unserem
Benutzermodul. Okay, hier ist die Post-Methode. Hier
registrieren wir einen neuen Benutzer. Wenn Sie sich nun die
Antwort ansehen, die wir hier zurückgeben, geben
wir ein Objekt
mit diesen drei Eigenschaften zurück. Jetzt können wir das
JCN-Webtoken hier als weitere Eigenschaft hinzufügen , aber das ist ein bisschen hässlich weil es keine
Eigenschaft eines Benutzers ist Ein besserer Ansatz besteht darin,
das JCN-Webtoken
in einem SDDP-Header zurückzugeben das JCN-Webtoken
in einem SDDP-Header So wie wir
Header in unserer Anfrage haben, haben
wir auch Header in unserem Antwortobjekt Also gehe ich zurück zu unserem Auth-Modul und leihe mir diese Codezeile
für die Generierung des Tokens aus Also kopiere das jetzt
zurück in das Benutzermodul. Bevor wir die
Antwort an den Client senden, generieren
wir das Token und rufen
dann einen
Antwort-Punktheader auf. Damit können wir einen Header setzen. Nun sollten wir allen benutzerdefinierten Headern , die wir in
unserer Anwendung definieren, , die wir in
unserer Anwendung definieren,
diesen Headern ein X voranstellen. Jetzt geben wir ihnen einen beliebigen Namen wie Authentifizierung oder Token Dies ist das erste Argument, das der Name des Headers ist Das zweite Argument
ist der Wert
, der in diesem
Fall unser Token ist. Mit dieser einfachen Änderung setzen
wir also diesen Header und senden
dann diese Antwort
an den Client. Okay? Jetzt in Zeile 20 verwenden
wir sowohl JWT
als auch das Confit-Modul Also müssen wir
diese oben importieren. Bei konstantem TWT haben wir das so eingestellt
, dass ein JCN-Web-Token erforderlich ist. Und in ähnlicher Weise setzen
wir Constant Config so, dass Confit erforderlich ist Lassen Sie uns das jetzt testen.
In der letzten Vorlesung habe ich die Anwendung also mit dem
Node-Modus statt mit dem Nor-Modus ausgeführt. Meine Änderungen sind also nicht sichtbar. Also müssen wir die
Anwendung stoppen und im
Knotenmodus ausführen . Okay, wunderschön. Jetzt, zurück in Postman hier auf dieser Registerkarte für die
Registrierung eines Benutzers, werde
ich diese E-Mail in eine E-Mail
ändern , die ich noch
nicht registriert Gesendet. Okay, sieh es dir an. Also hier ist der Hauptteil der
Antwort genau wie zuvor. Jetzt haben
wir im Headertab Look diesen neuen
Header, das X-Token Und das ist auf
unseren JCN WebToken eingestellt. also in unserer Client-App Wenn wir also in unserer Client-App einen Benutzer registrieren, können
wir diesen Header lesen Wir können dieses JCN
WebtGen auf dem Client speichern. Und wenn wir das nächste Mal einen API-Aufruf tätigen, werden
wir ihn an den Server senden
13. Einkapselung von Logik in Mongoose-Modellen: Nun, es gibt ein Problem in
unserer aktuellen Implementierung. Im Benutzermodul in Zeile 22 generieren wir auf diese Weise
ein JCN-Webtoken Wir haben genau den gleichen Kern
im Auth-Modul in Zeile 20. Schauen Sie sich nun die Nutzlast dieses
JCN-Web-Tokens an. In dieser Payload haben
wir derzeit nur die Wahrscheinlich werden
wir morgen
eine weitere Eigenschaft zu dieser Bezahlung hinzufügen ,
vielleicht den Namen des Benutzers, vielleicht seine E-Mail-Adresse,
vielleicht seine Rolle Wir wollen wissen, ob
es einen Admin-Benutzer gibt oder nicht. Bei der aktuellen Implementierung müssen wir
jedes Mal, wenn
wir diese Payload
ändern wollen, daran denken,
dass wir zu
einem anderen Modul wechseln und genau
dieselbe Änderung vornehmen Und auf lange Sicht
werden Sie diese Anforderungen vergessen In diesem Vortrag werde
ich Ihnen zeigen,
wie Sie diese
Logik an einem einzigen Ort zusammenfassen Nun, wohin sollten wir diese Logik
verschieben? Ein Amateurprogrammierer
könnte denken: Okay, ich werde eine Funktion
wie das Generieren eines
Authentifizierungstoken erstellen und diese Funktion irgendwo
platzieren, damit wir sie wiederverwenden können, vielleicht in einem anderen
Modul, das wir sowohl in Earth
als auch in Benutzermodule
importieren können sowohl in Earth
als auch in Benutzermodule
importieren Und damit haben wir die
Logik an einem einzigen Ort. Nun, das ist wahr. Das funktioniert. Aber mit diesem Ansatz werden
Sie am Ende eine Menge Funktionen haben, die
überall herumhängen. In der objektorientierten Programmierung haben
wir ein Prinzip, das als
Informationsexperten-Prinzip bezeichnet wird. Das bedeutet ein Objekt, das über
genügend Informationen verfügt und
ein Experte auf einem bestimmten Gebiet ist. Dieses Objekt sollte dafür verantwortlich
sein , Entscheidungen zu treffen und Aufgaben
auszuführen. Stellen Sie sich als Beispiel aus der Praxis einen Koch vor. Ein Koch hat
Kochkenntnisse. Deshalb wird das Kochen in
einem Restaurant von einem
Koch und nicht von einem Kellner gemacht Der Kellner hat nicht
das richtige Wissen, die richtigen Informationen über
das
Kochen in einem Restaurant Wenn der Koch also ein Objekt ist, sollten
wir das
Kochen dem Koch übertragen Nehmen Sie nun dieses Prinzip
und wenden Sie es in diesem Code an. Also,
was brauchen wir hier, als Teil der Erstellung
dieses Chase- und Web-Tokens, in der Payload Wir benötigen die ID des Benutzers. Morgen benötigen wir möglicherweise den Namen des Benutzers
oder seine E-Mail-Adresse. All diese Informationen sind also hier
im
Benutzerobjekt gekapselt Es ist also das
Benutzerobjekt, das für die Generierung
dieses Authentifizierungstokens
verantwortlich sein sollte Generierung
dieses Authentifizierungstokens
verantwortlich Also die Funktion
, die ich hier geschrieben habe, Authentifizierungstoken
generieren
, diese Funktion
sollte nicht irgendwo
in einem Modul hängen. Das sollte eine Methode
im Benutzerobjekt sein. Hier haben wir also ein Benutzerobjekt , das wir aus der Datenbank laden. Wir müssen
diesem Benutzerobjekt eine Methode wie folgt hinzufügen. Benutzer, der ein
Authentifizierungstoken generiert. Und das gibt uns ein
Token, so einfach ist das. Nun, wie können wir das hinzufügen? Wir müssen zu unserem
Benutzermodul gehen, wo wir
das Benutzermodell definieren und dort eine
einfache Änderung vornehmen. In Ordnung. Also hier in unserem Benutzermodell müssen
wir die Definition
dieses Schemas extrahieren und
es in eine separate Konstante legen es in eine separate Konstante weil wir mit dieser separaten
arbeiten werden. Also werde ich diesen ganzen Code
auswählen. Wenn wir also das
Benutzermodell als zweites Argument erstellen, übergeben
wir das Benutzerschema, und das haben wir noch nicht
erstellt. Das werden wir jetzt tun. Also konstantes Benutzerschema, und wir setzen das auf diesen
Ausdruck wie folgt. Okay. Also hier ist unser Benutzerschema. Jetzt möchten Sie diesem Schema eine
Methode hinzufügen. Also Benutzerschema, dass
wir eine Eigenschaft haben, Methoden, das gibt ein Objekt zurück. Wir können diesem Objekt zusätzliche
Schlüssel-Wert-Paare hinzufügen. So können wir einen Schlüssel hinzufügen, eine
Authentifizierung oder ein Token generieren. Wir setzen das auf eine Funktion.
Also Schlüssel-Wert-Paar. Wenn wir das tun, verfügt unser
Benutzerobjekt über
eine Methode namens Generate
Authentication Token. Hier, in dieser Funktion, können
wir Parameter haben. Wenn wir hier also einen Parameter haben, beim Aufrufen dieser Methode können
wir beim Aufrufen dieser Methode Argumente übergeben. In diesem Fall
benötigen wir keine Parameter, also muss ich nur
diese Logik zur Generierung des Tokens
abrufen, sie von hier abrufen und in diese neue Methode verschieben
. Also hier in der Payload brauchen
wir das D des
Benutzers. Wie bekommen wir das Nun, diese Methode wird
Teil des Benutzerobjekts sein. Um also auf
das Objekt selbst zu verweisen, ersetzen
wir den Benutzer durch dieses. Und das bedeutet, dass Sie hier die reguläre
Funktionssyntax verwenden
sollten. Sie können dies nicht
durch eine Pfeilfunktion ersetzen. Denn wie ich Ihnen bereits gesagt habe, haben
Pfeilfunktionen hier nichts zu suchen. Dies in einer
Pfeilfunktion verweist auf
die aufrufende Funktion. Daher verwenden wir in der Regel Pfeilfunktionen für
eigenständige Funktionen. Wenn Sie eine Methode erstellen möchten
, die Teil eines Objekts ist, sollten
Sie keine Pfeilfunktion verwenden
. Lassen Sie uns das jetzt rückgängig machen. Also hier haben wir das Token, und schließlich geben wir
es so einfach zurück Hier verweisen wir auf
JWT- und Konfliktmodule. Also müssen wir
das oben importieren. Also gehe ich zurück zu
unserem Auth-Modul oben. Wir benötigen diese
erforderlichen Anweisungen nicht mehr. Also werde ich sie von
hier holen. Und lege sie auf
das Benutzermodul. Jetzt zurück im
Authentifizierungsmodul, also generieren wir das Token und senden es
dann an den Client. Wir müssen die gleichen
Änderungen im Modul unseres Benutzers vornehmen. Benutzermodul, wir
löschen diese Zeile und setzen das Token auf den Benutzer
, der AuthToken generiert Lassen Sie uns das abschließend testen und sicherstellen, dass
alles funktioniert Also werde ich hier
einen neuen Benutzer registrieren. Sende, wunderschön. Und hier ist unser
Authentifizierungstoken.
14. Autorisierungs-Middleware: Zu Beginn
dieses Abschnitts
haben wir uns daher entschlossen,
die Operationen zu schützen, bei denen Daten geändert werden
, und sie nur
authentifizierten Benutzern
zur Verfügung zu stellen nur
authentifizierten Benutzern
zur Verfügung zu Gehen wir also zu unserem Unternehmenspunkt CHASE Piers über, der Post-Methode
für die Gründung eines neuen Unternehmens Dieser API-Endpunkt
sollte nur von einem
authentifizierten Benutzer aufgerufen werden Wie können wir das also durchsetzen? Nun, hier
haben wir eine Logik wie diese angewendet. Wir müssen die Header der
Anfrage lesen. Dieses Anforderungsobjekt hat also
eine Methode namens Header. Hier geben wir den
Namen des Headers an, also das X-Token. Wir erwarten, dass in diesem Header ein JCN-Webtoken
gespeichert ist. Also speichern wir das
als konstantes Token. Jetzt wollen wir das validieren. Wenn dies gültig ist,
gewähren wir Zugriff auf
diesen API-Endpunkt. Andernfalls werden wir
eine Antwort wie diese zurückgeben. Antwort für den
Statuscode vier auf eins,
was bedeutet, dass der
Client nicht über die Anmeldeinformationen für den
Zugriff auf diese Ressource verfügt. Das ist also das große Ganze. Jetzt wollen wir diese Logik nicht am
Anfang jedes
Route-Handlers
wiederholen , der Daten ändert Also müssen wir diese Logik
in eine Middleware-Funktion einfügen. Denken Sie daran,
Middleware-Funktionen, über die wir im Abschnitt
Express-Themen für Fortgeschrittene gesprochen haben . Wir haben diese Logik also in
eine Middleware-Funktion integriert, und dann können wir diese Funktion in
Route-Handlern anwenden
, die Daten ändern müssen.
Lass es mich dir zeigen. Lass uns das von hier holen. Ordnung, hier wollen wir
einen neuen Ordner namens Middleware hinzufügen einen neuen Ordner namens Middleware Also haben wir alle unsere
Middleware-Funktionen hier platziert. In diesem Ordner hatten wir
eine neue Datei, die t dot hat. Hier wollen wir nun eine Funktion namens
OT
definieren , die drei Parameter Request Response“ und „Next“ verwendet, mit
denen wir die Steuerung an die nächste Middleware-Funktion
in
der Pipeline zur
Anforderungsverarbeitung übergeben nächste Middleware-Funktion
in
der Pipeline zur
Anforderungsverarbeitung Falls Ihnen dieses Konzept
nicht vertraut vorkommt, müssen
Sie zum Abschnitt
Express Advanced Topics
zurückkehren, da wir
dort die Express Advanced Topics
zurückkehren, da Middleware-Funktionen im Detail untersuchen Also hier in dieser Funktion sollten
wir diese Logik implementieren.
Wir bekommen das Token Die Chancen stehen gut, dass wir überhaupt kein Token
haben. In diesem Fall geben wir
eine Antwort von 41 mit einer
Nachricht wie dieser zurück . Zugriff verweigert. Es wurde kein Token bereitgestellt. Dies hilft dem
Client also
herauszufinden, warum er nicht
auf diese Ressource zugreifen kann. Ansonsten
gibt es jetzt ein Token. Wir müssen überprüfen, ob es
sich um ein gültiges Token handelt. Also hier müssen wir
unser JCN-Web-Token-Modul verwenden. also zunächst das Lassen Sie uns also zunächst das
JCN-Webtoken benötigen und es in JW speichern Jetzt nennen wir hier jwt dot Verifi. Als erstes Argument übergeben
wir das Token und als zweites Argument übergeben
wir den geheimen Schlüssel
für die Dekodierung Also haben wir diesen geheimen Schlüssel
in einer Umgebungsvariablen gespeichert. Wir müssen ein
Konfigurationsmodul verwenden, um sie zu lesen. Benötige also die Konfiguration
und speichere sie hier. Also wie zuvor rufen
wir config dot g JWT Ccret key auf. Jetzt verifiziert
diese Überprüfungsmethode unseren JCN
WebToken Wenn sie gültig ist, wird sie
dekodiert und die Payload zurückgegeben. Also hier bekommen wir die
dekodierte Nutzlast. Wenn dieses
Token jedoch nicht gültig ist, wird
es eine Ausnahme auslösen Also müssen wir diese Zeile
mit einem Try-Cache-Block umschließen. Also versuche es mit Cache, wir
bekommen eine Ausnahme. Wenn wir hier ankommen, wollen wir
dem Client mitteilen , dass dies ein ungültiges Token
ist. Wir setzen diesen Status auf
400, weil es
eine schlechte Anfrage gibt , weil das, was der Client uns sendet, nicht
die richtigen Daten enthält. Senden Sie also ein ungültiges Token. Auch hier können
wir mit dieser Fehlermeldung die
Authentifizierungsprobleme beheben. Wenn wir also auf dem Client nicht auf einen bestimmten API-Endpunkt
zugreifen können , schauen
wir uns die Fehlermeldung an. Wir stellen fest, dass wir
ein ungültiges Token senden. Dann schauen wir uns die Logik auf
dem Client an, wo wir
das Token bekommen und
es an den Server senden. Das ist also unser Cache-Block. Nun zurück zum Tri-Block, hier haben wir die Gehaltsabrechnung Also können wir das
in die Anfrage aufnehmen. Also, unserem Anforderungsobjekt fügen
wir die Benutzereigenschaft hinzu und setzen das auf diese Dekodierung Also haben wir früher
nur die ID des
Benutzers in die Payload Lass es mich dir zeigen.
Gehen wir also zu unserem Benutzermodul. Hier ist das Schema unseres Benutzers. Wir haben diese Methode zum Generieren von
Authentifizierungstoken hinzugefügt. Wir haben das JCN WebToken erstellt
und das ist unsere Nutzlast. Wenn wir also dieses JWT dekodieren, erhalten dieses Objekt Und wir werden es als Benutzerobjekt in die
Anfrage aufnehmen. In unserem Route-Handler können
wir also auf Request Dot
User Dot Underline
Dot ID und SOW zugreifen User Dot Underline
Dot ID und SOW Okay? Also setzen
wir im Tri-Block die Anfrage auf den Punkt user, und dann müssen wir die Steuerung
an
die nächste Middleware-Funktion
in der Pipeline zur
Anforderungsverarbeitung übergeben die nächste Middleware-Funktion
in der Pipeline zur
Anforderungsverarbeitung In diesem Fall ist das unser
Route-Handler. Also rufen wir als Nächstes an. Wie ich Ihnen bereits sagte, beenden
wir
bei Middleware-Funktionen entweder den
Anforderungsantwort-SL-Zyklus oder übergeben die Steuerung an die
nächste Middleware-Funktion Nun, nur ein kleines
Problem in diesem Code Falls wir kein Token haben, werden
wir diese
Antwort an den Client senden Aber ich möchte sicherstellen, dass
wir diese Funktion beenden. In Ordnung, wir sind mit
unserer Middleware-Funktion fertig. Am Ende setzen wir die
Modulpunktexporte auf OTO. Eine Abkürzung dafür
ist, es hier einzustellen Also setzen wir Module Dot Exports, wir setzen es auf eine Funktion. Wir brauchen hier kein Em. Und dann können wir die Linie 17
loswerden. Erledigt.
15. Routen schützen: Jetzt, wo wir eine
Middleware-Funktion haben, können
wir zu Index Dot JS gehen.
Schauen Sie, hier wenden wir
Middleware-Funktionen Also können wir das hier hinzufügen, und dann wird es
vor jedem Route-Handler ausgeführt Aber wir wollen das nicht
tun, weil nicht alle API-Endpunkte geschützt werden
sollten Einige unserer API-Endpunkte
sollten öffentlich sein, z. B. die Registrierung
eines Benutzers oder das
Einloggen oder das Abrufen der Liste der
Unternehmen oder Kunden In diesem Fall möchten
wir
diese Middleware-Funktion also
selektiv auf bestimmte Endpunkte anwenden diese Middleware-Funktion selektiv Also zurück zum Modul des Unternehmens,
hier ist unser Post-Route-Handler Das erste Argument ist eine Route. Das zweite ist
optional Middleware, und das dritte ist der
eigentliche Route-Handler Gehen wir also nach oben und
vermitteln diese Middleware-Funktion .
Also benötige. Jetzt müssen wir eine
Ebene höher gehen und dann zum Middleware-Ordner gehen und
das
Earth-Modul laden Wir holen es und legen es hier ab. Und schließlich übergeben
wir hier
in der Post-Methode OT
als Middleware-Funktion, übergeben
wir hier
in der Post-Methode OT
als die vor dieser anderen
Middleware-Funktion
ausgeführt wird ,
die in diesem Fall ein Route-Handler ist Lassen Sie uns das jetzt wieder in Postman testen
. Ich werde einen neuen Tab öffnen und eine Post-Anfrage an
den Endpunkt des Unternehmens
senden Also lokaler STDP-Host,
API-Unternehmen. In diesem Fall mache ich mir keine Sorgen um den
Hauptteil der Anfrage Ich möchte nur wissen, ob wir diesen API-Endpunkt
aufrufen können oder nicht. Also sende Okay, schau, wir haben diesen 401- oder
unautorisierten Fehler. Und hier ist die Fehlermeldung. Zugriff verweigert, Noto kann zur Verfügung stellen. Geben wir nun
ein ungültiges Token an. Also gehen wir zur Registerkarte Header und
legen den Schlüssel fest, der X-Token ist Ich habe ein ungültiges Token eingegeben, wir haben 400 oder eine schlechte
Anfrage mit dieser Nachricht Ungültiges Token.
Wunderschön. Lassen Sie uns jetzt endlich zu unserem
Register zurückkehren und einen Tab verwenden. Wir haben ein gültiges
Authentifizierungstoken. Kopieren wir das also
zurück auf den dritten Tab. Leg es hierher und sende es dann. Okay, jetzt haben wir eine schlechte Anfrage bekommen, aber das liegt nicht
an der Authentifizierung. Das liegt daran, dass wir
die Eigenschaft name im Hauptteil
der Anfrage erwartet haben. Wenn ich also hier im
Hauptteil ein
JSON-Objekt hinzufüge , nenne ich das neue Unternehmen. Jetzt sollten wir gut sein. Senden.
Also haben wir eine Antwort von 200 und das ist die neue Firma. Als Übung möchte
ich, dass Sie diese
Middleware-Funktion
auf andere Route-Handler anwenden , die
16. Den aktuellen Benutzer erhalten: In vielen Anwendungen müssen wir manchmal
Informationen über den
aktuell angemeldeten Benutzer abrufen . In dieser Vorlesung werden
wir also
einen neuen API-Endpunkt hinzufügen, um den
aktuellen Benutzer abzurufen. Gehen wir also zu unserem Benutzermodul. Derzeit haben wir nur
einen Route-Handler. Das ist für die Erstellung eines neuen Benutzers. Jetzt müssen wir einen weiteren
Handler für Get-Methoden hinzufügen. Fügen Sie jetzt hier einen Pfad oder eine Route hinzu. Wir können einen Parameter übergeben, aber das bedeutet, dass der Client die
ID an den Server senden
sollte. Dieser Ansatz
ist zwar völlig in Ordnung, manchmal möchten
Sie vielleicht aus
Sicherheitsgründen keinen solchen
Endpunkt
haben, weil ich dann die ID eines anderen Benutzers senden und mir dessen
Konto ansehen
kann , wo es Informationen gibt , die mich
vielleicht nicht sichtbar
sein sollten. Der Ansatz, den wir
häufig verwenden, um
Informationen über
den aktuellen Benutzer zu erhalten, besteht also häufig verwenden, um
Informationen über
den aktuellen Benutzer zu erhalten darin,
einen API-Endpunkt wie mich zu haben. Damit sendet der Client die Benutzer-ID nicht
. Wir haben es vom JCN-Web-Tool. Ich kann also nicht das JCN WebTken eines
anderen fälschen das JCN WebTken eines
anderen weil ich Ihnen gesagt habe, dass
ich dafür eine
neue digitale Signatur
für dieses JCN WebTken erstellen muss für Fügen wir also den Route-Handler hinzu, die asynchrone Anfrage und die Antwort gehen zu diesem Jetzt sollte dieser API-Endpunkt nur für
authentifizierte Benutzer verfügbar sein Hier müssen wir also
unsere OT-Middleware hinzufügen. Lassen Sie uns oben
OT von Middleware Auth laden. Nur zur Verdeutlichung:
Der Autor steht hier für Autorisierung,
nicht für Authentifizierung, da es bei der Authentifizierung um die Überprüfung des Benutzernamens und des Passworts
geht Hier wollen wir sehen, ob der Benutzer berechtigt
ist, auf
eine Ressource zuzugreifen oder nicht, und das ist Autorisierung Wir fügen hier unsere Middleware hinzu. Mit dieser Middleware werden
wir nie zu diesem Route-Handler gelangen, wenn ein Client kein
gültiges JCN-Webtoken sendet wir nie zu diesem Route-Handler gelangen Wenn Sie jedoch hier ankommen, wie Sie bei der
Implementierung
dieser Middleware-Funktion hier gesehen haben, werden
wir das Benutzerobjekt request dot haben Wir können also hier auf die
ID-Eigenschaft zugreifen. Anstatt also
die ID-Eigenschaft im
Pfad oder in der Route zu übergeben , erhalten
wir sie von der Punkt-ID des Anforderungspunkts, die eigentlich
aus unserem JSON-Webtoken stammt. Das ist also ein sichererer Ansatz. Jetzt wollen wir einen
Benutzer anhand der angegebenen ID finden. Also nennen wir den Benutzer Dot Fine nach ID. Übergeben Sie diesen Wert vorab, warten Sie
dann auf das Versprechen und
holen Sie sich das Benutzerobjekt hierher. Jetzt wollen wir das Passwort
des Benutzers nicht
an den Client zurückgeben . Rufen wir hier also Select auf und schließen die
Passwort-Eigenschaft aus. In Ihrer Anwendung möchten
Sie vielleicht auch andere
Eigenschaften ausschließen. Vielleicht Adresse,
vielleicht Telefonnummer. Also hier haben wir ein Benutzerobjekt. Schließlich senden wir
das an den Client. Senden Sie den Benutzer also
so einfach. Lassen Sie uns das jetzt testen. Also hier in Postman werde
ich einen neuen Tab hinzufügen, eine Get-Anfrage an den lokalen
Host für 3.000 API-Benutzer
senden Jetzt
möchte ich zunächst kein JCN-WebToken senden. Also Send Xs verweigert kein Token, bereitgestellt.
Wunderschön. Gehen wir jetzt zur Registerkarte „Überschriften“. Fügen Sie hier X oder ein Token hinzu
und reichen Sie dann einen
Hochzeitskäse und ein Web-Token SN. Das ist mein Benutzerkonto. Wir können sehen, dass das Passwort ausgeschlossen ist.
17. Benutzer abmelden: Deshalb definieren
wir in unserem Auth-Modul diese Route für die
Authentifizierung von Benutzern Was ist mit dem Abmelden von Benutzern? Brauchen wir dafür eine separate
Route? Nein, weil wir dieses Token
nirgends auf dem Server
speichern. Wir benötigen also keinen
separaten Route-Handler , um dieses Token zu löschen. Technisch gesehen
müssen Sie
die Abmeldefunktion also auf dem
Client implementieren , nicht auf dem Server. der Benutzer sich also in der Client-Anwendung Wenn der Benutzer sich also in der Client-Anwendung abmelden möchte, löschen
Sie dieses
Token einfach vom Client. Jetzt habe ich Kurse
und Tutorials gesehen, in denen Sie
lernen, dieses Token
auf dem Server in der Datenbank zu speichern . Dies ist eine sehr schlechte Vorgehensweise
, da diese Token wie
Schlüssel sind , die einem Client
Zugriff auf geschützte API-Endpunkte gewähren Zugriff auf geschützte API-Endpunkte Wenn ein Hacker
Zugriff auf Ihre Datenbank erhält, kann er all diese Token
für authentifizierte Benutzer sehen Sie müssen nicht einmal
das Passwort eines Benutzers kennen. Sie können einfach
ihr
Authentifizierungstoken abrufen und es an
den Server senden , um die
Anfrage im Namen eines Benutzers auszuführen. Sie sollten keine
Token in Ihrer Datenbank speichern. Und wenn Sie wissen,
was Sie tun und Sie das Token wirklich in
der Datenbank speichern möchten,
stellen Sie sicher, dass Sie es verschlüsseln.
Stellen Sie sicher, dass Sie es hashen Genau wie die Passwörter. Speichern eines Tokens in
einem Klartext in Datenbank ist so, als würde man den Reisepass oder den
Führerschein aller Benutzer abrufen, sie an einem zentralen
Ort
ablegen, und dann kann
jeder, jeder böswillige Benutzer, der
Zugriff auf diesen zentralen Ort hat, diese Pässe einfach abrufen Sie können diese
Führerscheine erwerben und andere
Benutzer, andere Kunden nachahmen Also noch einmal, speichern Sie
die Token nicht auf dem Server, auf dem Client Aus Sicherheitsgründen sollten Sie
immer HTTPS verwenden, wenn Sie das Token
vom Client an den Server
senden das Token
vom Client an den Server . Ein Hacker, der
mittendrin sitzt und den Verkehr abschnüffelt, kann das vom Client
an den Server
gesendete Token nicht lesen , sodass die Daten
zwischen dem Client
und dem Server verschlüsselt werden zwischen dem Client
und dem
18. Rollenbasierte Autorisierung: Bisher haben wir Authentifizierung
und Autorisierung erfolgreich
implementiert und Autorisierung Lassen Sie uns diese
Anwendung nun auf die nächste Stufe bringen. Stellen wir uns vor, dass bestimmte
Operationen wie Löschen von Daten nur von
Admins ausgeführt werden können Lassen Sie mich Ihnen zeigen, wie Sie eine
rollenbasierte Autorisierung implementieren Zuerst müssen wir
zu unserem Benutzermodell gehen. Das ist also unser Benutzerschema. Derzeit haben wir
drei Eigenschaften
: Name, E-Mail und Passwort. Jetzt müssen wir
eine weitere Eigenschaft hinzufügen, um zu sehen, ob ein bestimmter Benutzer ein Administrator
ist oder nicht. Fügen wir also eine neue Eigenschaft namens admin
vom Typ Boolean hinzu. Das ist also der erste Schritt. Jetzt gehe ich
in Mongo DB Compass, schnappe mir einen dieser Benutzer und
mache ihn zum Administrator. Also bearbeite Ich werde nach dem Passwort ein
Feld hinzufügen, und die Reihenfolge
spielt keine Rolle. Das gilt auch für admin und standardmäßig können
Sie sehen, dass
der Typ eine Zeichenfolge ist. Wir werden das auf Boolean ändern
. Lassen Sie uns das als wahr bezeichnen und dann endlich das Update anwenden Also hier habe ich einen Benutzer
, der ein Administrator ist. Jetzt, wenn ich mich anmelde, möchte
ich
diese Eigenschaft in unsere
JSON-Web-Token-Nutzlast aufnehmen diese Eigenschaft in unsere
JSON-Web-Token-Nutzlast sie also das nächste Mal dieses
JCN-WebToken an den Server senden, können
wir diese Eigenschaft
direkt aus dem Token extrahieren Wir müssen die ID nicht abrufen, in die Datenbank
gehen und nachschauen,
ob sie Admin sind Und wie ich Ihnen bereits gesagt habe, mit der digitalen Signatur, die in einem JCN-Webtken
enthalten ist, böswilliger Benutzer
mit der digitalen Signatur, die in einem JCN-Webtken
enthalten ist,
den Wert seines Administrators
für sein Benutzerkonto nicht ändern den Wert seines Administrators
für Wenn sie Änderungen vornehmen, müssen
sie
die digitale Signatur neu generieren. Dazu müssen sie den privaten Schlüssel
kennen, den wir in einer
Umgebungsvariablen auf dem Server gespeichert haben Jetzt, zurück in unserem Benutzermodul, wenn wir das
Authentifizierungstoken generieren, möchten
wir diese
Eigenschaft zur Nutzlast hinzufügen Also hier ist unsere Nutzlast. Lassen Sie uns eine neue Eigenschaft hinzufügen, die admin
ist. Wir haben das auf eingestellt. Dieser DT ist Admin. Das ist also der Vorteil der Kapselung dieser Logik
innerhalb des Benutzerobjekts Es gibt also einen einzigen Ort
, den wir ändern müssen. Zuvor hatten wir das
an zwei verschiedenen Orten. Und bei dieser Änderung des Symbols mussten
wir daran denken, diese Änderung an zwei verschiedenen
Stellen im Code anzuwenden . Das ist also unser Kniezeichen. Jetzt benötigen wir auf dem Server
eine neue
Middleware-Funktion, um zu überprüfen, ob der aktuelle Benutzer
ein Administrator ist oder Also hier im
Middleware-Ordner werde
ich eine
neue Datei hinzufügen, werde
ich eine
neue Datei hinzufügen Hier legen wir also ein Modul fest , das in eine
Middleware-Funktion exportiert Und nimmt eine Anfrage, eine Antwort
und einen Verweis auf die
nächste Middleware-Funktion
in der Pipeline zur Anforderungsverarbeitung Hier gehen wir also davon aus, dass
diese Middleware-Funktion nach
unserer Autorisierungs-Middleware-Funktion ausgeführt
wird unserer Unsere
Autorisierungs-Middleware-Funktion setzt also
Anfrage statt Benutzer, sodass wir in dieser Funktion darauf zugreifen können Also frage ich den
Benutzer, der Admin ist, oder sagen wir, wenn er
nicht im Admin-Modus ist, wir den
Antwortstatus zurück Wir haben den Status 24 auf
drei gesetzt, was verboten ist. Dies ist einer der Bereiche,
in denen viele Entwickler falsch liegen. Wir haben also 41, was unerlaubt bedeutet, und wir haben vier oder drei,
was verboten bedeutet. Wir verwenden Unauthorized, wenn der Benutzer versucht, auf
eine geschützte Ressource zuzugreifen, er
aber kein
gültiges JSN-WebToken bereitstellt Also geben wir ihnen die Möglichkeit, es erneut
zu versuchen und ein gültiges JCN-WebToken senden.
Wenn sie ein
gültiges GSN-Webtoken und sie immer noch nicht auf die Zielressource zugreifen dürfen , dann verwenden wir
vier oder drei
, was verboten bedeutet,
was bedeutet, versuchen Sie es nicht erneut,
wir können einfach nicht ein gültiges JCN-WebToken zu senden.
Wenn sie ein
gültiges GSN-Webtoken senden
und sie immer noch nicht auf die Zielressource zugreifen dürfen
, dann verwenden wir
vier oder drei
, was verboten bedeutet,
was bedeutet, versuchen Sie es nicht erneut,
wir können einfach nicht auf diese Ressource zugreifen. Also hier setzen wir den Status und senden eine
Nachricht Andernfalls, wenn
der Benutzer Admin ist, übergeben
wir die Kontrolle an die
nächste Middleware-Funktion
, in diesem Fall
den Route-Handler Jetzt werden wir
diese Middleware-Funktion
auf eine unserer Routen anwenden diese Middleware-Funktion
auf eine unserer Routen Also zurück zu den Unternehmen Punkt JS, schauen wir uns die Löschmethode an. Also, hier ist unsere Löschmethode. Wir wollen hier zwei
Middleware-Funktionen anwenden. Also müssen wir ein Array übergeben. Der erste ist OT und
der zweite ist admin. Diese Middleware-Funktionen
werden also nacheinander ausgeführt erste Teil, wenn der Client ein abwechslungsreiches Jas im
Webtoken
sendet und dann
kommen wir zur Der Benutzer ist ein Admin, dann wird die dritte
Middleware-Funktion oder der dritte Route-Handler Jetzt müssen wir
das auf den TA importieren. Also Constant Admin,
wir haben das so eingestellt, den
Middleware-Ordner gehen
und das Admin-Modul laden
müssen und das Admin-Modul laden Lassen Sie uns das jetzt testen.
Zurück in Postman Ich öffne
einen neuen Tab und sende
eine Löschanfrage
an diesen Endpunkt, lokalen
STDP-Host für
3.000 API-Unternehmen Lassen Sie mich jetzt eine ID für
ein Unternehmen aus der
Mongo IV-Datenbank abrufen ein Unternehmen aus der
Mongo IV-Datenbank Gehen Sie also hier zu Companies
Collection, kopieren Sie diese ID und geben Sie sie wie folgt in
unseren Endpunkt ein Vergessen Sie nicht,
das Quotensymbol anzugeben. Andernfalls erhalten Sie
den Autorisierungsfehler. Überschreitung verweigert, kein
Token stellt sie zur Verfügung. Also werden wir das Token platzieren
und es jetzt senden. Wunderschön. Wir haben
eine Antwort von 200 und hier ist die Firma
, die gelöscht wurde.